1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * Editor 31 */ 32 33 #include <crypt.h> 34 #include <libgen.h> 35 #include <wait.h> 36 #include <string.h> 37 #include <sys/types.h> 38 #include <locale.h> 39 #include <regexpr.h> 40 #include <regex.h> 41 #include <errno.h> 42 #include <paths.h> 43 44 static const char *msgtab[] = 45 { 46 "write or open on pipe failed", /* 0 */ 47 "warning: expecting `w'", /* 1 */ 48 "mark not lower case ascii", /* 2 */ 49 "Cannot open input file", /* 3 */ 50 "PWB spec problem", /* 4 */ 51 "nothing to undo", /* 5 */ 52 "restricted shell", /* 6 */ 53 "cannot create output file", /* 7 */ 54 "filesystem out of space!", /* 8 */ 55 "cannot open file", /* 9 */ 56 "cannot link", /* 10 */ 57 "Range endpoint too large", /* 11 */ 58 "unknown command", /* 12 */ 59 "search string not found", /* 13 */ 60 "-", /* 14 */ 61 "line out of range", /* 15 */ 62 "bad number", /* 16 */ 63 "bad range", /* 17 */ 64 "Illegal address count", /* 18 */ 65 "incomplete global expression", /* 19 */ 66 "illegal suffix", /* 20 */ 67 "illegal or missing filename", /* 21 */ 68 "no space after command", /* 22 */ 69 "fork failed - try again", /* 23 */ 70 "maximum of 64 characters in file names", /* 24 */ 71 "`\\digit' out of range", /* 25 */ 72 "interrupt", /* 26 */ 73 "line too long", /* 27 */ 74 "illegal character in input file", /* 28 */ 75 "write error", /* 29 */ 76 "out of memory for append", /* 30 */ 77 "temp file too big", /* 31 */ 78 "I/O error on temp file", /* 32 */ 79 "multiple globals not allowed", /* 33 */ 80 "global too long", /* 34 */ 81 "no match", /* 35 */ 82 "illegal or missing delimiter", /* 36 */ 83 "-", /* 37 */ 84 "replacement string too long", /* 38 */ 85 "illegal move destination", /* 39 */ 86 "-", /* 40 */ 87 "no remembered search string", /* 41 */ 88 "'\\( \\)' imbalance", /* 42 */ 89 "Too many `\\(' s", /* 43 */ 90 "more than 2 numbers given", /* 44 */ 91 "'\\}' expected", /* 45 */ 92 "first number exceeds second", /* 46 */ 93 "incomplete substitute", /* 47 */ 94 "newline unexpected", /* 48 */ 95 "'[ ]' imbalance", /* 49 */ 96 "regular expression overflow", /* 50 */ 97 "regular expression error", /* 51 */ 98 "command expected", /* 52 */ 99 "a, i, or c not allowed in G", /* 53 */ 100 "end of line expected", /* 54 */ 101 "no remembered replacement string", /* 55 */ 102 "no remembered command", /* 56 */ 103 "illegal redirection", /* 57 */ 104 "possible concurrent update", /* 58 */ 105 "-", /* 59 */ 106 "the x command has become X (upper case)", /* 60 */ 107 "Warning: 'w' may destroy input file " 108 "(due to `illegal char' read earlier)", 109 /* 61 */ 110 "Caution: 'q' may lose data in buffer;" 111 " 'w' may destroy input file", 112 /* 62 */ 113 "Encryption of string failed", /* 63 */ 114 "Encryption facility not available", /* 64 */ 115 "Cannot encrypt temporary file", /* 65 */ 116 "Enter key:", /* 66 */ 117 "Illegal byte sequence", /* 67 */ 118 "File does not exist", /* 68 */ 119 "tempnam failed", /* 69 */ 120 "Cannot open temporary file", /* 70 */ 121 0 122 }; 123 124 #include <stdlib.h> 125 #include <limits.h> 126 #include <stdio.h> 127 #include <signal.h> 128 #include <sys/types.h> 129 #include <sys/stat.h> 130 #include <sys/statvfs.h> 131 #include <unistd.h> 132 #include <termio.h> 133 #include <ctype.h> 134 #include <setjmp.h> 135 #include <fcntl.h> 136 #include <wchar.h> /* I18N */ 137 #include <wctype.h> /* I18N */ 138 #include <widec.h> /* I18N */ 139 140 #define FTYPE(A) (A.st_mode) 141 #define FMODE(A) (A.st_mode) 142 #define IDENTICAL(A, B) (A.st_dev == B.st_dev && A.st_ino == B.st_ino) 143 #define ISBLK(A) ((A.st_mode & S_IFMT) == S_IFBLK) 144 #define ISCHR(A) ((A.st_mode & S_IFMT) == S_IFCHR) 145 #define ISDIR(A) ((A.st_mode & S_IFMT) == S_IFDIR) 146 #define ISFIFO(A) ((A.st_mode & S_IFMT) == S_IFIFO) 147 #define ISREG(A) ((A.st_mode & S_IFMT) == S_IFREG) 148 149 #define PUTM() if (xcode >= 0) puts(gettext(msgtab[xcode])) 150 #define UNGETC(c) (peekc = c) 151 #define FNSIZE PATH_MAX 152 #define LBSIZE LINE_MAX 153 154 /* size of substitution replacement pattern buffer */ 155 #define RHSIZE (LINE_MAX*2) 156 157 #define KSIZE 8 158 159 #define READ 0 160 #define WRITE 1 161 162 extern char *optarg; /* Value of argument */ 163 extern int optind; /* Indicator of argument */ 164 165 struct Fspec { 166 char Ftabs[22]; 167 char Fdel; 168 unsigned char Flim; 169 char Fmov; 170 char Ffill; 171 }; 172 static struct Fspec fss; 173 174 static char *fsp; 175 static int fsprtn; 176 static char line[70]; 177 static char *linp = line; 178 static int sig; 179 static int Xqt = 0; 180 static int lastc; 181 static char savedfile[FNSIZE]; 182 static char file[FNSIZE]; 183 static char funny[FNSIZE]; 184 static int funlink = 0; 185 static char linebuf[LBSIZE]; 186 static char *tstring = linebuf; 187 188 static char *expbuf; 189 190 static char rhsbuf[RHSIZE]; 191 struct lin { 192 long cur; 193 long sav; 194 }; 195 typedef struct lin *LINE; 196 static LINE zero; 197 static LINE dot; 198 static LINE dol; 199 static LINE endcore; 200 static LINE fendcore; 201 static LINE addr1; 202 static LINE addr2; 203 static LINE savdol, savdot; 204 static int globflg; 205 static int initflg; 206 static char genbuf[LBSIZE]; 207 static long count; 208 static int numpass; /* Number of passes thru dosub(). */ 209 static int gsubf; /* Occurrence value. LBSIZE-1=all. */ 210 static int ocerr1; /* Allows lines NOT changed by dosub() to NOT be put */ 211 /* out. Retains last line changed as current line. */ 212 static int ocerr2; /* Flags if ANY line changed by substitute(). 0=nc. */ 213 static char *nextip; 214 static char *linebp; 215 static int ninbuf; 216 static int peekc; 217 static int io; 218 static void (*oldhup)(), (*oldintr)(); 219 static void (*oldquit)(), (*oldpipe)(); 220 static void quit(int) __NORETURN; 221 static int vflag = 1; 222 static int xflag; 223 static int xtflag; 224 static int kflag; 225 static int crflag; 226 /* Flag for determining if file being read is encrypted */ 227 static int hflag; 228 static int xcode = -1; 229 static char crbuf[LBSIZE]; 230 static int perm[2]; 231 static int tperm[2]; 232 static int permflag; 233 static int tpermflag; 234 static int col; 235 static char *globp; 236 static int tfile = -1; 237 static int tline; 238 static char *tfname; 239 extern char *locs; 240 static char ibuff[LBSIZE]; 241 static int iblock = -1; 242 static char obuff[LBSIZE]; 243 static int oblock = -1; 244 static int ichanged; 245 static int nleft; 246 static long savnames[26], names[26]; 247 static int anymarks; 248 static long subnewa; 249 static int fchange; 250 static int nline; 251 static int fflg, shflg; 252 static char prompt[16] = "*"; 253 static int rflg; 254 static int readflg; 255 static int eflg; 256 static int qflg = 0; 257 static int ncflg; 258 static int listn; 259 static int listf; 260 static int pflag; 261 static int flag28 = 0; /* Prevents write after a partial read */ 262 static int save28 = 0; /* Flag whether buffer empty at start of read */ 263 static long savtime; 264 static char *name = "SHELL"; 265 static char *rshell = "/usr/lib/rsh"; 266 static char *val; 267 static char *home; 268 static int nodelim; 269 270 int makekey(int *); 271 int _mbftowc(char *, wchar_t *, int (*)(), int *); 272 static int error(int code); 273 static void tlist(struct Fspec *); 274 static void tstd(struct Fspec *); 275 static void gdelete(void); 276 static void delete(void); 277 static void exfile(void); 278 static void filename(int comm); 279 static void newline(void); 280 static int gettty(void); 281 static void commands(void); 282 static void undo(void); 283 static void save(void); 284 static void strcopy(char *source, char *dest); 285 static int strequal(char **scan1, char *str); 286 static int stdtab(char *, char *); 287 static int lenchk(char *, struct Fspec *); 288 static void clear(struct Fspec *); 289 static int expnd(char *, char *, int *, struct Fspec *); 290 static void tincr(int, struct Fspec *); 291 static void targ(struct Fspec *); 292 static int numb(void); 293 static int fspec(char *, struct Fspec *, int); 294 static void red(char *); 295 static void newtime(void); 296 static void chktime(void); 297 static void getime(void); 298 static void mkfunny(void); 299 static int eopen(char *, int); 300 static void eclose(int f); 301 static void globaln(int); 302 static char *getkey(const char *); 303 static int execute(int, LINE); 304 static void error1(int); 305 static int getcopy(void); 306 static void move(int); 307 static void dosub(void); 308 static int getsub(void); 309 static int compsub(void); 310 static void substitute(int); 311 static void join(void); 312 static void global(int); 313 static void init(void); 314 static void rdelete(LINE, LINE); 315 static void append(int (*)(void), LINE); 316 static int getfile(void); 317 static void putfile(void); 318 static void onpipe(int); 319 static void onhup(int); 320 static void onintr(int); 321 static void setdot(void); 322 static void setall(void); 323 static void setnoaddr(void); 324 static void nonzero(void); 325 static void setzeroasone(void); 326 static long putline(void); 327 static LINE address(void); 328 static char *getaline(long); 329 static char *getblock(long, long); 330 static char *place(char *, char *, char *); 331 static void comple(wchar_t); 332 static void putchr(unsigned char); 333 static void putwchr(wchar_t); 334 static int getchr(void); 335 static void unixcom(void); 336 static void blkio(int, char *, ssize_t (*)()); 337 static void reverse(LINE, LINE); 338 static void putd(); 339 static wchar_t get_wchr(void); 340 341 static struct stat Fl, Tf; 342 #ifndef RESEARCH 343 static struct statvfs U; 344 static int Short = 0; 345 static mode_t oldmask; /* No umask while writing */ 346 #endif 347 static jmp_buf savej; 348 349 #ifdef NULLS 350 int nulls; /* Null count */ 351 #endif 352 static long ccount; 353 354 static int errcnt = 0; 355 356 357 static void 358 onpipe(int sig) 359 { 360 (int)error(0); 361 } 362 363 int 364 main(int argc, char **argv) 365 { 366 char *p1, *p2; 367 int c; 368 369 (void) setlocale(LC_ALL, ""); 370 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 371 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 372 #endif 373 (void) textdomain(TEXT_DOMAIN); 374 375 oldquit = signal(SIGQUIT, SIG_IGN); 376 oldhup = signal(SIGHUP, SIG_IGN); 377 oldintr = signal(SIGINT, SIG_IGN); 378 oldpipe = signal(SIGPIPE, onpipe); 379 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) 380 signal(SIGTERM, quit); 381 p1 = *argv; 382 while (*p1++) 383 ; 384 while (--p1 >= *argv) 385 if (*p1 == '/') 386 break; 387 *argv = p1 + 1; 388 /* if SHELL set in environment and is /usr/lib/rsh, set rflg */ 389 if ((val = getenv(name)) != NULL) 390 if (strcmp(val, rshell) == 0) 391 rflg++; 392 if (**argv == 'r') 393 rflg++; 394 home = getenv("HOME"); 395 while (1) { 396 while ((c = getopt(argc, argv, "sp:qxC")) != EOF) { 397 switch (c) { 398 399 case 's': 400 vflag = 0; 401 break; 402 403 case 'p': 404 strncpy(prompt, optarg, sizeof (prompt)-1); 405 shflg = 1; 406 break; 407 408 case 'q': 409 signal(SIGQUIT, SIG_DFL); 410 vflag = 1; 411 break; 412 413 case 'x': 414 crflag = -1; 415 xflag = 1; 416 break; 417 418 case 'C': 419 crflag = 1; 420 xflag = 1; 421 break; 422 423 case '?': 424 (void) fprintf(stderr, gettext( 425 "Usage: ed [- | -s] [-p string] [-x] [-C] [file]\n" 426 " red [- | -s] [-p string] [-x] [-C] [file]\n")); 427 exit(2); 428 } 429 } 430 if (argv[optind] && strcmp(argv[optind], "-") == 0 && 431 strcmp(argv[optind-1], "--") != 0) { 432 vflag = 0; 433 optind++; 434 continue; 435 } 436 break; 437 } 438 argc = argc - optind; 439 argv = &argv[optind]; 440 441 if (xflag) { 442 if (permflag) 443 crypt_close(perm); 444 permflag = 1; 445 kflag = run_setkey(&perm[0], getkey(msgtab[66])); 446 if (kflag == -1) { 447 puts(gettext(msgtab[64])); 448 xflag = 0; 449 kflag = 0; 450 } 451 if (kflag == 0) 452 crflag = 0; 453 } 454 455 if (argc > 0) { 456 p1 = *argv; 457 if (strlen(p1) >= (size_t)FNSIZE) { 458 puts(gettext("file name too long")); 459 if (kflag) 460 crypt_close(perm); 461 exit(2); 462 } 463 p2 = savedfile; 464 while (*p2++ = *p1++) 465 ; 466 globp = "e"; 467 fflg++; 468 } else /* editing with no file so set savtime to 0 */ 469 savtime = 0; 470 eflg++; 471 if ((tfname = tempnam("", "ea")) == NULL) { 472 puts(gettext(msgtab[69])); 473 exit(2); 474 } 475 476 fendcore = (LINE)sbrk(0); 477 init(); 478 if (oldintr != SIG_IGN) 479 signal(SIGINT, onintr); 480 if (oldhup != SIG_IGN) 481 signal(SIGHUP, onhup); 482 setjmp(savej); 483 commands(); 484 quit(sig); 485 return (0); 486 } 487 488 static void 489 commands(void) 490 { 491 LINE a1; 492 int c; 493 char *p1, *p2; 494 int fsave, m, n; 495 496 for (;;) { 497 nodelim = 0; 498 if (pflag) { 499 pflag = 0; 500 addr1 = addr2 = dot; 501 goto print; 502 } 503 if (shflg && globp == 0) 504 write(1, gettext(prompt), strlen(gettext(prompt))); 505 addr1 = 0; 506 addr2 = 0; 507 if ((c = getchr()) == ',') { 508 addr1 = zero + 1; 509 addr2 = dol; 510 #ifdef XPG6 511 /* XPG4 - it was an error if the second address was */ 512 /* input and the first address was ommitted */ 513 /* Parse second address */ 514 if ((a1 = address()) != 0) { 515 addr2 = a1; 516 } 517 #endif 518 c = getchr(); 519 goto swch; 520 } else if (c == ';') { 521 addr1 = dot; 522 addr2 = dol; 523 #ifdef XPG6 524 /* XPG4 - it was an error if the second address was */ 525 /* input and the first address was ommitted */ 526 /* Parse second address */ 527 if ((a1 = address()) != 0) { 528 addr2 = a1; 529 } 530 #endif 531 c = getchr(); 532 goto swch; 533 } else 534 peekc = c; 535 do { 536 addr1 = addr2; 537 if ((a1 = address()) == 0) { 538 c = getchr(); 539 break; 540 } 541 addr2 = a1; 542 if ((c = getchr()) == ';') { 543 c = ','; 544 dot = a1; 545 } 546 } while (c == ','); 547 if (addr1 == 0) 548 addr1 = addr2; 549 swch: 550 switch (c) { 551 552 case 'a': 553 setdot(); 554 newline(); 555 if (!globflg) save(); 556 append(gettty, addr2); 557 continue; 558 559 case 'c': 560 #ifdef XPG6 561 setzeroasone(); 562 #endif 563 delete(); 564 append(gettty, addr1-1); 565 566 /* XPG4 - If no new lines are inserted, then the current */ 567 /* line becomes the line after the lines deleted. */ 568 569 if (((linebuf[0] != '.') || (dot == (addr1-1))) && 570 (addr2 <= dol)) 571 dot = addr1; 572 continue; 573 574 case 'd': 575 delete(); 576 continue; 577 578 case 'E': 579 fchange = 0; 580 c = 'e'; 581 /* FALLTHROUGH */ 582 case 'e': 583 fflg++; 584 setnoaddr(); 585 if (vflag && fchange) { 586 fchange = 0; 587 (void) error(1); 588 } 589 filename(c); 590 eflg++; 591 init(); 592 addr2 = zero; 593 goto caseread; 594 595 case 'f': 596 setnoaddr(); 597 filename(c); 598 if (!ncflg) /* there is a filename */ 599 getime(); 600 else 601 ncflg--; 602 puts(savedfile); 603 continue; 604 605 case 'g': 606 global(1); 607 continue; 608 case 'G': 609 globaln(1); 610 continue; 611 612 case 'h': 613 newline(); 614 setnoaddr(); 615 PUTM(); 616 continue; 617 618 case 'H': 619 newline(); 620 setnoaddr(); 621 if (!hflag) { 622 hflag = 1; 623 PUTM(); 624 } 625 else 626 hflag = 0; 627 continue; 628 629 case 'i': 630 #ifdef XPG6 631 setzeroasone(); 632 #endif 633 setdot(); 634 nonzero(); 635 newline(); 636 if (!globflg) save(); 637 append(gettty, addr2-1); 638 if (dot == addr2-1) 639 dot += 1; 640 continue; 641 642 case 'j': 643 if (addr2 == 0) { 644 addr1 = dot; 645 addr2 = dot+1; 646 } 647 setdot(); 648 newline(); 649 nonzero(); 650 if (!globflg) save(); 651 join(); 652 continue; 653 654 case 'k': 655 if ((c = getchr()) < 'a' || c > 'z') 656 (void) error(2); 657 newline(); 658 setdot(); 659 nonzero(); 660 names[c-'a'] = addr2->cur & ~01; 661 anymarks |= 01; 662 continue; 663 664 case 'm': 665 move(0); 666 continue; 667 668 case '\n': 669 if (addr2 == 0) 670 addr2 = dot+1; 671 addr1 = addr2; 672 goto print; 673 674 case 'n': 675 listn++; 676 newline(); 677 goto print; 678 679 case 'l': 680 listf++; 681 /* FALLTHROUGH */ 682 case 'p': 683 newline(); 684 print: 685 setdot(); 686 nonzero(); 687 a1 = addr1; 688 do { 689 if (listn) { 690 count = a1 - zero; 691 putd(); 692 putchr('\t'); 693 } 694 puts(getaline((a1++)->cur)); 695 } while (a1 <= addr2); 696 dot = addr2; 697 pflag = 0; 698 listn = 0; 699 listf = 0; 700 continue; 701 702 case 'Q': 703 fchange = 0; 704 /* FALLTHROUGH */ 705 case 'q': 706 setnoaddr(); 707 newline(); 708 quit(sig); 709 710 case 'r': 711 filename(c); 712 caseread: 713 readflg = 1; 714 save28 = (dol != fendcore); 715 if (crflag == 2 || crflag == -2) 716 crflag = -1; /* restore crflag for next file */ 717 errno = 0; 718 if ((io = eopen(file, O_RDONLY)) < 0) { 719 lastc = '\n'; 720 /* if first entering editor and file does not exist */ 721 /* set saved access time to 0 */ 722 if (eflg) { 723 savtime = 0; 724 eflg = 0; 725 if (c == 'e' && vflag == 0) 726 qflg = 1; 727 } 728 if (errno == ENOENT) { 729 (void) error(68); 730 } else { 731 (void) error(3); 732 } 733 } 734 /* get last mod time of file */ 735 /* eflg - entered editor with ed or e */ 736 if (eflg) { 737 eflg = 0; 738 getime(); 739 } 740 setall(); 741 ninbuf = 0; 742 n = zero != dol; 743 #ifdef NULLS 744 nulls = 0; 745 #endif 746 if (!globflg && (c == 'r')) save(); 747 append(getfile, addr2); 748 exfile(); 749 readflg = 0; 750 fchange = n; 751 continue; 752 753 case 's': 754 setdot(); 755 nonzero(); 756 if (!globflg) save(); 757 substitute(globp != 0); 758 continue; 759 760 case 't': 761 move(1); 762 continue; 763 764 case 'u': 765 setdot(); 766 newline(); 767 if (!initflg) 768 undo(); 769 else 770 (void) error(5); 771 fchange = 1; 772 continue; 773 774 case 'v': 775 global(0); 776 continue; 777 case 'V': 778 globaln(0); 779 continue; 780 781 case 'W': 782 case 'w': 783 if (flag28) { 784 flag28 = 0; 785 fchange = 0; 786 (void) error(61); 787 } 788 setall(); 789 790 /* on NULL-RE condition do not generate error */ 791 792 if ((linebuf[0] != '.') && (zero != dol) && 793 (addr1 <= zero || addr2 > dol)) 794 (void) error(15); 795 filename(c); 796 if (Xqt) { 797 io = eopen(file, O_WRONLY); 798 n = 1; /* set n so newtime will not execute */ 799 } else { 800 struct stat lFl; 801 fstat(tfile, &Tf); 802 if (stat(file, &Fl) < 0) { 803 if ((io = creat(file, S_IRUSR|S_IWUSR|S_IRGRP 804 |S_IWGRP|S_IROTH|S_IWOTH)) < 0) 805 (void) error(7); 806 fstat(io, &Fl); 807 Fl.st_mtime = 0; 808 lFl = Fl; 809 close(io); 810 } else { 811 #ifndef RESEARCH 812 oldmask = umask(0); 813 /* 814 * Must determine if file is 815 * a symbolic link 816 */ 817 lstat(file, &lFl); 818 #endif 819 } 820 #ifndef RESEARCH 821 /* 822 * Determine if there are enough free blocks on system 823 */ 824 if (!Short && statvfs(file, &U) == 0 && 825 U.f_bfree < ((Tf.st_size/U.f_frsize) + 100)) { 826 Short = 1; 827 (void) error(8); 828 } 829 Short = 0; 830 #endif 831 p1 = savedfile; /* The current filename */ 832 p2 = file; 833 m = strcmp(p1, p2); 834 if (c == 'w' && Fl.st_nlink == 1 && ISREG(lFl)) { 835 if (close(open(file, O_WRONLY)) < 0) 836 (void) error(9); 837 if (!(n = m)) 838 chktime(); 839 mkfunny(); 840 /* 841 * If funlink equals one it means that 842 * funny points to a valid file which must 843 * be unlinked when interrupted. 844 */ 845 846 funlink = 1; 847 if ((io = creat(funny, FMODE(Fl))) >= 0) { 848 chown(funny, Fl.st_uid, Fl.st_gid); 849 chmod(funny, FMODE(Fl)); 850 putfile(); 851 exfile(); 852 853 if (rename(funny, file)) 854 (void) error(10); 855 funlink = 0; 856 /* if filenames are the same */ 857 if (!n) 858 newtime(); 859 /* check if entire buffer was written */ 860 fsave = fchange; 861 if (((addr1 == zero) || 862 (addr1 == (zero + 1))) && 863 (addr2 == dol)) 864 fchange = 0; 865 else 866 fchange = 1; 867 if (fchange == 1 && m != 0) 868 fchange = fsave; 869 continue; 870 } 871 } else { 872 n = 1; /* set n so newtime will not execute */ 873 } 874 if ((io = open(file, 875 (c == 'w') ? O_WRONLY|O_CREAT|O_TRUNC 876 : O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR 877 |S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)) < 0) 878 (void) error(7); 879 } 880 putfile(); 881 exfile(); 882 if (!n) 883 newtime(); 884 fsave = fchange; 885 fchange = (((addr1 == zero) || (addr1 == (zero + 1))) && 886 (addr2 == dol)) ? 0 : 1; 887 /* Leave fchange alone if partial write was to another file */ 888 if (fchange == 1 && m != 0) fchange = fsave; 889 continue; 890 891 case 'C': 892 crflag = 1; 893 /* 894 * C is same as X, but always assume input files are 895 * ciphertext 896 */ 897 goto encrypt; 898 899 case 'X': 900 crflag = -1; 901 encrypt: 902 setnoaddr(); 903 newline(); 904 xflag = 1; 905 if (permflag) 906 (void) crypt_close(perm); 907 permflag = 1; 908 if ((kflag = run_setkey(&perm[0], getkey(msgtab[66]))) == -1) { 909 xflag = 0; 910 kflag = 0; 911 crflag = 0; 912 (void) error(64); 913 } 914 if (kflag == 0) 915 crflag = 0; 916 continue; 917 918 case '=': 919 setall(); 920 newline(); 921 count = (addr2-zero)&077777; 922 putd(); 923 putchr('\n'); 924 continue; 925 926 case '!': 927 unixcom(); 928 continue; 929 930 case EOF: 931 return; 932 933 case 'P': 934 setnoaddr(); 935 newline(); 936 if (shflg) 937 shflg = 0; 938 else 939 shflg++; 940 continue; 941 } 942 if (c == 'x') 943 (void) error(60); 944 else 945 (void) error(12); 946 } 947 } 948 949 LINE 950 address(void) 951 { 952 int minus, c; 953 LINE a1; 954 int n, relerr, retval; 955 956 minus = 0; 957 a1 = 0; 958 for (;;) { 959 c = getchr(); 960 if ('0' <= c && c <= '9') { 961 n = 0; 962 do { 963 n *= 10; 964 n += c - '0'; 965 } while ((c = getchr()) >= '0' && c <= '9'); 966 peekc = c; 967 if (a1 == 0) 968 a1 = zero; 969 if (minus < 0) 970 n = -n; 971 a1 += n; 972 minus = 0; 973 continue; 974 } 975 relerr = 0; 976 if (a1 || minus) 977 relerr++; 978 switch (c) { 979 case ' ': 980 case '\t': 981 continue; 982 983 case '+': 984 minus++; 985 if (a1 == 0) 986 a1 = dot; 987 continue; 988 989 case '-': 990 case '^': 991 minus--; 992 if (a1 == 0) 993 a1 = dot; 994 continue; 995 996 case '?': 997 case '/': 998 comple(c); 999 a1 = dot; 1000 for (;;) { 1001 if (c == '/') { 1002 a1++; 1003 if (a1 > dol) 1004 a1 = zero; 1005 } else { 1006 a1--; 1007 if (a1 < zero) 1008 a1 = dol; 1009 } 1010 1011 if (execute(0, a1)) 1012 break; 1013 if (a1 == dot) 1014 (void) error(13); 1015 } 1016 break; 1017 1018 case '$': 1019 a1 = dol; 1020 break; 1021 1022 case '.': 1023 a1 = dot; 1024 break; 1025 1026 case '\'': 1027 if ((c = getchr()) < 'a' || c > 'z') 1028 (void) error(2); 1029 for (a1 = zero; a1 <= dol; a1++) 1030 if (names[c-'a'] == (a1->cur & ~01)) 1031 break; 1032 break; 1033 1034 default: 1035 peekc = c; 1036 if (a1 == 0) 1037 return (0); 1038 a1 += minus; 1039 1040 /* on NULL-RE condition do not generate error */ 1041 1042 if ((linebuf[0] != '.') && (a1 < zero || a1 > dol)) 1043 (void) error(15); 1044 return (a1); 1045 } 1046 if (relerr) 1047 (void) error(16); 1048 } 1049 } 1050 1051 static void 1052 setdot(void) 1053 { 1054 if (addr2 == 0) 1055 addr1 = addr2 = dot; 1056 if (addr1 > addr2) 1057 (void) error(17); 1058 } 1059 1060 static void 1061 setall(void) 1062 { 1063 if (addr2 == 0) { 1064 addr1 = zero+1; 1065 addr2 = dol; 1066 if (dol == zero) 1067 addr1 = zero; 1068 } 1069 setdot(); 1070 } 1071 1072 static void 1073 setnoaddr(void) 1074 { 1075 if (addr2) 1076 (void) error(18); 1077 } 1078 1079 static void 1080 nonzero(void) 1081 { 1082 /* on NULL-RE condition do not generate error */ 1083 1084 if ((linebuf[0] != '.') && (addr1 <= zero || addr2 > dol)) 1085 (void) error(15); 1086 } 1087 1088 static void 1089 setzeroasone(void) 1090 { 1091 /* for the c and i commands 0 equal to 1 address */ 1092 if (addr1 == zero) { 1093 addr1 = zero+1; 1094 } 1095 if (addr2 == zero) { 1096 addr2 = zero+1; 1097 } 1098 } 1099 1100 1101 static void 1102 newline(void) 1103 { 1104 int c; 1105 1106 if ((c = getchr()) == '\n') 1107 return; 1108 if (c == 'p' || c == 'l' || c == 'n') { 1109 pflag++; 1110 if (c == 'l') listf++; 1111 if (c == 'n') listn++; 1112 if ((c = getchr()) == '\n') 1113 return; 1114 } 1115 (void) error(20); 1116 } 1117 1118 static void 1119 filename(int comm) 1120 { 1121 char *p1, *p2; 1122 int c; 1123 int i = 0; 1124 1125 count = 0; 1126 c = getchr(); 1127 if (c == '\n' || c == EOF) { 1128 p1 = savedfile; 1129 if (*p1 == 0 && comm != 'f') 1130 (void) error(21); 1131 /* ncflg set means do not get mod time of file */ 1132 /* since no filename followed f */ 1133 if (comm == 'f') 1134 ncflg++; 1135 p2 = file; 1136 while (*p2++ = *p1++) 1137 ; 1138 red(savedfile); 1139 return; 1140 } 1141 if (c != ' ') 1142 (void) error(22); 1143 while ((c = getchr()) == ' ') 1144 ; 1145 if (c == '!') 1146 ++Xqt, c = getchr(); 1147 if (c == '\n') 1148 (void) error(21); 1149 p1 = file; 1150 do { 1151 if (++i >= FNSIZE) 1152 (void) error(24); 1153 *p1++ = c; 1154 if (c == EOF || (c == ' ' && !Xqt)) 1155 (void) error(21); 1156 } while ((c = getchr()) != '\n'); 1157 *p1++ = 0; 1158 if (Xqt) 1159 if (comm == 'f') { 1160 --Xqt; 1161 (void) error(57); 1162 } 1163 else 1164 return; 1165 if (savedfile[0] == 0 || comm == 'e' || comm == 'f') { 1166 p1 = savedfile; 1167 p2 = file; 1168 while (*p1++ = *p2++) 1169 ; 1170 } 1171 red(file); 1172 } 1173 1174 1175 static void 1176 exfile(void) 1177 { 1178 #ifdef NULLS 1179 int c; 1180 #endif 1181 1182 #ifndef RESEARCH 1183 if (oldmask) { 1184 umask(oldmask); 1185 oldmask = 0; 1186 } 1187 #endif 1188 eclose(io); 1189 io = -1; 1190 if (vflag) { 1191 putd(); 1192 putchr('\n'); 1193 #ifdef NULLS 1194 if (nulls) { 1195 c = count; 1196 count = nulls; 1197 nulls = 0; 1198 putd(); 1199 puts(gettext(" nulls replaced by '\\0'")); 1200 count = c; 1201 } 1202 #endif 1203 } 1204 } 1205 1206 static void 1207 onintr(int sig) 1208 { 1209 signal(SIGINT, onintr); 1210 putchr('\n'); 1211 lastc = '\n'; 1212 globflg = 0; 1213 if (funlink) unlink(funny); /* remove tmp file */ 1214 /* if interrupted a read, only part of file may be in buffer */ 1215 if (readflg) { 1216 sprintf(tstring, "\007read may be incomplete - beware!\007"); 1217 puts(gettext(tstring)); 1218 fchange = 0; 1219 } 1220 (void) error(26); 1221 } 1222 1223 static void 1224 onhup(int sig) 1225 { 1226 signal(SIGINT, SIG_IGN); 1227 signal(SIGHUP, SIG_IGN); 1228 /* 1229 * if there are lines in file and file was not written 1230 * since last update, save in ed.hup, or $HOME/ed.hup 1231 */ 1232 if (dol > zero && fchange == 1) { 1233 addr1 = zero+1; 1234 addr2 = dol; 1235 io = creat("ed.hup", 1236 S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH); 1237 if (io < 0 && home) { 1238 char *fn; 1239 1240 fn = (char *)calloc(strlen(home) + 8, sizeof (char)); 1241 if (fn) { 1242 strcpy(fn, home); 1243 strcat(fn, "/ed.hup"); 1244 io = creat(fn, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP 1245 |S_IROTH|S_IWOTH); 1246 free(fn); 1247 } 1248 } 1249 if (io > 0) 1250 putfile(); 1251 } 1252 fchange = 0; 1253 ++errcnt; 1254 quit(sig); 1255 } 1256 1257 static int 1258 error(int code) 1259 { 1260 int c; 1261 1262 if (code == 28 && save28 == 0) { 1263 fchange = 0; 1264 flag28++; 1265 } 1266 readflg = 0; 1267 ++errcnt; 1268 listf = listn = 0; 1269 pflag = 0; 1270 #ifndef RESEARCH 1271 if (oldmask) { 1272 umask(oldmask); 1273 oldmask = 0; 1274 } 1275 #endif 1276 #ifdef NULLS /* Not really nulls, but close enough */ 1277 /* This is a bug because of buffering */ 1278 if (code == 28) /* illegal char. */ 1279 putd(); 1280 #endif 1281 /* Cant open file or file does not exist */ 1282 if ((code == 3) || (code == 68)) { 1283 if (qflg == 0) { 1284 putchr('?'); 1285 puts(file); 1286 } 1287 else 1288 qflg = 0; 1289 } 1290 else 1291 { 1292 putchr('?'); 1293 putchr('\n'); 1294 } 1295 count = 0; 1296 lseek(0, (long)0, 2); 1297 if (globp) 1298 lastc = '\n'; 1299 globp = 0; 1300 peekc = lastc; 1301 if (lastc) 1302 while ((c = getchr()) != '\n' && c != EOF) 1303 ; 1304 if (io) { 1305 eclose(io); 1306 io = -1; 1307 } 1308 xcode = code; 1309 if (hflag) 1310 PUTM(); 1311 if (code == 4) 1312 return (0); /* Non-fatal error. */ 1313 longjmp(savej, 1); 1314 /* NOTREACHED */ 1315 } 1316 1317 static int 1318 getchr(void) 1319 { 1320 char c; 1321 if (lastc = peekc) { 1322 peekc = 0; 1323 return (lastc); 1324 } 1325 if (globp) { 1326 if ((lastc = (unsigned char)*globp++) != 0) 1327 return (lastc); 1328 globp = 0; 1329 return (EOF); 1330 } 1331 if (read(0, &c, 1) <= 0) 1332 return (lastc = EOF); 1333 lastc = (unsigned char)c; 1334 return (lastc); 1335 } 1336 1337 static int 1338 gettty(void) 1339 { 1340 int c; 1341 char *gf; 1342 char *p; 1343 1344 p = linebuf; 1345 gf = globp; 1346 while ((c = getchr()) != '\n') { 1347 if (c == EOF) { 1348 if (gf) 1349 peekc = c; 1350 return (c); 1351 } 1352 if (c == 0) 1353 continue; 1354 *p++ = c; 1355 1356 if (p > &linebuf[LBSIZE-1]) 1357 (void) error(27); 1358 } 1359 *p++ = 0; 1360 if (linebuf[0] == '.' && linebuf[1] == 0) 1361 return (EOF); 1362 1363 /* 1364 * POSIX.2/XPG4 explicitly says no to this: 1365 * 1366 * in Solaris backslash followed by special character "." is 1367 * special character "." itself; (so terminating input mode can be 1368 * "\.\n"). 1369 * 1370 * however, POSIX2/XPG4 says, input mode is terminated by 1371 * entering line consisting of only 2 characters: ".\n" 1372 * 1373 * if (linebuf[0]=='\\' && linebuf[1]=='.' && linebuf[2]==0) { 1374 * linebuf[0] = '.'; 1375 * linebuf[1] = 0; 1376 * } 1377 */ 1378 return (0); 1379 } 1380 1381 static int 1382 getfile(void) 1383 { 1384 char c; 1385 char *lp, *fp; 1386 1387 lp = linebuf; 1388 fp = nextip; 1389 do { 1390 if (--ninbuf < 0) { 1391 if ((ninbuf = read(io, genbuf, LBSIZE)-1) < 0) 1392 if (lp > linebuf) { 1393 puts(gettext("'\\n' appended")); 1394 *genbuf = '\n'; 1395 } 1396 else 1397 return (EOF); 1398 if (crflag == -1) { 1399 if (isencrypt(genbuf, ninbuf + 1)) 1400 crflag = 2; 1401 else 1402 crflag = -2; 1403 } 1404 fp = genbuf; 1405 if (crflag > 0) 1406 if (run_crypt(count, genbuf, ninbuf+1, perm) == -1) 1407 (void) error(63); 1408 } 1409 if (lp >= &linebuf[LBSIZE]) { 1410 lastc = '\n'; 1411 (void) error(27); 1412 } 1413 if ((*lp++ = c = *fp++) == 0) { 1414 #ifdef NULLS 1415 lp[-1] = '\\'; 1416 *lp++ = '0'; 1417 nulls++; 1418 #else 1419 lp--; 1420 continue; 1421 #endif 1422 } 1423 count++; 1424 } while (c != '\n'); 1425 *--lp = 0; 1426 nextip = fp; 1427 if (fss.Ffill && fss.Flim && lenchk(linebuf, &fss) < 0) { 1428 write(1, gettext("line too long: lno = "), 1429 strlen(gettext("line too long: lno = "))); 1430 ccount = count; 1431 count = (++dot-zero)&077777; 1432 dot--; 1433 putd(); 1434 count = ccount; 1435 putchr('\n'); 1436 } 1437 return (0); 1438 } 1439 1440 static void 1441 putfile(void) 1442 { 1443 int n; 1444 LINE a1; 1445 char *fp, *lp; 1446 int nib; 1447 1448 nib = LBSIZE; 1449 fp = genbuf; 1450 a1 = addr1; 1451 do { 1452 lp = getaline(a1++->cur); 1453 if (fss.Ffill && fss.Flim && lenchk(linebuf, &fss) < 0) { 1454 write(1, gettext("line too long: lno = "), 1455 strlen(gettext("line too long: lno = "))); 1456 ccount = count; 1457 count = (a1-zero-1)&077777; 1458 putd(); 1459 count = ccount; 1460 putchr('\n'); 1461 } 1462 for (;;) { 1463 if (--nib < 0) { 1464 n = fp-genbuf; 1465 if (kflag) 1466 if (run_crypt(count-n, genbuf, n, perm) == -1) 1467 (void) error(63); 1468 if (write(io, genbuf, n) != n) 1469 (void) error(29); 1470 nib = LBSIZE - 1; 1471 fp = genbuf; 1472 } 1473 if (dol->cur == 0L)break; /* Allow write of null file */ 1474 count++; 1475 if ((*fp++ = *lp++) == 0) { 1476 fp[-1] = '\n'; 1477 break; 1478 } 1479 } 1480 } while (a1 <= addr2); 1481 n = fp-genbuf; 1482 if (kflag) 1483 if (run_crypt(count-n, genbuf, n, perm) == -1) 1484 (void) error(63); 1485 if (write(io, genbuf, n) != n) 1486 (void) error(29); 1487 } 1488 1489 static void 1490 append(int (*f)(void), LINE a) 1491 { 1492 LINE a1, a2, rdot; 1493 long tl; 1494 1495 nline = 0; 1496 dot = a; 1497 while ((*f)() == 0) { 1498 if (dol >= endcore) { 1499 if ((int)sbrk(512 * sizeof (struct lin)) == -1) { 1500 lastc = '\n'; 1501 (void) error(30); 1502 } 1503 endcore += 512; 1504 } 1505 tl = putline(); 1506 nline++; 1507 a1 = ++dol; 1508 a2 = a1+1; 1509 rdot = ++dot; 1510 while (a1 > rdot) 1511 (--a2)->cur = (--a1)->cur; 1512 rdot->cur = tl; 1513 } 1514 } 1515 1516 static void 1517 unixcom(void) 1518 { 1519 void (*savint)(); 1520 pid_t pid, rpid; 1521 int retcode; 1522 static char savcmd[LBSIZE]; /* last command */ 1523 char curcmd[LBSIZE]; /* current command */ 1524 char *psavcmd, *pcurcmd, *psavedfile; 1525 int endflg = 1, shflg = 0; 1526 wchar_t c; 1527 int len; 1528 1529 setnoaddr(); 1530 if (rflg) 1531 (void) error(6); 1532 pcurcmd = curcmd; 1533 /* read command til end */ 1534 1535 /* 1536 * a '!' found in beginning of command is replaced with the saved 1537 * command. a '%' found in command is replaced with the current 1538 * filename 1539 */ 1540 1541 c = getchr(); 1542 if (c == '!') { 1543 if (savcmd[0] == 0) 1544 (void) error(56); 1545 else { 1546 psavcmd = savcmd; 1547 while (*pcurcmd++ = *psavcmd++) 1548 ; 1549 --pcurcmd; 1550 shflg = 1; 1551 } 1552 } else 1553 UNGETC(c); /* put c back */ 1554 while (endflg == 1) { 1555 while ((c = get_wchr()) != '\n' && c != '%' && c != '\\') { 1556 if ((len = wctomb(pcurcmd, c)) <= 0) { 1557 *pcurcmd = (unsigned char)c; 1558 len = 1; 1559 } 1560 pcurcmd += len; 1561 } 1562 1563 if (c == '%') { 1564 if (savedfile[0] == 0) 1565 (void) error(21); 1566 else { 1567 psavedfile = savedfile; 1568 while (pcurcmd < curcmd + LBSIZE && 1569 (*pcurcmd++ = *psavedfile++)) 1570 ; 1571 --pcurcmd; 1572 shflg = 1; 1573 } 1574 } else if (c == '\\') { 1575 c = get_wchr(); 1576 if (c != '%') 1577 *pcurcmd++ = '\\'; 1578 if ((len = wctomb(pcurcmd, c)) <= 0) { 1579 *pcurcmd = (unsigned char)c; 1580 len = 1; 1581 } 1582 pcurcmd += len; 1583 } 1584 else 1585 /* end of command hit */ 1586 endflg = 0; 1587 } 1588 *pcurcmd++ = 0; 1589 if (shflg == 1) 1590 puts(curcmd); 1591 /* save command */ 1592 strcpy(savcmd, curcmd); 1593 1594 if ((pid = fork()) == 0) { 1595 signal(SIGHUP, oldhup); 1596 signal(SIGQUIT, oldquit); 1597 close(tfile); 1598 execlp(_PATH_BSHELL, "sh", "-c", curcmd, NULL); 1599 exit(0100); 1600 } 1601 savint = signal(SIGINT, SIG_IGN); 1602 while ((rpid = wait(&retcode)) != pid && rpid != (pid_t)-1) 1603 ; 1604 signal(SIGINT, savint); 1605 if (vflag) puts("!"); 1606 } 1607 1608 static void 1609 quit(int sig) 1610 { 1611 if (vflag && fchange) { 1612 fchange = 0; 1613 if (flag28) { 1614 flag28 = 0; 1615 (void) error(62); 1616 } 1617 1618 /* 1619 * For case where user reads in BOTH a good 1620 * file & a bad file 1621 */ 1622 (void) error(1); 1623 } 1624 unlink(tfname); 1625 if (kflag) 1626 crypt_close(perm); 1627 if (xtflag) 1628 crypt_close(tperm); 1629 exit(errcnt? 2: 0); 1630 } 1631 1632 static void 1633 delete(void) 1634 { 1635 setdot(); 1636 newline(); 1637 nonzero(); 1638 if (!globflg) 1639 save(); 1640 rdelete(addr1, addr2); 1641 } 1642 1643 static void 1644 rdelete(LINE ad1, LINE ad2) 1645 { 1646 LINE a1, a2, a3; 1647 1648 a1 = ad1; 1649 a2 = ad2+1; 1650 a3 = dol; 1651 dol -= a2 - a1; 1652 do { 1653 (a1++)->cur = (a2++)->cur; 1654 } while (a2 <= a3); 1655 a1 = ad1; 1656 if (a1 > dol) 1657 a1 = dol; 1658 dot = a1; 1659 fchange = 1; 1660 } 1661 1662 static void 1663 gdelete(void) 1664 { 1665 LINE a1, a2, a3; 1666 1667 a3 = dol; 1668 for (a1 = zero+1; (a1->cur&01) == 0; a1++) 1669 if (a1 >= a3) 1670 return; 1671 for (a2 = a1 + 1; a2 <= a3; ) { 1672 if (a2->cur & 01) { 1673 a2++; 1674 dot = a1; 1675 } else 1676 (a1++)->cur = (a2++)->cur; 1677 } 1678 dol = a1-1; 1679 if (dot > dol) 1680 dot = dol; 1681 fchange = 1; 1682 } 1683 1684 static char * 1685 getaline(long tl) 1686 { 1687 char *bp, *lp; 1688 int nl; 1689 1690 lp = linebuf; 1691 bp = getblock(tl, READ); 1692 nl = nleft; 1693 tl &= ~0377; 1694 while (*lp++ = *bp++) 1695 if (--nl == 0) { 1696 bp = getblock(tl += 0400, READ); 1697 nl = nleft; 1698 } 1699 return (linebuf); 1700 } 1701 1702 static long 1703 putline(void) 1704 { 1705 char *bp, *lp; 1706 int nl; 1707 long tl; 1708 1709 fchange = 1; 1710 lp = linebuf; 1711 tl = tline; 1712 bp = getblock(tl, WRITE); 1713 nl = nleft; 1714 tl &= ~0377; 1715 while (*bp = *lp++) { 1716 if (*bp++ == '\n') { 1717 *--bp = 0; 1718 linebp = lp; 1719 break; 1720 } 1721 if (--nl == 0) { 1722 bp = getblock(tl += 0400, WRITE); 1723 nl = nleft; 1724 } 1725 } 1726 nl = tline; 1727 tline += (((lp-linebuf)+03)>>1)&077776; 1728 return (nl); 1729 } 1730 1731 static char * 1732 getblock(long atl, long iof) 1733 { 1734 int bno, off; 1735 char *p1, *p2; 1736 int n; 1737 1738 bno = atl >> 8; 1739 off = (atl<<1)&0774; 1740 1741 /* bno is limited to 16 bits */ 1742 if (bno >= 65535) { 1743 lastc = '\n'; 1744 (void) error(31); 1745 } 1746 nleft = 512 - off; 1747 if (bno == iblock) { 1748 ichanged |= iof; 1749 return (ibuff+off); 1750 } 1751 if (bno == oblock) 1752 return (obuff+off); 1753 if (iof == READ) { 1754 if (ichanged) { 1755 if (xtflag) 1756 if (run_crypt(0L, ibuff, 512, tperm) == -1) 1757 (void) error(63); 1758 blkio(iblock, ibuff, write); 1759 } 1760 ichanged = 0; 1761 iblock = bno; 1762 blkio(bno, ibuff, read); 1763 if (xtflag) 1764 if (run_crypt(0L, ibuff, 512, tperm) == -1) 1765 (void) error(63); 1766 return (ibuff+off); 1767 } 1768 if (oblock >= 0) { 1769 if (xtflag) { 1770 p1 = obuff; 1771 p2 = crbuf; 1772 n = 512; 1773 while (n--) 1774 *p2++ = *p1++; 1775 if (run_crypt(0L, crbuf, 512, tperm) == -1) 1776 (void) error(63); 1777 blkio(oblock, crbuf, write); 1778 } else 1779 blkio(oblock, obuff, write); 1780 } 1781 oblock = bno; 1782 return (obuff+off); 1783 } 1784 1785 static void 1786 blkio(int b, char *buf, ssize_t (*iofcn)()) 1787 { 1788 lseek(tfile, (long)b<<9, 0); 1789 if ((*iofcn)(tfile, buf, 512) != 512) { 1790 if (dol != zero) 1791 (void) error(32); /* Bypass this if writing null file */ 1792 } 1793 } 1794 1795 static void 1796 init(void) 1797 { 1798 long *markp; 1799 mode_t omask; 1800 1801 if (tfile != -1) { 1802 (void) close(tfile); 1803 (void) unlink(tfname); 1804 } 1805 1806 tline = 2; 1807 for (markp = names; markp < &names[26]; ) 1808 *markp++ = 0L; 1809 subnewa = 0L; 1810 anymarks = 0; 1811 iblock = -1; 1812 oblock = -1; 1813 ichanged = 0; 1814 initflg = 1; 1815 omask = umask(0); 1816 1817 if ((tfile = open(tfname, O_CREAT|O_EXCL|O_RDWR, 1818 S_IRUSR|S_IWUSR)) < 0) { 1819 puts(gettext(msgtab[70])); 1820 exit(2); 1821 } 1822 1823 umask(omask); 1824 if (xflag) { 1825 xtflag = 1; 1826 if (tpermflag) 1827 (void) crypt_close(tperm); 1828 tpermflag = 1; 1829 if (makekey(tperm)) { 1830 xtflag = 0; 1831 puts(gettext(msgtab[65])); 1832 } 1833 } 1834 brk((char *)fendcore); 1835 dot = zero = dol = savdot = savdol = fendcore; 1836 flag28 = save28 = 0; 1837 endcore = fendcore - sizeof (struct lin); 1838 } 1839 1840 static void 1841 global(int k) 1842 { 1843 char *gp; 1844 wchar_t l; 1845 char multic[MB_LEN_MAX]; 1846 wchar_t c; 1847 LINE a1; 1848 char globuf[LBSIZE]; 1849 int n; 1850 int len; 1851 1852 if (globp) 1853 (void) error(33); 1854 setall(); 1855 nonzero(); 1856 if ((n = _mbftowc(multic, &l, getchr, &peekc)) <= 0) 1857 (void) error(67); 1858 if (l == '\n') 1859 (void) error(19); 1860 save(); 1861 comple(l); 1862 gp = globuf; 1863 while ((c = get_wchr()) != '\n') { 1864 if (c == EOF) 1865 (void) error(19); 1866 1867 /* '\\' has special meaning only if preceding a '\n' */ 1868 if (c == '\\') { 1869 c = get_wchr(); 1870 if (c != '\n') 1871 *gp++ = '\\'; 1872 } 1873 if ((gp + (unsigned int)MB_CUR_MAX) >= &globuf[LBSIZE-1]) 1874 (void) error(34); 1875 if ((len = wctomb(gp, c)) <= 0) { 1876 *gp = (unsigned char)c; 1877 len = 1; 1878 } 1879 gp += len; 1880 } 1881 if (gp == globuf) 1882 *gp++ = 'p'; 1883 *gp++ = '\n'; 1884 *gp++ = 0; 1885 for (a1 = zero; a1 <= dol; a1++) { 1886 a1->cur &= ~01; 1887 if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k) 1888 a1->cur |= 01; 1889 } 1890 /* 1891 * Special case: g/.../d (avoid n^2 algorithm) 1892 */ 1893 if (globuf[0] == 'd' && globuf[1] == '\n' && globuf[2] == '\0') { 1894 gdelete(); 1895 return; 1896 } 1897 for (a1 = zero; a1 <= dol; a1++) { 1898 if (a1->cur & 01) { 1899 a1->cur &= ~01; 1900 dot = a1; 1901 globp = globuf; 1902 globflg = 1; 1903 commands(); 1904 globflg = 0; 1905 a1 = zero; 1906 } 1907 } 1908 } 1909 1910 static void 1911 join(void) 1912 { 1913 char *gp, *lp; 1914 LINE a1; 1915 1916 if (addr1 == addr2) 1917 return; 1918 gp = genbuf; 1919 for (a1 = addr1; a1 <= addr2; a1++) { 1920 lp = getaline(a1->cur); 1921 while (*gp = *lp++) 1922 if (gp++ > &genbuf[LBSIZE-1]) 1923 (void) error(27); 1924 } 1925 lp = linebuf; 1926 gp = genbuf; 1927 while (*lp++ = *gp++) 1928 ; 1929 addr1->cur = putline(); 1930 if (addr1 < addr2) 1931 rdelete(addr1+1, addr2); 1932 dot = addr1; 1933 } 1934 1935 static void 1936 substitute(int inglob) 1937 { 1938 int nl; 1939 LINE a1; 1940 long *markp; 1941 int ingsav; /* For saving arg. */ 1942 1943 ingsav = inglob; 1944 ocerr2 = 0; 1945 gsubf = compsub(); 1946 for (a1 = addr1; a1 <= addr2; a1++) { 1947 if (execute(0, a1) == 0) 1948 continue; 1949 numpass = 0; 1950 ocerr1 = 0; 1951 inglob |= 01; 1952 dosub(); 1953 if (gsubf) { 1954 while (*loc2) { 1955 if (execute(1, (LINE)0) == 0) 1956 break; 1957 dosub(); 1958 } 1959 } 1960 if (ocerr1 == 0)continue; /* Don't put out-not changed. */ 1961 subnewa = putline(); 1962 a1->cur &= ~01; 1963 if (anymarks) { 1964 for (markp = names; markp < &names[26]; markp++) 1965 if (*markp == a1->cur) 1966 *markp = subnewa; 1967 } 1968 a1->cur = subnewa; 1969 append(getsub, a1); 1970 nl = nline; 1971 a1 += nl; 1972 addr2 += nl; 1973 } 1974 if (ingsav) 1975 return; /* Was in global-no error msg allowed. */ 1976 if (inglob == 0) 1977 (void) error(35); /* Not in global, but not found. */ 1978 if (ocerr2 == 0) 1979 (void) error(35); /* RE found, but occurrence match failed. */ 1980 } 1981 1982 static int 1983 compsub(void) 1984 { 1985 int c; 1986 wchar_t seof; 1987 char *p; 1988 char multic[MB_LEN_MAX]; 1989 int n; 1990 static char remem[RHSIZE]; 1991 static int remflg = -1; 1992 int i; 1993 1994 if ((n = _mbftowc(multic, &seof, getchr, &peekc)) <= 0) 1995 (void) error(67); 1996 if (seof == '\n' || seof == ' ') 1997 (void) error(36); 1998 comple(seof); 1999 p = rhsbuf; 2000 for (;;) { 2001 wchar_t cl; 2002 if ((n = _mbftowc(multic, &cl, getchr, &peekc)) <= 0) 2003 (void) error(67); 2004 if (cl == '\\') { 2005 *p++ = '\\'; 2006 if (p >= &rhsbuf[RHSIZE]) 2007 (void) error(38); 2008 if ((n = _mbftowc(multic, &cl, getchr, &peekc)) <= 0) 2009 (void) error(67); 2010 } else if (cl == '\n') { 2011 if (nodelim == 1) { 2012 nodelim = 0; 2013 (void) error(36); 2014 } 2015 if (!(globp && globp[0])) { 2016 UNGETC('\n'); 2017 pflag++; 2018 break; 2019 } 2020 } else if (cl == seof) 2021 break; 2022 if (p + n > &rhsbuf[RHSIZE]) 2023 (void) error(38); 2024 (void) strncpy(p, multic, n); 2025 p += n; 2026 } 2027 *p++ = 0; 2028 if (rhsbuf[0] == '%' && rhsbuf[1] == 0) 2029 /* 2030 * If there isn't a remembered string, it is an error; 2031 * otherwise the right hand side is the previous right 2032 * hand side. 2033 */ 2034 2035 if (remflg == -1) 2036 (void) error(55); 2037 else 2038 strcpy(rhsbuf, remem); 2039 else { 2040 strcpy(remem, rhsbuf); 2041 remflg = 0; 2042 } 2043 c = 0; 2044 peekc = getchr(); /* Gets char after third delimiter. */ 2045 if (peekc == 'g') { 2046 c = LBSIZE; peekc = 0; 2047 } 2048 if (peekc >= '1' && peekc <= '9') { 2049 c = peekc-'0'; 2050 peekc = 0; /* Allows getchr() to get next char. */ 2051 while (1) { 2052 i = getchr(); 2053 if (i < '0' || i > '9') 2054 break; 2055 c = c*10 + i-'0'; 2056 if (c > LBSIZE-1) 2057 (void) error(20); /* "Illegal suffix" */ 2058 } 2059 peekc = i; /* Effectively an unget. */ 2060 } 2061 newline(); 2062 return (c); 2063 2064 /* 2065 * Returns occurrence value. 0 & 1 both do first occurrence 2066 * only: c = 0 if ordinary substitute; c = 1 2067 * if use 1 in global sub(s/a/b/1). 0 in global form is illegal. 2068 */ 2069 } 2070 2071 static int 2072 getsub(void) 2073 { 2074 char *p1, *p2; 2075 2076 p1 = linebuf; 2077 if ((p2 = linebp) == 0) 2078 return (EOF); 2079 while (*p1++ = *p2++) 2080 ; 2081 linebp = 0; 2082 return (0); 2083 } 2084 2085 static void 2086 dosub(void) 2087 { 2088 char *lp, *sp, *rp; 2089 int c; 2090 2091 if (gsubf > 0 && gsubf < LBSIZE) { 2092 numpass++; 2093 if (gsubf != numpass) 2094 return; 2095 } 2096 ocerr1++; 2097 ocerr2++; 2098 lp = linebuf; 2099 sp = genbuf; 2100 rp = rhsbuf; 2101 while (lp < loc1) 2102 *sp++ = *lp++; 2103 while (c = *rp++) { 2104 if (c == '&') { 2105 sp = place(sp, loc1, loc2); 2106 continue; 2107 } else if (c == '\\') { 2108 c = *rp++; 2109 if (c >= '1' && c < nbra + '1') { 2110 sp = place(sp, braslist[c-'1'], 2111 braelist[c-'1']); 2112 continue; 2113 } 2114 } 2115 *sp++ = c; 2116 if (sp >= &genbuf[LBSIZE]) 2117 (void) error(27); 2118 } 2119 lp = loc2; 2120 loc2 = sp - genbuf + linebuf; 2121 while (*sp++ = *lp++) 2122 if (sp >= &genbuf[LBSIZE]) 2123 (void) error(27); 2124 lp = linebuf; 2125 sp = genbuf; 2126 while (*lp++ = *sp++) 2127 ; 2128 } 2129 2130 static char * 2131 place(char *sp, char *l1, char *l2) 2132 { 2133 2134 while (l1 < l2) { 2135 *sp++ = *l1++; 2136 if (sp >= &genbuf[LBSIZE]) 2137 (void) error(27); 2138 } 2139 return (sp); 2140 } 2141 2142 static void 2143 comple(wchar_t seof) 2144 { 2145 int cclass = 0; 2146 wchar_t c; 2147 int n; 2148 char *cp = genbuf; 2149 char multic[MB_LEN_MAX]; 2150 2151 while (1) { 2152 if ((n = _mbftowc(multic, &c, getchr, &peekc)) < 0) 2153 error1(67); 2154 if (n == 0 || c == '\n') { 2155 if (cclass) 2156 error1(49); 2157 else 2158 break; 2159 } 2160 if (c == seof && !cclass) 2161 break; 2162 if (cclass && c == ']') { 2163 cclass = 0; 2164 if (cp > &genbuf[LBSIZE-1]) 2165 error1(50); 2166 *cp++ = ']'; 2167 continue; 2168 } 2169 if (c == '[' && !cclass) { 2170 cclass = 1; 2171 if (cp > &genbuf[LBSIZE-1]) 2172 error1(50); 2173 *cp++ = '['; 2174 if ((n = _mbftowc(multic, &c, getchr, &peekc)) < 0) 2175 error1(67); 2176 if (n == 0 || c == '\n') 2177 error1(49); 2178 } 2179 if (c == '\\' && !cclass) { 2180 if (cp > &genbuf[LBSIZE-1]) 2181 error1(50); 2182 *cp++ = '\\'; 2183 if ((n = _mbftowc(multic, &c, getchr, &peekc)) < 0) 2184 error1(67); 2185 if (n == 0 || c == '\n') 2186 error1(36); 2187 } 2188 if (cp + n > &genbuf[LBSIZE-1]) 2189 error1(50); 2190 (void) strncpy(cp, multic, n); 2191 cp += n; 2192 } 2193 *cp = '\0'; 2194 if (n != 0 && c == '\n') 2195 UNGETC('\n'); 2196 if (n == 0 || c == '\n') 2197 nodelim = 1; 2198 2199 /* 2200 * NULL RE: do not compile a null regular expression; but process 2201 * input with last regular expression encountered 2202 */ 2203 2204 if (genbuf[0] != '\0') { 2205 if (expbuf) 2206 free(expbuf); 2207 expbuf = compile(genbuf, (char *)0, (char *)0); 2208 } 2209 if (regerrno) 2210 error1(regerrno); 2211 } 2212 2213 static void 2214 move(int cflag) 2215 { 2216 LINE adt, ad1, ad2; 2217 2218 setdot(); 2219 nonzero(); 2220 if ((adt = address()) == 0) 2221 (void) error(39); 2222 newline(); 2223 if (!globflg) save(); 2224 if (cflag) { 2225 ad1 = dol; 2226 append(getcopy, ad1++); 2227 ad2 = dol; 2228 } else { 2229 ad2 = addr2; 2230 for (ad1 = addr1; ad1 <= ad2; ) 2231 (ad1++)->cur &= ~01; 2232 ad1 = addr1; 2233 } 2234 ad2++; 2235 if (adt < ad1) { 2236 dot = adt + (ad2-ad1); 2237 if ((++adt) == ad1) 2238 return; 2239 reverse(adt, ad1); 2240 reverse(ad1, ad2); 2241 reverse(adt, ad2); 2242 } else if (adt >= ad2) { 2243 dot = adt++; 2244 reverse(ad1, ad2); 2245 reverse(ad2, adt); 2246 reverse(ad1, adt); 2247 } else 2248 (void) error(39); 2249 fchange = 1; 2250 } 2251 2252 static void 2253 reverse(LINE a1, LINE a2) 2254 { 2255 long t; 2256 2257 for (;;) { 2258 t = (--a2)->cur; 2259 if (a2 <= a1) 2260 return; 2261 a2->cur = a1->cur; 2262 (a1++)->cur = t; 2263 } 2264 } 2265 2266 static int 2267 getcopy(void) 2268 { 2269 2270 if (addr1 > addr2) 2271 return (EOF); 2272 (void) getaline((addr1++)->cur); 2273 return (0); 2274 } 2275 2276 2277 /* 2278 * Handles error code returned from comple() routine: regular expression 2279 * compile and match routines 2280 */ 2281 2282 static void 2283 error1(int code) 2284 { 2285 nbra = 0; 2286 (void) error(code); 2287 } 2288 2289 2290 static int 2291 execute(int gf, LINE addr) 2292 { 2293 char *p1; 2294 int c; 2295 2296 for (c = 0; c < nbra; c++) { 2297 braslist[c] = 0; 2298 braelist[c] = 0; 2299 } 2300 if (gf) 2301 locs = p1 = loc2; 2302 else { 2303 if (addr == zero) 2304 return (0); 2305 p1 = getaline(addr->cur); 2306 locs = 0; 2307 } 2308 return (step(p1, expbuf)); 2309 } 2310 2311 2312 static void 2313 putd() 2314 { 2315 int r; 2316 2317 r = (int)(count%10); 2318 count /= 10; 2319 if (count) 2320 putd(); 2321 putchr(r + '0'); 2322 } 2323 2324 2325 int 2326 puts(const char *sp) 2327 { 2328 int n; 2329 wchar_t c; 2330 int sz, i; 2331 if (fss.Ffill && (listf == 0)) { 2332 2333 /* deliberate attempt to remove constness of sp because */ 2334 /* it needs to be expanded */ 2335 2336 if ((i = expnd((char *)sp, funny, &sz, &fss)) == -1) { 2337 write(1, funny, fss.Flim & 0377); 2338 putchr('\n'); 2339 write(1, gettext("too long"), 2340 strlen(gettext("too long"))); 2341 } 2342 else 2343 write(1, funny, sz); 2344 putchr('\n'); 2345 if (i == -2) 2346 write(1, gettext("tab count\n"), 2347 strlen(gettext("tab count\n"))); 2348 return (0); 2349 } 2350 col = 0; 2351 while (*sp) { 2352 n = mbtowc(&c, sp, MB_LEN_MAX); 2353 if (listf) { 2354 if (n < 1) 2355 (void) error(28); 2356 else if (n == 1) 2357 putchr((unsigned char)*sp++); 2358 else { 2359 sp += n; 2360 putwchr(c); 2361 } 2362 } else { 2363 putchr((unsigned char)*sp++); 2364 } 2365 } 2366 #ifndef XPG6 2367 if (listf) 2368 putchr('$'); /* end of line is marked with a $ */ 2369 #else 2370 if (listf) { 2371 /* xpg6 - ensure that the end of line $ is not preceeded with a "\" */ 2372 /* by doing a putchr() with listf=0, thereby avoiding the $ case */ 2373 /* statement in putchr() */ 2374 listf = 0; 2375 putchr('$'); /* end of line is marked with a $ */ 2376 listf++; 2377 } 2378 #endif 2379 putchr('\n'); 2380 return (1); 2381 } 2382 2383 2384 static void 2385 putwchr(wchar_t ac) 2386 { 2387 char buf[MB_LEN_MAX], *p; 2388 char *lp; 2389 wchar_t c; 2390 short len; 2391 2392 lp = linp; 2393 c = ac; 2394 if (listf) { 2395 if (!iswprint(c)) { 2396 p = &buf[0]; 2397 if ((len = wctomb(p, c)) <= 0) { 2398 *p = (unsigned char)c; 2399 len = 1; 2400 }; 2401 while (len--) { 2402 if (col + 4 >= 72) { 2403 col = 0; 2404 *lp++ = '\\'; 2405 *lp++ = '\n'; 2406 } 2407 (void) sprintf(lp, "\\%03o", 2408 *(unsigned char *)p++); 2409 col += 4; 2410 lp += 4; 2411 } 2412 } else { 2413 if ((len = wcwidth(c)) <= 0) 2414 len = 0; 2415 if (col + len >= 72) { 2416 col = 0; 2417 *lp++ = '\\'; 2418 *lp++ = '\n'; 2419 } 2420 col += len; 2421 if ((len = wctomb(lp, c)) <= 0) { 2422 *lp = (unsigned char)c; 2423 len = 1; 2424 } 2425 lp += len; 2426 } 2427 } else { 2428 if ((len = wctomb(lp, c)) <= 0) { 2429 *lp = (unsigned char)c; 2430 len = 1; 2431 } 2432 lp += len; 2433 } 2434 if (c == '\n' || lp >= &line[64]) { 2435 linp = line; 2436 len = lp - line; 2437 write(1, line, len); 2438 return; 2439 } 2440 linp = lp; 2441 } 2442 2443 2444 static void 2445 putchr(unsigned char c) 2446 { 2447 char *lp; 2448 int len; 2449 2450 lp = linp; 2451 if (listf && c != '\n') { 2452 switch (c) { 2453 case '\\' : 2454 *lp++ = '\\'; 2455 *lp++ = '\\'; 2456 col += 2; 2457 break; 2458 case '\007' : 2459 *lp++ = '\\'; 2460 *lp++ = 'a'; 2461 col += 2; 2462 break; 2463 case '\b' : 2464 *lp++ = '\\'; 2465 *lp++ = 'b'; 2466 col += 2; 2467 break; 2468 case '\f' : 2469 *lp++ = '\\'; 2470 *lp++ = 'f'; 2471 col += 2; 2472 break; 2473 case '\r' : 2474 *lp++ = '\\'; 2475 *lp++ = 'r'; 2476 col += 2; 2477 break; 2478 case '\t' : 2479 *lp++ = '\\'; 2480 *lp++ = 't'; 2481 col += 2; 2482 break; 2483 case '\v' : 2484 *lp++ = '\\'; 2485 *lp++ = 'v'; 2486 col += 2; 2487 break; 2488 #ifdef XPG6 2489 /* if $ characters are within the line preceed with \ */ 2490 case '$' : 2491 *lp++ = '\\'; 2492 *lp++ = '$'; 2493 col += 2; 2494 break; 2495 #endif 2496 default: 2497 if (isprint(c)) { 2498 *lp++ = c; 2499 col += 1; 2500 } else { 2501 (void) sprintf(lp, "\\%03o", c); 2502 col += 4; 2503 lp += 4; 2504 } 2505 break; 2506 } 2507 2508 /* 2509 * long lines are folded w/ pt of folding indicated by writing 2510 * backslash/newline character 2511 */ 2512 2513 if (col + 1 >= 72) { 2514 col = 0; 2515 *lp++ = '\\'; 2516 *lp++ = '\n'; 2517 } 2518 } else 2519 *lp++ = c; 2520 if (c == '\n' || lp >= &line[64]) { 2521 linp = line; 2522 len = lp - line; 2523 (void) write(1, line, len); 2524 return; 2525 } 2526 linp = lp; 2527 } 2528 2529 2530 static char * 2531 getkey(const char *prompt) 2532 { 2533 struct termio b; 2534 int save; 2535 void (*sig)(); 2536 static char key[KSIZE+1]; 2537 char *p; 2538 int c; 2539 2540 sig = signal(SIGINT, SIG_IGN); 2541 ioctl(0, TCGETA, &b); 2542 save = b.c_lflag; 2543 b.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL); 2544 ioctl(0, TCSETAW, &b); 2545 write(1, gettext(prompt), strlen(gettext(prompt))); 2546 p = key; 2547 while (((c = getchr()) != EOF) && (c != '\n')) { 2548 if (p < &key[KSIZE]) 2549 *p++ = c; 2550 } 2551 *p = 0; 2552 write(1, "\n", 1); 2553 b.c_lflag = save; 2554 ioctl(0, TCSETAW, &b); 2555 signal(SIGINT, sig); 2556 return (key); 2557 } 2558 2559 2560 static void 2561 globaln(int k) 2562 { 2563 char *gp; 2564 int c; 2565 int n; 2566 wchar_t cl; 2567 LINE a1; 2568 int nfirst; 2569 char globuf[LBSIZE]; 2570 char multic[MB_LEN_MAX]; 2571 int len; 2572 int pflag_save = 0; 2573 int listf_save = 0; 2574 int listn_save = 0; 2575 2576 if (globp) 2577 (void) error(33); 2578 setall(); 2579 nonzero(); 2580 if ((n = _mbftowc(multic, &cl, getchr, &peekc)) <= 0) 2581 (void) error(67); 2582 if (cl == '\n') 2583 (void) error(19); 2584 save(); 2585 comple(cl); 2586 for (a1 = zero; a1 <= dol; a1++) { 2587 a1->cur &= ~01; 2588 if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k) 2589 a1->cur |= 01; 2590 } 2591 nfirst = 0; 2592 newline(); 2593 /* 2594 * preserve the p, l, and n suffix commands of the G and V 2595 * commands during the interactive section and restore 2596 * on completion of the G and V command. 2597 */ 2598 pflag_save = pflag; 2599 listf_save = listf; 2600 listn_save = listn; 2601 pflag = 0; 2602 listf = 0; 2603 listn = 0; 2604 for (a1 = zero; a1 <= dol; a1++) { 2605 if (a1->cur & 01) { 2606 a1->cur &= ~01; 2607 dot = a1; 2608 puts(getaline(a1->cur)); 2609 if ((c = get_wchr()) == EOF) 2610 (void) error(52); 2611 if (c == 'a' || c == 'i' || c == 'c') 2612 (void) error(53); 2613 if (c == '\n') { 2614 a1 = zero; 2615 continue; 2616 } 2617 if (c != '&') { 2618 gp = globuf; 2619 if ((len = wctomb(gp, c)) <= 0) { 2620 *gp = (unsigned char)c; 2621 len = 1; 2622 } 2623 gp += len; 2624 while ((c = get_wchr()) != '\n') { 2625 2626 /* '\\' has special meaning only if preceding a '\n' */ 2627 if (c == '\\') { 2628 c = get_wchr(); 2629 if (c != '\n') 2630 *gp++ = '\\'; 2631 } 2632 if ((gp + (unsigned int)MB_CUR_MAX) >= 2633 &globuf[LBSIZE-1]) 2634 (void) error(34); 2635 2636 if ((len = wctomb(gp, c)) <= 0) { 2637 *gp = (unsigned char)c; 2638 len = 1; 2639 } 2640 gp += len; 2641 } 2642 *gp++ = '\n'; 2643 *gp++ = 0; 2644 nfirst = 1; 2645 } else if ((c = get_wchr()) != '\n') 2646 (void) error(54); 2647 globp = globuf; 2648 if (nfirst) { 2649 globflg = 1; 2650 commands(); 2651 globflg = 0; 2652 } else 2653 (void) error(56); 2654 globp = 0; 2655 a1 = zero; 2656 } 2657 } 2658 pflag = pflag_save; 2659 listf = listf_save; 2660 listn = listn_save; 2661 } 2662 2663 2664 static int 2665 eopen(char *string, int rw) 2666 { 2667 #define w_or_r(a, b) (rw ? a : b) 2668 int pf[2]; 2669 pid_t i; 2670 int io; 2671 int chcount; /* # of char read. */ 2672 2673 if (rflg) { /* restricted shell */ 2674 if (Xqt) { 2675 Xqt = 0; 2676 (void) error(6); 2677 } 2678 } 2679 if (!Xqt) { 2680 if ((io = open(string, rw)) >= 0) { 2681 if (fflg) { 2682 chcount = read(io, crbuf, LBSIZE); 2683 if (crflag == -1) { 2684 if (isencrypt(crbuf, chcount)) 2685 crflag = 2; 2686 else 2687 crflag = -2; 2688 } 2689 if (crflag > 0) 2690 if (run_crypt(0L, crbuf, chcount, perm) == -1) 2691 (void) error(63); 2692 if (fspec(crbuf, &fss, 0) < 0) { 2693 fss.Ffill = 0; 2694 fflg = 0; 2695 (void) error(4); 2696 } 2697 lseek(io, 0L, 0); 2698 } 2699 } 2700 fflg = 0; 2701 return (io); 2702 } 2703 if (pipe(pf) < 0) 2704 xerr: (void) error(0); 2705 if ((i = fork()) == 0) { 2706 signal(SIGHUP, oldhup); 2707 signal(SIGQUIT, oldquit); 2708 signal(SIGPIPE, oldpipe); 2709 signal(SIGINT, (void (*)()) 0); 2710 close(w_or_r(pf[1], pf[0])); 2711 close(w_or_r(0, 1)); 2712 dup(w_or_r(pf[0], pf[1])); 2713 close(w_or_r(pf[0], pf[1])); 2714 execlp(_PATH_BSHELL, "sh", "-c", string, (char *)0); 2715 exit(1); 2716 } 2717 if (i == (pid_t)-1) 2718 goto xerr; 2719 close(w_or_r(pf[0], pf[1])); 2720 return (w_or_r(pf[1], pf[0])); 2721 } 2722 2723 2724 static void 2725 eclose(int f) 2726 { 2727 close(f); 2728 if (Xqt) 2729 Xqt = 0, wait((int *)0); 2730 } 2731 2732 2733 static void 2734 mkfunny(void) 2735 { 2736 char *p, *p1, *p2; 2737 2738 p2 = p1 = funny; 2739 p = file; 2740 /* 2741 * Go to end of file name 2742 */ 2743 while (*p) 2744 p++; 2745 while (*--p == '/') /* delete trailing slashes */ 2746 *p = '\0'; 2747 /* 2748 * go back to beginning of file 2749 */ 2750 p = file; 2751 /* 2752 * Copy file name to funny setting p2 at 2753 * basename of file. 2754 */ 2755 while (*p1++ = *p) 2756 if (*p++ == '/') 2757 p2 = p1; 2758 /* 2759 * Set p1 to point to basename of tfname. 2760 */ 2761 p1 = strrchr(tfname, '/'); 2762 if (strlen(tfname) > (size_t)6) 2763 p1 = &tfname[strlen(tfname)-6]; 2764 p1++; 2765 *p2 = '\007'; /* add unprintable char for funny a unique name */ 2766 /* 2767 * Copy tfname to file. 2768 */ 2769 while (*++p2 = *p1++) 2770 ; 2771 } 2772 2773 2774 static void 2775 getime(void) /* get modified time of file and save */ 2776 { 2777 if (stat(file, &Fl) < 0) 2778 savtime = 0; 2779 else 2780 savtime = Fl.st_mtime; 2781 } 2782 2783 2784 static void 2785 chktime(void) /* check saved mod time against current mod time */ 2786 { 2787 if (savtime != 0 && Fl.st_mtime != 0) { 2788 if (savtime != Fl.st_mtime) 2789 (void) error(58); 2790 } 2791 } 2792 2793 2794 static void 2795 newtime(void) /* get new mod time and save */ 2796 { 2797 stat(file, &Fl); 2798 savtime = Fl.st_mtime; 2799 } 2800 2801 2802 /* 2803 * restricted - check for '/' in name and delete trailing '/' 2804 */ 2805 static void 2806 red(char *op) 2807 { 2808 char *p; 2809 2810 p = op; 2811 while (*p) 2812 if (*p++ == '/'&& rflg) { 2813 *op = 0; 2814 (void) error(6); 2815 } 2816 /* delete trailing '/' */ 2817 while (p > op) { 2818 if (*--p == '/') 2819 *p = '\0'; 2820 else break; 2821 } 2822 } 2823 2824 2825 /* 2826 * Searches thru beginning of file looking for a string of the form 2827 * <: values... :> 2828 * 2829 * where "values" are 2830 * 2831 * \b ignored 2832 * s<num> sets the Flim to <num> 2833 * t??? sets tab stop stuff 2834 * d ignored 2835 * m<num> ignored 2836 * e ignored 2837 */ 2838 2839 static int 2840 fspec(char line[], struct Fspec *f, int up) 2841 { 2842 struct termio arg; 2843 int havespec, n; 2844 int len; 2845 2846 if (!up) clear(f); 2847 2848 havespec = fsprtn = 0; 2849 for (fsp = line; *fsp && *fsp != '\n'; fsp += len) { 2850 if ((len = mblen(fsp, MB_CUR_MAX)) <= 0) 2851 len = 1; 2852 switch (*fsp) { 2853 2854 case '<': if (havespec) 2855 return (-1); 2856 if (*(fsp+1) == ':') { 2857 havespec = 1; 2858 clear(f); 2859 if (!ioctl(1, TCGETA, &arg) && 2860 ((arg.c_oflag & TAB3) == 2861 TAB3)) 2862 f->Ffill = 1; 2863 fsp++; 2864 } 2865 continue; 2866 2867 case ' ': continue; 2868 2869 case 's': if (havespec && (n = numb()) >= 0) 2870 f->Flim = n; 2871 continue; 2872 2873 case 't': if (havespec) targ(f); 2874 continue; 2875 2876 case 'd': continue; 2877 2878 case 'm': if (havespec) n = numb(); 2879 continue; 2880 2881 case 'e': continue; 2882 case ':': if (!havespec) continue; 2883 if (*(fsp+1) != '>') fsprtn = -1; 2884 return (fsprtn); 2885 2886 default: if (!havespec) continue; 2887 return (-1); 2888 } 2889 } 2890 return (1); 2891 } 2892 2893 2894 static int 2895 numb(void) 2896 { 2897 int n; 2898 2899 n = 0; 2900 while (*++fsp >= '0' && *fsp <= '9') 2901 n = 10*n + *fsp-'0'; 2902 fsp--; 2903 return (n); 2904 } 2905 2906 2907 static void 2908 targ(struct Fspec *f) 2909 { 2910 2911 if (*++fsp == '-') { 2912 if (*(fsp + 1) >= '0' && *(fsp+1) <= '9') tincr(numb(), f); 2913 else tstd(f); 2914 return; 2915 } 2916 if (*fsp >= '0' && *fsp <= '9') { 2917 tlist(f); 2918 return; 2919 } 2920 fsprtn = -1; 2921 fsp--; 2922 } 2923 2924 2925 static void 2926 tincr(int n, struct Fspec *f) 2927 { 2928 int l, i; 2929 2930 l = 1; 2931 for (i = 0; i < 20; i++) 2932 f->Ftabs[i] = l += n; 2933 f->Ftabs[i] = 0; 2934 } 2935 2936 2937 static void 2938 tstd(struct Fspec *f) 2939 { 2940 char std[3]; 2941 2942 std[0] = *++fsp; 2943 if (*(fsp+1) >= '0' && *(fsp+1) <= '9') { 2944 std[1] = *++fsp; 2945 std[2] = '\0'; 2946 } else { 2947 std[1] = '\0'; 2948 } 2949 fsprtn = stdtab(std, f->Ftabs); 2950 } 2951 2952 2953 static void 2954 tlist(struct Fspec *f) 2955 { 2956 int n, last, i; 2957 2958 fsp--; 2959 last = i = 0; 2960 2961 do { 2962 if ((n = numb()) <= last || i >= 20) { 2963 fsprtn = -1; 2964 return; 2965 } 2966 f->Ftabs[i++] = last = n; 2967 } while (*++fsp == ','); 2968 2969 f->Ftabs[i] = 0; 2970 fsp--; 2971 } 2972 2973 2974 static int 2975 expnd(char line[], char buf[], int *sz, struct Fspec *f) 2976 { 2977 char *l, *t; 2978 int b; 2979 2980 l = line - 1; 2981 b = 1; 2982 t = f->Ftabs; 2983 fsprtn = 0; 2984 2985 while (*++l && *l != '\n' && b < 511) { 2986 if (*l == '\t') { 2987 while (*t && b >= *t) 2988 t++; 2989 if (*t == 0) 2990 fsprtn = -2; 2991 do { 2992 buf[b-1] = ' '; 2993 } while (++b < *t); 2994 } else { 2995 buf[b++ - 1] = *l; 2996 } 2997 } 2998 2999 buf[b] = '\0'; 3000 *sz = b; 3001 if (*l != '\0' && *l != '\n') { 3002 buf[b-1] = '\n'; 3003 return (-1); 3004 } 3005 buf[b-1] = *l; 3006 if (f->Flim && (b-1 > (int)f->Flim)) 3007 return (-1); 3008 return (fsprtn); 3009 } 3010 3011 3012 static void 3013 clear(struct Fspec *f) 3014 { 3015 f->Ftabs[0] = f->Fdel = f->Fmov = f->Ffill = 0; 3016 f->Flim = 0; 3017 } 3018 3019 3020 static int 3021 lenchk(char line[], struct Fspec *f) 3022 { 3023 char *l, *t; 3024 int b; 3025 3026 l = line - 1; 3027 b = 1; 3028 t = f->Ftabs; 3029 3030 while (*++l && *l != '\n' && b < 511) { 3031 if (*l == '\t') { 3032 while (*t && b >= *t) 3033 t++; 3034 while (++b < *t) 3035 ; 3036 } else { 3037 b++; 3038 } 3039 } 3040 3041 if ((*l != '\0' && *l != '\n') || (f->Flim && (b-1 > (int)f->Flim))) 3042 return (-1); 3043 return (0); 3044 } 3045 #define NTABS 21 3046 3047 3048 /* 3049 * stdtabs: standard tabs table 3050 * format: option code letter(s), null, tabs, null 3051 */ 3052 3053 static char stdtabs[] = { 3054 'a', 0, 1, 10, 16, 36, 72, 0, /* IBM 370 Assembler */ 3055 'a', '2', 0, 1, 10, 16, 40, 72, 0, /* IBM Assembler alternative */ 3056 'c', 0, 1, 8, 12, 16, 20, 55, 0, /* COBOL, normal */ 3057 'c', '2', 0, 1, 6, 10, 14, 49, 0, /* COBOL, crunched */ 3058 'c', '3', 0, 1, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 3059 54, 58, 62, 67, 0, 3060 'f', 0, 1, 7, 11, 15, 19, 23, 0, /* FORTRAN */ 3061 'p', 0, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 0, 3062 /* PL/I */ 3063 's', 0, 1, 10, 55, 0, /* SNOBOL */ 3064 'u', 0, 1, 12, 20, 44, 0, /* UNIVAC ASM */ 3065 0 }; 3066 3067 3068 /* 3069 * stdtab: return tab list for any "canned" tab option. 3070 * entry: option points to null-terminated option string 3071 * tabvect points to vector to be filled in 3072 * exit: return (0) if legal, tabvect filled, ending with zero 3073 * return (-1) if unknown option 3074 */ 3075 3076 3077 static int 3078 stdtab(char option[], char tabvect[NTABS]) 3079 { 3080 char *scan; 3081 tabvect[0] = 0; 3082 scan = stdtabs; 3083 while (*scan) { 3084 if (strequal(&scan, option)) { 3085 strcopy(scan, tabvect); 3086 break; 3087 } else 3088 while (*scan++) /* skip over tab specs */ 3089 ; 3090 } 3091 3092 /* later: look up code in /etc/something */ 3093 return (tabvect[0] ? 0 : -1); 3094 } 3095 3096 3097 /* 3098 * strequal: checks strings for equality 3099 * entry: scan1 points to scan pointer, str points to string 3100 * exit: return (1) if equal, return (0) if not 3101 * *scan1 is advanced to next nonzero byte after null 3102 */ 3103 3104 3105 static int 3106 strequal(char **scan1, char *str) 3107 { 3108 char c, *scan; 3109 scan = *scan1; 3110 while ((c = *scan++) == *str && c) 3111 str++; 3112 *scan1 = scan; 3113 if (c == 0 && *str == 0) 3114 return (1); 3115 if (c) 3116 while (*scan++) 3117 ; 3118 *scan1 = scan; 3119 return (0); 3120 } 3121 3122 3123 /* strcopy: copy source to destination */ 3124 3125 3126 static void 3127 strcopy(char *source, char *dest) 3128 { 3129 while (*dest++ = *source++) 3130 ; 3131 } 3132 3133 3134 /* This is called before a buffer modifying command so that the */ 3135 /* current array of line ptrs is saved in sav and dot and dol are saved */ 3136 3137 3138 static void 3139 save(void) 3140 { 3141 LINE i; 3142 int j; 3143 3144 savdot = dot; 3145 savdol = dol; 3146 for (j = 0; j <= 25; j++) 3147 savnames[j] = names[j]; 3148 3149 for (i = zero + 1; i <= dol; i++) 3150 i->sav = i->cur; 3151 initflg = 0; 3152 } 3153 3154 3155 /* The undo command calls this to restore the previous ptr array sav */ 3156 /* and swap with cur - dot and dol are swapped also. This allows user to */ 3157 /* undo an undo */ 3158 3159 3160 static void 3161 undo(void) 3162 { 3163 int j; 3164 long tmp; 3165 LINE i, tmpdot, tmpdol; 3166 3167 tmpdot = dot; dot = savdot; savdot = tmpdot; 3168 tmpdol = dol; dol = savdol; savdol = tmpdol; 3169 /* swap arrays using the greater of dol or savdol as upper limit */ 3170 for (i = zero + 1; i <= ((dol > savdol) ? dol : savdol); i++) { 3171 tmp = i->cur; 3172 i->cur = i->sav; 3173 i->sav = tmp; 3174 } 3175 /* 3176 * If the current text lines are swapped with the 3177 * text lines in the save buffer, then swap the current 3178 * marks with those in the save area. 3179 */ 3180 3181 for (j = 0; j <= 25; j++) { 3182 tmp = names[j]; 3183 names[j] = savnames[j]; 3184 savnames[j] = tmp; 3185 } 3186 } 3187 3188 static wchar_t 3189 get_wchr(void) 3190 { 3191 wchar_t wc; 3192 char multi[MB_LEN_MAX]; 3193 3194 if (_mbftowc(multi, &wc, getchr, &peekc) <= 0) 3195 wc = getchr(); 3196 return (wc); 3197 } 3198