![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to visual.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / news / src|
Return to visual.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / news / src |
1.1 root 1: /*
2: * visual - visual news interface.
3: * Kenneth Almquist
4: */
5:
6: #ifdef SCCSID
7: static char *SccsId = "@(#)visual.c 1.38 10/15/87";
8: #endif /* SCCSID */
9:
10: #include "rparams.h"
11: #ifdef USG
12: #include <sys/ioctl.h>
13: #include <termio.h>
14: #include <fcntl.h>
15: #else /* !USG */
16: #include <sgtty.h>
17: #endif /* !USG */
18:
19: #include <errno.h>
20: #ifdef BSD4_2
21: #ifndef sigmask
22: #define sigmask(m) (1<<((m)-1))
23: #endif /* !sigmask */
24: #endif /* BSD4_2 */
25:
26: #ifdef MYDB
27: #include "db.h"
28: #endif /* MYDB */
29:
30: extern int errno;
31:
32: #ifdef SIGTSTP
33: #include <setjmp.h>
34: #endif /* SIGTSTP */
35:
36: #define ARTWLEN (ROWS-2)/* number of lines used to display article */
37: #define even(cols) ((cols&1) ? cols + 1 : cols)
38: #ifdef STATTOP
39: #define PRLINE 0 /* prompter line */
40: #define SPLINE 1 /* secondary prompt line */
41: #define ARTWIN 2 /* first line of article window */
42: #define SECPRLEN 81 /* length of secondary prompter */
43: #else
44: #define PRLINE (ROWS-1)/* prompter line */
45: #define SPLINE (ROWS-2)/* secondary prompt line */
46: #define ARTWIN 0 /* first line of article window */
47: #define SECPRLEN 100 /* length of secondary prompter */
48: #endif
49:
50: #define PIPECHAR '|' /* indicate save command should pipe to program */
51: #define CAGAIN ('e'&0x1F) /* Save-to-same-place indicator */
52: #define META 0200 /* meta character bit (as in emacs) */
53: /* print (display) flags */
54: #define HDRONLY 0001 /* print header only */
55: #define NOPRT 0002 /* don't print at all */
56: #define NEWART 0004 /* force article display to be regenerated */
57: #define HELPMSG 0010 /* display currently contains help message */
58: /* prun flags */
59: #define CWAIT 0001 /* type "continue?" and wait for return */
60: #define BKGRND 0002 /* run process in the background */
61: /* values of curflag */
62: #define CURP1 1 /* cursor after prompt */
63: #define CURP2 2 /* cursor after secondary prompt */
64: #define CURHOME 3 /* cursor at home position */
65: /* flags for vsave routine */
66: #define SVHEAD 01 /* write out article header */
67: #define OVWRITE 02 /* overwrite the file if it already exists */
68: /* other files */
69:
70: #define saveart oobit = bit;strcpy(ofilename1, filename);strcpy(ogroupdir, groupdir);hptr = h;h = hold;hold = hptr;ongsize = pngsize
71: #define NLINES(h, fp) (h->numlines[0] ? h->intnumlines : (h->intnumlines=linecnt(fp),sprintf(h->numlines, "%d", h->intnumlines), h->intnumlines))
72:
73: /* terminal handler stuff */
74: extern int _junked;
75: #define okclear() (_junked = 1)
76: extern int COLS;
77: extern int ROWS;
78: extern int hasscroll;
79:
80: FILE *tmpfile();
81: char *getmailname();
82: #ifdef MYDB
83: char *findparent();
84: #endif /* MYDB */
85: int onint();
86: int onstop();
87: int xxit();
88:
89: char *Progname = "vnews"; /* for xerror */
90:
91: /* variables shared between vnews routines */
92: static char linebuf[LBUFLEN]; /* temporary workspace */
93: static FILE *tfp; /* temporary file */
94: static char tfname[] = "/tmp/vnXXXXXX"; /* name of temp file */
95: static long artbody; /* offset of body into article */
96: static int quitflg; /* if set, then quit */
97: static int erased; /* current article has been erased */
98: static int artlines; /* # lines in article body */
99: static int artread; /* entire article has been read */
100: static int hdrstart; /* beginning of header */
101: static int hdrend; /* end of header */
102: static int lastlin; /* number of lines in tempfile */
103: static int tflinno = 0; /* next line in tempfile */
104: static int maxlinno; /* number of lines in file + folded */
105: static char secpr[SECPRLEN]; /* secondary prompt */
106: static char prompt[30]; /* prompter */
107: static short prflags; /* print flags (controls updscr) */
108: static short curflag; /* where to locate cursor */
109: static int dlinno; /* top line on screen */
110: static char timestr[20]; /* current time */
111: static int ismail; /* true if user has mail */
112: static char *mailf; /* user's mail file */
113: static int alflag; /* set if unprocessed alarm signal */
114: static int atend; /* set if at end of article */
115: static char cerase; /* erase character */
116: static char ckill; /* kill character */
117: static char cintr; /* interrupt character */
118: #ifdef TIOCGLTC
119: static char cwerase; /* word erase character */
120: #endif /* TIOCGLTC */
121: short ospeed; /* terminal speed NOT STATIC */
122: static int intflag; /* set if interrupt received */
123:
124: #ifdef SIGTSTP
125: static int reading; /* to keep stupid BSD from restarting reads */
126: jmp_buf intjmp, alrmjmp;
127: #endif /* SIGTSTP */
128:
129: #ifdef MYDB
130: static int hasdb; /* true if article data base exists */
131: #endif /* MYDB */
132:
133: #ifdef DIGPAGE
134: static int endsuba; /* end of sub-article in digest */
135: #endif
136:
137: #ifdef MYDEBUG
138: FILE *debugf; /* file to write debugging info on */
139: #endif
140:
141: char *tft = "/tmp/folXXXXXX";
142:
143: /*
144: * These were made static for u370 with its buggy cc.
145: * I judged it better to have one copy with no ifdefs than
146: * to conditionally compile them as automatic variables
147: * in readr (which they originally were). Performance
148: * considerations might warrant moving some of the simple
149: * things into register variables, but I don't know what
150: * breaks the u370 cc.
151: */
152: #ifndef SERVER
153: static char goodone[BUFLEN]; /* last decent article */
154: #endif /* !SERVER */
155: static char ogroupdir[BUFLEN]; /* last groupdir */
156: static char edcmdbuf[128];
157: static int rfq = 0; /* for last article */
158: static long ongsize; /* Previous ngsize */
159: static long pngsize; /* Printing ngsize */
160: static char *bptr; /* temp pointer. */
161: static char *tfilename; /* temporary file name */
162: static char ofilename1[BUFLEN]; /* previous file name */
163: static struct hbuf hbuf1, hbuf2; /* for minusing */
164: static struct hbuf *h = &hbuf1, /* current header */
165: *hold = &hbuf2, /* previous header */
166: *hptr; /* temporary */
167: static char *ptr1, *ptr2, *ptr3; /* for reply manipulation */
168: static int aabs = FALSE; /* TRUE if we asked absolutely */
169: static char *ed, tf[100];
170: static long oobit; /* last bit, really */
171: static int dgest = 0;
172: static FILE *fp; /* current article to be printed*/
173:
174: readr()
175: {
176:
177: #ifdef MYDEBUG
178: debugf = fopen("DEBUG", "w");
179: setbuf(debugf, (char *)NULL);
180: #endif
181: if (aflag) {
182: if (*datebuf) {
183: if ((atime = cgtdate(datebuf)) == -1)
184: xerror("Cannot parse date string");
185: } else
186: atime = 0;
187: }
188:
189: if (SigTrap)
190: xxit(1);
191: (void) mktemp(tfname);
192: (void) close(creat(tfname,0666));
193: if ((tfp = fopen(tfname, "w+")) == NULL)
194: xerror("Can't create temp file");
195: (void) unlink(tfname);
196: mailf = getmailname();
197: #ifdef MYDB
198: if (opendb() >= 0) {
199: hasdb = 1;
200: fputs("Using article data base\n", stderr); /*DEBUG*/
201: getng();
202: }
203: #endif
204: ttysave();
205: (void) signal(SIGINT, onint);
206: (void) signal(SIGQUIT, xxit);
207: if (SigTrap)
208: xxit(1);
209: ttyraw();
210: timer();
211:
212: /* loop reading articles. */
213: fp = NULL;
214: obit = -1;
215: nextng();
216: quitflg = 0;
217: while (quitflg == 0) {
218: if (getnextart(FALSE))
219: break;
220: #ifndef SERVER
221: (void) strcpy(goodone, filename);
222: #endif /* !SERVER */
223: if (SigTrap)
224: return;
225: vcmd();
226: }
227:
228: if (!news) {
229: ttycooked();
230: ospeed = 0; /* to convince xxit() not to clear screen */
231: fprintf(stderr, "No news.\n");
232: }
233: }
234:
235: /*
236: * Read and execute a command.
237: */
238: vcmd() {
239: register c;
240: char *p;
241: long count;
242: int countset;
243:
244: if (prflags & HDRONLY)
245: appfile(fp, lastlin + 1);
246: else
247: appfile(fp, dlinno + ARTWLEN + 1);
248:
249: #ifdef DIGPAGE
250: endsuba = findend(dlinno);
251: if (artlines > dlinno + ARTWLEN
252: || endsuba > 0 && endsuba < artlines
253: #else
254: if (artlines > dlinno + ARTWLEN
255: #endif
256: || (prflags & HDRONLY) && artlines > hdrend) {
257: atend = 0;
258: if (prflags&HDRONLY || maxlinno == 0)
259: (void) strcpy(prompt, "more? ");
260: else
261: #ifdef DIGPAGE
262: (void) sprintf(prompt, "more(%d%%)? ",
263: ((((endsuba > 0) ?
264: endsuba : (dlinno + ARTWLEN)) -
265: hdrend) * 100) / maxlinno);
266: #else /* !DIGPAGE */
267: (void) sprintf(prompt, "more(%d%%)? ",
268: ((dlinno + ARTWLEN - hdrend) * 100) / maxlinno);
269: #endif /* !DIGPAGE */
270: } else {
271: atend = 1;
272: (void) strcpy(prompt, "next? ");
273: if (!erased)
274: clear(bit); /* article read */
275: }
276: curflag = CURP1;
277: p = prompt + strlen(prompt);
278: countset = 0;
279: count = 0;
280: /*
281: * Loop while accumulating a count, until an action character
282: * is entered. Also handle "meta" here.
283: *
284: * Count is the current count. Countset=0 means no count
285: * currently exists. Countset=1, count=0 is valid and means
286: * a count of 0 has been entered
287: */
288: for (;;) {
289: c = vgetc();
290: if (c == cerase || c == '\b' || c == '\177') {
291: if (countset == 0)
292: break; /* Use as action char */
293: if (count < 10)
294: countset = 0; /* Erase only char of count */
295: else
296: count /= 10L; /* Erase 1 char of count */
297: } else {
298: #ifdef TIOCGLTC
299: if (c == ckill || c == cwerase) {
300: #else
301: if (c == ckill) {
302: #endif
303: if (countset == 0)
304: break;
305: countset = 0;
306: } else if (c < '0' || c > '9')
307: break;
308: else {
309: countset = 1;
310: count = (count * 10) + (c - '0');
311: }
312: }
313: if (countset) {
314: (void) sprintf(p, "%ld", count);
315: } else {
316: *p = '\0';
317: count = 0;
318: }
319: }
320:
321: if (c == '\033') { /* escape */
322: (void) strcat(prompt, "M-");
323: c = vgetc();
324: if (c != cintr)
325: c |= META;
326: }
327: secpr[0] = '\0';
328: if (countset == 0)
329: count = 1;
330: docmd(c, count, countset);
331: if (c != '?' && c != 'H') /* UGGH */
332: prflags &=~ HELPMSG;
333: if (dlinno > hdrstart)
334: prflags &=~ HDRONLY;
335: }
336:
337:
338: /*
339: * Process one command, which has already been typed in.
340: */
341: docmd(c, count, countset)
342: int c;
343: long count;
344: int countset;
345: {
346: int i;
347: long nart, Hoffset;
348: char *findhist();
349:
350: switch (c) {
351:
352: /* display list of articles in current group */
353: case 'l':
354: case 'L':
355: botscreen();
356: ttycooked();
357: list_group(groupdir, countset ? (int) count : 0,
358: (c == 'l') ? FALSE : TRUE, pngsize);
359: ttyraw();
360: okclear();
361: updscr();
362: break;
363:
364: /* Show more of current article, or advance to next article */
365: case '\n':
366: case ' ':
367: #ifdef DIGPAGE
368: case 'm':
369: #endif /* DIGPAGE */
370: case '\06': /* Control-F for vi compat */
371: prflags &=~ NOPRT;
372: if (atend)
373: goto next;
374: else if (prflags & HDRONLY) {
375: prflags &=~ HDRONLY;
376: if (hasscroll)
377: dlinno = hdrstart;}
378: #ifdef DIGPAGE
379: else if (endsuba > 0)
380: dlinno = endsuba;
381: else if (c == 'm') {
382: do {
383: if (lastlin >= maxlinno)
384: goto next;
385: else
386: appfile(fp, lastlin + 1);
387: } while(STRNCMP(linebuf, "------------------------", 24)
388: != 0);
389: dlinno = endsuba = lastlin;
390: }
391: #endif
392: else if ((appfile(fp, dlinno + 2 * ARTWLEN), artread)
393: && hasscroll && artlines - dlinno <= ARTWLEN + 2)
394: dlinno = artlines - ARTWLEN;
395: else
396: dlinno += ARTWLEN * count;
397: break;
398:
399: /* No. Go on to next article. */
400: case '.': /* useful if you have a keypad */
401: next: case 'n':
402: readmode = NEXT;
403: FCLOSE(fp);
404: clear(bit);
405: saveart;
406: nextbit();
407: break;
408:
409:
410: /* Back up count pages */
411: case '\b':
412: case '\177':
413: if (dlinno == 0)
414: goto backupone;
415: /* NO BREAK */
416: case META|'v':
417: case '\002': /* Control-B */
418: dlinno -= ARTWLEN * count;
419: if (dlinno < 0)
420: dlinno = 0;
421: break;
422:
423: /* forward half a page */
424: case '\004': /* Control-D, as in vi */
425: if (!atend)
426: dlinno += ARTWLEN/2 * count;
427: break;
428:
429: /* backward half a page */
430: case '\025': /* Control-U */
431: dlinno -= ARTWLEN/2 * count;
432: if (dlinno < 0)
433: dlinno = 0;
434: break;
435:
436: /* forward count lines */
437: case '\016': /* Control-N */
438: case '\005': /* Control-E */
439: dlinno += count;
440: break;
441:
442: /* backwards count lines */
443: case '\020': /* Control-P */
444: case '\031': /* Control-Y */
445: dlinno -= count;
446: if (dlinno < 0)
447: dlinno = 0;
448: break;
449:
450: /* Turn displaying of article back on */
451: case 'd':
452: prflags &=~ NOPRT;
453: break;
454:
455: /* display header */
456: case 'h':
457: dlinno = hdrstart;
458: prflags |= HDRONLY;
459: prflags &=~ NOPRT;
460: break;
461:
462: /*
463: * Unsubscribe to the newsgroup and go on to next group
464: */
465:
466: case 'U':
467: case 'u':
468: strcat(prompt, "u");
469: c = vgetc();
470: if (c == 'g') {
471: obit = -1;
472: FCLOSE(fp);
473: zapng = TRUE;
474: saveart;
475: if (nextng()) {
476: if (actdirect == BACKWARD)
477: msg("Can't back up.");
478: else
479: quitflg = 1; /* probably unnecessary */
480: }
481: } else {
482: if (c != cintr && c != ckill)
483: beep();
484: msg("Illegal command");
485: }
486: break;
487:
488: /* Print the current version of news */
489: case 'v':
490: msg("News version: %s", news_version);
491: break;
492:
493:
494: /* Decrypt joke. Always does rot 13 */
495: case 'D':
496: appfile(fp, 32767);
497: for (i = hdrend ; i < artlines ; i++) {
498: register char ch, *p;
499: tfget(linebuf, i);
500: for (p = linebuf ; (ch = *p) != '\0' ; p++) {
501: if (ch >= 'a' && ch <= 'z')
502: *p = (ch - 'a' + 13) % 26 + 'a';
503: else if (ch >= 'A' && ch <= 'Z')
504: *p = (ch - 'A' + 13) % 26 + 'A';
505: }
506: tfput(linebuf, i);
507: }
508: prflags |= NEWART;
509: prflags &=~ (HDRONLY|NOPRT);
510: break;
511:
512: /* write out the article someplace */
513: /* w writes out without the header */
514: /* | defaults to pipeing */
515: {
516: static char savebuf[BUFLEN];
517: int wflags;
518:
519: case PIPECHAR:
520: case 's':
521: case 'w':
522: /* We loop back to here each time user types ^U to prompt */
523: do {
524: /* Prompt based on command char */
525: msg( (c==PIPECHAR)? "|": "file: ");
526: curflag = CURP2;
527: while ((wflags = vgetc()) == ' ');
528: if (wflags == cintr) {
529: secpr[0] = '\0';
530: break;
531: }
532: if (wflags != CAGAIN) {
533: if ((wflags & 0x1F) == wflags) { /* control char */
534: pushback(wflags);
535: savebuf[0] = 0;
536: } else {
537: if (c == PIPECHAR) {
538: savebuf[0] = PIPECHAR;
539: savebuf[1] = wflags;
540: savebuf[2] = 0;
541: } else {
542: savebuf[0] = wflags;
543: savebuf[1] = 0;
544: }
545: }
546: } else {
547: /* don't let them pipe to a saved filename */
548: if (c == PIPECHAR && savebuf[0] != PIPECHAR) {
549: savebuf[0] = PIPECHAR;
550: savebuf[1] = 0;
551: }
552: }
553:
554: wflags = prget( (savebuf[0] == PIPECHAR) ? "" : "file: ",
555: savebuf);
556: } while (wflags == 2);
557: if (wflags) break; /* Interrupted out */
558: wflags = 0;
559: if (c == PIPECHAR) c = 's';
560: if (c == 's')
561: wflags |= SVHEAD;
562: if (count != 1)
563: wflags |= OVWRITE;
564: bptr = savebuf;
565: while( *bptr == ' ')
566: bptr++; /* strip leading spaces */
567:
568: if (*bptr != PIPECHAR && *bptr != '/') {
569: char hetyped[BUFLEN];
570: char *boxptr;
571: (void) strcpy(hetyped, bptr);
572: if (hetyped[0] == '~' && hetyped[1] == '/') {
573: strcpy(hetyped, bptr+2);
574: strcpy(bptr, userhome);
575: } else if (boxptr = getenv("NEWSBOX")) {
576: if (index(boxptr, '%')) {
577: struct stat stbf;
578: sprintf(bptr, boxptr, groupdir);
579: if (stat(bptr,&stbf) < 0) {
580: if (mkdir(bptr, 0777) < 0) {
581: msg("Cannot create directory %s", bptr);
582: break;
583: }
584: } else if ((stbf.st_mode&S_IFMT) != S_IFDIR) {
585: msg("%s not a directory", bptr);
586: break;
587: }
588: } else
589: strcpy(bptr, boxptr);
590: } else
591: bptr[0] = '\0';
592:
593: if (bptr[0])
594: (void) strcat(bptr, "/");
595: if (hetyped[0] != '\0')
596: (void) strcat(bptr, hetyped);
597: else
598: (void) strcat(bptr, "Articles");
599: }
600:
601: /* handle ~/ for pipes */
602: if (*bptr == PIPECHAR) {
603: char fullname[BUFLEN];
604: bptr++; /* skip PIPECHAR */
605: while( *bptr == ' ')
606: bptr++; /* strip leading spaces */
607: if (bptr[0] == '~' && bptr[1] == '/') {
608: strcpy(fullname,userhome);
609: strcat(fullname,bptr+2);
610: } else
611: strcpy(fullname,bptr);
612: /* we know PIPECHAR is in *savebuf */
613: strcpy(savebuf+1,fullname);
614: bptr = savebuf;
615: }
616:
617: vsave(bptr, wflags);
618: break;
619: }
620:
621: /* back up */
622: case '-':
623: caseminus:
624: aabs = TRUE;
625: if (!*ofilename1) {
626: msg("Can't back up.");
627: break;
628: }
629: FCLOSE(fp);
630: hptr = h;
631: h = hold;
632: hold = hptr;
633: (void) strcpy(bfr, filename);
634: (void) strcpy(filename, ofilename1);
635: (void) strcpy(ofilename1, bfr);
636: obit = bit;
637: if (STRCMP(groupdir, ogroupdir)) {
638: (void) strcpy(bfr, groupdir);
639: selectng(ogroupdir, FALSE, FALSE);
640: (void) strcpy(groupdir, ogroupdir);
641: (void) strcpy(ogroupdir, bfr);
642: ngrp = 1;
643: back();
644: }
645: bit = oobit;
646: oobit = obit;
647: obit = -1;
648: getnextart(TRUE);
649: break;
650:
651: /* skip forwards */
652: case '+':
653: case '=':
654: caseplus: if (count == 0)
655: break;
656: saveart;
657: last = bit;
658: for (i = 0; i < count; i++) {
659: nextbit();
660: if ((bit > pngsize) || (rflag && bit < 1))
661: break;
662: }
663: FCLOSE(fp);
664: obit = -1;
665: break;
666:
667: /* exit - time updated to that of most recently read article */
668: case 'q':
669: quitflg = 1;
670: break;
671:
672: case 'x':
673: xxit(0);
674: break;
675:
676: /* cancel the article. */
677: case 'c':
678: strcpy(prompt, "cancel [n]? ");
679: if (vgetc() != 'y') {
680: msg("Article not cancelled");
681: break;
682: }
683: cancel_command();
684: break;
685:
686: /* escape to shell */
687: case '!': {
688: register char *p;
689: int flags;
690:
691: p = linebuf;
692: *p = 0;
693: if (prget("!", p))
694: break;
695: flags = CWAIT;
696: if (*p == '\0') {
697: (void) strcpy(linebuf, SHELL);
698: flags = 0;
699: }
700: while (*p) p++;
701: while (p > linebuf && p[-1] == ' ')
702: p--;
703: if (*--p == '&') {
704: *p = '\0';
705: flags = BKGRND;
706: } else if (*p == PIPECHAR) {
707: *p = '\0';
708: (void) sprintf(bfr, "(%s)%cmail '%s'", linebuf, PIPECHAR, username);
709: (void) strcpy(linebuf, bfr);
710: flags |= BKGRND;
711: } else {
712: prflags |= NOPRT;
713: }
714: shcmd(linebuf, flags);
715: break;
716: }
717:
718: /* mail reply */
719: case 'r':
720: reply(FALSE);
721: break;
722:
723: case 'R':
724: reply(TRUE);
725: break;
726:
727: case META|'r':
728: direct_reply();
729: break;
730:
731: /* next newsgroup */
732: case 'N':
733: FCLOSE(fp);
734: if (next_ng_command())
735: quitflg = 1;
736: break;
737:
738: /* mark the rest of the articles in this group as read */
739: case 'K':
740: saveart;
741: while (bit <= ngsize && bit >= minartno) {
742: clear(bit);
743: nextbit();
744: }
745: FCLOSE(fp);
746: break;
747:
748: /* Print the full header */
749: case 'H':
750: if (fp == NULL) {
751: msg("No current article");
752: break;
753: }
754: move(ARTWIN, 0);
755: Hoffset = ftell(fp);
756: (void) fseek(fp, 0L, 0);
757: for (i = 0; i < ARTWLEN; i++) {
758: if (fgets(linebuf, COLS, fp) == NULL)
759: break;
760: if (linebuf[0] == '\n')
761: break;
762: linebuf[COLS] = '\0';
763: addstr(linebuf);
764: }
765: (void) fseek(fp, Hoffset, 0);
766: for(; i < ARTWLEN; i++)
767: addstr(linebuf);
768: prflags |= HELPMSG|NEWART;
769: break;
770: case 'b': /* backup 1 article */
771: backupone:
772: count = bit - 1;
773: /* NO BREAK */
774:
775: case 'A': /* specific number */
776: if (count > pngsize) {
777: msg("not that many articles");
778: break;
779: }
780: readmode = SPEC;
781: aabs = TRUE;
782: bit = count;
783: obit = -1;
784: FCLOSE(fp);
785: break;
786:
787: /* display parent article */
788: case 'p':
789: #ifdef MYDB
790: if (hasdb && (ptr3 = findparent(h->ident, &nart)) != NULL) {
791: msg("parent: %s/%ld", ptr3, nart); /*DEBUG*/
792: updscr(); /*DEBUG*/
793: goto selectart;
794: }
795: #endif
796: if (h->followid[0] == '\0') {
797: msg("no references line");
798: break;
799: }
800: ptr1 = h->followid + strlen(h->followid);
801: do {
802: ptr2 = ptr1;
803: if (*ptr2 == '\0')
804: ptr1 = rindex(h->followid, ' ');
805: else {
806: *ptr2 = '\0';
807: ptr1 = rindex(h->followid, ' ');
808: *ptr2 = ' ';
809: }
810: } while (ptr1 != NULL && --count > 0);
811: if (ptr1 == NULL)
812: ptr1 = h->followid;
813: else ++ptr1;
814: (void) strncpy(linebuf, ptr1, ptr2 - ptr1);
815: linebuf[ptr2 - ptr1] = '\0';
816: msg("%s", linebuf);
817: curflag = CURP2;
818: updscr(); /* may take this out later */
819: goto searchid;
820: /* specific message ID. */
821: case '<':
822: /* could improve this */
823: linebuf[0] = '<'; linebuf[1] = 0;
824: if (prget("", linebuf)) {
825: secpr[0] = 0;
826: break;
827: }
828: searchid: secpr[0] = '\0';
829: if (index(linebuf, '@') == NULL && index(linebuf, '>') == NULL) {
830: ptr1 = linebuf;
831: if (*ptr1 == '<')
832: ptr1++;
833: ptr2 = index(ptr1, '.');
834: if (ptr2 != NULL) {
835: *ptr2++ = '\0';
836: (void) sprintf(bfr, "<%s@%s.UUCP>", ptr2, ptr1);
837: (void) strcpy(linebuf, bfr);
838: }
839: }
840: if (index(linebuf, '>') == NULL)
841: (void) strcat(linebuf, ">");
842:
843: ptr1 = findhist(linebuf);
844: if (ptr1 == NULL) {
845: msg("%s not found", linebuf);
846: break;
847: }
848: ptr2 = index(ptr1, '\t');
849: ptr3 = index(++ptr2, '\t');
850: ptr2 = index(++ptr3, ' ');
851: if (ptr2)
852: *ptr2 = '\0';
853: ptr2 = index(ptr3, '/');
854: if (!ptr2) {
855: if (STRCMP(ptr3, "cancelled") == 0)
856: msg("%s has been cancelled", linebuf);
857: else
858: msg("%s has expired", linebuf);
859: break;
860: }
861: *ptr2++ = '\0';
862: (void) sscanf(ptr2, "%ld", &nart);
863:
864: /*
865: * Go to a given article. Ptr3 specifies the newsgroup
866: * and nart specifies the article number.
867: */
868: #ifdef MYDB
869: selectart:
870: #endif /* MYDB */
871: aabs = TRUE;
872: FCLOSE(fp);
873: saveart;
874: (void) strcpy(ogroupdir, ptr3);
875: if (STRCMP(groupdir, ogroupdir)) {
876: (void) strcpy(bfr, groupdir);
877: selectng(ogroupdir, TRUE, PERHAPS);
878: (void) strcpy(groupdir, ogroupdir);
879: (void) strcpy(ogroupdir, bfr);
880: ngrp = 1;
881: back();
882: }
883: bit = nart;
884: oobit = obit;
885: obit = -1;
886: getnextart(TRUE);
887: if (bit != nart || STRCMP(groupdir, ptr3) != 0) {
888: msg("can't read %s/%ld", ptr3, nart);
889: goto caseminus;
890: }
891: rfq = 0;
892: break;
893:
894: /* follow-up article */
895: case 'f':
896: if (STRCMP(h->followto, "poster") == 0) {
897: reply(FALSE);
898: break;
899: }
900: #ifdef SERVER
901: (void) sprintf(bfr, "%s/%s", BIN, "postnews");
902: #else /* !SERVER */
903: (void) sprintf(bfr, "%s/%s %s", BIN, "postnews", goodone);
904: #endif /* !SERVER */
905: shcmd(bfr, CWAIT);
906: break;
907:
908: /* erase - pretend we haven't seen this article. */
909: case 'e':
910: erased = 1;
911: set(bit);
912: goto caseplus; /* skip this article for now */
913:
914: case '#':
915: msg("Article %ld of %ld", rfq ? oobit : bit, pngsize);
916: break;
917:
918: /* error */
919: case '?':
920: {
921: FILE *helpf;
922: (void) sprintf(linebuf, "%s/vnews.help", LIB);
923: if ((helpf = fopen(linebuf, "r")) == NULL) {
924: msg("Can't open help file");
925: break;
926: }
927: move(ARTWIN, 0);
928: while (fgets(linebuf, LBUFLEN, helpf) != NULL)
929: addstr(linebuf);
930: (void) fclose(helpf);
931: prflags |= HELPMSG|NEWART;
932: }
933: break;
934:
935: default:
936: if (c != ckill && c != cintr && c != cerase)
937: #ifdef TIOCGLTC
938: if (c != cwerase)
939: #endif
940: {
941: beep();
942: msg("Illegal command");
943: }
944: break;
945: }
946: }
947:
948: cancel_command()
949: {
950: register char *poster, *r;
951: int notauthor;
952: char *senderof();
953:
954: poster = senderof(h);
955: /* only compare up to '.' or ' ' */
956: r = index(poster,'.');
957: if (r == NULL)
958: r = index(poster,' ');
959: if (r != NULL)
960: *r = '\0';
961: tfilename = filename;
962: notauthor = STRCMP(username, poster);
963: if (uid != ROOTID && uid && notauthor) {
964: msg("Can't cancel what you didn't write.");
965: return;
966: }
967: if (!cancel(stderr, h, notauthor)) {
968: clear(bit);
969: saveart;
970: nextbit();
971: obit = -1;
972: fp = NULL;
973: }
974: FCLOSE(fp);
975: }
976: /*
977: * Generate replies
978: */
979:
980: reply(include)
981: int include;
982: {
983: char *arg[4];
984: register FILE *rfp;
985: char subj[132];
986: register char *p;
987: char *replyname();
988: struct stat statb;
989: time_t creatm;
990:
991: /* Put the user in the editor to create the body of the reply. */
992: ed = getenv("EDITOR");
993: if (ed == NULL || *ed == '\0')
994: ed = DFTEDITOR;
995: if (ed == NULL) {
996: msg("You don't have an editor");
997: return;
998: }
999:
1000: arg[0] = "/bin/sh";
1001: arg[1] = "-c";
1002:
1003: (void) strcpy(tf, tft);
1004: (void) mktemp(tf);
1005: (void) close(creat(tf,0600));
1006: if ((rfp = fopen(tf, "w")) == NULL) {
1007: msg("Can't create %s", tf) ;
1008: return;
1009: }
1010: (void) strcpy(subj, h->title);
1011: if (!PREFIX(subj, "Re:")){
1012: (void) strcpy(bfr, subj);
1013: (void) sprintf(subj, "Re: %s", bfr);
1014: }
1015:
1016: p = replyname(h);
1017: fprintf(rfp, "To: %s\n", p);
1018: fprintf(rfp, "Subject: %s\n", subj);
1019: fprintf(rfp, "In-reply-to: your article %s\n", h->ident);
1020: #ifdef INTERNET
1021: fprintf(rfp, "News-Path: %s\n", h->path);
1022: #endif /* INTERNET */
1023: (void) sprintf(rcbuf, "%s -t < %s; rm -f %s", MAILPARSER, tf, tf);
1024: putc('\n', rfp);
1025: if (include) {
1026: FILE *of;
1027: char buf[BUFSIZ];
1028:
1029: #ifndef SERVER
1030: of = xart_open(goodone, "r");
1031: while (fgets(buf, sizeof buf, of) != NULL)
1032: if (buf[0] == '\n')
1033: break;
1034: while (fgets(buf, sizeof buf, of) != NULL)
1035: fprintf(rfp, "> %s", buf);
1036: fclose(of);
1037: putc('\n', rfp);
1038: #endif /* !SERVER */
1039: }
1040:
1041: fflush(rfp);
1042: (void) fstat(fileno(rfp), &statb);
1043: creatm = statb.st_mtime;
1044: (void) fclose(rfp);
1045:
1046: (void) sprintf(edcmdbuf, "exec %s %s", ed, tf);
1047: arg[2] = edcmdbuf;
1048: arg[3] = NULL;
1049: if (prun(arg, 0) != 0) {
1050: msg("Couldn't run editor");
1051: (void) unlink(tf);
1052: return;
1053: }
1054:
1055: if (access(tf, 4) || stat(tf, &statb)) {
1056: msg("No input file - mail not sent");
1057: (void) unlink(tf);
1058: return;
1059: }
1060: if (statb.st_mtime == creatm || statb.st_size < 5) {
1061: msg("File unchanged - no message posted");
1062: (void) unlink(tf);
1063: return;
1064: }
1065:
1066: arg[2] = rcbuf;
1067: arg[3] = NULL;
1068: prun(arg, BKGRND);
1069: prflags |= NOPRT;
1070: }
1071:
1072: direct_reply()
1073: {
1074: register char *p;
1075: register char *q;
1076: char *arg[4];
1077: char address[PATHLEN];
1078: extern char *replyname();
1079: extern char *getenv();
1080:
1081: arg[0] = "/bin/sh";
1082: arg[1] = "-c";
1083: p = replyname(h);
1084: q = address;
1085: while (*p != '\0') {
1086: if (index("\"\\$", *p) != 0)
1087: *q++ = '\\';
1088: *q++ = *p++;
1089: }
1090: *q++ = '\0';
1091: if ((MAILER = getenv("MAILER")) == NULL)
1092: MAILER = "mail";
1093: sprintf(rcbuf, MAILER, hptr->title);
1094: sprintf(bfr, "%s %s", rcbuf, address);
1095: arg[2] = bfr;
1096: arg[3] = NULL;
1097: if (prun(arg, 0) != 0) {
1098: msg("Couldn't run mailer");
1099: return;
1100: }
1101: prflags |= NOPRT;
1102: }
1103:
1104: next_ng_command()
1105: {
1106: set(bit);
1107: obit = -1;
1108: linebuf[0] = 0;
1109: if (prget("group? ", linebuf))
1110: return FALSE;
1111: bptr = linebuf;
1112: if (!*bptr || *bptr == '-') {
1113: if (*bptr)
1114: actdirect = BACKWARD;
1115: saveart;
1116: if (nextng()) {
1117: if (actdirect == BACKWARD)
1118: msg("Can't back up.");
1119: else
1120: return TRUE;
1121: }
1122: return FALSE;
1123: }
1124: while (isspace(*bptr))
1125: bptr++;
1126: if (!validng(bptr)) {
1127: msg("No such group.");
1128: return FALSE;
1129: }
1130: saveart;
1131: back();
1132: selectng(bptr, TRUE, TRUE);
1133: return FALSE;
1134: }
1135:
1136: /*
1137: * Find the next article we want to consider, if we're done with
1138: * the last one, and show the header.
1139: */
1140: getnextart(minus)
1141: int minus;
1142: {
1143: int noaccess;
1144: #ifdef SERVER
1145: char workspace[256];
1146: #else /* !SERVER */
1147: register DIR *dirp;
1148: register struct direct *dir;
1149: #endif /* !SERVER */
1150: long nextnum, tnum;
1151: long atol();
1152: noaccess = 0;
1153: if (minus)
1154: goto nextart2; /* Kludge for "-" command. */
1155:
1156: if (bit == obit) /* Return if still on same article as last time */
1157: return 0;
1158:
1159: nextart:
1160: if (news) {
1161: curflag = CURHOME;
1162: _amove(0, 0);
1163: vflush();
1164: }
1165: dgest = 0;
1166:
1167: /* If done with this newsgroup, find the next one. */
1168: while (ngsize <= 0 || (!rflag && ((long) bit > ngsize)) || (rflag && bit < minartno)) {
1169: if (nextng()) {
1170: if (actdirect == BACKWARD) {
1171: msg("Can't back up.");
1172: actdirect = FORWARD;
1173: continue;
1174: }
1175: else /* if (rfq++ || pflag || cflag) */
1176: return 1;
1177: }
1178: if (rflag)
1179: bit = ngsize + 1;
1180: else
1181: bit = -1;
1182: noaccess = 2;
1183: }
1184:
1185: /* speed things up by not searching for article -1 */
1186: if (bit < 0) {
1187: bit = minartno - 1;
1188: nextbit();
1189: aabs = FALSE;
1190: goto nextart;
1191: }
1192:
1193: nextart2:
1194: if (rcreadok)
1195: rcreadok = 2; /* have seen >= 1 article */
1196: #ifdef SERVER
1197: if ((fp = getarticle(groupdir, bit, "ARTICLE")) == NULL)
1198: goto badart;
1199: strcpy(filename, article_name());
1200: (void) fclose(fp);
1201: fp = NULL;
1202: #else /* !SERVER */
1203: (void) sprintf(filename, "%s/%ld", dirname(groupdir), bit);
1204: if (rfq && goodone[0]) /* ??? */
1205: strcpy(filename, goodone);
1206: #endif /* !SERVER */
1207: if (SigTrap == SIGHUP)
1208: return 1;
1209: /* Decide if we want to show this article. */
1210: if ((fp = art_open(filename, "r")) == NULL) {
1211: /* since there can be holes in legal article numbers, */
1212: /* we wait till we hit 5 consecutive bad articles */
1213: /* before we haul off and scan the directory */
1214: if (++noaccess < 5)
1215: goto badart;
1216: noaccess = 0;
1217: #ifdef SERVER
1218: if (*groupdir == ' ' || *groupdir == '\0' ||
1219: set_group(groupdir) == NULL)
1220: goto nextart;
1221: #else /* !SERVER */
1222: dirp = opendir(dirname(groupdir));
1223: if (dirp == NULL) {
1224: if (errno != EACCES)
1225: msg("Can't open %s", dirname(groupdir));
1226: goto nextart;
1227: }
1228: #endif /* !SERVER */
1229: nextnum = rflag ? minartno - 1 : ngsize + 1;
1230: #ifdef SERVER
1231: tnum = nextnum;
1232: for(;;){
1233: (void) sprintf(bfr,"STAT %ld",tnum);
1234: put_server(bfr);
1235: (void) get_server(workspace,sizeof(workspace));
1236: if (*workspace != CHAR_OK) {
1237: if (rflag)
1238: tnum++;
1239: else
1240: tnum--;
1241: continue;
1242: }
1243: #else /* !SERVER */
1244: while ((dir = readdir(dirp)) != NULL) {
1245: if (!dir->d_ino)
1246: continue;
1247: tnum = atol(dir->d_name);
1248: if (tnum <= 0)
1249: continue;
1250: #endif /* !SERVER */
1251: if (rflag ? (tnum > nextnum && tnum < bit)
1252: : (tnum < nextnum && tnum > bit))
1253: nextnum = tnum;
1254: #ifdef SERVER
1255: break; /* not exactly right */
1256: #endif /* SERVER */
1257: }
1258: #ifndef SERVER
1259: closedir(dirp);
1260: #endif /* !SERVER */
1261: if (rflag ? (nextnum >= bit) : (nextnum <= bit))
1262: goto badart;
1263: do {
1264: clear(bit);
1265: nextbit();
1266: } while (rflag ? (nextnum < bit) : (nextnum > bit));
1267: obit = -1;
1268: aabs = FALSE;
1269: goto nextart;
1270: } else
1271: noaccess = 0;
1272:
1273: if (hread(h, fp, TRUE) == NULL || (!rfq && !aselect(h, aabs))) {
1274: badart:
1275: FCLOSE(fp);
1276: clear(bit);
1277: obit = -1;
1278: nextbit();
1279: aabs = FALSE;
1280: goto nextart;
1281: }
1282: aabs = FALSE;
1283: actdirect = FORWARD;
1284: news = TRUE;
1285: artbody = ftell(fp);
1286: fmthdr();
1287: artlines = lastlin;
1288: artread = 0;
1289: prflags |= NEWART;
1290: prflags &=~ NOPRT;
1291: if (! cflag && hdrend < ARTWLEN && !cflag)
1292: prflags |= HDRONLY;
1293: dlinno = 0;
1294: maxlinno = NLINES(h, fp);
1295: erased = 0;
1296:
1297: obit = bit;
1298: #ifdef SERVER
1299: (void) unlink(filename);
1300: #endif /* SERVER */
1301: return 0;
1302: }
1303:
1304: /*
1305: * Print out whatever the appropriate header is
1306: */
1307: fmthdr() {
1308: char *briefdate();
1309: static FILE *ngfd = NULL;
1310: static int triedopen = 0;
1311: char pbuf[BUFLEN], *printbuffer = groupdir;
1312:
1313: lastlin = 0;
1314: if (ngrp) {
1315: pngsize = ngsize;
1316: ngrp--;
1317: if (!hflag) {
1318: if (!triedopen) {
1319: (void) sprintf(pbuf,"%s/newsgroups", LIB);
1320: ngfd = fopen(pbuf, "r");
1321: triedopen++;
1322: }
1323: if (ngfd != NULL) {
1324: register char *p;
1325: char ibuf[BUFLEN];
1326: rewind(ngfd);
1327: while (fgets(ibuf, BUFLEN, ngfd) != NULL) {
1328: p = index(ibuf, '\t');
1329: if (p)
1330: *p++ = '\0';
1331: if (STRCMP(ibuf, groupdir) == 0) {
1332: register char *q;
1333: q = rindex(p, '\t');
1334: if (q) {
1335: p = q;
1336: *p++ = '\0';
1337: }
1338: if (p) {
1339: q = index(p, '\n');
1340: if (q)
1341: *q = '\0';
1342: if (*--q == '.')
1343: *q = '\0';
1344: (void) sprintf(pbuf,"%s (%s)",
1345: groupdir, p);
1346: printbuffer = pbuf;
1347: }
1348: break;
1349: }
1350: }
1351: }
1352: (void) sprintf(linebuf, "Newsgroup %s", printbuffer);
1353: tfappend(linebuf);
1354: }
1355: }
1356: hdrstart = lastlin;
1357: if (!hflag) {
1358: (void) sprintf(linebuf, "Article %s %s",
1359: h->ident, briefdate(h->subdate));
1360: tfappend(linebuf);
1361: }
1362: xtabs(h);
1363: vhprint(h, pflag ? 1 : 0);
1364: (void) sprintf(linebuf, "(%d lines)", NLINES(h, fp)); tfappend(linebuf);
1365: tfappend("");
1366: hdrend = lastlin;
1367: }
1368:
1369: /*
1370: * Grow tabs into spaces in header fields, 'cause the rest of this
1371: * lax program drops turds all over tabs (so it does with \b's, but ..)
1372: */
1373: xtabs(p)
1374: register struct hbuf *p;
1375: {
1376: xtabf(p->from, sizeof p->from);
1377: xtabf(p->path, sizeof p->path);
1378: xtabf(p->nbuf, sizeof p->nbuf);
1379: xtabf(p->title, sizeof p->title);
1380: xtabf(p->ident, sizeof p->ident);
1381: xtabf(p->replyto, sizeof p->replyto);
1382: xtabf(p->followid, sizeof p->followid);
1383: xtabf(p->subdate, sizeof p->subdate);
1384: xtabf(p->expdate, sizeof p->expdate);
1385: xtabf(p->ctlmsg, sizeof p->ctlmsg);
1386: xtabf(p->sender, sizeof p->sender);
1387: xtabf(p->followto, sizeof p->followto);
1388: xtabf(p->distribution, sizeof p->distribution);
1389: xtabf(p->organization, sizeof p->organization);
1390: xtabf(p->numlines, sizeof p->numlines);
1391: xtabf(p->keywords, sizeof p->keywords);
1392: xtabf(p->summary, sizeof p->summary);
1393: xtabf(p->approved, sizeof p->approved);
1394: xtabf(p->nf_id, sizeof p->nf_id);
1395: xtabf(p->nf_from, sizeof p->nf_from);
1396: #ifdef DOXREFS
1397: xtabf(p->xref, sizeof p->xref);
1398: #endif /* DOXREFS */
1399: }
1400:
1401: xtabf(s, size)
1402: char *s;
1403: int size;
1404: {
1405: register char *p, *str;
1406: register c, i;
1407: char buf[LBUFLEN];
1408:
1409: str = s;
1410: if (index(str, '\t') == NULL)
1411: return;
1412: i = 0;
1413: for (p = buf; c = *str++; i++) {
1414: if (c == '\t') {
1415: *p++ = ' ';
1416: if ((i & 7) != 7)
1417: str--;
1418: } else if (c == '\n') {
1419: i = -1;
1420: *p++ = c;
1421: } else
1422: *p++ = c;
1423: }
1424: *p = '\0';
1425: strncpy(s, buf, size - 1);
1426: }
1427:
1428: /*
1429: * Print the file header to the temp file.
1430: */
1431: vhprint(hp, verbose)
1432: register struct hbuf *hp;
1433: int verbose;
1434: {
1435: register char *p1, *p2;
1436: char fname[BUFLEN];
1437: char *tailpath();
1438:
1439: fname[0] = '\0'; /* init name holder */
1440:
1441: p1 = index(hp->from, '('); /* Find the sender's full name. */
1442: if (p1 == NULL && hp->path[0])
1443: p1 = index(hp->path, '(');
1444: if (p1 != NULL) {
1445: (void) strcpy(fname, p1+1);
1446: p2 = index(fname, ')');
1447: if (p2 != NULL)
1448: *p2 = '\0';
1449: }
1450:
1451: (void) sprintf(linebuf, "Subject: %s", hp->title);
1452: tfappend(linebuf);
1453: if (!hflag && hp->summary[0])
1454: (void) sprintf(linebuf, "Summary: %s", hp->summary), tfappend(linebuf);
1455: if (!hflag && hp->keywords[0])
1456: (void) sprintf(linebuf, "Keywords: %s", hp->keywords), tfappend(linebuf);
1457: if (verbose) {
1458: (void) sprintf(linebuf, "From: %s", hp->from); tfappend(linebuf);
1459: (void) sprintf(linebuf, "Path: %s", hp->path); tfappend(linebuf);
1460: if (hp->organization[0]) {
1461: (void) sprintf(linebuf, "Organization: %s", hp->organization);
1462: tfappend(linebuf);
1463: }
1464: }
1465: else {
1466: if (p1 != NULL)
1467: *--p1 = '\0'; /* bump over the '(' */
1468: #ifdef INTERNET
1469: /*
1470: * Prefer Path line if it's in internet format, or if we don't
1471: * understand internet format here, or if there is no reply-to.
1472: */
1473: (void) sprintf(linebuf, "From: %s", hp->from);
1474: #else
1475: (void) sprintf(linebuf, "Path: %s", tailpath(hp));
1476: #endif
1477: if (fname[0] || (hp->organization[0] && !hflag)) {
1478: (void) strcat(linebuf, " (");
1479: if (fname[0] == '\0') {
1480: (void) strcpy(fname, hp->from);
1481: p2 = index(fname,'@');
1482: if (p2)
1483: *p2 = '\0';
1484: }
1485: (void) strcat(linebuf, fname);
1486: if (hp->organization[0] && !hflag) {
1487: (void) strcat(linebuf, " @ ");
1488: (void) strcat(linebuf, hp->organization);
1489: }
1490: (void) strcat(linebuf, ")");
1491: }
1492: tfappend(linebuf);
1493: if (p1 != NULL)
1494: *p1 = ' ';
1495: if (hp->ctlmsg[0]) {
1496: (void) sprintf(linebuf, "Control: %s", hp->ctlmsg);
1497: tfappend(linebuf);
1498: }
1499: }
1500:
1501: if (verbose) {
1502: (void) sprintf(linebuf, "Newsgroups: %s", hp->nbuf); tfappend(linebuf);
1503: (void) sprintf(linebuf, "Date: %s", hp->subdate); tfappend(linebuf);
1504: if (hp->sender[0]) {
1505: (void) sprintf(linebuf, "Sender: %s", hp->sender);
1506: tfappend(linebuf);
1507: }
1508: if (hp->replyto[0]) {
1509: (void) sprintf(linebuf, "Reply-To: %s", hp->replyto);
1510: tfappend(linebuf);
1511: }
1512: if (hp->followto[0]) {
1513: (void) sprintf(linebuf, "Followup-To: %s", hp->followto);
1514: tfappend(linebuf);
1515: }
1516: }
1517: else if (STRCMP(hp->nbuf, groupdir) != 0) {
1518: (void) sprintf(linebuf, "Newsgroups: %s", hp->nbuf);
1519: tfappend(linebuf);
1520: timer();
1521: }
1522: }
1523:
1524: #ifdef MYDB
1525:
1526: char *
1527: findparent(id, num)
1528: char *id;
1529: long *num;
1530: {
1531: struct artrec a;
1532: char idbuf[BUFSIZE];
1533: char *ngname();
1534:
1535: strcpy(idbuf, id);
1536: lcase(idbuf);
1537:
1538: if (lookart(id, &a) == DNULL)
1539: return NULL;
1540: if (a.parent == DNULL)
1541: return NULL;
1542: readrec(a.parent, &a);
1543: *num = a.groups[0].artno;
1544: return ngname(a.groups[0].newsgroup);
1545: }
1546:
1547: #endif
1548:
1549:
1550: /*
1551: * Append file to temp file, handling control characters, folding lines, etc.
1552: * We don't grow the temp file to more than nlines so that a user won't have
1553: * to wait for 20 seconds to read in a monster file from net.sources.
1554: * What we really want is coroutines--any year now.
1555: */
1556:
1557: #define ULINE 0200
1558: static char *maxcol;
1559:
1560: appfile(iop, nlines)
1561: register FILE *iop;
1562: {
1563: register int c;
1564: register char *icol; /* &linebuf[0] <= icol <= maxcol */
1565:
1566: if (artread || artlines >= nlines || iop == NULL)
1567: return;
1568: maxcol = linebuf;
1569: icol = linebuf;
1570: while ((c = getc(iop)) != EOF) {
1571: switch (c) {
1572: case ' ':
1573: if (icol == maxcol && icol < linebuf + LBUFLEN - 1) {
1574: *icol++ = ' ';
1575: maxcol = icol;
1576: } else {
1577: if (*icol == '_')
1578: *icol++ = ULINE | ' ';
1579: else
1580: icol++;
1581: }
1582: break;
1583: case '\t':
1584: icol = (icol - linebuf &~ 07) + 8 + linebuf;
1585: growline(icol);
1586: break;
1587: case '\b':
1588: if (icol > linebuf) --icol;
1589: break;
1590: case '\n':
1591: outline();
1592: if (artlines >= nlines)
1593: return;
1594: icol = linebuf;
1595: break;
1596: case '\r':
1597: icol = linebuf;
1598: break;
1599: case '\f':
1600: outline(); outline(); outline();
1601: if (artlines >= nlines)
1602: return;
1603: icol = linebuf;
1604: break;
1605: default:
1606: if (c < ' ' || c > '~')
1607: break;
1608: else if (icol >= linebuf + LBUFLEN - 1)
1609: icol++;
1610: else if (icol == maxcol) {
1611: *icol++ = c;
1612: maxcol = icol; }
1613: else if (c == '_')
1614: *icol++ |= ULINE;
1615: else if (*icol == '_')
1616: *icol++ = (c | ULINE);
1617: else *icol++ = c;
1618: break;
1619: }
1620: }
1621: if (maxcol != linebuf) /* file not terminated with newline */
1622: outline();
1623: artread++;
1624: }
1625:
1626: growline(col)
1627: char *col;
1628: {
1629: while (maxcol < col && maxcol < linebuf + LBUFLEN - 1)
1630: *maxcol++ = ' ';
1631: }
1632:
1633: outline()
1634: {
1635: *maxcol = '\0';
1636: if (STRNCMP(linebuf, ">From ", 6) == 0) {
1637: register char *p;
1638: for (p = linebuf ; (*p = p[1]) != '\0' ; p++);
1639: }
1640: tfappend(linebuf);
1641: if (maxcol > linebuf)
1642: artlines = lastlin;
1643: maxcol = linebuf;
1644: }
1645:
1646:
1647: /*
1648: * Prompt the user and get a line.
1649: * "prompter" is the prompt. "buf" contains a string which
1650: * will be used as the initial user response (which may be edited
1651: * by the user with backspace, ^U, etc). The resulting line is
1652: * returned in "buf". The result of prget() is:
1653: * 0 if the line was terminated by NL or CR
1654: * 1 if it was terminated by the interrupt character.
1655: * 2 if it was terminated by erasing all the characters, including
1656: * one or more that were prompted initially in "buf". (If "buf"
1657: * was empty, this will never occur.)
1658: */
1659: int
1660: prget(prompter, buf)
1661: char *prompter, *buf;
1662: {
1663: register char *p, *q, *r;
1664: register char c;
1665: char lastc;
1666: char hadprompt = buf[0];
1667:
1668: curflag = CURP2;
1669: r = buf + strlen(buf);
1670: lastc = '\0';
1671: for (;;) {
1672: p = secpr;
1673: for (q = prompter ; *q ; q++)
1674: *p++ = *q;
1675: for (q = buf ; *q ; q++) {
1676: if (p < &secpr[SECPRLEN-1] && *q >= ' ' && *q <= '~')
1677: *p++ = *q;
1678: }
1679: *p = '\0';
1680: c = vgetc();
1681: if (c == '\n' || c == '\r' || c == cintr) {
1682: break;
1683: }
1684: if (c == cerase || c == '\b' || c == '\177') {
1685: if (lastc == '\\')
1686: r[-1] = c;
1687: else if (r > buf)
1688: r--;
1689: } else if (c == ckill) {
1690: if (lastc == '\\')
1691: r[-1] = c;
1692: else
1693: r = buf;
1694: #ifdef TIOCGLTC
1695: } else if (c == cwerase) {
1696: if (lastc == '\\')
1697: r[-1] = c;
1698: else {
1699: while (r > buf && (r[-1] == ' ' || r[-1] == '\t'))
1700: r--;
1701: while (r > buf && r[-1] != ' ' && r[-1] != '\t')
1702: r--;
1703: }
1704: #endif
1705: } else {
1706: *r++ = c;
1707: }
1708: lastc = c;
1709: *r = '\0';
1710: if ((r == buf) && hadprompt)
1711: return 2;
1712: }
1713: curflag = CURHOME;
1714: secpr[0] = '\0';
1715: return (c == cintr);
1716: }
1717:
1718:
1719:
1720: /*
1721: * Execute a shell command.
1722: */
1723:
1724: shcmd(cmd, flags)
1725: char *cmd;
1726: {
1727: char *arg[4];
1728:
1729: arg[0] = SHELL, arg[1] = "-c", arg[2] = cmd, arg[3] = NULL;
1730: return prun(arg, flags);
1731: }
1732:
1733:
1734: prun(args, flags)
1735: char **args;
1736: {
1737: int pid;
1738: int i;
1739: int (*savequit)();
1740: char *env[100], **envp, **oenvp;
1741: char a[BUFLEN + 2];
1742: extern char **environ;
1743: int pstatus, retval;
1744:
1745: if (!(flags & BKGRND)) {
1746: botscreen();
1747: ttycooked();
1748: #ifdef SIGTSTP
1749: (void) signal(SIGTSTP, SIG_DFL);
1750: (void) signal(SIGTTIN, SIG_DFL);
1751: (void) signal(SIGTTOU, SIG_DFL);
1752: #endif
1753: }
1754: #if defined(BSD4_2) && !defined(sun)
1755: while ((pid = vfork()) == -1)
1756: #else /* !BSD4_2 */
1757: /* 4.1 BSD (at least) can't handle this vfork with -ljobs */
1758: while ((pid = fork()) == -1)
1759: #endif /* !BSD4_2 */
1760: sleep(1); /* must not clear alarm */
1761: if (pid == 0) {
1762: for (i = 3 ; i < 20 ; i++)
1763: close(i);
1764: if (flags & BKGRND) {
1765: (void) signal(SIGINT, SIG_IGN);
1766: (void) signal(SIGQUIT, SIG_IGN);
1767: #ifdef SIGTSTP
1768: (void) signal(SIGTSTP, SIG_IGN);
1769: (void) signal(SIGTTIN, SIG_IGN);
1770: (void) signal(SIGTTOU, SIG_IGN);
1771: #endif
1772: (void) close(0);
1773: (void) close(1);
1774: (void) open("/dev/null", 2);
1775: (void) dup(0);
1776: }
1777: /* set $A */
1778: (void) sprintf(a, "A=%s", filename);
1779: oenvp = environ;
1780: env[0] = a;
1781: for (envp = env + 1 ; *oenvp != NULL && envp < env + 98 ; oenvp++)
1782: if ((*oenvp)[0] != 'A' || (*oenvp)[1] != '=')
1783: *envp++ = *oenvp;
1784: *envp = NULL;
1785:
1786: (void) umask(savmask);
1787: execve(args[0], args, env);
1788: perror(args[0]);
1789: exit(20);
1790: }
1791: if (!(flags & BKGRND)) {
1792: savequit = signal(SIGQUIT, SIG_IGN);
1793: while ((i = wait(&pstatus)) != pid && (i != -1 || errno == EINTR))
1794: ;
1795: if (i == -1)
1796: retval = 1;
1797: else
1798: retval = pstatus;
1799: if (flags & CWAIT) {
1800: fprintf(stderr, "[Hit return to continue]");
1801: while ((errno = 0, i = getchar()) != '\n'
1802: && (i != EOF || errno == EINTR));
1803: }
1804: (void) signal(SIGQUIT, savequit);
1805: ttyraw();
1806: okclear();
1807: #ifdef SIGTSTP
1808: (void) signal(SIGTSTP, onstop);
1809: (void) signal(SIGTTIN, onstop);
1810: (void) signal(SIGTTOU, onstop);
1811: #endif
1812: return retval;
1813: } else
1814: return 0;
1815: }
1816:
1817: #ifdef DIGPAGE
1818:
1819:
1820: /*
1821: * Find end of current subarticle in digest.
1822: */
1823:
1824: findend(l)
1825: {
1826: register int i, n;
1827: register char *p;
1828:
1829: for (i = l ; i < l + ARTWLEN && i < lastlin ; i++) {
1830: tfget(linebuf, i);
1831: for (p = linebuf ; *p == '-' ; p++)
1832: ;
1833: n = (int) (p - linebuf);
1834: if ( (n > 23 && n < 33) || (n > 65 && n < 79)) {
1835: tfget(linebuf, ++i);
1836: if (linebuf[0] == '\0')
1837: return i + 1;
1838: }
1839: }
1840: return 0;
1841: }
1842:
1843: #endif
1844:
1845:
1846: /*** Routines for handling temporary file ***/
1847:
1848: /*
1849: * Append to temp file.
1850: * Long lines are folded.
1851: */
1852:
1853: tfappend(tline)
1854: register char *tline;
1855: {
1856: register char *nxtlin;
1857:
1858: do {
1859: nxtlin = index(tline, '\n');
1860: if (nxtlin)
1861: *nxtlin++ = '\0';
1862:
1863: while (strlen(tline) > COLS) {
1864: tfput(tline, lastlin++);
1865: tline += COLS;
1866: maxlinno++;
1867: }
1868: tfput(tline, lastlin++);
1869: } while ((tline = nxtlin) != NULL);
1870: }
1871:
1872:
1873: tfput(tline, linno)
1874: char *tline;
1875: {
1876: register char *p;
1877: register FILE *rtfp; /* try to make it a little faster */
1878: register int i;
1879:
1880: p = tline, i = even(COLS);
1881: tfseek(linno, 1);
1882: rtfp = tfp;
1883: while (--i >= 0) {
1884: if (*p)
1885: putc(*p++, rtfp);
1886: else
1887: putc('\0', rtfp);
1888: }
1889: tflinno++;
1890: }
1891:
1892:
1893: tfget(tline, linno)
1894: char *tline;
1895: {
1896: tfseek(linno, 0);
1897: fread(tline, even(COLS), 1, tfp);
1898: tline[COLS] = '\0';
1899: tflinno++;
1900: }
1901:
1902:
1903: tfseek(linno, wrflag)
1904: {
1905: static int lastwrflag = 1;
1906:
1907: if (linno != tflinno || wrflag != lastwrflag) {
1908: (void) fseek(tfp, (long)linno * even(COLS), 0);
1909: tflinno = linno;
1910: lastwrflag = wrflag;
1911: }
1912: }
1913:
1914: /* VARARGS1 */
1915: msg(s, a1, a2, a3, a4)
1916: char *s;
1917: long a1, a2, a3, a4;
1918: {
1919: (void) sprintf(secpr, s, a1, a2, a3, a4);
1920: }
1921:
1922:
1923: /*
1924: * Update the display.
1925: * The display is entirely controlled by this routine,
1926: * which means that this routine may get pretty snarled.
1927: */
1928:
1929: static int savelinno = -1; /* dlinno on last call to updscr */
1930: static int savepr; /* prflags on last call */
1931: #ifdef TIOCGWINSZ
1932: static int UPDATING = 0, WINCH = 0;
1933:
1934: /*
1935: * called by winch() from virtterm.c -- resets state information back
1936: * to start-up state and forces a full redraw of the screen. The
1937: * current article is rewound to the beginning because it's would
1938: * be very difficult to get the screen to return to the exact point
1939: * in the file that the user left off (I know, I tried).
1940: */
1941: winch_upd()
1942: {
1943: if(UPDATING) /* concurrency. wow! */
1944: WINCH++;
1945: else if((WINCH == 0) && (savelinno >= 0)) {
1946: int saveflag = curflag;
1947:
1948: /* reread the article */
1949: FCLOSE(fp);
1950: obit = -1;
1951: getnextart(FALSE);
1952: appfile(fp, dlinno + ARTWLEN + 1);
1953:
1954: /* fix up the screen */
1955: curflag = saveflag;
1956: strcpy(prompt,"more? ");
1957: okclear();
1958: updscr();
1959: }
1960: }
1961: #endif /* TIOCGWINSZ */
1962:
1963:
1964: updscr()
1965: {
1966: int count;
1967: int i;
1968:
1969: #ifdef TIOCGWINSZ
1970: UPDATING++;
1971: #endif /* TIOCGWINSZ */
1972: if (checkin())
1973: return;
1974: if ((prflags & HELPMSG) == 0
1975: && (dlinno != savelinno || savepr != prflags)
1976: && quitflg == 0) {
1977: if (dlinno != savelinno)
1978: prflags &=~ NOPRT;
1979: count = ARTWLEN;
1980: if (prflags & NOPRT)
1981: count = 0;
1982: if ((prflags & HDRONLY) && count > hdrend)
1983: count = hdrend - dlinno;
1984: #ifdef DIGPAGE
1985: if (endsuba > 0 && count > endsuba - dlinno)
1986: count = endsuba - dlinno;
1987: #endif
1988: if ((prflags & NEWART) == 0)
1989: ushift(ARTWIN, ARTWIN+ARTWLEN-1, dlinno - savelinno);
1990: if (count > lastlin - dlinno)
1991: count = lastlin - dlinno;
1992: for (i = ARTWIN ; i < ARTWIN + ARTWLEN ; i++)
1993: clrline(i);
1994: for (i = 0 ; i < count ; i++) {
1995: tfget(linebuf, dlinno + i);
1996: mvaddstr(ARTWIN + i, 0, linebuf);
1997: }
1998: prflags &=~ NEWART;
1999: savepr = prflags;
2000: savelinno = dlinno;
2001: }
2002: clrline(SPLINE), clrline(PRLINE);
2003: #ifdef STATTOP
2004: mvaddstr(PRLINE, 0, prompt);
2005: #else
2006: if (strlen(secpr) <= COLS)
2007: mvaddstr(PRLINE, 0, prompt);
2008: #endif
2009: mvaddstr(PRLINE, 59, timestr);
2010: mvaddstr(PRLINE, 17, groupdir);
2011: addch(' '); addnum(bit); addch('/'); addnum(pngsize); addch(' ');
2012: if (ismail)
2013: mvaddstr(PRLINE, 75, ismail > 1? "MAIL" : "mail");
2014: mvaddstr(SPLINE, 0, secpr);
2015: if (curflag == CURP1)
2016: move(PRLINE, strlen(prompt));
2017: else if (curflag == CURHOME)
2018: move(0, 0);
2019: refresh();
2020: #ifdef TIOCGWINSZ
2021: UPDATING=0;
2022: if (WINCH) { /* window changed while updating screen */
2023: WINCH = 0;
2024: winch_upd();
2025: }
2026: #endif /* TIOCGWINSZ */
2027: }
2028:
2029: addnum(n)
2030: register long n;
2031: {
2032: if (n >= 10)
2033: addnum(n / 10);
2034: addch((char)(n % 10 + '0'));
2035: }
2036:
2037: /*
2038: * Called on alarm signal.
2039: * Simply sets flag, signal processed later.
2040: */
2041:
2042: onalarm()
2043: {
2044: #ifdef SIGTSTP
2045: int dojump = reading;
2046:
2047: reading = FALSE;
2048: alflag++;
2049: if (dojump)
2050: longjmp(alrmjmp, 1);
2051: #else /* !SIGTSTP */
2052: alflag++;
2053: #endif
2054: }
2055:
2056: /*
2057: * Process alarm signal (or start clock)
2058: */
2059: timer()
2060: {
2061: time_t tod;
2062: int hour;
2063: int i;
2064: struct tm *t;
2065: struct stat statb;
2066: struct tm *localtime();
2067: static char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
2068: static long oldmsize = 1000000L;
2069: static int rccount = 10;
2070: static time_t lastismail = 0;
2071:
2072: alflag = 0;
2073: (void) signal(SIGALRM, onalarm);
2074: (void) time(&tod);
2075: t = localtime(&tod);
2076: i = 60 - t->tm_sec;
2077: (void) alarm(i > 30? 30 : i); /* reset alarm */
2078: hour = t->tm_hour % 12;
2079: if (hour == 0) hour = 12;
2080: (void) sprintf(timestr, "%.3s %d %d:%02d",
2081: months + 3 * t->tm_mon, t->tm_mday, hour, t->tm_min);
2082: if (mailf == NULL || stat(mailf, &statb) < 0) {
2083: statb.st_size = 0;
2084: }
2085: if (statb.st_size > oldmsize) {
2086: ismail = 2;
2087: beep();
2088: } else {
2089: if (statb.st_size == 0)
2090: ismail = 0;
2091: /* force MAIL for at least 30 seconds */
2092: else if (ismail > 1 && (lastismail+30) < tod)
2093: ismail = 1;
2094: }
2095: oldmsize = statb.st_size;
2096: lastismail = tod;
2097: if (uflag && !xflag && --rccount < 0) {
2098: writeoutrc();
2099: if (secpr[0] == '\0')
2100: (void) strcpy(secpr, ".newsrc updated");
2101: rccount = 10;
2102: }
2103: }
2104:
2105: char *
2106: getmailname()
2107: {
2108: static char mailname[32];
2109: register char *p;
2110:
2111: if( (p = getenv("MAIL")) != NULL)
2112: return p;
2113: #ifndef MMDF
2114: if (username[0] == '\0' || strlen(username) > 15)
2115: return NULL;
2116: #ifdef USG
2117: (void) sprintf(mailname, "/usr/mail/%s", username);
2118: #else /* !USG */
2119: (void) sprintf(mailname, "/usr/spool/mail/%s", username);
2120: #endif /* !USG */
2121: #else /* MMDF */
2122: (void) sprintf(mailname, "%s/mailbox", userhome);
2123: #endif /* MMDF */
2124: return mailname;
2125: }
2126:
2127:
2128:
2129: /*** Terminal I/O ***/
2130:
2131: #define INBUFSIZ 8
2132:
2133: char inbuf[INBUFSIZ]; /* input buffer */
2134: char outbuf[BUFSIZ]; /* output buffer */
2135: int innleft = 0; /* # of chars in input buffer */
2136: int outnleft = BUFSIZ; /* room left in output buffer */
2137: char *innext; /* next input character */
2138: char *outnext = outbuf; /* next space in output buffer */
2139: #ifdef USG
2140: int oflags; /* fcntl flags (for nodelay read) */
2141: #endif
2142:
2143: /*
2144: * Input a character
2145: */
2146:
2147: vgetc()
2148: {
2149: register c;
2150: #if defined(BSD4_2) || defined(BSD4_1C)
2151: int readfds, exceptfds;
2152: #endif
2153:
2154: recurse:
2155: if (--innleft >= 0) {
2156: c = *innext++;
2157: } else {
2158: if (alflag)
2159: timer();
2160: updscr(); /* update the display */
2161: for (;;) {
2162: if (innleft > 0 || alflag)
2163: goto recurse;
2164: intflag = 0;
2165: #ifdef USG
2166: if (oflags & O_NDELAY) {
2167: oflags &=~ O_NDELAY;
2168: fcntl(0, F_SETFL, oflags);
2169: }
2170: #endif
2171: #ifdef SIGTSTP
2172: if (setjmp(alrmjmp))
2173: continue;
2174: if (setjmp(intjmp))
2175: return cintr;
2176: reading = TRUE;
2177: #endif /* SIGTSTP */
2178: #if defined(BSD4_2) || defined(BSD4_1C)
2179: /* Use a select because it can be interrupted. */
2180: readfds = 1; exceptfds = 1;
2181: select(1, &readfds, (int *)0, &exceptfds, (int *)0);
2182: if (!(readfds & 1))
2183: break;
2184: #endif
2185: innleft = read(0, inbuf, INBUFSIZ);
2186: #ifdef SIGTSTP
2187: reading = FALSE;
2188: #endif /* SIGTSTP */
2189: if (innleft > 0)
2190: break;
2191: if (innleft == 0) {
2192: quitflg++;
2193: return cintr;
2194: }
2195: if (errno != EINTR)
2196: abort(); /* "Can't happen" */
2197: if (intflag) {
2198: intflag--;
2199: return cintr;
2200: }
2201: }
2202: innext = inbuf + 1;
2203: innleft--;
2204: c = inbuf[0];
2205: }
2206: #ifndef USG
2207: #ifndef CBREAK
2208: c &= 0177;
2209: if (c == '\034') /* FS character */
2210: xxit(0);
2211: #endif
2212: #endif
2213: if (c == '\f') {
2214: okclear();
2215: prflags &=~ NOPRT;
2216: goto recurse;
2217: }
2218: if (c == '\r')
2219: c = '\n';
2220: return c;
2221: }
2222:
2223:
2224: /*
2225: * Push a character back onto the input stream.
2226: */
2227:
2228: pushback(c)
2229: {
2230: if (innext <= inbuf)
2231: abort();
2232: *--innext = c;
2233: innleft++;
2234: }
2235:
2236: /*
2237: * Check for terminal input
2238: */
2239:
2240: checkin()
2241: {
2242: #ifdef FIONREAD
2243: int count;
2244: #endif
2245: #ifdef STATTOP
2246: if (innleft > 0)
2247: #else
2248: if (innleft > 0 || alflag)
2249: #endif
2250: return 1;
2251: #if defined(USG) || defined(FIONREAD)
2252: if (ospeed >= B9600)
2253: return 0;
2254: vflush();
2255: if (ospeed <= B300)
2256: ttyowait();
2257: #ifdef USG
2258: if ((oflags & O_NDELAY) == 0) {
2259: oflags |= O_NDELAY;
2260: (void) fcntl(0, F_SETFL, oflags);
2261: }
2262: if ((innleft = read(0, inbuf, INBUFSIZ)) > 0) {
2263: innext = inbuf;
2264: return 1;
2265: }
2266: #endif
2267: #ifdef FIONREAD
2268: count = 0; /* in case FIONREAD fails */
2269: (void) ioctl(0, FIONREAD, (char *)&count);
2270: if (count)
2271: return 1;
2272: #endif
2273: #endif
2274: return 0;
2275: }
2276:
2277:
2278:
2279: /*
2280: * flush terminal input queue.
2281: */
2282:
2283: clearin()
2284: {
2285: #ifdef USG
2286: (void) ioctl(0, TCFLSH, (char *)0);
2287: #else
2288: #ifdef TIOCFLUSH
2289: (void) ioctl(0, TIOCFLUSH, (char *)0);
2290: #else
2291: struct sgttyb tty;
2292: (void) ioctl(0, TIOCGETP, &tty);
2293: (void) ioctl(0, TIOCSETP, &tty);
2294: #endif
2295: #endif
2296: innleft = 0;
2297: }
2298:
2299: vputc(c)
2300: {
2301: if (--outnleft < 0) {
2302: vflush();
2303: outnleft--;
2304: }
2305: *outnext++ = c;
2306: }
2307:
2308: /*
2309: * Flush the output buffer
2310: */
2311:
2312: vflush()
2313: {
2314: register char *p;
2315: register int i;
2316: #ifdef BSD4_2
2317: int mask;
2318: #else
2319: unsigned oalarm;
2320: #endif
2321:
2322: #ifdef BSD4_2
2323: mask = sigblock(1 << (SIGALRM-1));
2324: #else
2325: oalarm = alarm(0);
2326: #endif
2327: for (p = outbuf ; p < outnext ; p += i) {
2328: if ((i = write(1, p, outnext - p)) < 0) {
2329: if (errno != EINTR)
2330: abort(); /* "Can't happen" */
2331: i = 0;
2332: }
2333: }
2334: outnleft = BUFSIZ;
2335: outnext = outbuf;
2336: #ifdef BSD4_2
2337: sigsetmask(mask);
2338: #else
2339: (void) alarm(oalarm);
2340: #endif
2341: }
2342:
2343: /*** terminal modes ***/
2344:
2345: #ifdef USG
2346: static struct termio oldtty, newtty;
2347:
2348: /*
2349: * Save tty modes
2350: */
2351:
2352: ttysave()
2353: {
2354: if (ioctl(1, TCGETA, &oldtty) < 0)
2355: xerror("Can't get tty modes");
2356: newtty = oldtty;
2357: newtty.c_iflag &=~ (INLCR|IGNCR|ICRNL);
2358: newtty.c_oflag &=~ (OPOST);
2359: newtty.c_lflag &=~ (ICANON|ECHO|ECHOE|ECHOK|ECHONL);
2360: newtty.c_lflag |= (NOFLSH);
2361: newtty.c_cc[VMIN] = 1;
2362: newtty.c_cc[VTIME] = 0;
2363: cerase = oldtty.c_cc[VERASE];
2364: ckill = oldtty.c_cc[VKILL];
2365: cintr = oldtty.c_cc[VINTR];
2366: ospeed = oldtty.c_cflag & CBAUD;
2367: initterm();
2368: }
2369:
2370:
2371: /*
2372: * Set tty modes for visual processing
2373: */
2374:
2375: ttyraw()
2376: {
2377: while (ioctl(1, TCSETAF, &newtty) < 0 && errno == EINTR)
2378: ;
2379: rawterm();
2380: }
2381:
2382: ttyowait()
2383: { /* wait for output queue to drain */
2384: while (ioctl(1, TCSETAW, &newtty) < 0 && errno == EINTR)
2385: ;
2386: }
2387:
2388: /*
2389: * Restore tty modes
2390: */
2391:
2392: ttycooked()
2393: {
2394: cookedterm();
2395: vflush();
2396: while (ioctl(1, TCSETAF, &oldtty) < 0 && errno == EINTR)
2397: ;
2398: oflags &=~ O_NDELAY;
2399: (void) fcntl(0, F_SETFL, oflags) ;
2400: }
2401:
2402: #else
2403:
2404: static struct sgttyb oldtty, newtty;
2405: #ifdef TIOCGLTC
2406: static struct ltchars oldltchars, newltchars;
2407: #endif
2408:
2409: /*
2410: * Save tty modes
2411: */
2412:
2413: ttysave()
2414: {
2415: #ifdef CBREAK
2416: struct tchars tchars; /* special characters, including interrupt */
2417: #endif
2418: #ifdef SIGTSTP
2419: int getpgrp();
2420: #if defined(BSD4_2) || defined(BSD4_1C)
2421: int tpgrp;
2422: #else /* BSD4_1 */
2423: short tpgrp;
2424: #endif /* BSD4_1 */
2425:
2426: retry:
2427: #ifdef BSD4_2
2428: (void) sigblock(sigmask(SIGTSTP)|sigmask(SIGTTIN)|sigmask(SIGTTOU));
2429: #else /* !BSD4_2 */
2430: (void) signal(SIGTSTP, SIG_HOLD);
2431: (void) signal(SIGTTIN, SIG_HOLD);
2432: (void) signal(SIGTTOU, SIG_HOLD);
2433: #endif /* !BSD4_2 */
2434: if (ioctl(2, TIOCGPGRP, (char *)&tpgrp) < 0)
2435: goto nottty;
2436: if (tpgrp != getpgrp(0)) { /* not in foreground */
2437: (void) signal(SIGTTOU, SIG_DFL);
2438: #ifdef BSD4_2
2439: (void) sigsetmask(sigblock(0) & ~sigmask(SIGTTOU));
2440: #endif /* BSD4_2 */
2441: (void) kill(0, SIGTTOU);
2442: /* job stops here waiting for SIGCONT */
2443: goto retry;
2444: }
2445: (void) signal(SIGTTIN, SIG_DFL);
2446: (void) signal(SIGTTOU, SIG_DFL);
2447: (void) signal(SIGTSTP, SIG_DFL);
2448: #ifdef BSD4_2
2449: (void) sigsetmask(sigblock(0) & ~(sigmask(SIGTSTP)|sigmask(SIGTTIN)|sigmask(SIGTTOU)));
2450: #endif /* BSD4_2 */
2451: #endif /* SIGTSTP */
2452: if (ioctl(1, TIOCGETP, (char *)&oldtty) < 0)
2453: nottty: xerror("Can't get tty modes");
2454: newtty = oldtty;
2455: newtty.sg_flags &=~ (CRMOD|ECHO|XTABS);
2456: #ifdef CBREAK
2457: newtty.sg_flags |= CBREAK;
2458: ioctl(1, TIOCGETC, (char *)&tchars);
2459: cintr = tchars.t_intrc;
2460: #else /* !CBREAK */
2461: newtty.sg_flags |= RAW;
2462: cintr = '\0177'; /* forcibly this on V6 systems */
2463: #endif /* !CBREAK */
2464: cerase = oldtty.sg_erase;
2465: ckill = oldtty.sg_kill;
2466: ospeed = oldtty.sg_ospeed;
2467: #ifdef TIOCGLTC
2468: if (ioctl(1, TIOCGLTC, (char *)&oldltchars) >= 0) {
2469: newltchars = oldltchars;
2470: newltchars.t_dsuspc = -1;
2471: cwerase = oldltchars.t_werasc;
2472: }
2473: #endif
2474: initterm();
2475: #ifdef SIGTSTP
2476: (void) signal(SIGTTIN, onstop);
2477: (void) signal(SIGTTOU, onstop);
2478: (void) signal(SIGTSTP, onstop);
2479: #endif /* SIGTSTP */
2480: }
2481:
2482:
2483: /*
2484: * Set tty modes for visual processing
2485: */
2486:
2487: ttyraw()
2488: {
2489: while (ioctl(1, TIOCSETN, (char *)&newtty) < 0 && errno == EINTR)
2490: ;
2491: #ifdef TIOCGLTC
2492: if (newltchars.t_dsuspc == '\377')
2493: while (ioctl(1, TIOCSLTC, (char *)&newltchars) < 0 && errno == EINTR)
2494: ;
2495: #endif
2496: rawterm();
2497: }
2498:
2499: ttyowait()
2500: { /* wait for output queue to drain */
2501: #ifdef TIOCDRAIN /* This ioctl is a local mod on linus */
2502: (void) ioctl(1, TIOCDRAIN, (char *)0);
2503: #endif
2504: }
2505:
2506:
2507: /*
2508: * Restore tty modes
2509: */
2510:
2511: ttycooked()
2512: {
2513: cookedterm();
2514: vflush();
2515: while (ioctl(1, TIOCSETN, (char *)&oldtty) < 0 && errno == EINTR)
2516: ;
2517: #ifdef TIOCGLTC
2518: if (newltchars.t_dsuspc == '\377')
2519: while (ioctl(1, TIOCSLTC, (char *)&oldltchars) < 0 && errno == EINTR)
2520: ;
2521: #endif
2522: }
2523:
2524: #endif
2525:
2526:
2527:
2528: /*** signal handlers ***/
2529:
2530: onint() {
2531: #ifdef SIGTSTP
2532: int dojump = reading;
2533:
2534: reading = FALSE;
2535: #endif /* SIGTSTP */
2536: if (!news) {
2537: ttycooked();
2538: xxit(1);
2539: }
2540: (void) signal(SIGINT, onint);
2541: clearin(); /* flush input queue */
2542: #ifdef SIGTSTP
2543: if (dojump)
2544: longjmp(intjmp, 1);
2545: #endif /* SIGTSTP */
2546: intflag++;
2547: }
2548:
2549: #ifdef SIGTSTP
2550: onstop(signo)
2551: int signo;
2552: {
2553: /* restore old terminal state */
2554: botscreen();
2555: vflush();
2556: ttycooked();
2557: (void) signal(signo, SIG_DFL);
2558: #ifdef BSD4_2
2559: (void) sigblock(sigmask(SIGALRM)|sigmask(SIGINT));
2560: (void) sigsetmask(sigblock(0) & ~sigmask(signo));
2561: #else /* BSD4_1 */
2562: (void) alarm(0);
2563: #endif /* BSD4_1 */
2564: (void) kill(0, signo); /* stop here until continued */
2565:
2566: (void) signal(signo, onstop);
2567: /* restore our special terminal state */
2568: ttyraw();
2569: #ifdef TIOCGWINSZ
2570: winch(); /* get current window size and redraw screen */
2571: #else /* !TIOCGWINSZ */
2572: okclear();
2573: updscr();
2574: #endif /* !TIOCGWINSZ */
2575: #ifdef BSD4_2
2576: (void) sigsetmask(sigblock(0) & ~(sigmask(SIGALRM)|sigmask(SIGINT)));
2577: #else /* BSD4_1 */
2578: timer();
2579: #endif /* BSD4_1 */
2580: }
2581: #endif
2582:
2583: /*** stolen from rfuncs2.c and modified ***/
2584:
2585: vsave(to, flags)
2586: register char *to;
2587: {
2588: register FILE *ufp;
2589: int isprogram = 0;
2590: int isnew = 1;
2591: long saveoff;
2592: char temp[20];
2593: char *fname;
2594: char prog[BUFLEN + 24];
2595: int err;
2596:
2597: saveoff = ftell(fp);
2598: (void) fseek(fp, artbody, 0);
2599: fname = to;
2600: if (*to == PIPECHAR) {
2601: if (strlen(to) > BUFLEN) {
2602: msg("Command name too long");
2603: goto out;
2604: }
2605: flags |= OVWRITE;
2606: (void) strcpy(temp, "/tmp/vnXXXXXX");
2607: (void) mktemp(temp);
2608: fname = temp;
2609: _amove(ROWS - 1, 0);
2610: vflush();
2611: }
2612: if ((flags & OVWRITE) == 0) {
2613: ufp = fopen(fname, "r");
2614: if (ufp != NULL) {
2615: (void) fclose(ufp);
2616: isnew = 0;
2617: }
2618: }
2619: (void) umask(savmask);
2620:
2621: if (*to == PIPECHAR)
2622: isprogram++;
2623: if ((ufp = fopen(fname, (flags & OVWRITE) == 0? "a" : "w")) == NULL) {
2624: msg("Cannot open %s", fname);
2625: goto out;
2626: }
2627: /*
2628: * V7MAIL code is here to conform to V7 mail format.
2629: * If you need a different format to be able to
2630: * use your local mail command (such as four ^A's
2631: * on the end of articles) substitute it here.
2632: */
2633: if (flags & SVHEAD) {
2634: #ifdef MMDF
2635: if (!isprogram)
2636: fprintf(ufp, "\001\001\001\001\n");
2637: #endif /* MMDF */
2638: #ifdef V7MAIL
2639: h->subtime = cgtdate(h->subdate);
2640: fprintf(ufp, "From %s %s", replyname(h), ctime(&h->subtime));
2641: #endif
2642: hprint(h, ufp, 2);
2643: #ifdef V7MAIL
2644: tprint(fp, ufp, TRUE);
2645: putc('\n', ufp); /* force blank line at end (ugh) */
2646: #else
2647: tprint(fp, ufp, FALSE);
2648: #endif
2649: } else {
2650: tprint(fp, ufp, FALSE);
2651: }
2652:
2653: err = ferror(ufp);
2654:
2655: fclose(ufp);
2656: if (isprogram) {
2657: if (err)
2658: msg("error in writing temp file, maybe disk full?");
2659: else {
2660: (void) sprintf(prog, "(%s)<%s", to + 1, fname);
2661: shcmd(prog, CWAIT);
2662: prflags |= NOPRT;
2663: }
2664: } else {
2665: msg("%sfile: %s %s",
2666: err? "ERROR WHILE WRITING ": "",
2667: to,
2668: (flags&OVWRITE)? "written":
2669: isnew ? "created" : "appended");
2670: }
2671:
2672: /* If we got an error, screen may be messed. E.g. 4.2BSD
2673: * writes "disk full" messages to the user's tty.
2674: */
2675: if (err) {
2676: okclear();
2677: updscr();
2678: }
2679:
2680: out:
2681: if (isprogram) {
2682: (void) unlink(fname);
2683: }
2684: (void) umask(N_UMASK);
2685: (void) fseek(fp, saveoff, 0);
2686: }
2687:
2688: xxit(status)
2689: int status;
2690: {
2691: (void) unlink(infile);
2692: (void) unlink(outfile);
2693: #ifdef SORTACTIVE
2694: if (STRNCMP(ACTIVE,"/tmp/", 5) == 0)
2695: (void) unlink(ACTIVE);
2696: #endif /* SORTACTIVE */
2697: #ifdef SERVER
2698: (void) unlink(active_name());
2699: close_server();
2700: #endif /* SERVER */
2701: if (ospeed) { /* is == 0, we haven't been in raw mode yet */
2702: botscreen();
2703: vflush();
2704: ttycooked();
2705: }
2706: exit(status);
2707: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.