![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / mf|
Return to mf.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / mf |
1.1 root 1: /* mf.c - mail filter subroutines */
2:
3: #include "mf.h"
4: #include <ctype.h>
5: #include <stdio.h>
6:
7: static int compress(), isat(), parse_address(), phrase(), route_addr(),
8: local_part(), domain(), route(), my_lex();
9:
10: /* */
11:
12: static char *
13: getcpy(s)
14: register char *s;
15: {
16: register char *p;
17:
18: if (!s) { _cleanup(); abort(); for(;;) pause();}
19: if ((p = malloc ((unsigned) (strlen (s) + 2))) != NULL)
20: (void) strcpy (p, s);
21: return p;
22: }
23:
24:
25: static char *
26: add(s1, s2)
27: register char *s1, *s2;
28: {
29: register char *p;
30:
31: if (s2 == NULL)
32: return getcpy (s1);
33:
34: if ((p = malloc ((unsigned) (strlen (s1) + strlen (s2) + 2))) != NULL)
35: (void) sprintf (p, "%s%s", s2, s1);
36: free (s2);
37: return p;
38: }
39:
40: /* */
41:
42: isfrom(string)
43: register char *string;
44: {
45: return (strncmp (string, "From ", 5) == 0
46: || strncmp (string, ">From ", 6) == 0);
47: }
48:
49:
50: lequal(a, b)
51: register char *a, *b;
52: {
53: for (; *a; a++, b++)
54: if (*b == NULL)
55: return FALSE;
56: else {
57: char c1 = islower (*a) ? toupper (*a) : *a;
58: char c2 = islower (*b) ? toupper (*b) : *b;
59: if (c1 != c2)
60: return FALSE;
61: }
62:
63: return (*b == NULL);
64: }
65:
66: /* */
67:
68: /*
69: *
70: * seekadrx() is tricky. We want to cover both UUCP-style and ARPA-style
71: * addresses, so for each list of addresses we see if we can find some
72: * character to give us a hint.
73: *
74: */
75:
76:
77: #define CHKADR 0 /* undertermined address style */
78: #define UNIXDR 1 /* UNIX-style address */
79: #define ARPADR 2 /* ARPAnet-style address */
80:
81:
82: static char *punctuators = ";<>.()[]";
83: static char *vp = NULL;
84: static char *tp = NULL;
85:
86: static struct adrx adrxs1;
87:
88: /* */
89:
90: struct adrx *
91: seekadrx(addrs)
92: register char *addrs;
93: {
94: static int state = CHKADR;
95: register char *cp;
96: register struct adrx *adrxp;
97:
98: if (state == CHKADR)
99: for (state = UNIXDR, cp = addrs; *cp; cp++)
100: if (index (punctuators, *cp)) {
101: state = ARPADR;
102: break;
103: }
104:
105: switch (state) {
106: case UNIXDR:
107: adrxp = uucpadrx (addrs);
108: break;
109:
110: case ARPADR:
111: default:
112: adrxp = getadrx (addrs);
113: break;
114: }
115:
116: if (adrxp == NULL)
117: state = CHKADR;
118:
119: return adrxp;
120: }
121:
122: /* */
123:
124: /*
125: *
126: * uucpadrx() implements a partial UUCP-style address parser. It's based
127: * on the UUCP notion that addresses are separated by spaces or commas.
128: *
129: */
130:
131:
132: struct adrx *
133: uucpadrx(addrs)
134: register char *addrs;
135: {
136: register char *cp,
137: *wp,
138: *xp,
139: *yp,
140: *zp;
141: register struct adrx *adrxp = &adrxs1;
142:
143: if (vp == NULL) {
144: vp = tp = getcpy (addrs);
145: compress (addrs, vp);
146: }
147: else
148: if (tp == NULL) {
149: free (vp);
150: vp = NULL;
151: return NULL;
152: }
153:
154: for (cp = tp; isspace (*cp); cp++)
155: continue;
156: if (*cp == NULL) {
157: free (vp);
158: vp = tp = NULL;
159: return NULL;
160: }
161:
162: /* */
163:
164: if ((wp = index (cp, ',')) == NULL)
165: if ((wp = index (cp, ' ')) != NULL) {
166: xp = wp;
167: while (isspace (*xp))
168: xp++;
169: if (*xp != NULL && isat (--xp)) {
170: yp = xp + 4;
171: while (isspace (*yp))
172: yp++;
173: if (*yp != NULL)
174: if ((zp = index (yp, ' ')) != NULL)
175: *zp = NULL, tp = ++zp;
176: else
177: tp = NULL;
178: else
179: *wp = NULL, tp = ++wp;
180: }
181: else
182: *wp = NULL, tp = ++wp;
183: }
184: else
185: tp = NULL;
186: else
187: *wp = NULL, tp = ++wp;
188:
189: if (adrxp -> text)
190: free (adrxp -> text);
191: adrxp -> text = getcpy (cp);
192: adrxp -> mbox = cp;
193: adrxp -> host = adrxp -> path = NULL;
194: if ((wp = rindex (cp, '@')) != NULL) {
195: *wp++ = NULL;
196: adrxp -> host = *wp ? wp : NULL;
197: }
198: else
199: for (wp = cp + strlen (cp) - 4; wp >= cp; wp--)
200: if (isat (wp)) {
201: *wp++ = NULL;
202: adrxp -> host = wp + 3;
203: }
204:
205: adrxp -> pers = adrxp -> grp = adrxp -> note = adrxp -> err = NULL;
206: adrxp -> ingrp = 0;
207:
208: return adrxp;
209: }
210:
211: /* */
212:
213: static int
214: compress(fp, tp)
215: register char *fp, *tp;
216: {
217: register char c,
218: *cp;
219:
220: for (c = ' ', cp = tp; (*tp = *fp++) != NULL;)
221: if (isspace (*tp)) {
222: if (c != ' ')
223: *tp++ = c = ' ';
224: }
225: else
226: c = *tp++;
227:
228: if (c == ' ' && cp < tp)
229: *--tp = NULL;
230: }
231:
232:
233: static int
234: isat(p)
235: register char *p;
236: {
237: return (strncmp (p, " AT ", 4)
238: && strncmp (p, " At ", 4)
239: && strncmp (p, " aT ", 4)
240: && strncmp (p, " at ", 4) ? FALSE : TRUE);
241: }
242:
243: /* */
244:
245: /*
246: *
247: * getadrx() implements a partial 822-style address parser. The parser
248: * is neither complete nor correct. It does however recognize nearly all
249: * of the 822 address syntax. In addition it handles the majority of the
250: * 733 syntax as well. Most problems arise from trying to accomodate both.
251: *
252: * In terms of 822, the route-specification in
253: *
254: * "<" [route] local-part "@" domain ">"
255: *
256: * is parsed and returned unchanged. Multiple at-signs are compressed
257: * via source-routing. Recursive groups are not allowed as per the
258: * standard.
259: *
260: * In terms of 733, " at " is recognized as equivalent to "@".
261: *
262: * In terms of both the parser will not complain about missing hosts.
263: *
264: * -----
265: *
266: * We should not allow addresses like
267: *
268: * Marshall T. Rose <MRose@UCI>
269: *
270: * but should insist on
271: *
272: * "Marshall T. Rose" <MRose@UCI>
273: *
274: * Unfortunately, a lot of mailers stupidly let people get away with this.
275: *
276: * -----
277: *
278: * We should not allow addresses like
279: *
280: * <MRose@UCI>
281: *
282: * but should insist on
283: *
284: * MRose@UCI
285: *
286: * Unfortunately, a lot of mailers stupidly let people's UAs get away with
287: * this.
288: *
289: * -----
290: *
291: * We should not allow addresses like
292: *
293: * @UCI:MRose@UCI-750a
294: *
295: * but should insist on
296: *
297: * Marshall Rose <@UCI:MRose@UCI-750a>
298: *
299: * Unfortunately, a lot of mailers stupidly do this.
300: *
301: */
302:
303: /* */
304:
305: #define QUOTE '\\'
306:
307: #define LX_END 0
308: #define LX_ERR 1
309: #define LX_ATOM 2
310: #define LX_QSTR 3
311: #define LX_DLIT 4
312: #define LX_SEMI 5
313: #define LX_COMA 6
314: #define LX_LBRK 7
315: #define LX_RBRK 8
316: #define LX_COLN 9
317: #define LX_DOT 10
318: #define LX_AT 11
319:
320: static struct {
321: char lx_chr;
322: int lx_val;
323: } special[] = {
324: ';', LX_SEMI,
325: ',', LX_COMA,
326: '<', LX_LBRK,
327: '>', LX_RBRK,
328: ':', LX_COLN,
329: '.', LX_DOT,
330: '@', LX_AT,
331: '(', LX_ERR,
332: ')', LX_ERR,
333: QUOTE, LX_ERR,
334: '"', LX_ERR,
335: '[', LX_ERR,
336: ']', LX_ERR,
337: NULL, NULL
338: };
339:
340: /* */
341:
342: static int glevel = 0;
343: static int ingrp = 0;
344: static int last_lex = LX_END;
345:
346: static char *dp = NULL;
347: static char *cp = NULL;
348: static char *ap = NULL;
349: static char *pers = NULL;
350: static char *mbox = NULL;
351: static char *host = NULL;
352: static char *path = NULL;
353: static char *grp = NULL;
354: static char *note = NULL;
355: static char err[BUFSIZ];
356: static char adr[BUFSIZ];
357:
358: static struct adrx adrxs2;
359:
360: /* */
361:
362: struct adrx *
363: getadrx(addrs)
364: register char *addrs;
365: {
366: register char *bp;
367: register struct adrx *adrxp = &adrxs2;
368:
369: if (pers)
370: free (pers);
371: if (mbox)
372: free (mbox);
373: if (host)
374: free (host);
375: if (path)
376: free (path);
377: if (grp)
378: free (grp);
379: if (note)
380: free (note);
381: pers = mbox = host = path = grp = note = NULL;
382: err[0] = NULL;
383:
384: if (dp == NULL) {
385: dp = cp = getcpy (addrs ? addrs : "");
386: glevel = 0;
387: }
388: else
389: if (cp == NULL) {
390: free (dp);
391: dp = NULL;
392: return NULL;
393: }
394:
395: switch (parse_address ()) {
396: case DONE:
397: free (dp);
398: dp = cp = NULL;
399: return NULL;
400:
401: case OK:
402: switch (last_lex) {
403: case LX_COMA:
404: case LX_END:
405: break;
406:
407: default: /* catch trailing comments */
408: bp = cp;
409: (void) my_lex (adr);
410: cp = bp;
411: break;
412: }
413: break;
414:
415: default:
416: break;
417: }
418:
419: if (err[0])
420: for (;;) {
421: switch (last_lex) {
422: case LX_COMA:
423: case LX_END:
424: break;
425:
426: default:
427: (void) my_lex (adr);
428: continue;
429: }
430: break;
431: }
432: while (isspace (*ap))
433: ap++;
434: if (cp)
435: (void) sprintf (adr, "%.*s", cp - ap, ap);
436: else
437: (void) strcpy (adr, ap);
438: bp = adr + strlen (adr) - 1;
439: if (*bp == ',' || *bp == ';' || *bp == '\n')
440: *bp = NULL;
441:
442: /* */
443:
444: adrxp -> text = adr;
445: adrxp -> pers = pers;
446: adrxp -> mbox = mbox;
447: adrxp -> host = host;
448: adrxp -> path = path;
449: adrxp -> grp = grp;
450: adrxp -> ingrp = ingrp;
451: adrxp -> note = note;
452: adrxp -> err = err[0] ? err : NULL;
453:
454: return adrxp;
455: }
456:
457: /* */
458:
459: static int
460: parse_address()
461: {
462: char buffer[BUFSIZ];
463:
464: again: ;
465: ap = cp;
466: switch (my_lex (buffer)) {
467: case LX_ATOM:
468: case LX_QSTR:
469: pers = getcpy (buffer);
470: break;
471:
472: case LX_SEMI:
473: if (glevel-- <= 0) {
474: (void) strcpy (err, "extraneous semi-colon");
475: return NOTOK;
476: }
477: case LX_COMA:
478: if (note) {
479: free (note);
480: note = NULL;
481: }
482: goto again;
483:
484: case LX_END:
485: return DONE;
486:
487: case LX_LBRK: /* sigh (2) */
488: goto get_addr;
489:
490: case LX_AT: /* sigh (3) */
491: cp = ap;
492: if (route_addr (buffer) == NOTOK)
493: return NOTOK;
494: return OK; /* why be choosy? */
495:
496: default:
497: (void) sprintf (err, "illegal address construct (%s)", buffer);
498: return NOTOK;
499: }
500:
501: /* */
502:
503: switch (my_lex (buffer)) {
504: case LX_ATOM:
505: case LX_QSTR:
506: pers = add (buffer, add (" ", pers));
507: more_phrase: ; /* sigh (1) */
508: if (phrase (buffer) == NOTOK)
509: return NOTOK;
510:
511: switch (last_lex) {
512: case LX_LBRK:
513: get_addr: ;
514: if (route_addr (buffer) == NOTOK)
515: return NOTOK;
516: if (last_lex == LX_RBRK)
517: return OK;
518: (void) sprintf (err, "missing right-bracket (%s)", buffer);
519: return NOTOK;
520:
521: case LX_COLN:
522: get_group: ;
523: if (glevel++ > 0) {
524: (void) sprintf (err, "nested groups not allowed (%s)",
525: pers);
526: return NOTOK;
527: }
528: grp = add (": ", pers);
529: pers = NULL;
530: {
531: char *pp = cp;
532:
533: for (;;)
534: switch (my_lex (buffer)) {
535: case LX_SEMI:
536: case LX_END: /* tsk, tsk */
537: glevel--;
538: return OK;
539:
540: case LX_COMA:
541: continue;
542:
543: default:
544: cp = pp;
545: return parse_address ();
546: }
547: }
548:
549: case LX_DOT: /* sigh (1) */
550: pers = add (".", pers);
551: goto more_phrase;
552:
553: default:
554: (void) sprintf (err,
555: "no mailbox in address, only a phrase (%s%s)",
556: pers, buffer);
557: return NOTOK;
558: }
559:
560: /* */
561:
562: case LX_LBRK:
563: goto get_addr;
564:
565: case LX_COLN:
566: goto get_group;
567:
568: case LX_DOT:
569: mbox = add (buffer, pers);
570: pers = NULL;
571: if (route_addr (buffer) == NOTOK)
572: return NOTOK;
573: goto check_end;
574:
575: case LX_AT:
576: ingrp = glevel;
577: mbox = pers;
578: pers = NULL;
579: if (domain (buffer) == NOTOK)
580: return NOTOK;
581: check_end: ;
582: switch (last_lex) {
583: case LX_SEMI:
584: if (glevel-- <= 0) {
585: (void) strcpy (err, "extraneous semi-colon");
586: return NOTOK;
587: }
588: case LX_COMA:
589: case LX_END:
590: return OK;
591:
592: default:
593: (void) sprintf (err, "junk after local@domain (%s)",
594: buffer);
595: return NOTOK;
596: }
597:
598: case LX_SEMI: /* no host */
599: case LX_COMA:
600: case LX_END:
601: ingrp = glevel;
602: if (last_lex == LX_SEMI && glevel-- <= 0) {
603: (void) strcpy (err, "extraneous semi-colon");
604: return NOTOK;
605: }
606: mbox = pers;
607: pers = NULL;
608: return OK;
609:
610: default:
611: (void) sprintf (err, "missing mailbox (%s)", buffer);
612: return NOTOK;
613: }
614: }
615:
616: /* */
617:
618: static int
619: phrase(buffer)
620: register char *buffer;
621: {
622: for (;;)
623: switch (my_lex (buffer)) {
624: case LX_ATOM:
625: case LX_QSTR:
626: pers = add (buffer, add (" ", pers));
627: continue;
628:
629: default:
630: return OK;
631: }
632: }
633:
634: /* */
635:
636: static int
637: route_addr(buffer)
638: register char *buffer;
639: {
640: register char *pp = cp;
641:
642: if (my_lex (buffer) == LX_AT) {
643: if (route (buffer) == NOTOK)
644: return NOTOK;
645: }
646: else
647: cp = pp;
648:
649: if (local_part (buffer) == NOTOK)
650: return NOTOK;
651:
652: switch (last_lex) {
653: case LX_AT:
654: return domain (buffer);
655:
656: case LX_RBRK: /* no host */
657: case LX_COMA:
658: case LX_END:
659: return OK;
660:
661: default:
662: (void) sprintf (err, "no at-sign after local-part (%s)", buffer);
663: return NOTOK;
664: }
665: }
666:
667: /* */
668:
669: static int
670: local_part(buffer)
671: register char *buffer;
672: {
673: ingrp = glevel;
674:
675: for (;;) {
676: switch (my_lex (buffer)) {
677: case LX_ATOM:
678: case LX_QSTR:
679: mbox = add (buffer, mbox);
680: break;
681:
682: default:
683: (void) sprintf (err, "no mailbox in local-part (%s)", buffer);
684: return NOTOK;
685: }
686:
687: switch (my_lex (buffer)) {
688: case LX_DOT:
689: mbox = add (buffer, mbox);
690: continue;
691:
692: default:
693: return OK;
694: }
695: }
696: }
697:
698: /* */
699:
700: static int
701: domain(buffer)
702: register char *buffer;
703: {
704: for (;;) {
705: switch (my_lex (buffer)) {
706: case LX_ATOM:
707: case LX_DLIT:
708: host = add (buffer, host);
709: break;
710:
711: default:
712: (void) sprintf (err,
713: "no sub-domain in domain-part of address (%s)",
714: buffer);
715: return NOTOK;
716: }
717:
718: switch (my_lex (buffer)) {
719: case LX_DOT:
720: host = add (buffer, host);
721: continue;
722:
723: case LX_AT: /* sigh (0) */
724: mbox = add (host, add ("%", mbox));
725: free (host);
726: host = NULL;
727: continue;
728:
729: default:
730: return OK;
731: }
732: }
733: }
734:
735: /* */
736:
737: static int
738: route(buffer)
739: register char *buffer;
740: {
741: path = getcpy ("@");
742:
743: for (;;) {
744: switch (my_lex (buffer)) {
745: case LX_ATOM:
746: case LX_DLIT:
747: path = add (buffer, path);
748: break;
749:
750: default:
751: (void) sprintf (err,
752: "no sub-domain in domain-part of address (%s)",
753: buffer);
754: return NOTOK;
755: }
756: switch (my_lex (buffer)) {
757: case LX_COMA:
758: path = add (buffer, path);
759: for (;;) {
760: switch (my_lex (buffer)) {
761: case LX_COMA:
762: continue;
763:
764: case LX_AT:
765: path = add (buffer, path);
766: break;
767:
768: default:
769: (void) sprintf (err,
770: "no at-sign found for next domain in route (%s)",
771: buffer);
772: }
773: break;
774: }
775: continue;
776:
777: case LX_AT: /* XXX */
778: case LX_DOT:
779: path = add (buffer, path);
780: continue;
781:
782: case LX_COLN:
783: path = add (buffer, path);
784: return OK;
785:
786: default:
787: (void) sprintf (err,
788: "no colon found to terminate route (%s)", buffer);
789: return NOTOK;
790: }
791: }
792: }
793:
794: /* */
795:
796: static int
797: my_lex(buffer)
798: register char *buffer;
799: {
800: int i;
801: register char c,
802: *bp;
803:
804: bp = buffer;
805: *bp = NULL;
806: if (!cp)
807: return (last_lex = LX_END);
808:
809: c = *cp++;
810: while (isspace (c))
811: c = *cp++;
812: if (c == NULL) {
813: cp = NULL;
814: return (last_lex = LX_END);
815: }
816:
817: if (c == '(')
818: for (*bp++ = c, i = 0;;)
819: switch (c = *cp++) {
820: case NULL:
821: cp = NULL;
822: return (last_lex = LX_ERR);
823: case QUOTE:
824: *bp++ = c;
825: if ((c = *cp++) == NULL) {
826: cp = NULL;
827: return (last_lex = LX_ERR);
828: }
829: *bp++ = c;
830: continue;
831: case '(':
832: i++;
833: default:
834: *bp++ = c;
835: continue;
836: case ')':
837: *bp++ = c;
838: if (--i < 0) {
839: *bp = NULL;
840: note = note ? add (buffer, add (" ", note))
841: : getcpy (buffer);
842: return my_lex (buffer);
843: }
844: }
845:
846: /* */
847:
848: if (c == '"')
849: for (*bp++ = c;;)
850: switch (c = *cp++) {
851: case NULL:
852: cp = NULL;
853: return (last_lex = LX_ERR);
854: case QUOTE:
855: *bp++ = c;
856: if ((c = *cp++) == NULL) {
857: cp = NULL;
858: return (last_lex = LX_ERR);
859: }
860: default:
861: *bp++ = c;
862: continue;
863: case '"':
864: *bp++ = c;
865: *bp = NULL;
866: return (last_lex = LX_QSTR);
867: }
868:
869: if (c == '[')
870: for (*bp++ = c;;)
871: switch (c = *cp++) {
872: case NULL:
873: cp = NULL;
874: return (last_lex = LX_ERR);
875: case QUOTE:
876: *bp++ = c;
877: if ((c = *cp++) == NULL) {
878: cp = NULL;
879: return (last_lex = LX_ERR);
880: }
881: default:
882: *bp++ = c;
883: continue;
884: case ']':
885: *bp++ = c;
886: *bp = NULL;
887: return (last_lex = LX_DLIT);
888: }
889:
890: /* */
891:
892: *bp++ = c;
893: *bp = NULL;
894: for (i = 0; special[i].lx_chr != NULL; i++)
895: if (c == special[i].lx_chr)
896: return (last_lex = special[i].lx_val);
897:
898: if (iscntrl (c))
899: return (last_lex = LX_ERR);
900:
901: for (;;) {
902: if ((c = *cp++) == NULL)
903: break;
904: for (i = 0; special[i].lx_chr != NULL; i++)
905: if (c == special[i].lx_chr)
906: goto got_atom;
907: if (iscntrl (c) || isspace (c))
908: break;
909: *bp++ = c;
910: }
911: got_atom: ;
912: if (c == NULL)
913: cp = NULL;
914: else
915: cp--;
916: *bp = NULL;
917: last_lex = !lequal (buffer, "at") || cp == NULL || index (cp, '<') != NULL
918: ? LX_ATOM : LX_AT;
919: return last_lex;
920: }
921:
922: /* */
923:
924: char *
925: legal_person(p)
926: register char *p;
927: {
928: int i;
929: register char *cp;
930: static char buffer[BUFSIZ];
931:
932: if (*p == '"')
933: return p;
934: for (cp = p; *cp; cp++)
935: for (i = 0; special[i].lx_chr; i++)
936: if (*cp == special[i].lx_chr) {
937: (void) sprintf (buffer, "\"%s\"", p);
938: return buffer;
939: }
940:
941: return p;
942: }
943:
944: /* */
945:
946: mfgets(in, bp)
947: register FILE *in;
948: register char **bp;
949: {
950: int i;
951: register char *cp,
952: *dp,
953: *ep;
954: static int len = 0;
955: static char *pp = NULL;
956:
957: if (pp == NULL)
958: if ((pp = malloc ((unsigned) (len = BUFSIZ))) == NULL)
959: return NOTOK;
960:
961: for (ep = (cp = pp) + len - 2;;) {
962: switch (i = getc (in)) {
963: case EOF:
964: eol: ;
965: if (cp != pp) {
966: *cp = NULL;
967: *bp = pp;
968: return OK;
969: }
970: eoh: ;
971: *bp = NULL;
972: free (pp);
973: pp = NULL;
974: return DONE;
975:
976: case NULL:
977: continue;
978:
979: case '\n':
980: if (cp == pp) /* end of headers, gobble it */
981: goto eoh;
982: switch (i = getc (in)) {
983: default: /* end of line */
984: case '\n': /* end of headers, save for next call */
985: (void) ungetc (i, in);
986: goto eol;
987:
988: case ' ': /* continue headers */
989: case '\t':
990: *cp++ = '\n';
991: break;
992: } /* fall into default case */
993:
994: default:
995: *cp++ = i;
996: break;
997: }
998: if (cp >= ep)
999: if ((dp = realloc (pp, (unsigned) (len += BUFSIZ))) == NULL) {
1000: free (pp);
1001: pp = NULL;
1002: return NOTOK;
1003: }
1004: else
1005: cp += dp - pp, ep = (pp = cp) + len - 2;
1006: }
1007: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.