4.3BSD - /usr/src/new/mh/support/pop/mmdfII/pop/dropsbr.c

   1: /* dropsbr.c - write to a mailbox */
   2: 
   3: #include <stdio.h>
   4: #ifndef MMDFONLY
   5: #include "../h/mh.h"
   6: #include "../h/dropsbr.h"
   7: #include "../zotnet/mts.h"
   8: #else   MMDFONLY
   9: #include "dropsbr.h"
  10: #include "strings.h"
  11: #include "mmdfonly.h"
  12: #endif	MMDFONLY
  13: #include <errno.h>
  14: #include <sys/types.h>
  15: #include <sys/stat.h>
  16: 
  17: 
  18: #define MMDF    1
  19: #define UUCP    2
  20: 
  21: /*  */
  22: 
  23: static  int mbx_style = MMDF;
  24: 
  25: 
  26: extern int  errno;
  27: 
  28: 
  29: long   lseek ();
  30: 
  31: /*  */
  32: 
  33: int     mbx_mmdf () {
  34:     int     style = mbx_style;
  35: 
  36:     mbx_style = MMDF;
  37:     return style;
  38: }
  39: 
  40: 
  41: int     mbx_uucp () {
  42:     int     style = mbx_style;
  43: 
  44:     mbx_style = UUCP;
  45:     return style;
  46: }
  47: 
  48: /*  */
  49: 
  50: int     mbx_open (file, uid, gid, mode)
  51: char   *file;
  52: int     uid,
  53:         gid,
  54:     mode;
  55: {
  56:     int     clear,
  57:             fd;
  58: 
  59:     if ((fd = mbx_Xopen (file, uid, gid, mode, &clear)) == NOTOK)
  60:     return fd;
  61: 
  62:     if (!clear)
  63:     switch (mbx_style) {
  64:         case MMDF:
  65:         default:
  66:         if (mbx_chk (fd) == NOTOK) {
  67:             (void) close (fd);
  68:             return NOTOK;
  69:         }
  70:         break;
  71: 
  72:         case UUCP:
  73:         if (lseek (fd, 0L, 2) == (long) NOTOK) {
  74:             (void) close (fd);
  75:             return NOTOK;
  76:         }
  77:         break;
  78:     }
  79: 
  80:     return fd;
  81: }
  82: 
  83: /*  */
  84: 
  85: int mbx_Xopen (file, uid, gid, mode, clear)
  86: char   *file;
  87: int uid,
  88:     gid,
  89:     mode,
  90:        *clear;
  91: {
  92:     register int j;
  93:     int     count,
  94:             fd;
  95:     struct stat st;
  96: 
  97:     for (*clear = 0, count = 4, j = 0; count > 0; count--)
  98:     if ((fd = lkopen (file, 6)) == NOTOK)
  99:         switch (errno) {
 100:         case ENOENT:
 101:             if (mbx_create (file, uid, gid, mode) == NOTOK)
 102:             return NOTOK;
 103:             (*clear)++;
 104:             break;
 105: 
 106: #ifdef  BSD42
 107:         case EWOULDBLOCK:
 108: #endif	BSD42
 109:         case ETXTBSY:
 110:             j = errno;
 111:             sleep (5);
 112:             break;
 113: 
 114:         default:
 115:             return NOTOK;
 116:         }
 117:     else {
 118:         *clear = fstat (fd, &st) != NOTOK && st.st_size == 0L;
 119:         break;
 120:     }
 121: 
 122:     errno = j;
 123:     return fd;
 124: }
 125: 
 126: /*  */
 127: 
 128: static int  mbx_create (file, uid, gid, mode)
 129: char   *file;
 130: int     uid,
 131:         gid,
 132:     mode;
 133: {
 134:     int     fd;
 135: 
 136:     if ((fd = creat (file, 0600)) == NOTOK)
 137:     return NOTOK;
 138: 
 139:     (void) close (fd);
 140:     (void) chown (file, uid, gid);
 141:     (void) chmod (file, mode);
 142: 
 143:     return OK;
 144: }
 145: 
 146: 
 147: static int  mbx_chk (fd)
 148: int     fd;
 149: {
 150:     int     count;
 151:     char    ldelim[BUFSIZ];
 152: 
 153:     count = strlen (mmdlm2);
 154: 
 155:     if (lseek (fd, (long) (-count), 2) == (long) NOTOK
 156:         || read (fd, ldelim, count) != count)
 157:     return NOTOK;
 158:     ldelim[count] = NULL;
 159: 
 160:     if (strcmp (ldelim, mmdlm2)
 161:         && write (fd, "\n", 1) != 1
 162:         && write (fd, mmdlm2, count) != count)
 163:     return NOTOK;
 164: 
 165:     return OK;
 166: }
 167: 
 168: /*  */
 169: 
 170: int mbx_read (fp, pos, drops, noisy)
 171: register FILE  *fp;
 172: register long   pos;
 173: struct drop **drops;
 174: int noisy;
 175: {
 176:     register int    len,
 177:                     size;
 178:     long    ld1,
 179:             ld2;
 180:     register char  *bp;
 181:     char    buffer[BUFSIZ];
 182:     register struct drop   *cp,
 183:                            *dp,
 184:                            *ep,
 185:                            *pp;
 186: 
 187:     pp = (struct drop  *) calloc ((unsigned) (len = MAXFOLDER), sizeof *dp);
 188:     if (pp == NULL) {
 189:     if (noisy)
 190:         admonish (NULLCP, "unable to allocate drop storage");
 191:     return NOTOK;
 192:     }
 193: 
 194:     ld1 = (long) strlen (mmdlm1);
 195:     ld2 = (long) strlen (mmdlm2);
 196: 
 197:     (void) fseek (fp, pos, 0);
 198:     for (ep = (dp = pp) + len - 1; fgets (buffer, sizeof buffer, fp);) {
 199:     size = 0;
 200:     if (strcmp (buffer, mmdlm1) == 0)
 201:         pos += ld1, dp -> d_start = pos;
 202:     else {
 203:         dp -> d_start = pos, pos += (long) strlen (buffer);
 204:         for (bp = buffer; *bp; bp++, size++)
 205:         if (*bp == '\n')
 206:             size++;
 207:     }
 208: 
 209:     while (fgets (buffer, sizeof buffer, fp) != NULL)
 210:         if (strcmp (buffer, mmdlm2) == 0)
 211:         break;
 212:         else {
 213:         pos += (long) strlen (buffer);
 214:         for (bp = buffer; *bp; bp++, size++)
 215:             if (*bp == '\n')
 216:             size++;
 217:         }
 218: 
 219:     if (dp -> d_start != pos) {
 220:         dp -> d_id = 0;
 221:         dp -> d_size = size;
 222:         dp -> d_stop = pos;
 223:         dp++;
 224:     }
 225:     pos += ld2;
 226: 
 227:     if (dp >= ep) {
 228:         register int    curlen = dp - pp;
 229: 
 230:         cp = (struct drop  *) realloc ((char *) pp,
 231:                             (unsigned) (len += MAXFOLDER) * sizeof *pp);
 232:         if (cp == NULL) {
 233:         if (noisy)
 234:             admonish (NULLCP, "unable to allocate drop storage");
 235:         free ((char *) pp);
 236:         return 0;
 237:         }
 238:         dp = cp + curlen, ep = (pp = cp) + len - 1;
 239:     }
 240:     }
 241: 
 242:     if (dp == pp)
 243:     free ((char *) pp);
 244:     else
 245:     *drops = pp;
 246:     return (dp - pp);
 247: }
 248: 
 249: /*  */
 250: 
 251: int mbx_write (mailbox, md, fp, id, pos, stop, mapping, noisy)
 252: char   *mailbox;
 253: register FILE *fp;
 254: int     md,
 255:     id,
 256:     mapping,
 257:     noisy;
 258: register long   pos,
 259:         stop;
 260: {
 261:     register int    i,
 262:                     j,
 263:                     size;
 264:     register long   start,
 265:                     off;
 266:     register char  *cp;
 267:     char    buffer[BUFSIZ];
 268: 
 269:     off = lseek (md, 0L, 1);
 270:     j = strlen (mmdlm1);
 271:     if (write (md, mmdlm1, j) != j)
 272:     return NOTOK;
 273:     start = lseek (md, 0L, 1);
 274:     size = 0;
 275: 
 276:     (void) fseek (fp, pos, 0);
 277:     while (fgets (buffer, sizeof buffer, fp) != NULL && pos < stop) {
 278:     i = strlen (buffer);
 279:     for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++)
 280:         continue;
 281:     for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++)
 282:         continue;
 283:     if (write (md, buffer, i) != i)
 284:         return NOTOK;
 285:     pos += (long) i;
 286:     if (mapping)
 287:         for (cp = buffer; i-- > 0; size++)
 288:         if (*cp++ == '\n')
 289:             size++;
 290:     }
 291: 
 292:     stop = lseek (md, 0L, 1);
 293:     j = strlen (mmdlm2);
 294:     if (write (md, mmdlm2, j) != j)
 295:     return NOTOK;
 296:     if (mapping)
 297:     (void) map_write (mailbox, md, id, start, stop, off, size, noisy);
 298: 
 299:     return OK;
 300: }
 301: 
 302: /*  */
 303: 
 304: int     mbx_copy (mailbox, md, fd, mapping, text, noisy)
 305: char   *mailbox;
 306: int     md,
 307:         fd,
 308:     mapping,
 309:     noisy;
 310: char   *text;
 311: {
 312:     register int    i,
 313:                     j,
 314:                     size;
 315:     register long   start,
 316:                     stop,
 317:                     pos;
 318:     register char  *cp;
 319:     char    buffer[BUFSIZ];
 320:     register FILE  *fp;
 321: 
 322:     pos = lseek (md, 0L, 1);
 323:     size = 0;
 324: 
 325:     switch (mbx_style) {
 326:     case MMDF:
 327:     default:
 328:         j = strlen (mmdlm1);
 329:         if (write (md, mmdlm1, j) != j)
 330:         return NOTOK;
 331:         start = lseek (md, 0L, 1);
 332: 
 333:         if (text) {
 334:         i = strlen (text);
 335:         if (write (md, text, i) != i)
 336:             return NOTOK;
 337:         for (cp = buffer; *cp++; size++)
 338:             if (*cp == '\n')
 339:             size++;
 340:         }
 341: 
 342:         while ((i = read (fd, buffer, sizeof buffer)) > 0) {
 343:         for (j = 0;
 344:             (j = stringdex (mmdlm1, buffer)) >= 0;
 345:             buffer[j]++)
 346:             continue;
 347:         for (j = 0;
 348:             (j = stringdex (mmdlm2, buffer)) >= 0;
 349:             buffer[j]++)
 350:             continue;
 351:         if (write (md, buffer, i) != i)
 352:             return NOTOK;
 353:         if (mapping)
 354:             for (cp = buffer; i-- > 0; size++)
 355:             if (*cp++ == '\n')
 356:                 size++;
 357:         }
 358: 
 359:         stop = lseek (md, 0L, 1);
 360:         j = strlen (mmdlm2);
 361:         if (write (md, mmdlm2, j) != j)
 362:         return NOTOK;
 363:         if (mapping)
 364:         (void) map_write (mailbox, md, 0, start, stop, pos, size, noisy);
 365: 
 366:         return (i != NOTOK ? OK : NOTOK);
 367: 
 368:     case UUCP:      /* I hate this... */
 369:         if ((j = dup (fd)) == NOTOK)
 370:         return NOTOK;
 371:         if ((fp = fdopen (j, "r")) == NULL) {
 372:         (void) close (j);
 373:         return NOTOK;
 374:         }
 375:         start = lseek (md, 0L, 1);
 376: 
 377:         if (text) {
 378:         i = strlen (text);
 379:         if (write (md, text, i) != i)
 380:             return NOTOK;
 381:         for (cp = buffer; *cp++; size++)
 382:             if (*cp == '\n')
 383:             size++;
 384:         }
 385: 
 386:         for (j = 0; fgets (buffer, sizeof buffer, fp) != NULL; j++) {
 387:         if (j != 0 && strncmp (buffer, "From ", 5) == 0) {
 388:             (void) write (fd, ">", 1);
 389:             size++;
 390:         }
 391:         i = strlen (buffer);
 392:         if (write (md, buffer, i) != i) {
 393:             (void) fclose (fp);
 394:             return NOTOK;
 395:         }
 396:         if (mapping)
 397:             for (cp = buffer; i-- > 0; size++)
 398:             if (*cp++ == '\n')
 399:                 size++;
 400:         }
 401: 
 402:         (void) fclose (fp);
 403:         (void) lseek (fd, 0L, 2);
 404:         stop = lseek (md, 0L, 1);
 405:         if (mapping)
 406:         (void) map_write (mailbox, md, 0, start, stop, pos, size,
 407:                 noisy);
 408: 
 409:         return OK;
 410:     }
 411: }
 412: 
 413: /*  */
 414: 
 415: int mbx_size (md, start, stop)
 416: int md;
 417: long    start,
 418:     stop;
 419: {
 420:     register int    i,
 421:                     fd;
 422:     register long   pos;
 423:     register FILE  *fp;
 424: 
 425:     if ((fd = dup (md)) == NOTOK || (fp = fdopen (fd, "r")) == NULL) {
 426:     if (fd != NOTOK)
 427:         (void) close (fd);
 428:     return NOTOK;
 429:     }
 430: 
 431:     (void) fseek (fp, start, 0);
 432:     for (i = 0, pos = stop - start; pos-- > 0; i++)
 433:     if (fgetc (fp) == '\n')
 434:         i++;
 435: 
 436:     (void) fclose (fp);
 437: 
 438:     return i;
 439: }
 440: 
 441: /*  */
 442: 
 443: int     mbx_close (mailbox, md)
 444: char   *mailbox;
 445: int     md;
 446: {
 447:     (void) lkclose (md, mailbox);
 448: 
 449:     return OK;
 450: }
 451: 
 452: /*  */
 453: 
 454: /* This function is performed implicitly by getbbent.c:
 455: 
 456: 		bb -> bb_map = map_name (bb -> bb_file);
 457: */
 458: 
 459: char    *map_name (file)
 460: register char   *file;
 461: {
 462:     register char  *cp,
 463:                    *dp;
 464:     static char buffer[BUFSIZ];
 465: 
 466:     if ((dp = index (cp = r1bindex (file, '/'), '.')) == NULL)
 467:     dp = cp + strlen (cp);
 468:     if (cp == file)
 469:     (void) sprintf (buffer, ".%.*s%s", dp - cp, cp, ".map");
 470:     else
 471:     (void) sprintf (buffer, "%.*s.%.*s%s", cp - file, file, dp - cp,
 472:         cp, ".map");
 473: 
 474:     return buffer;
 475: }
 476: 
 477: /*  */
 478: 
 479: int map_read (file, pos, drops, noisy)
 480: char   *file;
 481: long    pos;
 482: struct drop **drops;
 483: int noisy;
 484: {
 485:     register int    i,
 486:                     md,
 487:                     msgp;
 488:     register char  *cp;
 489:     struct drop d;
 490:     register struct drop   *mp,
 491:                            *dp;
 492: 
 493:     if ((md = open (cp = map_name (file), 0)) == NOTOK
 494:         || map_chk (cp, md, mp = &d, pos, noisy)) {
 495:     if (md != NOTOK)
 496:         (void) close (md);
 497:     return 0;
 498:     }
 499: 
 500:     msgp = mp -> d_id;
 501:     dp = (struct drop  *) calloc ((unsigned) msgp, sizeof *dp);
 502:     if (dp == NULL) {
 503:     (void) close (md);
 504:     return 0;
 505:     }
 506: 
 507:     (void) lseek (md, (long) sizeof *mp, 0);
 508:     if ((i = read (md, (char *) dp, msgp * sizeof *dp)) < sizeof *dp) {
 509:     i = 0;
 510:     free ((char *) dp);
 511:     }
 512:     else
 513:     *drops = dp;
 514: 
 515:     (void) close (md);
 516: 
 517:     return (i / sizeof *dp);
 518: }
 519: 
 520: /*  */
 521: 
 522: int     map_write (mailbox, md, id, start, stop, pos, size, noisy)
 523: register char   *mailbox;
 524: int     md,
 525:         id,
 526:     size,
 527:     noisy;
 528: long    start,
 529:         stop,
 530:         pos;
 531: {
 532:     register int    i;
 533:     int     clear,
 534:             fd,
 535:             td;
 536:     char   *file;
 537:     register struct drop   *dp;
 538:     struct drop    d1,
 539:            d2,
 540:                   *rp;
 541:     register FILE *fp;
 542: 
 543:     if ((fd = map_open (file = map_name (mailbox), &clear, md)) == NOTOK)
 544:     return NOTOK;
 545: 
 546:     if (!clear && map_chk (file, fd, &d1, pos, noisy)) {
 547:     (void) unlink (file);
 548:     (void) mbx_close (file, fd);
 549:     if ((fd = map_open (file, &clear, md)) == NOTOK)
 550:         return NOTOK;
 551:     clear++;
 552:     }
 553: 
 554:     if (clear) {
 555:     if ((td = dup (md)) == NOTOK || (fp = fdopen (td, "r")) == NULL) {
 556:         if (noisy)
 557:         admonish (file, "unable to %s", td != NOTOK ? "fdopen" : "dup");
 558:         if (td != NOTOK)
 559:         (void) close (td);
 560:         (void) mbx_close (file, fd);
 561:         return NOTOK;
 562:     }
 563: 
 564:     switch (i = mbx_read (fp, 0L, &rp, noisy)) {
 565:         case NOTOK:
 566:         (void) fclose (fp);
 567:         (void) mbx_close (file, fd);
 568:         return NOTOK;
 569: 
 570:         case OK:
 571:         break;
 572: 
 573:         default:
 574:         d1.d_id = 0;
 575:         for (dp = rp; i-- >0; dp++) {
 576:             if (dp -> d_start == start)
 577:             dp -> d_id = id;
 578:             (void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
 579:             if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 580:             if (noisy)
 581:                 admonish (file, "write error");
 582:             (void) mbx_close (file, fd);
 583:             (void) fclose (fp);
 584:             return NOTOK;
 585:             }
 586:         }
 587:         free ((char *) rp);
 588:         break;
 589:     }
 590:     }
 591:     else {
 592:     dp = &d2;
 593:     dp -> d_id = id;
 594:     dp -> d_size = size ? size : mbx_size (fd, start, stop);
 595:     dp -> d_start = start;
 596:     dp -> d_stop = stop;
 597:     (void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
 598:     if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 599:         if (noisy)
 600:         admonish (file, "write error");
 601:         (void) mbx_close (file, fd);
 602:         return NOTOK;
 603:     }
 604:     }
 605: 
 606:     dp = &d1;
 607:     dp -> d_size = DRVRSN;
 608:     dp -> d_start = DRMAGIC;
 609:     dp -> d_stop = lseek (md, 0L, 1);
 610:     (void) lseek (fd, 0L, 0);
 611:     if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 612:     if (noisy)
 613:         admonish (file, "write error");
 614:     (void) mbx_close (file, fd);
 615:     return NOTOK;
 616:     }
 617: 
 618:     (void) mbx_close (file, fd);
 619: 
 620:     return OK;
 621: }
 622: 
 623: /*  */
 624: 
 625: static int  map_open (file, clear, md)
 626: char   *file;
 627: int    *clear,
 628:     md;
 629: {
 630:     int     mode;
 631:     struct  stat st;
 632: 
 633:     mode = fstat (md, &st) != NOTOK ? (int) (st.st_mode & 0777) : m_gmprot ();
 634:     return mbx_Xopen (file, st.st_uid, st.st_gid, mode, clear);
 635: }
 636: 
 637: /*  */
 638: 
 639: int  map_chk (file, fd, dp, pos, noisy)
 640: char   *file;
 641: int     fd,
 642:     noisy;
 643: register struct drop *dp;
 644: long    pos;
 645: {
 646:     long    count;
 647:     struct drop d;
 648:     register struct drop    *dl;
 649: 
 650:     if (read (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 651: #ifdef  notdef
 652:     admonish (NULLCP, "%s: missing or partial index", file);
 653: #endif	notdef
 654:     return NOTOK;
 655:     }
 656:     if (dp -> d_size != DRVRSN) {
 657:     if (noisy)
 658:         admonish (NULLCP, "%s: version mismatch", file);
 659:     return NOTOK;
 660:     }
 661:     if (dp -> d_start != DRMAGIC) {
 662:     if (noisy)
 663:         admonish (NULLCP, "%s: bad magic number", file);
 664:     return NOTOK;
 665:     }
 666:     if (dp -> d_stop != pos) {
 667:     if (noisy && pos != 0L)
 668:         admonish (NULLCP,
 669:             "%s: pointer mismatch or incomplete index (%ld!=%ld)",
 670:             file, dp -> d_stop, pos);
 671:     return NOTOK;
 672:     }
 673: 
 674:     if ((long) ((dp -> d_id + 1) * sizeof *dp) != lseek (fd, 0L, 2)) {
 675:     if (noisy)
 676:         admonish (NULLCP, "%s: corrupt index(1)", file);
 677:     return NOTOK;
 678:     }
 679: 
 680:     dl = &d;
 681:     count = (long) strlen (mmdlm2);
 682:     (void) lseek (fd, (long) (dp -> d_id * sizeof *dp), 0);
 683:     if (read (fd, (char *) dl, sizeof *dl) != sizeof *dl
 684:         || (dl -> d_stop != dp -> d_stop
 685:         && dl -> d_stop + count != dp -> d_stop)) {
 686:     if (noisy)
 687:         admonish (NULLCP, "%s: corrupt index(2)", file);
 688:     return NOTOK;
 689:     }
 690: 
 691:     return OK;
 692: }

Defined functions

Defined variables

Defined macros