Annotation of 43BSDReno/contrib/mh/uip/distsbr.c, revision 1.1.1.1

1.1       root        1: /* distsbr.c - routines to do additional "dist-style" processing */
                      2: 
                      3: #include "../h/mh.h"
                      4: #include <ctype.h>
                      5: #include <stdio.h>
                      6: 
                      7: 
                      8: static int  hdrfd = NOTOK;
                      9: static int  txtfd = NOTOK;
                     10: 
                     11: 
                     12: long lseek();
                     13: 
                     14: static void ready_msg();
                     15: 
                     16: /*  */
                     17: 
                     18: #define        BADHDR  "please re-edit %s to remove the ``%s'' header!"
                     19: #define        BADTXT  "please re-edit %s to consist of headers only!"
                     20: #define        BADMSG  "please re-edit %s to include a ``Resent-To:''!"
                     21: #define        BADRFT  "please re-edit %s and fix that header!"
                     22: 
                     23: distout(drft, msgnam, backup)
                     24:        register char *drft, *msgnam, *backup;
                     25: {
                     26:     int     state;
                     27:     register char  *dp,
                     28:                    *resent;
                     29:     char    name[NAMESZ],
                     30:             buffer[BUFSIZ];
                     31:     register    FILE *ifp,
                     32:                     *ofp;
                     33: 
                     34:     if (rename (drft, strcpy (backup, m_backup (drft))) == NOTOK)
                     35:        adios (backup, "unable to rename %s to",drft);
                     36:     if ((ifp = fopen (backup, "r")) == NULL)
                     37:        adios (backup, "unable to read");
                     38: 
                     39:     if ((ofp = fopen (drft, "w")) == NULL)
                     40:        adios (drft, "unable to create temporary file");
                     41:     (void) chmod (drft, m_gmprot ());
                     42: 
                     43:     ready_msg (msgnam);
                     44:     (void) lseek (hdrfd, 0L, 0);       /* msgnam not accurate */
                     45:     cpydata (hdrfd, fileno (ofp), msgnam, drft);
                     46: 
                     47: /*  */
                     48: 
                     49:     for (state = FLD, resent = NULL;;)
                     50:        switch (state =
                     51:                m_getfld (state, name, buffer, sizeof buffer, ifp)) {
                     52:            case FLD:
                     53:            case FLDPLUS:
                     54:            case FLDEOF:
                     55:                if (uprf (name, "distribute-"))
                     56:                    (void) sprintf (name, "%s%s", "Resent", &name[10]);
                     57:                if (uprf (name, "distribution-"))
                     58:                    (void) sprintf (name, "%s%s", "Resent", &name[12]);
                     59:                if (!uprf (name, "resent")) {
                     60:                    advise (NULLCP, BADHDR, "draft", name);
                     61:                    goto leave_bad;
                     62:                }
                     63:                if (state == FLD)
                     64:                    resent = add (":", add (name, resent));
                     65:                resent = add (buffer, resent);
                     66:                fprintf (ofp, "%s: %s", name, buffer);
                     67:                while (state == FLDPLUS) {
                     68:                    state = m_getfld (state, name,
                     69:                            buffer, sizeof buffer, ifp);
                     70:                    resent = add (buffer, resent);
                     71:                    fputs (buffer, ofp);
                     72:                }
                     73:                if (state == FLDEOF)
                     74:                    goto process;
                     75:                break;
                     76: 
                     77:            case BODY:
                     78:            case BODYEOF:
                     79:                for (dp = buffer; *dp; dp++)
                     80:                    if (!isspace (*dp)) {
                     81:                        advise (NULLCP, BADTXT, "draft");
                     82:                        goto leave_bad;
                     83:                    }
                     84: 
                     85:            case FILEEOF:
                     86:                goto process;
                     87: 
                     88:            case LENERR:
                     89:            case FMTERR:
                     90:                advise (NULLCP, BADRFT, "draft");
                     91:        leave_bad: ;
                     92:                (void) fclose (ifp);
                     93:                (void) fclose (ofp);
                     94:                (void) unlink (drft);
                     95:                if (rename (backup, drft) == NOTOK)
                     96:                    adios (drft, "unable to rename %s to", backup);
                     97:                return NOTOK;
                     98: 
                     99:            default:
                    100:                adios (NULLCP, "getfld() returned %d", state);
                    101:        }
                    102: process: ;
                    103:     (void) fclose (ifp);
                    104:     (void) fflush (ofp);
                    105: 
                    106: /*  */
                    107: 
                    108:     if (!resent) {
                    109:        advise (NULLCP, BADMSG, "draft");
                    110:        (void) fclose (ofp);
                    111:        (void) unlink (drft);
                    112:        if (rename (backup, drft) == NOTOK)
                    113:            adios (drft, "unable to rename %s to", backup);
                    114:        return NOTOK;
                    115:     }
                    116:     free (resent);
                    117: 
                    118:     if (txtfd != NOTOK) {
                    119:        (void) lseek (txtfd, 0L, 0);    /* msgnam not accurate */
                    120:        cpydata (txtfd, fileno (ofp), msgnam, drft);
                    121:     }
                    122: 
                    123:     (void) fclose (ofp);
                    124: 
                    125:     return OK;
                    126: }
                    127: 
                    128: /*  */
                    129: 
                    130: static void
                    131: ready_msg(msgnam)
                    132:        register char *msgnam;
                    133: {
                    134:     int     state,
                    135:             out;
                    136:     char    name[NAMESZ],
                    137:             buffer[BUFSIZ],
                    138:             tmpfil[BUFSIZ];
                    139:     register    FILE *ifp,
                    140:                     *ofp;
                    141: 
                    142:     if (hdrfd != NOTOK)
                    143:        (void) close (hdrfd), hdrfd = NOTOK;
                    144:     if (txtfd != NOTOK)
                    145:        (void) close (txtfd), txtfd = NOTOK;
                    146: 
                    147:     if ((ifp = fopen (msgnam, "r")) == NULL)
                    148:        adios (msgnam, "unable to open message");
                    149: 
                    150:     (void) strcpy (tmpfil, m_tmpfil ("dist"));
                    151:     if ((hdrfd = creat (tmpfil, 0600)) == NOTOK)
                    152:        adios (tmpfil, "unable to create temporary file");
                    153:     (void) close (hdrfd);
                    154:     if ((hdrfd = open (tmpfil, 2)) == NOTOK)
                    155:        adios (tmpfil, "unable to re-open temporary file");
                    156:     if ((out = dup (hdrfd)) == NOTOK
                    157:            || (ofp = fdopen (out, "w")) == NULL)
                    158:        adios (NULLCP, "no file descriptors -- you lose big");
                    159:     (void) unlink (tmpfil);
                    160: 
                    161: /*  */
                    162: 
                    163:     for (state = FLD;;)
                    164:        switch (state =
                    165:                m_getfld (state, name, buffer, sizeof buffer, ifp)) {
                    166:            case FLD:
                    167:            case FLDPLUS:
                    168:            case FLDEOF:
                    169:                if (uprf (name, "resent"))
                    170:                    fprintf (ofp, "Prev-");
                    171:                fprintf (ofp, "%s: %s", name, buffer);
                    172:                while (state == FLDPLUS) {
                    173:                    state = m_getfld (state, name,
                    174:                            buffer, sizeof buffer, ifp);
                    175:                    fputs (buffer, ofp);
                    176:                }
                    177:                if (state == FLDEOF)
                    178:                    goto process;
                    179:                break;
                    180: 
                    181:            case BODY:
                    182:            case BODYEOF:
                    183:                (void) fclose (ofp);
                    184: 
                    185:                (void) strcpy (tmpfil, m_tmpfil ("dist"));
                    186:                if ((txtfd = creat (tmpfil, 0600)) == NOTOK)
                    187:                    adios (tmpfil, "unable to create temporary file");
                    188:                (void) close (txtfd);
                    189:                if ((txtfd = open (tmpfil, 2)) == NOTOK)
                    190:                    adios (tmpfil, "unable to re-open temporary file");
                    191:                if ((out = dup (txtfd)) == NOTOK
                    192:                        || (ofp = fdopen (out, "w")) == NULL)
                    193:                    adios (NULLCP, "no file descriptors -- you lose big");
                    194:                (void) unlink (tmpfil);
                    195:                fprintf (ofp, "\n%s", buffer);
                    196:                while (state == BODY) {
                    197:                    state = m_getfld (state, name,
                    198:                            buffer, sizeof buffer, ifp);
                    199:                    fputs (buffer, ofp);
                    200:                }
                    201:            case FILEEOF:
                    202:                goto process;
                    203: 
                    204:            case LENERR:
                    205:            case FMTERR:
                    206:                adios (NULLCP, "format error in message %s", msgnam);
                    207: 
                    208:            default:
                    209:                adios (NULLCP, "getfld() returned %d", state);
                    210:        }
                    211: process: ;
                    212:     (void) fclose (ifp);
                    213:     (void) fclose (ofp);
                    214: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.