![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to configttys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / configttys|
Return to configttys.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / configttys |
1.1 root 1:
2: #ifndef lint
3: char sccsid[] = "@(#)configttys.c 4.4 (Berkeley) 6/19/83";
4: #endif
5:
6: /*
7: * configttys - configure "tty" ports
8: *
9: * David L. Wasley
10: * U.C.Berkeley
11: */
12:
13: #include <stdio.h>
14: #include <getty.h>
15: #include <signal.h>
16:
17: #define exists(file) (access(file, 0) == 0)
18:
19: char *etc_ttys = "/etc/ttys"; /* active port speed table */
20: char *etc_ttytype = "/etc/ttytype"; /* terminal type table */
21: char *etc_conf = "/etc/ttyconf"; /* master config file */
22: char *lockfile = "/etc/ttyconf.lock"; /* interlock file */
23:
24: struct ttys {
25: char ty_active; /* active login port */
26: char ty_speed; /* speed table character */
27: char ty_port[32]; /* port name */
28: } ttys[256];
29:
30: struct ttytype {
31: char tp_term[64]; /* terminal type name */
32: char tp_port[32]; /* port name */
33: } ttytype[256];
34:
35: char conformat[] = "%s\t%s\t%s\t%s\n";
36:
37: int error = 0;
38: int renamed = 0;
39: int debug = 0; /* debug mode */
40: int backup = 0; /* create backup copies of old data */
41: int interactive = 1; /* interactive mode */
42:
43: char *speedname(); /* port speed code name */
44: char speedchar(); /* getty table name */
45: char *termname(); /* name of terminal on this port */
46: char *rindex();
47: struct ttytype *type(); /* find ttytype for port */
48: FILE *fopen();
49:
50: main (argc, argv)
51: int argc;
52: char **argv;
53: {
54: int lineno;
55: int child;
56: int status;
57: char c;
58: struct ttys *ty;
59: struct ttytype *tp;
60: char port[32];
61: char active[16];
62: char speed[32];
63: char term[64];
64: FILE *tyf, *tpf, *conf;
65: char buf[1024];
66: char ans[32];
67:
68: while (--argc > 0)
69: {
70: if (**++argv == '-') switch (*++*argv)
71: {
72: case 'd':
73: debug = 1;
74: break;
75:
76: case 'n': /* non-interactive */
77: interactive = 0;
78: break;
79:
80: case 'b': /* backup old databases */
81: backup = 1;
82: break;
83:
84: default:
85: fprintf(stderr, "unknown option %c\n", **argv);
86: exit(1);
87: }
88: }
89:
90: if (debug)
91: {
92: etc_ttys = rindex(etc_ttys, '/') + 1;
93: etc_ttytype = rindex(etc_ttytype, '/') + 1;
94: etc_conf = rindex(etc_conf, '/') + 1;
95: lockfile = rindex(lockfile, '/') + 1;
96: }
97:
98: /*
99: * create backup copies of the databases?
100: */
101: if (backup)
102: {
103: if (exists(etc_ttys))
104: {
105: sprintf(buf, "/bin/cp %s %s.bak", etc_ttys, etc_ttys);
106: system(buf);
107: }
108: if (exists(etc_ttys))
109: {
110: sprintf(buf, "/bin/cp %s %s.bak", etc_ttytype, etc_ttytype);
111: system(buf);
112: }
113: if (exists(etc_conf))
114: {
115: sprintf(buf, "/bin/cp %s %s.bak", etc_conf, etc_conf);
116: system(buf);
117: }
118: }
119:
120: /*
121: * create interlock file
122: */
123: getlockfile(lockfile);
124:
125: /*
126: * always read ttys file for comparison
127: * It is afterall what really counts!
128: */
129: if (readttys() != 0)
130: quit(1);
131:
132: /*
133: * read old ttytypes if necessary
134: */
135: if (! exists(etc_conf))
136: {
137: /*
138: * open old ttytype file
139: */
140: if ((tpf = fopen(etc_ttytype, "r")) == NULL)
141: {
142: perror(etc_ttytype);
143: quit(1);
144: }
145:
146: /*
147: * read ttytype file
148: */
149: lineno = 0;
150: tp = ttytype;
151: while (fgets(buf, sizeof buf, tpf))
152: {
153: lineno++;
154: if (sscanf(buf, "%s %s", tp->tp_term, tp->tp_port) == 2)
155: tp++;
156: else
157: {
158: error++;
159: fprintf(stderr, "bad line %d in %s: %s",
160: lineno, etc_ttytype, buf);
161: }
162: }
163: fclose(tpf);
164: tp->tp_term[0] = '\0';
165:
166: if (error > 0)
167: quit(1);
168:
169: /*
170: * create master config file
171: */
172: if ((conf = fopen(etc_conf, "w")) == NULL)
173: {
174: perror(etc_conf);
175: quit(1);
176: }
177:
178: fprintf(conf, conformat, "port", "login", "speed\t", "terminal type");
179: fprintf(conf, conformat, "----", "-----", "-----\t", "-------------");
180: for (ty = ttys; ty->ty_active; ty++)
181: {
182: fprintf(conf, conformat, ty->ty_port,
183: ty->ty_active == '1'? "active":"-",
184: speedname(ty->ty_speed),
185: termname(ty->ty_port));
186: }
187: fclose(conf);
188: }
189:
190: /*
191: * open master config file
192: */
193: if ((conf = fopen(etc_conf, "r")) == NULL)
194: {
195: perror(etc_conf);
196: quit(1);
197: }
198:
199: if (interactive)
200: edit();
201:
202: /*
203: * read conf file
204: */
205: re_read:
206: rewind(conf);
207: ty = ttys;
208: renamed = 0;
209: error = 0;
210: lineno = 0;
211:
212: while (fgets(buf, sizeof buf, conf)) /* skip heading */
213: {
214: lineno++;
215: if (buf[0] == '-')
216: break;
217: }
218:
219: while (fgets(buf, sizeof buf, conf))
220: {
221: lineno++;
222: if (sscanf(buf, "%s %s %s %s", port, active, speed, term) < 4)
223: {
224: fprintf(stderr, "line %d: field(s) missing: %s",
225: lineno, buf);
226: error++;
227: break;
228: }
229:
230: if (strcmp(port, ty->ty_port) != 0)
231: {
232: if (! ty->ty_active || renamed)
233: strcpy(ty->ty_port, port);
234: else
235: {
236: fprintf(stderr, "line %d: port name changed! %s -> %s\n",
237: lineno, ty->ty_port, port);
238: fprintf(stderr, "Are you sure this is OK? ");
239: gets(ans);
240: if (ans[0] != 'y')
241: {
242: edit();
243: goto re_read;
244: }
245: renamed++;
246: strcpy(ty->ty_port, port);
247: }
248: }
249:
250: if (strcmp(active, "active") == 0)
251: ty->ty_active = '1';
252: else
253: ty->ty_active = '0';
254:
255: if (c = speedchar(speed))
256: ty->ty_speed = c;
257: else
258: {
259: fprintf(stderr, "line %d: speed name not known: %s\n",
260: lineno, speed);
261: error++;
262: }
263:
264: if (tp = type(port))
265: strcpy(tp->tp_term, term);
266: /* else ?? */
267:
268: ty++;
269: }
270:
271: if (ty == ttys)
272: {
273: fprintf(stderr, "%s empty??\n", etc_conf);
274: error++;
275: }
276:
277: if (error)
278: {
279: if (interactive)
280: {
281: fprintf(stderr, "re-edit? ");
282: gets(ans);
283: if (ans[0] == 'y')
284: {
285: edit();
286: goto re_read;
287: }
288: }
289: fprintf(stderr, "Files not modified.\n");
290: quit(1);
291: }
292:
293: writettys();
294: quit(0);
295: }
296:
297: /*
298: * read ttys file
299: */
300: readttys()
301: {
302: FILE *tyf;
303: register struct ttys *ty;
304: char buf[1024];
305: int lineno;
306: int error = 0;
307:
308: if ((tyf = fopen(etc_ttys, "r")) == NULL)
309: {
310: if (exists(etc_conf))
311: return (0); /* hope user has it together! */
312: perror(etc_ttys);
313: quit(1);
314: }
315:
316: lineno = 0;
317: ty = ttys;
318: while (fgets(buf, sizeof buf, tyf))
319: {
320: lineno++;
321: if (sscanf(buf, "%c%c%s",
322: &ty->ty_active, &ty->ty_speed, ty->ty_port) == 3)
323: ty++;
324: else
325: {
326: error++;
327: fprintf(stderr, "bad line %d in %s: %s",
328: lineno, etc_ttys, buf);
329: }
330: }
331: fclose(tyf);
332: ty->ty_active = '\0';
333: return(error);
334: }
335:
336: writettys()
337: {
338: int rtn = 0;
339: char temp[1024];
340: FILE *tyf, *tpf;
341: register struct ttys *ty;
342:
343: sprintf(temp, "%s.tmp", etc_ttys);
344: if ((tyf = fopen(temp, "w")) == NULL)
345: {
346: perror(temp);
347: quit(1);
348: }
349:
350: for (ty = ttys; ty->ty_active; ty++)
351: fprintf(tyf, "%c%c%s\n",
352: ty->ty_active, ty->ty_speed, ty->ty_port);
353: fclose(tyf);
354:
355: if (rename(temp, etc_ttys) != 0)
356: {
357: fprintf(stderr, "Can't rename %s\n", temp);
358: rtn = 1;
359: }
360:
361: sprintf(temp, "%s.tmp", etc_ttytype);
362: if ((tpf = fopen(temp, "w")) == NULL)
363: {
364: perror(temp);
365: quit(1);
366: }
367:
368: for (ty = ttys; ty->ty_active; ty++) /* same ports! */
369: fprintf(tpf, "%s %s\n",
370: type(ty->ty_port)->tp_term, ty->ty_port);
371: fclose(tpf);
372:
373: if (rename(temp, etc_ttytype) != 0)
374: {
375: fprintf(stderr, "Can't rename %s\n", temp);
376: rtn = 1;
377: }
378:
379: return (rtn);
380: }
381:
382: /*
383: * invoke editor
384: */
385: edit()
386: {
387: int child;
388: int status;
389:
390: if ((child = fork()) == 0)
391: {
392: execl("/usr/ucb/vi", "vi", etc_conf, 0);
393: execl("/bin/ed", "ed", etc_conf, 0);
394: exit(1);
395: }
396:
397: if (child < 0)
398: {
399: perror("can't fork editor");
400: quit(1);
401: }
402:
403: /*
404: * wait for editor
405: */
406: while (wait(&status) >= 0)
407: ;
408:
409: return (status);
410: }
411:
412: quit (n)
413: int n;
414: {
415: unlink (lockfile);
416: if (n > 1)
417: {
418: signal (n, SIG_DFL);
419: kill (getpid(), n);
420: }
421: exit (n);
422: }
423:
424: getlockfile ()
425: {
426: char *p;
427: char locktmp[64];
428: int fd;
429:
430: strcpy(locktmp, lockfile);
431: if (p = rindex(locktmp, '/'))
432: p++;
433: else
434: p = locktmp;
435: strcpy(p, "confttysXXXXXX");
436: mktemp(locktmp);
437:
438: if ((fd = creat(locktmp, 0600)) < 0)
439: {
440: perror(locktmp);
441: exit(1);
442: }
443:
444: if (link(locktmp, lockfile) < 0)
445: {
446: perror(lockfile);
447: unlink(locktmp);
448: exit(1);
449: }
450:
451: signal(SIGINT, quit);
452: signal(SIGQUIT, quit);
453:
454: unlink(locktmp);
455: return(0);
456: }
457:
458: struct speeds {
459: char *sp_name; /* human readable name */
460: char sp_table; /* getty table name */
461: } speeds[] = {
462: { "dialup", GT_DIALUP }, /* normal dialup rotation */
463: { "selector", GT_SELECTOR }, /* port selector pseudo-table autobaud*/
464: { "b110", GT_B110 }, /* 110 baud */
465: { "b134", GT_B134 }, /* 134.5 baud selectric */
466: { "b150", GT_B150 }, /* 150 baud */
467: { "b300", GT_B300 }, /* 300 baud */
468: { "b600", GT_B600 }, /* 600 baud */
469: { "b1200", GT_B1200 }, /* 1200 baud */
470: { "b2400", GT_B2400 }, /* 2400 baud */
471: { "b4800", GT_B4800 }, /* 4800 baud */
472: { "b9600", GT_B9600 }, /* 9600 baud */
473: { "dw2console", GT_DW2CONSOLE },/* Decwriter Console - 300 baud */
474: { "fastdialup", GT_FASTDIALUP },/* 1200-300 baud rotation for dialup */
475: { "fastdialup1",GT_FASTDIALUP1},/* 300-1200 " " " " */
476: { "crt", GT_CRT_HCPY }, /* 9600-300 CRT + hardcopy rotation */
477: { "hardcopy", GT_HCPY_CRT }, /* 300-9600 " " " */
478: { "plugboard", GT_PLUGBOARD }, /* 9600-300-1200 rotation */
479: { "plugboard1", GT_PLUGBOARD2 },/* 300-1200-9600 rotation */
480: { "plugboard2", GT_PLUGBOARD2 },/* 1200-9600-300 rotation */
481: { "interdata", GT_INTERDATA }, /* Interdata Console */
482: { "chess", GT_CHESS }, /* LSI Chess Terminal */
483: { "tty33", GT_TTY33 }, /* 110 baud Model 33 TTY */
484: { "network", GT_NETWORK }, /* network port */
485: { "", 0 }
486: };
487:
488: char *
489: speedname (c)
490: char c;
491: {
492: struct speeds *sp;
493: static char sbuf[32];
494:
495: for (sp = speeds; sp->sp_table; sp++)
496: if (sp->sp_table == c)
497: break;
498:
499: if (sp->sp_table)
500: strcpy(sbuf, sp->sp_name);
501: else
502: strcpy(sbuf, "-");
503:
504: if (strlen(sbuf) < 8)
505: strcat(sbuf, "\t");
506:
507: return (sbuf);
508: }
509:
510: char *
511: termname (port)
512: char *port;
513: {
514: register struct ttytype *tp;
515:
516: for (tp = ttytype; tp->tp_term[0]; tp++)
517: if (strcmp(port, tp->tp_port) == 0)
518: return (tp->tp_term);
519:
520: if (tp < &ttytype[(sizeof ttytype / sizeof (struct ttytype)) -1])
521: {
522: strcpy(tp->tp_port, port);
523: strcpy(tp->tp_term, "unknown");
524: (++tp)->tp_term[0] = '\0';
525: }
526:
527: return ("unknown");
528: }
529:
530: char
531: speedchar (speed)
532: char *speed;
533: {
534: register struct speeds *sp;
535:
536: for (sp = speeds; sp->sp_table; sp++)
537: if (strcmp(sp->sp_name, speed) == 0)
538: return (sp->sp_table);
539: return ('\0');
540: }
541:
542: struct ttytype *
543: type (port)
544: char *port;
545: {
546: register struct ttytype *tp;
547:
548: for (tp = ttytype; tp->tp_term[0]; tp++)
549: if (strcmp(tp->tp_port, port) == 0)
550: return (tp);
551:
552: if (tp < &ttytype[(sizeof ttytype / sizeof (struct ttytype)) -1])
553: {
554: strcpy(tp->tp_port, port);
555: strcpy(tp->tp_term, "unknown");
556: return(tp);
557: }
558:
559: return((struct ttytype *)0);
560: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.