![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cohtty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix|
Return to cohtty.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix |
1.1 root 1: /* Coherent tty locking support. This file was contributed by Bob
2: Hemedinger <[email protected]> of Mark Williams Corporation and
3: lightly edited by Ian Lance Taylor. */
4:
5: /* The bottom part of this file is lock.c.
6: * This is a hacked lock.c. A full lock.c can be found in the libmisc sources
7: * under /usr/src/misc.tar.Z.
8: *
9: * These are for checking for the existence of locks:
10: * lockexist(resource)
11: * lockttyexist(ttyname)
12: */
13:
14: #include "uucp.h"
15:
16: #if HAVE_COHERENT_LOCKFILES
17:
18: /* cohtty.c: Given a serial device name, read /etc/ttys and determine if
19: * the device is already enabled. If it is, disable the
20: * device and return a string so that it can be re-enabled
21: * at the completion of the uucico session as part of the
22: * function that resets the serial device before uucico
23: * terminates.
24: *
25: */
26:
27: #include "uudefs.h"
28: #include "sysdep.h"
29:
30: #include <ctype.h>
31: #include <access.h>
32:
33: /* fscoherent_disable_tty() is a COHERENT specific function. It takes the name
34: * of a serial device and then scans /etc/ttys for a match. If it finds one,
35: * it checks the first field of the entry. If it is a '1', then it will disable
36: * the port and set a flag. The flag will be checked later when uucico wants to
37: * reset the serial device to see if the device needs to be re-enabled.
38: */
39:
40: /* May 10, 1993: This function will always return true for the following
41: * reasons:
42: * 1) lock files have already been dealt with
43: * 2) if someone else already has the port open, uucico should fail anyways
44: * 3) Coherent's disable command return can return '0' or '1', but will
45: * succeed in any event.
46: * 4) It doesn't matter if there is a ttys entry for the port in question.
47: * /etc/ttys generally only lists devices that MAY be enabled for logins.
48: * If a device will never be used for logins, then there may not be a
49: * ttys entry, in which case, disable won't be called anyways.
50: * [email protected]
51: */
52:
53: boolean
54: fscoherent_disable_tty (zdevice, pzenable)
55: const char *zdevice;
56: char **pzenable;
57: {
58:
59:
60: struct ttyentry{ /* this is an /etc/ttys entry */
61: char enable_disable[1];
62: char remote_local[1];
63: char baud_rate[1];
64: char tty_device[16];
65: };
66:
67: struct ttyentry sought_tty;
68:
69: int x,y,z; /* dummy */
70: FILE * infp; /* this will point to /etc/ttys */
71: char disable_command[66]; /* this will be the disable command
72: * passed to the system.
73: */
74: char enable_device[16]; /* this will hold our device name
75: * to enable.
76: */
77:
78: *pzenable = NULL;
79:
80: strcpy(enable_device,""); /* initialize our strings */
81: strcpy(sought_tty.tty_device,"");
82:
83: if( (infp = fopen("/etc/ttys","r")) == NULL){
84: ulog(LOG_ERROR,"Error: check_disable_tty: failed to open /etc/ttys\n");
85: return FALSE;
86: }
87:
88: while (NULL !=(fgets(&sought_tty, sizeof (sought_tty), infp ))){
89: sought_tty.tty_device[strlen(sought_tty.tty_device) -1] = '\0';
90: strcpy(enable_device,sought_tty.tty_device);
91:
92: /* we must strip away the suffix to the com port name or
93: * we will never find a match. For example, if we are passed
94: * /dev/com4l to call out with and the port is already enabled,
95: * 9/10 the port enabled will be com4r. After we strip away the
96: * suffix of the port found in /etc/ttys, then we can test
97: * if the base port name appears in the device name string
98: * passed to us.
99: */
100:
101: for(z = strlen(sought_tty.tty_device) ; z > 0 ; z--){
102: if(isdigit(sought_tty.tty_device[z])){
103: break;
104: }
105: }
106: y = strlen(sought_tty.tty_device);
107: for(x = z+1 ; x <= y; x++){
108: sought_tty.tty_device[x] = '\0';
109: }
110:
111:
112: /* ulog(LOG_NORMAL,"found device {%s}\n",sought_tty.tty_device); */
113: if(strstr(zdevice, sought_tty.tty_device)){
114: if(sought_tty.enable_disable[0] == '1'){
115: ulog(LOG_NORMAL, "coh_tty: Disabling device %s {%s}\n",
116: zdevice, sought_tty.tty_device);
117: sprintf(disable_command, "/etc/disable %s",enable_device);
118: {
119: pid_t ipid;
120: const char *azargs[3];
121: int aidescs[3];
122:
123: azargs[0] = "/etc/disable";
124: azargs[1] = enable_device;
125: azargs[2] = NULL;
126: aidescs[0] = SPAWN_NULL;
127: aidescs[1] = SPAWN_NULL;
128: aidescs[2] = SPAWN_NULL;
129: ipid = ixsspawn (azargs, aidescs, TRUE,
130: FALSE,
131: (const char *) NULL, TRUE,
132: TRUE,
133: (const char *) NULL,
134: (const char *) NULL,
135: (const char *) NULL);
136: if (ipid < 0)
137: x = 1;
138: else
139: x = ixswait ((unsigned long) ipid,
140: (const char *) NULL);
141: }
142: *pzenable = zbufalc (sizeof "/dev/"
143: + strlen (enable_device));
144: sprintf(*pzenable,"/dev/%s", enable_device);
145: /* ulog(LOG_NORMAL,"Enable string is {%s}",*pzenable); */
146: return (TRUE);
147: }else{
148: /* device not enabled */
149: return TRUE;
150: }
151: }
152: }
153: return TRUE; /* no ttys entry found */
154: }
155:
156: /* The following is COHERENT 4.0 specific. It is used to test for any
157: * existing lockfiles on a port which would have been created by init
158: * when a user logs into a port.
159: */
160:
161: #define LOCKSIG 9 /* Significant Chars of Lockable Resources. */
162: #define LOKFLEN 64 /* Max Length of UUCP Lock File Name. */
163:
164: #define LOCKPRE "LCK.."
165: #define PIDLEN 6 /* Maximum length of string representing a pid. */
166:
167: #ifndef LOCKDIR
168: #define LOCKDIR SPOOLDIR
169: #endif
170:
171: /* There is a special version of DEVMASK for the PE multiport driver
172: * because of the peculiar way it uses the minor device number. For
173: * all other drivers, the lower 5 bits describe the physical port--
174: * the upper 3 bits give attributes for the port.
175: */
176:
177: #define PE_DRIVER 21 /* Major device number for the PE driver. */
178: #define PE_DEVMASK 0x3f /* PE driver minor device mask. */
179: #define DEVMASK 0x1f /* Minor device mask. */
180:
181: /*
182: * Generates a resource name for locking, based on the major number
183: * and the lower 4 bits of the minor number of the tty device.
184: *
185: * Builds the name in buff as two "." separated decimal numbers.
186: * Returns NULL on failure, buff on success.
187: */
188: static char *
189: gen_res_name(path, buff)
190: char *path;
191: char *buff;
192: {
193: struct stat sbuf;
194: int status;
195:
196: if (0 != (status = stat(path, &sbuf))) {
197: /* Can't stat the file. */
198: return (NULL);
199: }
200:
201: if (PE_DRIVER == major(sbuf.st_rdev)) {
202: sprintf(buff, "%d.%d", major(sbuf.st_rdev),
203: PE_DEVMASK & minor(sbuf.st_rdev));
204: } else {
205: sprintf(buff, "%d.%d", major(sbuf.st_rdev),
206: DEVMASK & minor(sbuf.st_rdev));
207: }
208:
209: return(buff);
210: } /* gen_res_name */
211:
212: /*
213: * lockexist(resource) char *resource;
214: *
215: * Test for existance of a lock on the given resource.
216: *
217: * Returns: (1) Resource is locked.
218: * (0) Resource is not locked.
219: */
220:
221: static boolean
222: lockexist(resource)
223: const char *resource;
224: {
225: char lockfn[LOKFLEN];
226:
227: if ( resource == NULL )
228: return(0);
229: sprintf(lockfn, "%s/%s%.*s", LOCKDIR, LOCKPRE, LOCKSIG, resource);
230:
231: return (!access(lockfn, AEXISTS));
232: } /* lockexist() */
233:
234: /*
235: * lockttyexist(ttyname) char *ttyname;
236: *
237: * Test for existance of a lock on the given tty.
238: *
239: * Returns: (1) Resource is locked.
240: * (0) Resource is not locked.
241: */
242: boolean
243: lockttyexist(ttyn)
244: const char *ttyn;
245: {
246: char resource[LOKFLEN];
247: char filename[LOKFLEN];
248:
249: sprintf(filename, "/dev/%s", ttyn);
250: if (NULL == gen_res_name(filename, resource)){
251: return(0); /* Non-existent tty can not be locked :-) */
252: }
253:
254: return(lockexist(resource));
255: } /* lockttyexist() */
256:
257: #endif /* HAVE_COHERENT_LOCKFILES */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.