![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm|
Return to main.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm |
1.1 root 1: /*
2: * $Source: /orpheus/u1/X11/clients/xterm/RCS/main.c,v $
3: * $Header: main.c,v 1.29 87/08/03 17:05:39 swick Locked $
4: */
5:
6: #include <X11/copyright.h>
7:
8: /*
9: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
10: *
11: * All Rights Reserved
12: *
13: * Permission to use, copy, modify, and distribute this software and its
14: * documentation for any purpose and without fee is hereby granted,
15: * provided that the above copyright notice appear in all copies and that
16: * both that copyright notice and this permission notice appear in
17: * supporting documentation, and that the name of Digital Equipment
18: * Corporation not be used in advertising or publicity pertaining to
19: * distribution of the software without specific, written prior permission.
20: *
21: *
22: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
23: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
24: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
25: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
26: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
27: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
28: * SOFTWARE.
29: */
30:
31: /* main.c */
32:
33: #ifndef lint
34: static char rcs_id[] = "$Header: main.c,v 1.29 87/08/03 17:05:39 swick Locked $";
35: #endif lint
36:
37: #include <pwd.h>
38: #include <sgtty.h>
39: #include <sys/wait.h>
40: #include <sys/time.h>
41: #include <sys/resource.h>
42: #include <stdio.h>
43: #include <sys/file.h>
44: #include <errno.h>
45: #include <signal.h>
46: #include <strings.h>
47: #include <setjmp.h>
48:
49: #ifdef apollo
50: #include <sys/types.h>
51: #define ttyslot() 1
52: #define vhangup() ;
53: #endif
54:
55: #include <utmp.h>
56: #include <sys/param.h> /* for NOFILE */
57: #include <X11/Xlib.h>
58: #include <X11/Xtlib.h>
59: #include "ptyx.h"
60: #include "data.h"
61: #include "error.h"
62: #include "main.h"
63:
64: extern Pixmap make_gray();
65: extern char *malloc();
66: extern char *calloc();
67: extern char *ttyname();
68: extern void exit();
69: extern void sleep();
70: extern void bcopy();
71: extern void vhangup();
72: extern long lseek();
73:
74: XrmNameList nameList;
75: XrmClassList classList;
76:
77: int switchfb[] = {0, 2, 1, 3};
78:
79: static int reapchild ();
80:
81: static char **command_to_exec;
82: static struct sgttyb d_sg = {
83: 0, 0, 0177, CKILL, EVENP|ODDP|ECHO|XTABS|CRMOD
84: };
85: static struct tchars d_tc = {
86: CINTR, CQUIT, CSTART,
87: CSTOP, CEOF, CBRK,
88: };
89: static struct ltchars d_ltc = {
90: CSUSP, CDSUSP, CRPRNT,
91: CFLUSH, CWERASE, CLNEXT
92: };
93: static int d_disipline = NTTYDISC;
94: static long int d_lmode = LCRTBS|LCRTERA|LCRTKIL|LCTLECH;
95: static char display[256];
96: static char etc_utmp[] = "/etc/utmp";
97: static char *get_ty;
98: static int inhibit;
99: static int log_on;
100: static int login_shell;
101: static char passedPty[2]; /* name if pty if slave */
102: static int loginpty;
103: #ifdef TIOCCONS
104: static int Console;
105: #endif TIOCCONS
106: static int tslot;
107: static jmp_buf env;
108:
109: #define XtNxterm "xterm"
110: #define XtNwindowName "windowName"
111: #define XtNboldFont "boldFont"
112: #define XtNc132 "c132"
113: #define XtNtitle "title"
114: #define XtNcurses "curses"
115: #define XtNcursor "cursor"
116: #define XtNcursorShape "cursorShape"
117: #define XtNgeometry "geometry"
118: #define XtNiconStartup "iconStartup"
119: #define XtNinternalBorder "internalBorder"
120: #define XtNjumpScroll "jumpScroll"
121: #define XtNlogFile "logFile"
122: #define XtNlogging "logging"
123: #define XtNlogInhibit "logInhibit"
124: #define XtNloginShell "loginShell"
125: #define XtNmarginBell "marginBell"
126: #define XtNmouse "mouse"
127: #define XtNmultiScroll "multiScroll"
128: #define XtNnMarginBell "nMarginBell"
129: #define XtNreverseWrap "reverseWrap"
130: #define XtNsaveLines "saveLines"
131: #define XtNscrollBar "scrollBar"
132: #define XtNscrollInput "scrollInput"
133: #define XtNscrollKey "scrollKey"
134: #define XtNsignalInhibit "signalInhibit"
135: #define XtNtekInhibit "tekInhibit"
136: #define XtNtekStartup "tekStartup"
137: #define XtNvisualBell "visualBell"
138:
139: #define XtCApp "App"
140: #define XtCC132 "C132"
141: #define XtCCurses "Curses"
142: #define XtCBitmapbits "Bitmapbits"
143: #define XtCGeometry "Geometry"
144: #define XtCIconstartup "Iconstartup"
145: #define XtCJumpscroll "Jumpscroll"
146: #define XtCLogfile "Logfile"
147: #define XtCLogging "Logging"
148: #define XtCLoginhibit "Loginhibit"
149: #define XtCLoginshell "Loginshell"
150: #define XtCMarginbell "Marginbell"
151: #define XtCMultiscroll "Multiscroll"
152: #define XtCColumn "Column"
153: #define XtCReverseVideo "ReverseVideo"
154: #define XtCReverseWrap "ReverseWrap"
155: #define XtCRows "Rows"
156: #define XtCScrollbar "ScrollBar"
157: #define XtCScrollcond "Scrollcond"
158: #define XtCSignalInibit "SignalInibit"
159: #define XtCTekInhibit "TekInhibit"
160: #define XtCTekStartup "TekStartup"
161: #define XtCVisualbell "Visualbell"
162:
163:
164: /* Defaults */
165: static Boolean defaultFALSE = FALSE;
166: static Boolean defaultTRUE = TRUE;
167: static char *defaultNULL = NULL;
168: static int defaultBorderWidth = DEFBORDERWIDTH;
169: static int defaultIntBorder = DEFBORDER;
170: static int defaultSaveLines = SAVELINES;
171: static int defaultNMarginBell = N_MARGINBELL;
172: static char *defaultFont = DEFFONT;
173: static char *defaultBoldFont = DEFBOLDFONT;
174:
175: /* term.screen.flags things that don't map directly from option */
176: static Boolean reverseWrap;
177: static Boolean logInhibit;
178: static Boolean signalInhibit;
179: static Boolean tekInhibit;
180:
181: /* term.screen.xxx things that don't map directly from option */
182: static Boolean scrollbar;
183:
184:
185: /*static*/ Resource resourceList[] = {
186: {XtNbackground, XtCColor, XrmRPixel, sizeof(Pixel),
187: (caddr_t) &term.screen.background, (caddr_t) &XtDefaultBGPixel},
188: {XtNforeground, XtCColor, XrmRPixel, sizeof(Pixel),
189: (caddr_t) &term.screen.foreground, (caddr_t) &XtDefaultFGPixel},
190: {XtNfont, XtCFont, XrmRString, sizeof(char *),
191: (caddr_t) &f_n, (caddr_t) &defaultNULL},
192: {XtNboldFont, XtCFont, XrmRString, sizeof(char *),
193: (caddr_t) &f_b, (caddr_t) &defaultNULL},
194: {XtNborder, XtCColor, XrmRPixel, sizeof(Pixel),
195: (caddr_t) &term.screen.bordercolor, (caddr_t) &XtDefaultFGPixel},
196: {XtNborderWidth,XtCBorderWidth, XrmRInt, sizeof(int),
197: (caddr_t) &term.screen.borderwidth, (caddr_t)&defaultBorderWidth},
198: {XtNc132, XtCC132, XrmRBoolean, sizeof(Boolean),
199: (caddr_t) &term.screen.c132, (caddr_t) &defaultFALSE},
200: {XtNcurses, XtCCurses, XrmRBoolean, sizeof(Boolean),
201: (caddr_t) &term.screen.curses, (caddr_t) &defaultFALSE},
202: {XtNcursor, XtCColor, XrmRPixel, sizeof(Pixel),
203: (caddr_t) &term.screen.cursorcolor,
204: (caddr_t) &term.screen.foreground},
205: {XtNcursorShape,XtCCursor, XrmRString, sizeof(char *),
206: (caddr_t) &curs_shape, (caddr_t) &defaultNULL},
207: {XtNgeometry,XtCGeometry, XrmRString, sizeof(char *),
208: (caddr_t) &geo_metry, (caddr_t) &defaultNULL},
209: {XtNiconStartup,XtCIconstartup, XrmRBoolean, sizeof(Boolean),
210: (caddr_t) &iconstartup, (caddr_t) &defaultFALSE},
211: {XtNinternalBorder,XtCBorderWidth,XrmRInt, sizeof(int),
212: (caddr_t) &term.screen.border, (caddr_t) &defaultIntBorder},
213: {XtNjumpScroll, XtCJumpscroll, XrmRBoolean, sizeof(Boolean),
214: (caddr_t) &term.screen.jumpscroll, (caddr_t) &defaultTRUE},
215: {XtNlogFile, XtCLogfile, XrmRString, sizeof(char *),
216: (caddr_t) &term.screen.logfile, (caddr_t) &defaultNULL},
217: {XtNlogging, XtCLogging, XrmRBoolean, sizeof(Boolean),
218: (caddr_t) &log_on, (caddr_t) &defaultFALSE},
219: {XtNlogInhibit, XtCLoginhibit, XrmRBoolean, sizeof(Boolean),
220: (caddr_t) &logInhibit, (caddr_t) &defaultFALSE},
221: {XtNloginShell, XtCLoginshell, XrmRBoolean, sizeof(Boolean),
222: (caddr_t) &login_shell, (caddr_t) &defaultFALSE},
223: {XtNmarginBell, XtCMarginbell, XrmRBoolean, sizeof(Boolean),
224: (caddr_t) &term.screen.marginbell, (caddr_t) &defaultFALSE},
225: {XtNmouse, XtCColor, XrmRPixel, sizeof(Pixel),
226: /* (caddr_t) &term.screen.mousecolor, (caddr_t) &XtDefaultFGPixel},
227: */
228: (caddr_t) &term.screen.mousecolor,
229: (caddr_t) &term.screen.cursorcolor},
230: {XtNmultiScroll,XtCMultiscroll, XrmRBoolean, sizeof(Boolean),
231: (caddr_t) &term.screen.multiscroll, (caddr_t) &defaultFALSE},
232: {XtNnMarginBell,XtCColumn, XrmRInt, sizeof(int),
233: (caddr_t) &term.screen.nmarginbell, (caddr_t) &defaultNMarginBell},
234: {XtNreverseVideo,XtCReverseVideo,XrmRBoolean, sizeof(Boolean),
235: (caddr_t) &re_verse, (caddr_t) &defaultFALSE},
236: {XtNreverseWrap,XtCReverseWrap, XrmRBoolean, sizeof(Boolean),
237: (caddr_t) &reverseWrap, (caddr_t) &defaultFALSE},
238: {XtNsaveLines, XtCRows, XrmRInt, sizeof(int),
239: (caddr_t) &save_lines, (caddr_t) &defaultSaveLines},
240: {XtNscrollBar, XtCScrollbar, XrmRBoolean, sizeof(Boolean),
241: (caddr_t) &scrollbar, (caddr_t) &defaultFALSE},
242: {XtNscrollInput,XtCScrollcond, XrmRBoolean, sizeof(Boolean),
243: (caddr_t) &term.screen.scrollinput, (caddr_t) &defaultTRUE},
244: {XtNscrollKey, XtCScrollcond, XrmRBoolean, sizeof(Boolean),
245: (caddr_t) &term.screen.scrollkey, (caddr_t) &defaultFALSE},
246: {XtNsignalInhibit,XtCSignalInibit,XrmRBoolean, sizeof(Boolean),
247: (caddr_t) &signalInhibit, (caddr_t) &defaultFALSE},
248: {XtNtekInhibit, XtCTekInhibit, XrmRBoolean, sizeof(Boolean),
249: (caddr_t) &tekInhibit, (caddr_t) &defaultFALSE},
250: {XtNtekStartup, XtCTekStartup, XrmRBoolean, sizeof(Boolean),
251: (caddr_t) &term.screen.TekEmu, (caddr_t) &defaultFALSE},
252: {XtNtitle, XtCString, XrmRString, sizeof(char *),
253: (caddr_t) &title_name, (caddr_t) &defaultNULL},
254: {XtNvisualBell,XtCVisualbell, XrmRBoolean, sizeof(Boolean),
255: (caddr_t) &term.screen.visualbell, (caddr_t) &defaultFALSE},
256: {XtNwindowName, XtCString, XrmRString, sizeof(char *),
257: (caddr_t) &window_name, (caddr_t) &defaultNULL},
258:
259: };
260:
261:
262: /* Command line options table. Only resources are entered here...there is a
263: pass over the remaining options after XtParseCommand is let loose. */
264:
265: static XrmOptionDescRec optionDescList[] = {
266: {"=", XtNgeometry, XrmoptionIsArg, (caddr_t) NULL},
267: {"-132", XtNc132, XrmoptionNoArg, (caddr_t) "on"},
268: {"+132", XtNc132, XrmoptionNoArg, (caddr_t) "off"},
269: {"-T", XtNtitle, XrmoptionSepArg, (caddr_t) NULL},
270: {"-b", XtNinternalBorder,XrmoptionSepArg, (caddr_t) NULL},
271: {"-bd", XtNborder, XrmoptionSepArg, (caddr_t) NULL},
272: {"-bg", XtNbackground, XrmoptionSepArg, (caddr_t) NULL},
273: {"-bw", XtNborderWidth, XrmoptionSepArg, (caddr_t) NULL},
274: {"-cr", XtNcursor, XrmoptionSepArg, (caddr_t) NULL},
275: {"-cu", XtNcurses, XrmoptionNoArg, (caddr_t) "on"},
276: {"+cu", XtNcurses, XrmoptionNoArg, (caddr_t) "off"},
277: {"-e", NULL, XrmoptionSkipLine, (caddr_t) NULL},
278: {"-fb", XtNboldFont, XrmoptionSepArg, (caddr_t) NULL},
279: {"-fg", XtNforeground, XrmoptionSepArg, (caddr_t) NULL},
280: {"-fn", XtNfont, XrmoptionSepArg, (caddr_t) NULL},
281: {"-i", XtNiconStartup, XrmoptionNoArg, (caddr_t) "on"},
282: {"-j", XtNjumpScroll, XrmoptionNoArg, (caddr_t) "on"},
283: {"+j", XtNjumpScroll, XrmoptionNoArg, (caddr_t) "off"},
284: {"-l", XtNlogging, XrmoptionNoArg, (caddr_t) "on"},
285: {"+l", XtNlogging, XrmoptionNoArg, (caddr_t) "off"},
286: {"-lf", XtNlogFile, XrmoptionSepArg, (caddr_t) NULL},
287: {"-ls", XtNloginShell, XrmoptionNoArg, (caddr_t) "on"},
288: {"+ls", XtNloginShell, XrmoptionNoArg, (caddr_t) "off"},
289: {"-mb", XtNmarginBell, XrmoptionNoArg, (caddr_t) "on"},
290: {"+mb", XtNmarginBell, XrmoptionNoArg, (caddr_t) "off"},
291: {"-ms", XtNmouse, XrmoptionSepArg, (caddr_t) NULL},
292: {"-n", XtNwindowName, XrmoptionSepArg, (caddr_t) NULL},
293: {"-nb", XtNnMarginBell, XrmoptionSepArg, (caddr_t) NULL},
294: {"-r", XtNreverseVideo,XrmoptionNoArg, (caddr_t) "on"},
295: {"+r", XtNreverseVideo,XrmoptionNoArg, (caddr_t) "off"},
296: {"-rv", XtNreverseVideo,XrmoptionNoArg, (caddr_t) "on"},
297: {"+rv", XtNreverseVideo,XrmoptionNoArg, (caddr_t) "off"},
298: {"-rw", XtNreverseWrap, XrmoptionNoArg, (caddr_t) "on"},
299: {"+rw", XtNreverseWrap, XrmoptionNoArg, (caddr_t) "off"},
300: {"-s", XtNmultiScroll, XrmoptionNoArg, (caddr_t) "on"},
301: {"+s", XtNmultiScroll, XrmoptionNoArg, (caddr_t) "off"},
302: {"-sb", XtNscrollBar, XrmoptionNoArg, (caddr_t) "on"},
303: {"+sb", XtNscrollBar, XrmoptionNoArg, (caddr_t) "off"},
304: {"-si", XtNscrollInput, XrmoptionNoArg, (caddr_t) "off"},
305: {"+si", XtNscrollInput, XrmoptionNoArg, (caddr_t) "on"},
306: {"-sk", XtNscrollKey, XrmoptionNoArg, (caddr_t) "on"},
307: {"+sk", XtNscrollKey, XrmoptionNoArg, (caddr_t) "off"},
308: {"-sl", XtNsaveLines, XrmoptionSepArg, (caddr_t) NULL},
309: {"-t", XtNtekStartup, XrmoptionNoArg, (caddr_t) "on"},
310: {"+t", XtNtekStartup, XrmoptionNoArg, (caddr_t) "off"},
311: {"-vb", XtNvisualBell, XrmoptionNoArg, (caddr_t) "on"},
312: {"+vb", XtNvisualBell, XrmoptionNoArg, (caddr_t) "off"},
313: {"-w", XtNborderWidth, XrmoptionSepArg, (caddr_t) NULL},
314: };
315:
316: void XtGetUsersDataBase()
317: {
318: XrmResourceDataBase resources, userResources;
319: int uid;
320: extern struct passwd *getpwuid();
321: struct passwd *pw;
322: char filename[1024];
323: FILE *f;
324:
325: strcpy(filename, LIBDIR);
326: strcat(filename, "/Xdefaults" );
327: f = fopen(filename, "r");
328: if (f) {
329: XrmGetDataBase(f, &resources);
330: fclose(f);
331: } else
332: resources = NULL;
333:
334: /* Open .Xdefaults file and merge into existing data base */
335: uid = getuid();
336: pw = getpwuid(uid);
337: if (pw) {
338: strcpy(filename, pw->pw_dir);
339: strcat(filename, "/.Xdefaults");
340: f = fopen(filename, "r");
341: if (f) {
342: XrmGetDataBase(f, &userResources);
343: if (resources)
344: XrmMergeDataBases(userResources, &resources);
345: else
346: resources = userResources;
347: fclose(f);
348: }
349: strcpy(filename, pw->pw_dir);
350: strcat(filename, "/.X11defaults");
351: f = fopen(filename, "r");
352: if (f) {
353: XrmGetDataBase(f, &userResources);
354: if (resources)
355: XrmMergeDataBases(userResources, &resources);
356: else
357: resources = userResources;
358: fclose(f);
359: }
360: }
361: if (resources) XrmSetCurrentDataBase(resources);
362: }
363:
364:
365: OpenDisplay()
366: {
367: register TScreen *screen = &term.screen;
368: register int try;
369: for (try = 10 ; ; ) {
370: if (screen->display = XOpenDisplay(display))
371: break;
372: if (!get_ty) {
373: fprintf(stderr, "%s: No such display server %s\n", xterm_name,
374: XDisplayName(display));
375: exit(ERROR_NOX);
376: }
377: if (--try <= 0) {
378: fprintf (stderr, "%s: Can't connect to display server %s\n",
379: xterm_name, XDisplayName(display));
380: exit (ERROR_NOX2);
381: }
382: sleep (5);
383: }
384:
385: if (screen->display->fd > 31) {
386: fprintf(stderr,
387: "%s: Display server returned bogus file descriptor %d\n",
388: xterm_name, screen->display->fd);
389: exit (ERROR_NOX3);
390: };
391: }
392:
393: /* ||| */
394: struct timeval startT, initT, endT;
395: struct timezone tz;
396:
397: main (argc, argv)
398: int argc;
399: char **argv;
400: {
401: register TScreen *screen = &term.screen;
402: register int i, pty;
403: int Xsocket, mode;
404: char *malloc();
405: char *basename();
406: int xerror(), xioerror();
407:
408: xterm_name = (XStrCmp(*argv, "-") == 0) ? "xterm" : basename(*argv);
409:
410: /* |||
411: gettimeofday(&startT, &tz);
412: */
413: /* Init the Toolkit. */
414: XtInitialize();
415: /* |||
416: gettimeofday(&initT, &tz);
417: */
418: /* Parse the command line for resources */
419: XtGetUsersDataBase();
420: XrmParseCommand(optionDescList, XtNumber(optionDescList), XtNxterm,
421: &argc, argv);
422:
423: /* Parse the rest of the command line */
424: display[0] = '\0';
425: for (argc--, argv++ ; argc > 0 ; argc--, argv++) {
426: if (**argv == '%') {
427: T_geometry = *argv;
428: *T_geometry = '=';
429: continue;
430: }
431:
432: if (**argv == '#') {
433: icon_geom = *argv;
434: *icon_geom = '=';
435: continue;
436: }
437:
438: if(index(*argv, ':') != NULL) {
439: strncpy(display, *argv, sizeof(display));
440: continue;
441: }
442:
443: if(!(i = (**argv == '-'))) Syntax (*argv);
444:
445: switch(argv[0][1]) {
446: #ifdef TIOCCONS
447: case 'C':
448: Console = TRUE;
449: continue;
450: #endif TIOCCONS
451: case 'L':
452: {
453: char tt[32];
454:
455: L_flag = 1;
456: get_ty = argv[--argc];
457: strcpy(tt,"/dev/");
458: strcat(tt, get_ty);
459: tt[5] = 'p';
460: loginpty = open( tt, O_RDWR, 0 );
461: dup2( loginpty, 4 );
462: close( loginpty );
463: loginpty = 4;
464: tt[5] = 't';
465: chown(tt, 0, 0);
466: chmod(tt, 0622);
467: if (open(tt, O_RDWR, 0) < 0) {
468: consolepr("open(%s) failed\n", tt);
469: }
470: signal(SIGHUP, SIG_IGN);
471: vhangup();
472: setpgrp(0,0);
473: signal(SIGHUP, SIG_DFL);
474: (void) close(0);
475: open(tt, O_RDWR, 0);
476: dup2(0, 1);
477: dup2(0, 2);
478: continue;
479: }
480: case 'S':
481: sscanf(*argv + 2, "%c%c%d", passedPty, passedPty+1,
482: &am_slave);
483: if (am_slave <= 0) Syntax(*argv);
484: continue;
485: #ifdef DEBUG
486: case 'D':
487: debug = TRUE;
488: continue;
489: #endif DEBUG
490: case 'e':
491: if (argc <= 1) Syntax (*argv);
492: command_to_exec = ++argv;
493: break;
494: default:
495: Syntax (*argv);
496: }
497: break;
498: }
499:
500:
501: /* Initialize the display connection */
502: OpenDisplay();
503: /* Get initial values from .Xdefaults file */
504: XtGetResources(
505: screen->display,
506: resourceList,
507: XtNumber(resourceList),
508: (ArgList) NULL,
509: 0,
510: DefaultRootWindow(screen->display),
511: XtNxterm,
512: XtCApp,
513: &nameList,
514: &classList);
515:
516: /* |||
517: gettimeofday(&endT, &tz);
518: printf("init: %8.3f, total: %8.3f\n",
519: ((initT.tv_sec*1000000.0+initT.tv_usec)
520: - (startT.tv_sec*1000000.0+startT.tv_usec))/1000000.0,
521: ((endT.tv_sec*1000000.0+endT.tv_usec)
522: - (startT.tv_sec*1000000.0+startT.tv_usec))/1000000.0);
523: exit(0);
524: */
525: /* Do additional processing on complex .Xdefaults stuff */
526:
527: if (!f_n) {
528: if (f_b)
529: f_n = f_b;
530: else {
531: f_n = defaultFont;
532: f_b = defaultBoldFont;
533: }
534: }
535:
536: term.flags = WRAPAROUND | AUTOREPEAT;
537: if (!screen->jumpscroll) term.flags |= SMOOTHSCROLL;
538: if (reverseWrap) term.flags |= REVERSEWRAP;
539:
540: inhibit = 0;
541: if (logInhibit) inhibit |= I_LOG;
542: if (signalInhibit) inhibit |= I_SIGNAL;
543: if (tekInhibit) inhibit |= I_TEK;
544:
545: if (scrollbar) screen->scrollbar = SCROLLBARWIDTH;
546:
547: screen->color = 0;
548: if (screen->foreground != XtDefaultFGPixel)
549: screen->color |= C_FOREGROUND;
550: if (screen->background != XtDefaultBGPixel) {
551: screen->color |= C_BACKGROUND;
552: }
553: if (screen->cursorcolor != XtDefaultFGPixel)
554: screen->color |= C_CURSOR;
555: if (screen->mousecolor != XtDefaultFGPixel)
556: screen->color |= C_MOUSE;
557:
558: term.initflags = term.flags;
559:
560: if(!window_name)
561: window_name = (get_ty ? "login" : (am_slave ? "xterm slave" :
562: (command_to_exec ? basename(command_to_exec[0]) :
563: xterm_name)));
564: if (!title_name)
565: title_name = window_name;
566: if(inhibit & I_TEK)
567: screen->TekEmu = FALSE;
568:
569: /* set up stderr properly */
570: i = -1;
571: #ifdef DEBUG
572: if(debug)
573: i = open ("xterm.debug.log", O_WRONLY | O_CREAT | O_TRUNC,
574: 0666);
575: else
576: #endif DEBUG
577: if(get_ty)
578: i = open("/dev/console", O_WRONLY, 0);
579: if(i >= 0)
580: fileno(stderr) = i;
581: if(fileno(stderr) != (NOFILE - 1)) {
582: dup2(fileno(stderr), (NOFILE - 1));
583: if(fileno(stderr) >= 3)
584: close(fileno(stderr));
585: fileno(stderr) = (NOFILE - 1);
586: }
587:
588: signal (SIGCHLD, reapchild);
589:
590: /* open a terminal for client */
591: get_terminal ();
592: spawn ();
593:
594: Xsocket = screen->display->fd;
595: pty = screen->respond;
596:
597: if (am_slave) { /* Write window id so master end can read and use */
598: write(pty, screen->TekEmu ? (char *)&TWindow(screen) :
599: (char *)&VWindow(screen), sizeof(Window));
600: write(pty, "\n", 1);
601: }
602:
603: if(log_on) {
604: log_on = FALSE;
605: StartLog(screen);
606: }
607: screen->inhibit = inhibit;
608: mode = 1;
609: if (ioctl (pty, FIONBIO, (char *)&mode) == -1) SysError (ERROR_FIONBIO);
610:
611: pty_mask = 1 << pty;
612: X_mask = 1 << Xsocket;
613: Select_mask = pty_mask | X_mask;
614: max_plus1 = (pty < Xsocket) ? (1 + Xsocket) : (1 + pty);
615:
616: #ifdef DEBUG
617: if (debug) printf ("debugging on\n");
618: #endif DEBUG
619: XSetErrorHandler(xerror);
620: XSetIOErrorHandler(xioerror);
621: for( ; ; )
622: if(screen->TekEmu)
623: TekRun();
624: else
625: VTRun();
626: }
627:
628: char *basename(name)
629: char *name;
630: {
631: register char *cp;
632: char *rindex();
633:
634: return((cp = rindex(name, '/')) ? cp + 1 : name);
635: }
636:
637: static char *ustring[] = {
638: "Usage: xterm [-132] [-b inner_border_width] [-bd border_color] \\\n",
639: #ifdef TIOCCONS
640: " [-bg backgrnd_color] [-bw border_width] [-C] [-cr cursor_color] [-cu] \\\n",
641: #else TIOCCONS
642: " [-bg backgrnd_color] [-bw border_width] [-cr cursor_color] [-cu] \\\n",
643: #endif TIOCCONS
644: " [-fb bold_font] [-fg foregrnd_color] [-fn norm_font] \\\n",
645: " [-i] [-j] [-l] [-lf logfile] [-ls] [-mb] [-ms mouse_color] \\\n",
646: " [-n name] [-nb bell_margin] [-rv] [-rw] [-s] \\\n",
647: " [-sb] [-si] [-sk] [-sl save_lines] [-sn] [-st] [-T title] [-t] [-tb] \\\n",
648: " [-vb] [=[width]x[height][[+-]xoff[[+-]yoff]]] \\\n",
649: " [%[width]x[height][[+-]xoff[[+-]yoff]]] [#[+-]xoff[[+-]yoff]] \\\n",
650: " [-e command_to_exec]\n\n",
651: "Fonts must be of fixed width and of same size;\n",
652: "If only one font is specified, it will be used for normal and bold text\n",
653: "The -132 option allows 80 <-> 132 column escape sequences\n",
654: #ifdef TIOCCONS
655: "The -C option forces output to /dev/console to appear in this window\n",
656: #endif TIOCCONS
657: "The -cu option turns a curses bug fix on\n",
658: "The -i option enables iconic startup\n",
659: "The -j option enables jump scroll\n",
660: "The -l option enables logging\n",
661: "The -ls option makes the shell a login shell\n",
662: "The -mb option turns the margin bell on\n",
663: "The -rv option turns reverse video on\n",
664: "The -rw option turns reverse wraparound on\n",
665: "The -s option enables asynchronous scrolling\n",
666: "The -sb option enables the scrollbar\n",
667: "The -si option disables re-positioning the scrollbar at the bottom on input\n",
668: "The -sk option causes the scrollbar to position at the bottom on a key\n",
669: "The -t option starts Tektronix mode\n",
670: "The -vb option enables visual bell\n",
671: 0
672: };
673:
674: Syntax (badOption)
675: char *badOption;
676: {
677: register char **us = ustring;
678:
679: fprintf(stderr, "Unknown option \"%s\"\n\n", badOption);
680: while (*us) fputs(*us++, stderr);
681: exit (1);
682: }
683:
684: get_pty (pty, tty)
685: /*
686: opens a pty, storing fildes in pty and tty.
687: */
688: int *pty, *tty;
689: {
690: int devindex, letter = 0;
691:
692: while (letter < 11) {
693: ttydev [8] = ptydev [8] = "pqrstuvwxyz" [letter++];
694: devindex = 0;
695:
696: while (devindex < 16) {
697: ttydev [9] = ptydev [9] = "0123456789abcdef" [devindex++];
698: if ((*pty = open (ptydev, O_RDWR)) < 0)
699: continue;
700: if ((*tty = open (ttydev, O_RDWR)) < 0) {
701: close(*pty);
702: continue;
703: }
704: return;
705: }
706: }
707:
708: fprintf (stderr, "%s: Not enough available pty's\n", xterm_name);
709: exit (ERROR_PTYS);
710: }
711:
712: get_terminal ()
713: /*
714: * sets up X and initializes the terminal structure except for term.buf.fildes.
715: */
716: {
717: register TScreen *screen = &term.screen;
718: char *malloc();
719:
720: screen->graybordertile = make_gray(screen->bordercolor,
721: screen->background,
722: DefaultDepth(screen->display, DefaultScreen(screen->display)));
723:
724: screen->arrow = make_arrow(screen->mousecolor, screen->background);
725:
726: XAutoRepeatOn(screen->display);
727:
728: if((screen->iconname = malloc((unsigned) strlen(window_name) + 10)) == NULL)
729: Error(ERROR_WINNAME);
730: strcpy(screen->iconname, window_name);
731: screen->iconnamelen = strlen(screen->iconname);
732: if((screen->titlename = malloc((unsigned) strlen(title_name) + 10)) == NULL)
733: Error(ERROR_WINNAME);
734: strcpy(screen->titlename, title_name);
735: screen->titlenamelen = strlen(screen->titlename);
736:
737: }
738:
739: static char *tekterm[] = {
740: "tek4015",
741: "tek4014",
742: "tek4013",
743: "tek4010",
744: "dumb",
745: 0
746: };
747:
748: static char *vtterm[] = {
749: "xterm",
750: "vt102",
751: "vt100",
752: "ansi",
753: "dumb",
754: 0
755: };
756:
757: hungtty()
758: {
759: longjmp(env, 1);
760: }
761:
762: spawn ()
763: /*
764: * Inits pty and tty and forks a login process.
765: * Does not close fd Xsocket.
766: * If getty, execs getty rather than csh and uses std fd's rather
767: * than opening a pty/tty pair.
768: * If slave, the pty named in passedPty is already open for use
769: */
770: {
771: register TScreen *screen = &term.screen;
772: int Xsocket = screen->display->fd;
773: int index1, tty = -1;
774: int discipline;
775: unsigned lmode;
776: struct tchars tc;
777: struct ltchars ltc;
778: struct sgttyb sg;
779:
780: char termcap [1024];
781: char newtc [1024];
782: char *ptr, *shname;
783: int i, no_dev_tty = FALSE;
784: char **envnew; /* new environment */
785: char buf[32];
786: char *TermName = NULL;
787: int ldisc = 0;
788: #ifdef sun
789: #ifdef TIOCSSIZE
790: struct ttysize ts;
791: #endif TIOCSSIZE
792: #else sun
793: #ifdef TIOCSWINSZ
794: struct winsize ws;
795: #endif TIOCSWINSZ
796: #endif sun
797: struct passwd *pw = NULL;
798: #ifdef UTMP
799: struct utmp utmp;
800: #endif UTMP
801: extern int Exit();
802: char *getenv();
803: char *index (), *rindex (), *strindex ();
804:
805: screen->uid = getuid();
806: screen->gid = getgid();
807:
808: /* so that TIOCSWINSZ || TIOCSIZE doesn't block */
809: signal(SIGTTOU,SIG_IGN);
810: if(!(screen->TekEmu ? TekInit() : VTInit()))
811: exit(ERROR_INIT);
812:
813: if(screen->TekEmu) {
814: envnew = tekterm;
815: ptr = newtc;
816: } else {
817: envnew = vtterm;
818: ptr = termcap;
819: }
820: while(*envnew) {
821: if(tgetent(ptr, *envnew) == 1) {
822: TermName = *envnew;
823: if(!screen->TekEmu)
824: resize(screen, TermName, termcap, newtc);
825: break;
826: }
827: envnew++;
828: }
829:
830: if (get_ty) {
831: screen->respond = loginpty;
832: if((tslot = ttyslot()) <= 0)
833: SysError(ERROR_TSLOT);
834: } else if (am_slave) {
835: screen->respond = am_slave;
836: ptydev[8] = ttydev[8] = passedPty[0];
837: ptydev[9] = ttydev[9] = passedPty[1];
838: if((tslot = ttyslot()) <= 0)
839: SysError(ERROR_TSLOT2);
840: setgid (screen->gid);
841: setuid (screen->uid);
842: } else {
843: /*
844: * Sometimes /dev/tty hangs on open (as in the case of a pty
845: * that has gone away). Simply make up some reasonable
846: * defaults.
847: */
848: signal(SIGALRM, hungtty);
849: alarm(1);
850: if (! setjmp(env)) {
851: tty = open ("/dev/tty", O_RDWR, 0);
852: alarm(0);
853: } else {
854: tty = -1;
855: errno = ENXIO;
856: }
857: signal(SIGALRM, SIG_DFL);
858:
859: if (tty < 0) {
860: if (errno != ENXIO) SysError(ERROR_OPDEVTTY);
861: else {
862: no_dev_tty = TRUE;
863: sg = d_sg;
864: tc = d_tc;
865: discipline = d_disipline;
866: ltc = d_ltc;
867: lmode = d_lmode;
868: }
869: } else {
870: /* get a copy of the current terminal's state */
871:
872: if(ioctl(tty, TIOCGETP, (char *)&sg) == -1)
873: SysError (ERROR_TIOCGETP);
874: if(ioctl(tty, TIOCGETC, (char *)&tc) == -1)
875: SysError (ERROR_TIOCGETC);
876: if(ioctl(tty, TIOCGETD, (char *)&discipline) == -1)
877: SysError (ERROR_TIOCGETD);
878: if(ioctl(tty, TIOCGLTC, (char *)<c) == -1)
879: SysError (ERROR_TIOCGLTC);
880: if(ioctl(tty, TIOCLGET, (char *)&lmode) == -1)
881: SysError (ERROR_TIOCLGET);
882: close (tty);
883:
884: /* close all std file descriptors */
885: for (index1 = 0; index1 < 3; index1++)
886: close (index1);
887: if ((tty = open ("/dev/tty", O_RDWR, 0)) < 0)
888: SysError (ERROR_OPDEVTTY2);
889:
890: if (ioctl (tty, TIOCNOTTY, (char *) NULL) == -1)
891: SysError (ERROR_NOTTY);
892: close (tty);
893: }
894:
895: get_pty (&screen->respond, &tty);
896:
897: if (screen->respond != Xsocket + 1) {
898: dup2 (screen->respond, Xsocket + 1);
899: close (screen->respond);
900: screen->respond = Xsocket + 1;
901: }
902:
903: /* change ownership of tty to real group and user id */
904: chown (ttydev, screen->uid, screen->gid);
905:
906: /* change protection of tty */
907: chmod (ttydev, 0622);
908:
909: if (tty != Xsocket + 2) {
910: dup2 (tty, Xsocket + 2);
911: close (tty);
912: tty = Xsocket + 2;
913: }
914:
915: /* set the new terminal's state to be the old one's
916: with minor modifications for efficiency */
917:
918: sg.sg_flags &= ~(ALLDELAY | XTABS | CBREAK | RAW);
919: sg.sg_flags |= ECHO | CRMOD;
920: /* make sure speed is set on pty so that editors work right*/
921: sg.sg_ispeed = B9600;
922: sg.sg_ospeed = B9600;
923: /* reset t_brkc to default value */
924: tc.t_brkc = -1;
925:
926: if (ioctl (tty, TIOCSETP, (char *)&sg) == -1)
927: SysError (ERROR_TIOCSETP);
928: if (ioctl (tty, TIOCSETC, (char *)&tc) == -1)
929: SysError (ERROR_TIOCSETC);
930: if (ioctl (tty, TIOCSETD, (char *)&discipline) == -1)
931: SysError (ERROR_TIOCSETD);
932: if (ioctl (tty, TIOCSLTC, (char *)<c) == -1)
933: SysError (ERROR_TIOCSLTC);
934: if (ioctl (tty, TIOCLSET, (char *)&lmode) == -1)
935: SysError (ERROR_TIOCLSET);
936: #ifdef TIOCCONS
937: if (Console) {
938: int on = 1;
939: if (ioctl (tty, TIOCCONS, (char *)&on) == -1)
940: SysError(ERROR_TIOCCONS);
941: }
942: #endif TIOCCONS
943:
944: close (open ("/dev/null", O_RDWR, 0));
945:
946: for (index1 = 0; index1 < 3; index1++)
947: dup2 (tty, index1);
948: if((tslot = ttyslot()) <= 0)
949: SysError(ERROR_TSLOT3);
950: #ifdef UTMP
951: if((pw = getpwuid(screen->uid)) &&
952: (i = open(etc_utmp, O_WRONLY)) >= 0) {
953: bzero((char *)&utmp, sizeof(struct utmp));
954: (void) strcpy(utmp.ut_line, &ttydev[5]);
955: (void) strcpy(utmp.ut_name, pw->pw_name);
956: (void) strcpy(utmp.ut_host, XDisplayName(display));
957: time(&utmp.ut_time);
958: lseek(i, (long)(tslot * sizeof(struct utmp)), 0);
959: write(i, (char *)&utmp, sizeof(struct utmp));
960: close(i);
961: } else
962: tslot = -tslot;
963: #endif UTMP
964: }
965:
966: #ifdef sun
967: #ifdef TIOCSSIZE
968: /* tell tty how big window is */
969: if(screen->TekEmu) {
970: ts.ts_lines = 38;
971: ts.ts_cols = 81;
972: } else {
973: ts.ts_lines = screen->max_row + 1;
974: ts.ts_cols = screen->max_col + 1;
975: }
976: ioctl (screen->respond, TIOCSSIZE, &ts);
977: #endif TIOCSSIZE
978: #else sun
979: #ifdef TIOCSWINSZ
980: /* tell tty how big window is */
981: if(screen->TekEmu) {
982: ws.ws_row = 38;
983: ws.ws_col = 81;
984: ws.ws_xpixel = TFullWidth(screen);
985: ws.ws_ypixel = TFullHeight(screen);
986: } else {
987: ws.ws_row = screen->max_row + 1;
988: ws.ws_col = screen->max_col + 1;
989: ws.ws_xpixel = FullWidth(screen);
990: ws.ws_ypixel = FullHeight(screen);
991: }
992: ioctl (screen->respond, TIOCSWINSZ, (char *)&ws);
993: #endif TIOCSWINSZ
994: #endif sun
995:
996: if (!am_slave) {
997: if ((screen->pid = fork ()) == -1)
998: SysError (ERROR_FORK);
999:
1000: if (screen->pid == 0) {
1001: extern char **environ;
1002: int pgrp = getpid();
1003:
1004: close (Xsocket);
1005: close (screen->respond);
1006: if(fileno(stderr) >= 3)
1007: close (fileno(stderr));
1008:
1009: if (tty >= 0) close (tty);
1010:
1011: signal (SIGCHLD, SIG_DFL);
1012: signal (SIGHUP, SIG_IGN);
1013:
1014: /* copy the environment before Setenving */
1015: for (i = 0 ; environ [i] != NULL ; i++) ;
1016: /*
1017: * The `4' is the number of Setenv() calls which may add
1018: * a new entry to the environment. The `1' is for the
1019: * NULL terminating entry.
1020: */
1021: envnew = (char **) calloc ((unsigned) i + (4 + 1), sizeof(char *));
1022: bcopy((char *)environ, (char *)envnew, i * sizeof(char *));
1023: environ = envnew;
1024: Setenv ("TERM=", TermName);
1025: if(!TermName)
1026: *newtc = 0;
1027: Setenv ("TERMCAP=", newtc);
1028: sprintf(buf, "%d", screen->TekEmu ? (int)TWindow(screen) :
1029: (int)VWindow(screen));
1030: Setenv ("WINDOWID=", buf);
1031: /* put the display into the environment of the shell*/
1032: if (display[0] != '\0')
1033: Setenv ("DISPLAY=", XDisplayName(display));
1034:
1035: signal(SIGTERM, SIG_DFL);
1036: ioctl(0, TIOCSPGRP, (char *)&pgrp);
1037: setpgrp (0, 0);
1038: close(open(ttyname(0), O_WRONLY, 0));
1039: setpgrp (0, pgrp);
1040:
1041: setgid (screen->gid);
1042: setuid (screen->uid);
1043:
1044: if (command_to_exec) {
1045: execvp(*command_to_exec, command_to_exec);
1046: /* print error message on screen */
1047: fprintf(stderr, "%s: Can't execvp %s\n", xterm_name,
1048: *command_to_exec);
1049: }
1050: signal(SIGHUP, SIG_IGN);
1051: if (get_ty) {
1052: ioctl (0, TIOCNOTTY, (char *) NULL);
1053: execl ("/etc/getty", "+", "Xwindow", get_ty, 0);
1054: }
1055: signal(SIGHUP, SIG_DFL);
1056:
1057: #ifdef UTMP
1058: if(((ptr = getenv("SHELL")) == NULL || *ptr == 0) &&
1059: ((pw == NULL && (pw = getpwuid(screen->uid)) == NULL) ||
1060: *(ptr = pw->pw_shell) == 0))
1061: #else UTMP
1062: if(((ptr = getenv("SHELL")) == NULL || *ptr == 0) &&
1063: ((pw = getpwuid(screen->uid)) == NULL ||
1064: *(ptr = pw->pw_shell) == 0))
1065: #endif UTMP
1066: ptr = "/bin/sh";
1067: if(shname = rindex(ptr, '/'))
1068: shname++;
1069: else
1070: shname = ptr;
1071: ldisc = XStrCmp("csh", shname + strlen(shname) - 3) == 0 ?
1072: NTTYDISC : 0;
1073: ioctl(0, TIOCSETD, (char *)&ldisc);
1074: execl (ptr, login_shell ? "-" : shname, 0);
1075: fprintf (stderr, "%s: Could not exec %s!\n", xterm_name, ptr);
1076: sleep(5);
1077: exit(ERROR_EXEC);
1078: }
1079: }
1080:
1081: if(tty >= 0) close (tty);
1082: signal(SIGHUP,SIG_IGN);
1083:
1084: if (!no_dev_tty) {
1085: if ((tty = open ("/dev/tty", O_RDWR, 0)) < 0)
1086: SysError(ERROR_OPDEVTTY3);
1087: for (index1 = 0; index1 < 3; index1++)
1088: dup2 (tty, index1);
1089: if (tty > 2) close (tty);
1090: }
1091:
1092: signal(SIGINT, Exit);
1093: signal(SIGQUIT, Exit);
1094: signal(SIGTERM, Exit);
1095: }
1096:
1097: Exit(n)
1098: int n;
1099: {
1100: register TScreen *screen = &term.screen;
1101: int pty = term.screen.respond; /* file descriptor of pty */
1102: #ifdef UTMP
1103: register int i;
1104: struct utmp utmp;
1105:
1106: if(!am_slave && tslot > 0 && (i = open(etc_utmp, O_WRONLY)) >= 0) {
1107: bzero((char *)&utmp, sizeof(struct utmp));
1108: lseek(i, (long)(tslot * sizeof(struct utmp)), 0);
1109: write(i, (char *)&utmp, sizeof(struct utmp));
1110: close(i);
1111: }
1112: #endif UTMP
1113: close(pty); /* close explicitly to avoid race with slave side */
1114: if(screen->logging)
1115: CloseLog(screen);
1116:
1117: if(!get_ty && !am_slave) {
1118: /* restore ownership of tty */
1119: chown (ttydev, 0, 0);
1120:
1121: /* restore modes of tty */
1122: chmod (ttydev, 0666);
1123: }
1124: exit(n);
1125: }
1126:
1127: resize(screen, TermName, oldtc, newtc)
1128: TScreen *screen;
1129: char *TermName;
1130: register char *oldtc, *newtc;
1131: {
1132: register char *ptr1, *ptr2;
1133: register int i;
1134: register int li_first = 0;
1135: register char *temp;
1136: char *index(), *strindex();
1137:
1138: if ((ptr1 = strindex (oldtc, "co#")) == NULL){
1139: fprintf(stderr, "%s: Can't find co# in termcap string %s\n",
1140: xterm_name, TermName);
1141: exit (ERROR_NOCO);
1142: }
1143: if ((ptr2 = strindex (oldtc, "li#")) == NULL){
1144: fprintf(stderr, "%s: Can't find li# in termcap string %s\n",
1145: xterm_name, TermName);
1146: exit (ERROR_NOLI);
1147: }
1148: if(ptr1 > ptr2) {
1149: li_first++;
1150: temp = ptr1;
1151: ptr1 = ptr2;
1152: ptr2 = temp;
1153: }
1154: ptr1 += 3;
1155: ptr2 += 3;
1156: strncpy (newtc, oldtc, i = ptr1 - oldtc);
1157: newtc += i;
1158: sprintf (newtc, "%d", li_first ? screen->max_row + 1 :
1159: screen->max_col + 1);
1160: newtc += strlen(newtc);
1161: ptr1 = index (ptr1, ':');
1162: strncpy (newtc, ptr1, i = ptr2 - ptr1);
1163: newtc += i;
1164: sprintf (newtc, "%d", li_first ? screen->max_col + 1 :
1165: screen->max_row + 1);
1166: ptr2 = index (ptr2, ':');
1167: strcat (newtc, ptr2);
1168: }
1169:
1170: static reapchild ()
1171: {
1172: union wait status;
1173: register int pid;
1174:
1175: #ifdef DEBUG
1176: if (debug) fputs ("Exiting\n", stderr);
1177: #endif DEBUG
1178: pid = wait3 (&status, WNOHANG, (struct rusage *)NULL);
1179: if (!pid) return;
1180: if (pid != term.screen.pid) return;
1181:
1182: Cleanup(0);
1183: }
1184:
1185: /* VARARGS1 */
1186: consolepr(fmt,x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)
1187: char *fmt;
1188: {
1189: extern int errno;
1190: extern char *sys_errlist[];
1191: int oerrno;
1192: int f;
1193: char buf[ BUFSIZ ];
1194:
1195: oerrno = errno;
1196: strcpy(buf, "xterm: ");
1197: sprintf(buf+strlen(buf), fmt, x0,x1,x2,x3,x4,x5,x6,x7,x8,x9);
1198: strcat(buf, ": ");
1199: strcat(buf, sys_errlist[oerrno]);
1200: strcat(buf, "\n");
1201: f = open("/dev/console",O_WRONLY);
1202: write(f, buf, strlen(buf));
1203: close(f);
1204: if ((f = open("/dev/tty", 2)) >= 0) {
1205: ioctl(f, TIOCNOTTY, (char *)NULL);
1206: close(f);
1207: }
1208: }
1209:
1210: checklogin()
1211: {
1212: register int ts, i;
1213: register struct passwd *pw;
1214: struct utmp utmp;
1215:
1216: ts = tslot > 0 ? tslot : -tslot;
1217: if((i = open(etc_utmp, O_RDONLY)) < 0)
1218: return(FALSE);
1219: lseek(i, (long)(ts * sizeof(struct utmp)), 0);
1220: ts = read(i, (char *)&utmp, sizeof(utmp));
1221: close(i);
1222: if(ts != sizeof(utmp) || XStrCmp(get_ty, utmp.ut_line) != 0 ||
1223: !*utmp.ut_name || (pw = getpwnam(utmp.ut_name)) == NULL)
1224: return(FALSE);
1225: chdir(pw->pw_dir);
1226: setgid(pw->pw_gid);
1227: setuid(pw->pw_uid);
1228: L_flag = 0;
1229: return(TRUE);
1230: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.