![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MH-patches CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / fred|
Return to MH-patches CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / fred |
1.1 root 1: [ MH-patches - Tue Jul 18 00:47:38 1989 - WP patches to MH - /mtr ]
2:
3:
4: Here are patches to MH 6.5 to allow send/whom to expand names into addresses.
5:
6: The user specifies a name by bracketing a WhitePages query between
7: '<<' and '>>' using fred's whois syntax, e.g.,
8:
9: To: << rose -org nyser >>
10:
11: At the "What now?" prompt, the user can say "whom" to have the
12: names expanded into addresses. Alternately, the "send" option can
13: be used as well. For each query appearing between '<<' and '>>',
14: fred will be asked to perform a white pages resolution. All
15: matches are printed and the user is asked to select one. If one is
16: not selected, the user remains with fred, to make more queries,
17: until eventually one is selected (or the user exits fred to abort
18: the expansion process).
19:
20: Note that expansion can occur only if whom/send is invoked
21: interactively. If you use push, then the expansion will fail
22: because fred will be unable to query you to select/confirm the
23: right entry to use for the substitution.
24:
25: To enable these patches, add "options WP" to your MH config file,
26: run mhconfig, apply the patches, and then do "make" from the
27: top-level. Note that this code has only been tested with
28:
29: #undef BERK
30:
31: in effect. I believe that it should work okay, but since I don't
32: run with BERK defined, I have no way of knowing.
33:
34: /mtr
35: diff -c sbr/*addrsbr.c
36: diff -c uip/_post.c uip/post.c
37: diff -c uip/*whom.c
38: diff -c uip/*whatnowsbr.c
39: diff -c zotnet/mf/*mf.c
40: *** sbr/:addrsbr.c Mon Oct 30 17:22:49 1989
41: --- sbr/addrsbr.c Sat Nov 4 22:18:39 1989
42: ***************
43: *** 103,108 ****
44: --- 103,117 ----
45:
46: char *getusr ();
47:
48: +
49: + #ifdef WP
50: + int do_wp = 0;
51: +
52: + #ifdef BERK
53: + char *wp_expand ();
54: + #endif
55: + #endif
56: +
57: /* */
58:
59: char *getname (addrs)
60: ***************
61: *** 171,176 ****
62: --- 180,214 ----
63: while ( (c = *addrs++) == ',' || isspace(c))
64: ;
65:
66: + #ifdef WP
67: + if (do_wp && c == '<' && *addrs == '<') {
68: + register char *cp,
69: + *dp,
70: + *ep;
71: +
72: + if (cp = index (++addrs, '>')) {
73: + *++cp = NULL;
74: + if (dp = wp_expand (addrs, NULLCP)) {
75: + *(addrs - 1) = NULL;
76: + ep = concat (saved_addr, dp, cp, NULLCP);
77: + addrs = ep + strlen (saved_addr);
78: + while ((c = *addrs++) == ',' || isspace (c))
79: + continue;
80: + free (saved_addr);
81: + saved_addr = ep;
82: + free (dp);
83: + }
84: + else {
85: + err = "unable to expand WhitePages query";
86: + (void) strcpy (adrtext, addrs);
87: + addrs = cp;
88: + goto out;
89: + }
90: +
91: + }
92: + }
93: + #endif
94: +
95: *nxtout = *adrcopy = '\0';
96: while (state != EOA) {
97: *adrcopy++ = c;
98: ***************
99: *** 267,280 ****
100: * addr points to where we should start scanning next time.
101: */
102: *(nxtout-1) = *(adrcopy-1) = '\0';
103: if (*adr && !err) {
104: adr_ptr = addrs-1;
105: - return adrtext;
106: } else {
107: free (saved_addr);
108: adr_ptr = NULL;
109: - return NULL;
110: }
111: #else not BERK
112: register struct adrx *ap;
113:
114: --- 305,320 ----
115: * addr points to where we should start scanning next time.
116: */
117: *(nxtout-1) = *(adrcopy-1) = '\0';
118: + #ifdef WP
119: + out: ;
120: + #endif
121: if (*adr && !err) {
122: adr_ptr = addrs-1;
123: } else {
124: free (saved_addr);
125: adr_ptr = NULL;
126: }
127: + return adrtext;
128: #else not BERK
129: register struct adrx *ap;
130:
131: ***************
132: *** 825,827 ****
133: --- 865,1013 ----
134:
135: return 0;
136: }
137: +
138: + /* */
139: +
140: + #ifdef WP
141: + #include <signal.h>
142: +
143: +
144: + static char *fredproc = NULL;
145: +
146: +
147: + char *wp_expand (query, error)
148: + char *query,
149: + *error;
150: + {
151: + register int cc,
152: + i,
153: + vecp;
154: + int (*istat) (), (*qstat) (), (*pstat) ();
155: + register char *bp,
156: + *cp;
157: + char *ep,
158: + buffer[BUFSIZ],
159: + fds[10],
160: + *vec[10];
161: + static int child_id = NOTOK,
162: + pdi[2],
163: + pdo[2];
164: +
165: + if (error)
166: + (void) strcpy (error, "unable to expand WhitePages query: ");
167: +
168: + if (child_id == NOTOK || kill (child_id, 0) == NOTOK) {
169: + if (!isatty (fileno (stdout))) {
170: + if (error)
171: + (void) strcat (error, "not a tty");
172: + return NULLCP;
173: + }
174: +
175: + if (fredproc == NULL && (fredproc = m_find ("fredproc")) == NULL)
176: + fredproc = "fred";
177: +
178: + if (pipe (pdi) == NOTOK) {
179: + if (error)
180: + (void) strcat (error, "unable to pipe");
181: +
182: + return NULLCP;
183: + }
184: +
185: + if (pipe (pdo) == NOTOK) {
186: + if (error)
187: + (void) strcat (error, "unable to pipe");
188: +
189: + losing: ;
190: + (void) close (pdi[0]);
191: + (void) close (pdi[1]);
192: + return NULLCP;
193: + }
194: +
195: + for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
196: + sleep (5);
197: +
198: + switch (child_id) {
199: + case NOTOK:
200: + if (error)
201: + (void) strcat (error, "unable to fork");
202: +
203: + (void) close (pdo[0]);
204: + (void) close (pdo[1]);
205: + goto losing;
206: +
207: + case OK:
208: + (void) close (pdi[0]);
209: + (void) close (pdo[1]);
210: + (void) sprintf (fds, "%d %d", pdo[0], pdi[1]);
211: + vecp = 0;
212: + vec[vecp++] = r1bindex (fredproc, '/');
213: + vec[vecp++] = "-q";
214: + vec[vecp++] = fds;
215: + vec[vecp] = NULL;
216: + execvp (fredproc, vec);
217: + _exit (-1); /* NOTREACHED */
218: +
219: + default:
220: + (void) close (pdi[1]);
221: + (void) close (pdo[0]);
222: + break;
223: + }
224: + }
225: +
226: + istat = signal (SIGINT, SIG_IGN);
227: + qstat = signal (SIGQUIT, SIG_IGN);
228: +
229: + pstat = signal (SIGPIPE, SIG_IGN);
230: +
231: + (void) sprintf (buffer, "%s\n", query);
232: + cc = write (pdo[1], buffer, i = strlen (buffer));
233: +
234: + (void) signal (SIGPIPE, pstat);
235: +
236: + if (cc != i) {
237: + if (error)
238: + (void) strcat (error, "write to pipe failed");
239: +
240: + lost_child: ;
241: + (void) kill (child_id, SIGTERM);
242: + (void) close (pdi[0]);
243: + (void) close (pdo[1]);
244: +
245: + child_id = NOTOK;
246: + return NULLCP;
247: + }
248: +
249: + for (ep = (bp = buffer) + sizeof buffer - 1;
250: + (i = read (pdi[0], bp, ep - bp)) > 0; ) {
251: + for (cp = bp + i; bp < cp; bp++)
252: + if (*bp == '\n')
253: + break;
254: + if (bp < cp)
255: + break;
256: + }
257: +
258: + (void) signal (SIGINT, istat);
259: + (void) signal (SIGQUIT, qstat);
260: +
261: + if (i == NOTOK) {
262: + if (error)
263: + (void) strcat (error, "read from pipe failed");
264: + goto lost_child;
265: + }
266: + if (i == 0) {
267: + if (error)
268: + (void) sprintf (error + strlen (error), "%s exited prematurely",
269: + fredproc);
270: + goto lost_child;
271: + }
272: + *bp = NULL;
273: +
274: + if (error)
275: + if (bp != buffer)
276: + error[0] = NULL;
277: + else
278: + (void) strcpy (error, "unable to expand WhitePages query");
279: +
280: + return (*buffer ? getcpy (buffer) : NULLCP);
281: + }
282: + #endif
283: *** uip/_post.c Mon Oct 30 17:22:54 1989
284: --- uip/post.c Tue Aug 8 20:28:58 1989
285: ***************
286: *** 91,97 ****
287: #define NWATCSW 17
288: "nowatch", 0,
289:
290: ! #define WHOMSW 18 /* interface from whom */
291: "whom", -4,
292:
293: #define WIDTHSW 19
294: --- 91,97 ----
295: #define NWATCSW 17
296: "nowatch", 0,
297:
298: ! #define WHOMSW 18 /* interface from whom */
299: "whom", -4,
300:
301: #define WIDTHSW 19
302: ***************
303: *** 122,127 ****
304: --- 122,130 ----
305: #define SNOOPSW 29
306: "snoop", -5,
307:
308: + #define FILLSW 30
309: + "fill-in file", -7,
310: +
311: NULL, NULL
312: };
313:
314: ***************
315: *** 284,289 ****
316: --- 287,298 ----
317: static int encryptsw = 0; /* encrypt it */
318:
319:
320: + #ifdef WP
321: + extern int do_wp; /* fill-in white pages queries */
322: + #endif
323: + static char *fill_in = NULLCP;
324: +
325: +
326: long lseek (), time ();
327:
328: /* MAIN */
329: ***************
330: *** 486,491 ****
331: --- 495,507 ----
332: snoop++;
333: continue;
334: #endif SENDMTS
335: +
336: + case FILLSW:
337: + #ifdef WP
338: + if (!(fill_in = *argp++) || *fill_in == '-')
339: + adios (NULLCP, "missing argument to %s", argp[-2]);
340: + #endif
341: + continue;
342: }
343: if (msg)
344: adios (NULLCP, "only one message at a time!");
345: ***************
346: *** 494,499 ****
347: --- 510,518 ----
348: }
349:
350: (void) alias (AliasFile);
351: + #ifdef WP
352: + do_wp++;
353: + #endif
354:
355: /* */
356:
357: ***************
358: *** 534,540 ****
359: else
360: #endif MHMTS
361: if (whomsw) {
362: ! if ((out = fopen ("/dev/null", "w")) == NULL)
363: adios ("/dev/null", "unable to open");
364: }
365: else {
366: --- 553,559 ----
367: else
368: #endif MHMTS
369: if (whomsw) {
370: ! if ((out = fopen (fill_in ? fill_in : "/dev/null", "w")) == NULL)
371: adios ("/dev/null", "unable to open");
372: }
373: else {
374: ***************
375: *** 575,581 ****
376: case BODY:
377: case BODYEOF:
378: finish_headers (out);
379: ! if (whomsw)
380: break;
381: fprintf (out, "\n%s", buf);
382: while (state == BODY) {
383: --- 594,600 ----
384: case BODY:
385: case BODYEOF:
386: finish_headers (out);
387: ! if (whomsw && !fill_in)
388: break;
389: fprintf (out, "\n%s", buf);
390: while (state == BODY) {
391: ***************
392: *** 699,709 ****
393: }
394:
395: hdr = &hdrtab[i];
396: ! if (hdr -> flags & HIGN)
397: return;
398: if (hdr -> flags & HBAD) {
399: ! advise (NULLCP, "illegal header line -- %s:", name);
400: ! badmsg++;
401: return;
402: }
403: msgflags |= (hdr -> set & ~(MVIS | MINV));
404: --- 718,735 ----
405: }
406:
407: hdr = &hdrtab[i];
408: ! if (hdr -> flags & HIGN) {
409: ! if (fill_in)
410: ! fprintf (out, "%s: %s", name, str);
411: return;
412: + }
413: if (hdr -> flags & HBAD) {
414: ! if (fill_in)
415: ! fprintf (out, "%s: %s", name, str);
416: ! else {
417: ! advise (NULLCP, "illegal header line -- %s:", name);
418: ! badmsg++;
419: ! }
420: return;
421: }
422: msgflags |= (hdr -> set & ~(MVIS | MINV));
423: ***************
424: *** 711,716 ****
425: --- 737,747 ----
426: if (hdr -> flags & HSUB)
427: subject = subject ? add (str, add ("\t", subject)) : getcpy (str);
428: if (hdr -> flags & HFCC) {
429: + if (fill_in) {
430: + fprintf (out, "%s: %s", name, str);
431: + return;
432: + }
433: +
434: if (cp = rindex (str, '\n'))
435: *cp = NULL;
436: for (cp = pp = str; cp = index (pp, ','); pp = cp) {
437: ***************
438: *** 759,765 ****
439:
440: nameoutput = linepos = 0;
441: (void) sprintf (namep, "%s%s",
442: ! (hdr -> flags & HMNG) ? "Original-" : "", name);
443:
444: for (grp = 0, mp = tmpaddrs.m_next; mp; mp = np)
445: if (mp -> m_nohost) { /* also used to test (hdr -> flags & HTRY) */
446: --- 790,797 ----
447:
448: nameoutput = linepos = 0;
449: (void) sprintf (namep, "%s%s",
450: ! !fill_in && (hdr -> flags & HMNG) ? "Original-" : "",
451: ! name);
452:
453: for (grp = 0, mp = tmpaddrs.m_next; mp; mp = np)
454: if (mp -> m_nohost) { /* also used to test (hdr -> flags & HTRY) */
455: ***************
456: *** 810,817 ****
457: advise (NULLCP, "%s: field does not allow groups", name);
458: badmsg++;
459: }
460: ! if (linepos)
461: (void) putc ('\n', out);
462: }
463:
464: /* */
465: --- 842,852 ----
466: advise (NULLCP, "%s: field does not allow groups", name);
467: badmsg++;
468: }
469: ! if (linepos) {
470: ! if (fill_in && grp > 0)
471: ! (void) putc (';', out);
472: (void) putc ('\n', out);
473: + }
474: }
475:
476: /* */
477: ***************
478: *** 942,948 ****
479:
480: if (mp -> m_mbox == NULL || ((flags & HTRY) && !insert (mp)))
481: return 0;
482: ! if ((flags & HBCC) || mp -> m_ingrp)
483: return 1;
484:
485: if (!nameoutput) {
486: --- 977,983 ----
487:
488: if (mp -> m_mbox == NULL || ((flags & HTRY) && !insert (mp)))
489: return 0;
490: ! if (!fill_in && ((flags & HBCC) || mp -> m_ingrp))
491: return 1;
492:
493: if (!nameoutput) {
494: ***************
495: *** 953,959 ****
496: if (*aka && mp -> m_type != UUCPHOST && !mp -> m_pers)
497: mp -> m_pers = getcpy (aka);
498: if (format) {
499: ! if (mp -> m_gname)
500: (void) sprintf (cp = buffer, "%s;", mp -> m_gname);
501: else
502: cp = adrformat (mp);
503: --- 988,994 ----
504: if (*aka && mp -> m_type != UUCPHOST && !mp -> m_pers)
505: mp -> m_pers = getcpy (aka);
506: if (format) {
507: ! if (mp -> m_gname && !fill_in)
508: (void) sprintf (cp = buffer, "%s;", mp -> m_gname);
509: else
510: cp = adrformat (mp);
511: ***************
512: *** 987,1004 ****
513: int len;
514: char *cp;
515:
516: ! if (flags & HBCC)
517: return;
518:
519: if (!nameoutput) {
520: fprintf (out, "%s: ", name);
521: linepos += (nameoutput = strlen (name) + 2);
522: }
523:
524: ! cp = concat (group, ";", NULLCP);
525: len = strlen (cp);
526:
527: ! if (linepos != nameoutput)
528: if (len + linepos + 2 > outputlinelen) {
529: fprintf (out, ",\n%*s", nameoutput, "");
530: linepos = nameoutput;
531: --- 1022,1041 ----
532: int len;
533: char *cp;
534:
535: ! if (!fill_in && (flags & HBCC))
536: return;
537:
538: if (!nameoutput) {
539: fprintf (out, "%s: ", name);
540: linepos += (nameoutput = strlen (name) + 2);
541: + if (fill_in)
542: + linepos -= strlen (group);
543: }
544:
545: ! cp = fill_in ? group : concat (group, ";", NULLCP);
546: len = strlen (cp);
547:
548: ! if (linepos > nameoutput)
549: if (len + linepos + 2 > outputlinelen) {
550: fprintf (out, ",\n%*s", nameoutput, "");
551: linepos = nameoutput;
552: *** uip/_whom.c Mon Oct 30 17:22:52 1989
553: --- uip/whom.c Mon Jul 17 09:22:31 1989
554: ***************
555: *** 35,40 ****
556: --- 35,43 ----
557: #define SNOOPSW 10
558: "snoop", -5,
559:
560: + #define FILLSW 11
561: + "fill-in file", -7,
562: +
563: NULL, NULL
564: };
565:
566: ***************
567: *** 125,130 ****
568: --- 128,134 ----
569: case ALIASW:
570: case CLIESW:
571: case SERVSW:
572: + case FILLSW:
573: vec[vecp++] = --cp;
574: if (!(cp = *argp++) || *cp == '-')
575: adios (NULLCP, "missing argument to %s", argp[-2]);
576: *** uip/_whatnowsbr.c Mon Oct 30 17:22:57 1989
577: --- uip/whatnowsbr.c Mon Jul 17 12:04:19 1989
578: ***************
579: *** 758,764 ****
580: --- 758,773 ----
581: int pid;
582: register int vecp;
583: char *vec[MAXARGS];
584: + #ifdef WP
585: + char *cp,
586: + draft[BUFSIZ],
587: + backup[BUFSIZ];
588: + #endif
589:
590: + #ifdef WP
591: + (void) strcpy (draft, m_scratch (file, invo_name));
592: + #endif
593: +
594: m_update ();
595: (void) fflush (stdout);
596:
597: ***************
598: *** 774,779 ****
599: --- 783,792 ----
600: if (arg)
601: while (*arg)
602: vec[vecp++] = *arg++;
603: + #ifdef WP
604: + vec[vecp++] = "-fill-in";
605: + vec[vecp++] = draft;
606: + #endif
607: vec[vecp] = NULL;
608:
609: execvp (whomproc, vec);
610: ***************
611: *** 782,787 ****
612: --- 795,822 ----
613: _exit (-1); /* NOTREACHED */
614:
615: default:
616: + #ifndef WP
617: return (pidwait (pid, NOTOK) & 0377 ? 1 : 0);
618: + #else
619: + if (pidwait (pid, NOTOK)) {
620: + (void) unlink (draft);
621: + return 1;
622: + }
623: + break;
624: + #endif
625: }
626: +
627: + #ifdef WP
628: + if (rename (file, cp = m_backup (file)) == NOTOK) {
629: + advise (cp, "unable to rename %s to", file);
630: + (void) unlink (draft);
631: + return 1;
632: + }
633: + if (rename (draft, file) == NOTOK) {
634: + advise (file, "unable to rename %s to ", draft);
635: + return 1;
636: + }
637: +
638: + return 0;
639: + #endif
640: }
641: *** zotnet/mf/_mf.c Mon Oct 30 17:22:59 1989
642: --- zotnet/mf/mf.c Mon Oct 30 20:32:38 1989
643: ***************
644: *** 298,303 ****
645: --- 298,306 ----
646:
647: #define QUOTE '\\'
648:
649: + #ifdef WP
650: + #define LX_WP (-1)
651: + #endif
652: #define LX_END 0
653: #define LX_ERR 1
654: #define LX_ATOM 2
655: ***************
656: *** 351,361 ****
657: --- 354,375 ----
658:
659: static struct adrx adrxs2;
660:
661: +
662: + #ifdef WP
663: + char *concat ();
664: +
665: + extern int do_wp;
666: + char *wp_expand ();
667: + #endif
668: +
669: /* */
670:
671: struct adrx *getadrx (addrs)
672: register char *addrs;
673: {
674: + #ifdef WP
675: + int save_lex;
676: + #endif
677: register char *bp;
678: register struct adrx *adrxp = &adrxs2;
679:
680: ***************
681: *** 385,390 ****
682: --- 399,427 ----
683: return NULL;
684: }
685:
686: + #ifdef WP
687: + bp = cp, save_lex = last_lex;
688: + if (my_lex (adr) == LX_WP) {
689: + register char *ep,
690: + *fp;
691: +
692: + if (fp = wp_expand (adr, err)) {
693: + *bp = NULL;
694: + ep = concat (dp, fp, cp, (char *) NULL);
695: + cp = ep + strlen (dp), last_lex = save_lex;
696: + free (dp);
697: + dp = ep;
698: + free (fp);
699: + }
700: + else {
701: + ap = bp, save_lex = last_lex;
702: + goto out;
703: + }
704: + }
705: + else
706: + cp = bp, last_lex = save_lex;
707: + #endif
708: +
709: switch (parse_address ()) {
710: case DONE:
711: free (dp);
712: ***************
713: *** 409,414 ****
714: --- 446,454 ----
715: break;
716: }
717:
718: + #ifdef WP
719: + out: ;
720: + #endif
721: if (err[0])
722: for (;;) {
723: switch (last_lex) {
724: ***************
725: *** 798,803 ****
726: --- 838,858 ----
727: cp = NULL;
728: return (last_lex = LX_END);
729: }
730: +
731: + #ifdef WP
732: + if (do_wp && c == '<' && *cp == '<')
733: + for (cp++;;)
734: + switch (c = *cp++) {
735: + case '>':
736: + *bp = NULL;
737: + cp++;
738: + return (last_lex = LX_WP);
739: +
740: + default:
741: + *bp++ = c;
742: + continue;
743: + }
744: + #endif
745:
746: if (c == '(')
747: for (*bp++ = c, i = 0;;)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.