1 /*- 2 * Copyright (c) 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * Copyright (c) 1993, 1994, 1995, 1996 5 * Keith Bostic. All rights reserved. 6 * 7 * See the LICENSE file for redistribution information. 8 */ 9 10 #include "config.h" 11 12 #ifndef lint 13 static const char sccsid[] = "@(#)cl_main.c 10.36 (Berkeley) 10/14/96"; 14 #endif /* not lint */ 15 16 #include <sys/types.h> 17 #include <sys/queue.h> 18 19 #include <bitstring.h> 20 #include <curses.h> 21 #include <errno.h> 22 #include <fcntl.h> 23 #include <signal.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <termios.h> 28 #include <unistd.h> 29 30 #include "../common/common.h" 31 #ifdef RUNNING_IP 32 #include "../ip/ip.h" 33 #endif 34 #include "cl.h" 35 #include "pathnames.h" 36 37 GS *__global_list; /* GLOBAL: List of screens. */ 38 sigset_t __sigblockset; /* GLOBAL: Blocked signals. */ 39 40 static void cl_func_std __P((GS *)); 41 static CL_PRIVATE *cl_init __P((GS *)); 42 static GS *gs_init __P((char *)); 43 static void perr __P((char *, char *)); 44 static int setsig __P((int, struct sigaction *, void (*)(int))); 45 static void sig_end __P((GS *)); 46 static void term_init __P((char *, char *)); 47 48 /* 49 * main -- 50 * This is the main loop for the standalone curses editor. 51 */ 52 int 53 main(argc, argv) 54 int argc; 55 char *argv[]; 56 { 57 static int reenter; 58 CL_PRIVATE *clp; 59 GS *gp; 60 size_t rows, cols; 61 int rval; 62 char *ip_arg, **p_av, **t_av, *ttype; 63 64 /* If loaded at 0 and jumping through a NULL pointer, stop. */ 65 if (reenter++) 66 abort(); 67 68 /* Create and initialize the global structure. */ 69 __global_list = gp = gs_init(argv[0]); 70 71 /* 72 * Strip out any arguments that vi isn't going to understand. There's 73 * no way to portably call getopt twice, so arguments parsed here must 74 * be removed from the argument list. 75 */ 76 #ifdef RUNNING_IP 77 ip_arg = NULL; 78 for (p_av = t_av = argv;;) { 79 if (*t_av == NULL) { 80 *p_av = NULL; 81 break; 82 } 83 if (!strcmp(*t_av, "--")) { 84 while ((*p_av++ = *t_av++) != NULL); 85 break; 86 } 87 if (!memcmp(*t_av, "-I", sizeof("-I") - 1)) { 88 if (t_av[0][2] != '\0') { 89 ip_arg = t_av[0] + 2; 90 ++t_av; 91 --argc; 92 continue; 93 } 94 if (t_av[1] != NULL) { 95 ip_arg = t_av[1]; 96 t_av += 2; 97 argc -= 2; 98 continue; 99 } 100 } 101 *p_av++ = *t_av++; 102 } 103 104 /* 105 * If we're being called as an editor library, we're done here, we 106 * get loaded with the curses screen, we don't share much code. 107 */ 108 if (ip_arg != NULL) 109 exit (ip_main(argc, argv, gp, ip_arg)); 110 #else 111 ip_arg = argv[0]; 112 #endif 113 114 /* Create and initialize the CL_PRIVATE structure. */ 115 clp = cl_init(gp); 116 117 /* 118 * Initialize the terminal information. 119 * 120 * We have to know what terminal it is from the start, since we may 121 * have to use termcap/terminfo to find out how big the screen is. 122 */ 123 if ((ttype = getenv("TERM")) == NULL) 124 ttype = "unknown"; 125 term_init(gp->progname, ttype); 126 127 /* Add the terminal type to the global structure. */ 128 if ((OG_D_STR(gp, GO_TERM) = 129 OG_STR(gp, GO_TERM) = strdup(ttype)) == NULL) 130 perr(gp->progname, NULL); 131 132 /* Figure out how big the screen is. */ 133 if (cl_ssize(NULL, 0, &rows, &cols, NULL)) 134 exit (1); 135 136 /* Add the rows and columns to the global structure. */ 137 OG_VAL(gp, GO_LINES) = OG_D_VAL(gp, GO_LINES) = rows; 138 OG_VAL(gp, GO_COLUMNS) = OG_D_VAL(gp, GO_COLUMNS) = cols; 139 140 /* Ex wants stdout to be buffered. */ 141 (void)setvbuf(stdout, NULL, _IOFBF, 0); 142 143 /* Start catching signals. */ 144 if (sig_init(gp, NULL)) 145 exit (1); 146 147 /* Run ex/vi. */ 148 rval = editor(gp, argc, argv); 149 150 /* Clean up signals. */ 151 sig_end(gp); 152 153 /* Clean up the terminal. */ 154 (void)cl_quit(gp); 155 156 /* 157 * XXX 158 * Reset the O_MESG option. 159 */ 160 if (clp->tgw != TGW_UNKNOWN) 161 (void)cl_omesg(NULL, clp, clp->tgw == TGW_SET); 162 163 /* 164 * XXX 165 * Reset the X11 xterm icon/window name. 166 */ 167 if (F_ISSET(clp, CL_RENAME)) { 168 (void)printf(XTERM_RENAME, ttype); 169 (void)fflush(stdout); 170 } 171 172 /* If a killer signal arrived, pretend we just got it. */ 173 if (clp->killersig) { 174 (void)signal(clp->killersig, SIG_DFL); 175 (void)kill(getpid(), clp->killersig); 176 /* NOTREACHED */ 177 } 178 179 /* Free the global and CL private areas. */ 180 #if defined(DEBUG) || defined(PURIFY) || defined(LIBRARY) 181 free(clp); 182 free(gp); 183 #endif 184 185 exit (rval); 186 } 187 188 /* 189 * gs_init -- 190 * Create and partially initialize the GS structure. 191 */ 192 static GS * 193 gs_init(name) 194 char *name; 195 { 196 CL_PRIVATE *clp; 197 GS *gp; 198 char *p; 199 200 /* Figure out what our name is. */ 201 if ((p = strrchr(name, '/')) != NULL) 202 name = p + 1; 203 204 /* Allocate the global structure. */ 205 CALLOC_NOMSG(NULL, gp, GS *, 1, sizeof(GS)); 206 if (gp == NULL) 207 perr(name, NULL); 208 209 210 gp->progname = name; 211 return (gp); 212 } 213 214 /* 215 * cl_init -- 216 * Create and partially initialize the CL structure. 217 */ 218 static CL_PRIVATE * 219 cl_init(gp) 220 GS *gp; 221 { 222 CL_PRIVATE *clp; 223 int fd; 224 225 /* Allocate the CL private structure. */ 226 CALLOC_NOMSG(NULL, clp, CL_PRIVATE *, 1, sizeof(CL_PRIVATE)); 227 if (clp == NULL) 228 perr(gp->progname, NULL); 229 gp->cl_private = clp; 230 231 /* 232 * Set the CL_STDIN_TTY flag. It's purpose is to avoid setting 233 * and resetting the tty if the input isn't from there. We also 234 * use the same test to determine if we're running a script or 235 * not. 236 */ 237 if (isatty(STDIN_FILENO)) 238 F_SET(clp, CL_STDIN_TTY); 239 else 240 F_SET(gp, G_SCRIPTED); 241 242 /* 243 * We expect that if we've lost our controlling terminal that the 244 * open() (but not the tcgetattr()) will fail. 245 */ 246 if (F_ISSET(clp, CL_STDIN_TTY)) { 247 if (tcgetattr(STDIN_FILENO, &clp->orig) == -1) 248 goto tcfail; 249 } else if ((fd = open(_PATH_TTY, O_RDONLY, 0)) != -1) { 250 if (tcgetattr(fd, &clp->orig) == -1) { 251 tcfail: perr(gp->progname, "tcgetattr"); 252 exit (1); 253 } 254 (void)close(fd); 255 } 256 257 /* Initialize the list of curses functions. */ 258 cl_func_std(gp); 259 260 return (clp); 261 } 262 263 /* 264 * term_init -- 265 * Initialize terminal information. 266 */ 267 static void 268 term_init(name, ttype) 269 char *name, *ttype; 270 { 271 int err; 272 273 /* Set up the terminal database information. */ 274 setupterm(ttype, STDOUT_FILENO, &err); 275 switch (err) { 276 case -1: 277 (void)fprintf(stderr, 278 "%s: No terminal database found\n", name); 279 exit (1); 280 case 0: 281 (void)fprintf(stderr, 282 "%s: %s: unknown terminal type\n", name, ttype); 283 exit (1); 284 } 285 } 286 287 #define GLOBAL_CLP \ 288 CL_PRIVATE *clp = GCLP(__global_list); 289 static void 290 h_hup(signo) 291 int signo; 292 { 293 GLOBAL_CLP; 294 295 F_SET(clp, CL_SIGHUP); 296 clp->killersig = SIGHUP; 297 } 298 299 static void 300 h_int(signo) 301 int signo; 302 { 303 GLOBAL_CLP; 304 305 F_SET(clp, CL_SIGINT); 306 } 307 308 static void 309 h_term(signo) 310 int signo; 311 { 312 GLOBAL_CLP; 313 314 F_SET(clp, CL_SIGTERM); 315 clp->killersig = SIGTERM; 316 } 317 318 static void 319 h_winch(signo) 320 int signo; 321 { 322 GLOBAL_CLP; 323 324 F_SET(clp, CL_SIGWINCH); 325 } 326 #undef GLOBAL_CLP 327 328 /* 329 * sig_init -- 330 * Initialize signals. 331 * 332 * PUBLIC: int sig_init __P((GS *, SCR *)); 333 */ 334 int 335 sig_init(gp, sp) 336 GS *gp; 337 SCR *sp; 338 { 339 CL_PRIVATE *clp; 340 341 clp = GCLP(gp); 342 343 if (sp == NULL) { 344 (void)sigemptyset(&__sigblockset); 345 if (sigaddset(&__sigblockset, SIGHUP) || 346 setsig(SIGHUP, &clp->oact[INDX_HUP], h_hup) || 347 sigaddset(&__sigblockset, SIGINT) || 348 setsig(SIGINT, &clp->oact[INDX_INT], h_int) || 349 sigaddset(&__sigblockset, SIGTERM) || 350 setsig(SIGTERM, &clp->oact[INDX_TERM], h_term) 351 #ifdef SIGWINCH 352 || 353 sigaddset(&__sigblockset, SIGWINCH) || 354 setsig(SIGWINCH, &clp->oact[INDX_WINCH], h_winch) 355 #endif 356 ) { 357 perr(gp->progname, NULL); 358 return (1); 359 } 360 } else 361 if (setsig(SIGHUP, NULL, h_hup) || 362 setsig(SIGINT, NULL, h_int) || 363 setsig(SIGTERM, NULL, h_term) 364 #ifdef SIGWINCH 365 || 366 setsig(SIGWINCH, NULL, h_winch) 367 #endif 368 ) { 369 msgq(sp, M_SYSERR, "signal-reset"); 370 } 371 return (0); 372 } 373 374 /* 375 * setsig -- 376 * Set a signal handler. 377 */ 378 static int 379 setsig(signo, oactp, handler) 380 int signo; 381 struct sigaction *oactp; 382 void (*handler) __P((int)); 383 { 384 struct sigaction act; 385 386 /* 387 * Use sigaction(2), not signal(3), since we don't always want to 388 * restart system calls. The example is when waiting for a command 389 * mode keystroke and SIGWINCH arrives. Besides, you can't portably 390 * restart system calls (thanks, POSIX!). On the other hand, you 391 * can't portably NOT restart system calls (thanks, Sun!). SunOS 392 * used SA_INTERRUPT as their extension to NOT restart read calls. 393 * We sure hope nobody else used it for anything else. Mom told me 394 * there'd be days like this. She just never told me that there'd 395 * be so many. 396 */ 397 act.sa_handler = handler; 398 sigemptyset(&act.sa_mask); 399 400 #ifdef SA_INTERRUPT 401 act.sa_flags = SA_INTERRUPT; 402 #else 403 act.sa_flags = 0; 404 #endif 405 return (sigaction(signo, &act, oactp)); 406 } 407 408 /* 409 * sig_end -- 410 * End signal setup. 411 */ 412 static void 413 sig_end(gp) 414 GS *gp; 415 { 416 CL_PRIVATE *clp; 417 418 clp = GCLP(gp); 419 (void)sigaction(SIGHUP, NULL, &clp->oact[INDX_HUP]); 420 (void)sigaction(SIGINT, NULL, &clp->oact[INDX_INT]); 421 (void)sigaction(SIGTERM, NULL, &clp->oact[INDX_TERM]); 422 #ifdef SIGWINCH 423 (void)sigaction(SIGWINCH, NULL, &clp->oact[INDX_WINCH]); 424 #endif 425 } 426 427 /* 428 * cl_func_std -- 429 * Initialize the standard curses functions. 430 */ 431 static void 432 cl_func_std(gp) 433 GS *gp; 434 { 435 gp->scr_addstr = cl_addstr; 436 gp->scr_attr = cl_attr; 437 gp->scr_baud = cl_baud; 438 gp->scr_bell = cl_bell; 439 gp->scr_busy = NULL; 440 gp->scr_clrtoeol = cl_clrtoeol; 441 gp->scr_cursor = cl_cursor; 442 gp->scr_deleteln = cl_deleteln; 443 gp->scr_event = cl_event; 444 gp->scr_ex_adjust = cl_ex_adjust; 445 gp->scr_fmap = cl_fmap; 446 gp->scr_insertln = cl_insertln; 447 gp->scr_keyval = cl_keyval; 448 gp->scr_move = cl_move; 449 gp->scr_msg = NULL; 450 gp->scr_optchange = cl_optchange; 451 gp->scr_refresh = cl_refresh; 452 gp->scr_rename = cl_rename; 453 gp->scr_screen = cl_screen; 454 gp->scr_suspend = cl_suspend; 455 gp->scr_usage = cl_usage; 456 } 457 458 /* 459 * perr -- 460 * Print system error. 461 */ 462 static void 463 perr(name, msg) 464 char *name, *msg; 465 { 466 (void)fprintf(stderr, "%s:", name); 467 if (msg != NULL) 468 (void)fprintf(stderr, "%s:", msg); 469 (void)fprintf(stderr, "%s\n", strerror(errno)); 470 exit(1); 471 } 472