diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/uip/RCS/dropsbr.c,v

   1 head    1.19;
   2 access;
   3 symbols;
   4 locks; strict;
   5 comment @ * @;
   6
   7
   8 1.19
   9 date    95.12.07.18.59.08;      author jromine; state Exp;
  10 branches;
  11 next    1.18;
  12
  13 1.18
  14 date    95.12.06.21.09.05;      author jromine; state Exp;
  15 branches;
  16 next    1.17;
  17
  18 1.17
  19 date    93.08.27.23.00.00;      author jromine; state Exp;
  20 branches;
  21 next    1.16;
  22
  23 1.16
  24 date    93.08.25.17.25.08;      author jromine; state Exp;
  25 branches;
  26 next    1.15;
  27
  28 1.15
  29 date    92.12.15.00.20.22;      author jromine; state Exp;
  30 branches;
  31 next    1.14;
  32
  33 1.14
  34 date    92.02.03.22.26.17;      author jromine; state Exp;
  35 branches;
  36 next    1.13;
  37
  38 1.13
  39 date    92.01.31.22.09.37;      author jromine; state Exp;
  40 branches;
  41 next    1.12;
  42
  43 1.12
  44 date    90.11.05.13.26.50;      author mh;      state Exp;
  45 branches;
  46 next    1.11;
  47
  48 1.11
  49 date    90.04.05.15.01.09;      author sources; state Exp;
  50 branches;
  51 next    1.10;
  52
  53 1.10
  54 date    90.04.02.14.20.04;      author sources; state Exp;
  55 branches;
  56 next    1.9;
  57
  58 1.9
  59 date    90.03.23.16.38.59;      author sources; state Exp;
  60 branches;
  61 next    1.8;
  62
  63 1.8
  64 date    90.03.16.14.50.27;      author sources; state Exp;
  65 branches;
  66 next    1.7;
  67
  68 1.7
  69 date    90.03.16.10.27.41;      author sources; state Exp;
  70 branches;
  71 next    1.6;
  72
  73 1.6
  74 date    90.03.16.09.43.56;      author sources; state Exp;
  75 branches;
  76 next    1.5;
  77
  78 1.5
  79 date    90.03.12.10.19.22;      author sources; state Exp;
  80 branches;
  81 next    1.4;
  82
  83 1.4
  84 date    90.03.12.10.13.31;      author sources; state Exp;
  85 branches;
  86 next    1.3;
  87
  88 1.3
  89 date    90.02.08.14.09.55;      author sources; state Exp;
  90 branches;
  91 next    1.2;
  92
  93 1.2
  94 date    90.02.06.13.18.17;      author sources; state Exp;
  95 branches;
  96 next    1.1;
  97
  98 1.1
  99 date    90.02.06.13.18.04;      author sources; state Exp;
 100 branches;
 101 next    ;
 102
 103
 104 desc
 105 @@
 106
 107
 108 1.19
 109 log
 110 @64bit fix: call mbx_read with 0L not (off_t)0
 111 @
 112 text
 113 @/* dropsbr.c - write to a mailbox */
 114 #ifndef lint
 115 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.18 1995/12/06 21:09:05 jromine Exp jromine $";
 116 #endif  /* lint */
 117
 118 #include <stdio.h>
 119 #ifndef MMDFONLY
 120 #include "../h/mh.h"
 121 #include "../h/dropsbr.h"
 122 #include "../zotnet/mts.h"
 123 #else   /* MMDFONLY */
 124 #include "dropsbr.h"
 125 #include "strings.h"
 126 #include "mmdfonly.h"
 127 #endif  /* MMDFONLY */
 128 #include <errno.h>
 129 #include <sys/types.h>
 130 #include <sys/stat.h>
 131 #if     (defined(BSD42) || defined(SOCKETS)) && defined(NTOHLSWAP)
 132 #include <netinet/in.h>
 133 #else
 134 #define ntohl(n) (n)
 135 #endif
 136
 137
 138 #define MMDF    1
 139 #define UUCP    2
 140
 141 /* \f */
 142
 143 static  int     mbx_style = MMDF;
 144
 145 static int      mbx_create(), mbx_chk(), map_open();
 146
 147 extern int  errno;
 148
 149 off_t   lseek ();
 150
 151 /* \f */
 152
 153 int     mbx_mmdf () {
 154     int     style = mbx_style;
 155
 156     mbx_style = MMDF;
 157     return style;
 158 }
 159
 160
 161 int     mbx_uucp () {
 162     int     style = mbx_style;
 163
 164     mbx_style = UUCP;
 165     return style;
 166 }
 167
 168 /* \f */
 169
 170 int     mbx_open (file, uid, gid, mode)
 171 char   *file;
 172 int     uid,
 173         gid,
 174         mode;
 175 {
 176     int     clear,
 177             fd;
 178
 179     if ((fd = mbx_Xopen (file, uid, gid, mode, &clear)) == NOTOK)
 180         return fd;
 181
 182     if (!clear)
 183         switch (mbx_style) {
 184             case MMDF:
 185             default:
 186                 if (mbx_chk (fd) == NOTOK) {
 187                     (void) close (fd);
 188                     return NOTOK;
 189                 }
 190                 break;
 191
 192             case UUCP:
 193                 if (lseek (fd, (off_t)0, 2) == (off_t) NOTOK) {
 194                     (void) close (fd);
 195                     return NOTOK;
 196                 }
 197                 break;
 198         }
 199
 200     return fd;
 201 }
 202
 203 /* \f */
 204
 205 int     mbx_Xopen (file, uid, gid, mode, clear)
 206 char   *file;
 207 int     uid,
 208         gid,
 209         mode,
 210        *clear;
 211 {
 212     register int j;
 213     int     count,
 214             fd;
 215     struct stat st;
 216
 217     for (*clear = 0, count = 4, j = 0; count > 0; count--)
 218         if ((fd = lkopen (file, 6)) == NOTOK)
 219             switch (errno) {
 220                 case ENOENT:
 221                     if (mbx_create (file, uid, gid, mode) == NOTOK)
 222                         return NOTOK;
 223                     (*clear)++;
 224                     break;
 225
 226 #ifdef  BSD42
 227                 case EWOULDBLOCK:
 228 #endif  /* BSD42 */
 229                 case ETXTBSY:
 230                     j = errno;
 231                     sleep (5);
 232                     break;
 233
 234                 default:
 235                     return NOTOK;
 236             }
 237         else {
 238             *clear = fstat (fd, &st) != NOTOK && st.st_size == (off_t)0;
 239             break;
 240         }
 241
 242     errno = j;
 243     return fd;
 244 }
 245
 246 /* \f */
 247
 248 static int  mbx_create (file, uid, gid, mode)
 249 char   *file;
 250 int     uid,
 251         gid,
 252         mode;
 253 {
 254     int     fd;
 255
 256     if ((fd = creat (file, 0600)) == NOTOK)
 257         return NOTOK;
 258
 259     (void) close (fd);
 260     (void) chown (file, uid, gid);
 261     (void) chmod (file, mode);
 262
 263     return OK;
 264 }
 265
 266
 267 static int  mbx_chk (fd)
 268 int     fd;
 269 {
 270     int     count;
 271     char    ldelim[BUFSIZ];
 272
 273     count = strlen (mmdlm2);
 274
 275     if (lseek (fd, (off_t) (-count), 2) == (off_t) NOTOK
 276             || read (fd, ldelim, count) != count)
 277         return NOTOK;
 278     ldelim[count] = 0;
 279
 280     if (strcmp (ldelim, mmdlm2)
 281             && write (fd, "\n", 1) != 1
 282             && write (fd, mmdlm2, count) != count)
 283         return NOTOK;
 284
 285     return OK;
 286 }
 287
 288 /* \f */
 289
 290 int     mbx_read (fp, pos, drops, noisy)
 291 register FILE  *fp;
 292 register long   pos;
 293 struct drop **drops;
 294 int     noisy;
 295 {
 296     register int    len,
 297                     size;
 298     register long     ld1,
 299                     ld2;
 300     register char  *bp;
 301     char    buffer[BUFSIZ];
 302     register struct drop   *cp,
 303                            *dp,
 304                            *ep,
 305                            *pp;
 306
 307     pp = (struct drop  *) calloc ((unsigned) (len = MAXFOLDER), sizeof *dp);
 308     if (pp == NULL) {
 309         if (noisy)
 310             admonish (NULLCP, "unable to allocate drop storage");
 311         return NOTOK;
 312     }
 313
 314     ld1 = (long) strlen (mmdlm1);
 315     ld2 = (long) strlen (mmdlm2);
 316
 317     (void) fseek (fp, pos, 0);
 318     for (ep = (dp = pp) + len - 1; fgets (buffer, sizeof buffer, fp);) {
 319         size = 0;
 320         if (strcmp (buffer, mmdlm1) == 0)
 321             pos += ld1, dp -> d_start = (long) pos;
 322         else {
 323             dp -> d_start = (long)pos , pos += (long) strlen (buffer);
 324             for (bp = buffer; *bp; bp++, size++)
 325                 if (*bp == '\n')
 326                     size++;
 327         }
 328
 329         while (fgets (buffer, sizeof buffer, fp) != NULL)
 330             if (strcmp (buffer, mmdlm2) == 0)
 331                 break;
 332             else {
 333                 pos += (long) strlen (buffer);
 334                 for (bp = buffer; *bp; bp++, size++)
 335                     if (*bp == '\n')
 336                         size++;
 337             }
 338
 339         if (dp -> d_start != (long) pos) {
 340             dp -> d_id = 0;
 341             dp -> d_size = (long) size;
 342             dp -> d_stop = (long) pos;
 343             dp++;
 344         }
 345         pos += ld2;
 346
 347         if (dp >= ep) {
 348             register int    curlen = dp - pp;
 349
 350             cp = (struct drop  *) realloc ((char *) pp,
 351                                     (unsigned) (len += MAXFOLDER) * sizeof *pp);
 352             if (cp == NULL) {
 353                 if (noisy)
 354                     admonish (NULLCP, "unable to allocate drop storage");
 355                 free ((char *) pp);
 356                 return 0;
 357             }
 358             dp = cp + curlen, ep = (pp = cp) + len - 1;
 359         }
 360     }
 361
 362     if (dp == pp)
 363         free ((char *) pp);
 364     else
 365         *drops = pp;
 366     return (dp - pp);
 367 }
 368
 369 /* \f */
 370
 371 int     mbx_write (mailbox, md, fp, id, last, pos, stop, mapping, noisy)
 372 char   *mailbox;
 373 register FILE *fp;
 374 int     md,
 375         id,
 376         mapping,
 377         noisy;
 378 long    last;
 379 register long   pos,
 380                 stop;
 381 {
 382     register int    i,
 383                     j,
 384                     size;
 385     long            start,
 386                     off;
 387     register char  *cp;
 388     char    buffer[BUFSIZ];
 389
 390     off = (long) lseek (md, (off_t)0, 1);
 391     j = strlen (mmdlm1);
 392     if (write (md, mmdlm1, j) != j)
 393         return NOTOK;
 394     start = (long) lseek (md, (off_t)0, 1);
 395     size = 0;
 396
 397     (void) fseek (fp, pos, 0);
 398     while (fgets (buffer, sizeof buffer, fp) != NULL && pos < stop) {
 399         i = strlen (buffer);
 400         for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++)
 401             continue;
 402         for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++)
 403             continue;
 404         if (write (md, buffer, i) != i)
 405             return NOTOK;
 406         pos += (long) i;
 407         if (mapping)
 408             for (cp = buffer; i-- > 0; size++)
 409                 if (*cp++ == '\n')
 410                     size++;
 411     }
 412
 413     stop = (long) lseek (md, (off_t)0, 1);
 414     j = strlen (mmdlm2);
 415     if (write (md, mmdlm2, j) != j)
 416         return NOTOK;
 417     if (mapping)
 418         (void) map_write (mailbox, md, id, last, start, stop, off, size, noisy);
 419
 420     return OK;
 421 }
 422
 423 /* \f */
 424
 425 int     mbx_copy (mailbox, md, fd, mapping, text, noisy)
 426 char   *mailbox;
 427 int     md,
 428         fd,
 429         mapping,
 430         noisy;
 431 char   *text;
 432 {
 433     register int    i,
 434                     j,
 435                     size;
 436     long           start,
 437                     stop,
 438                     pos;
 439     register char  *cp;
 440     char    buffer[BUFSIZ];
 441     register FILE  *fp;
 442
 443     pos = (long) lseek (md, (off_t)0, 1);
 444     size = 0;
 445
 446     switch (mbx_style) {
 447         case MMDF:
 448         default:
 449             j = strlen (mmdlm1);
 450             if (write (md, mmdlm1, j) != j)
 451                 return NOTOK;
 452             start = (long) lseek (md, (off_t)0, 1);
 453
 454             if (text) {
 455                 i = strlen (text);
 456                 if (write (md, text, i) != i)
 457                     return NOTOK;
 458                 for (cp = text; *cp++; size++)
 459                     if (*cp == '\n')
 460                         size++;
 461             }
 462
 463             while ((i = read (fd, buffer, sizeof buffer)) > 0) {
 464                 for (j = 0;
 465                         (j = stringdex (mmdlm1, buffer)) >= 0;
 466                         buffer[j]++)
 467                     continue;
 468                 for (j = 0;
 469                         (j = stringdex (mmdlm2, buffer)) >= 0;
 470                         buffer[j]++)
 471                     continue;
 472                 if (write (md, buffer, i) != i)
 473                     return NOTOK;
 474                 if (mapping)
 475                     for (cp = buffer; i-- > 0; size++)
 476                         if (*cp++ == '\n')
 477                             size++;
 478             }
 479
 480             stop = (long) lseek (md, (off_t)0, 1);
 481             j = strlen (mmdlm2);
 482             if (write (md, mmdlm2, j) != j)
 483                 return NOTOK;
 484             if (mapping)
 485                 (void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
 486                             noisy);
 487
 488             return (i != NOTOK ? OK : NOTOK);
 489
 490         case UUCP:              /* I hate this... */
 491             if ((j = dup (fd)) == NOTOK)
 492                 return NOTOK;
 493             if ((fp = fdopen (j, "r")) == NULL) {
 494                 (void) close (j);
 495                 return NOTOK;
 496             }
 497             start = (long) lseek (md, (off_t)0, 1);
 498
 499             if (text) {
 500                 i = strlen (text);
 501                 if (write (md, text, i) != i)
 502                     return NOTOK;
 503                 for (cp = text; *cp++; size++)
 504                     if (*cp == '\n')
 505                         size++;
 506             }
 507
 508             for (j = 0; fgets (buffer, sizeof buffer, fp) != NULL; j++) {
 509                 if (j != 0 && strncmp (buffer, "From ", 5) == 0) {
 510                     (void) write (md, ">", 1);
 511                     size++;
 512                 }
 513                 i = strlen (buffer);
 514                 if (write (md, buffer, i) != i) {
 515                     (void) fclose (fp);
 516                     return NOTOK;
 517                 }
 518                 if (mapping)
 519                     for (cp = buffer; i-- > 0; size++)
 520                         if (*cp++ == '\n')
 521                             size++;
 522             }
 523             if (write (md, "\n", 1) != 1) {
 524                 (void) fclose (fp);
 525                 return NOTOK;
 526             }
 527             if (mapping) size += 2;
 528
 529             (void) fclose (fp);
 530             (void) (long) lseek (fd, (off_t)0, 2);
 531             stop = (long) lseek (md, (off_t)0, 1);
 532             if (mapping)
 533                 (void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
 534                             noisy);
 535
 536             return OK;
 537     }
 538 }
 539
 540 /* \f */
 541
 542 int     mbx_size (md, start, stop)
 543 int     md;
 544 long    start,
 545         stop;
 546 {
 547     register int    i,
 548                     fd;
 549     register long   pos;
 550     register FILE  *fp;
 551
 552     if ((fd = dup (md)) == NOTOK || (fp = fdopen (fd, "r")) == NULL) {
 553         if (fd != NOTOK)
 554             (void) close (fd);
 555         return NOTOK;
 556     }
 557
 558     (void) fseek (fp, start, 0);
 559     for (i = 0, pos = stop - start; pos-- > 0; i++)
 560         if (fgetc (fp) == '\n')
 561             i++;
 562
 563     (void) fclose (fp);
 564
 565     return i;
 566 }
 567
 568 /* \f */
 569
 570 int     mbx_close (mailbox, md)
 571 char   *mailbox;
 572 int     md;
 573 {
 574     (void) lkclose (md, mailbox);
 575
 576     return OK;
 577 }
 578
 579 /* \f */
 580
 581 /* This function is performed implicitly by getbbent.c:
 582
 583                 bb -> bb_map = map_name (bb -> bb_file);
 584 */
 585
 586 char    *map_name (file)
 587 register char   *file;
 588 {
 589     register char  *cp;
 590     static char buffer[BUFSIZ];
 591
 592     if ((cp = r1bindex (file, '/')) == file)
 593         (void) sprintf (buffer, ".%s.map", cp);
 594     else
 595         (void) sprintf (buffer, "%.*s.%s.map", cp - file, file, cp);
 596
 597     return buffer;
 598 }
 599
 600 /* \f */
 601
 602 int     map_read (file, pos, drops, noisy)
 603 char   *file;
 604 long    pos;
 605 struct drop **drops;
 606 int     noisy;
 607 {
 608     register int    i, j,
 609                     md,
 610                     msgp;
 611     register char  *cp;
 612     struct drop d;
 613     register struct drop   *mp,
 614                            *dp;
 615
 616     if ((md = open (cp = map_name (file), 0)) == NOTOK
 617             || map_chk (cp, md, mp = &d, pos, noisy)) {
 618         if (md != NOTOK)
 619             (void) close (md);
 620         return 0;
 621     }
 622
 623     msgp = mp -> d_id;
 624     dp = (struct drop  *) calloc ((unsigned) (msgp + 1), sizeof *dp);
 625     if (dp == NULL) {
 626         (void) close (md);
 627         return 0;
 628     }
 629
 630     bcopy ((char *) mp, (char *) dp, sizeof *dp);
 631
 632     (void) lseek (md, (off_t) sizeof *mp, 0);
 633     if ((i = read (md, (char *) (dp + 1), msgp * sizeof *dp)) < sizeof *dp) {
 634         i = 0;
 635         free ((char *) dp);
 636     }
 637     else {
 638 #ifdef  NTOHLSWAP
 639         register struct drop *tdp;
 640         for (j = 0, tdp = dp; j < i / sizeof(*dp); j++, tdp++) {
 641             tdp->d_id = ntohl(tdp->d_id);
 642             tdp->d_size = ntohl(tdp->d_size);
 643             tdp->d_start = ntohl(tdp->d_start);
 644             tdp->d_stop = ntohl(tdp->d_stop);
 645         }
 646 #endif
 647         *drops = dp;
 648     }
 649
 650     (void) close (md);
 651
 652     return (i / sizeof *dp);
 653 }
 654
 655 /* \f */
 656
 657 int     map_write (mailbox, md, id, last, start, stop, pos, size, noisy)
 658 register char   *mailbox;
 659 int     md,
 660         id,
 661         size,
 662         noisy;
 663 long   last,
 664         start,
 665         stop,
 666         pos;
 667 {
 668     register int    i;
 669     int     clear,
 670             fd,
 671             td;
 672     char   *file;
 673     register struct drop   *dp;
 674     struct drop    d1,
 675                    d2,
 676                   *rp;
 677     register FILE *fp;
 678
 679     if ((fd = map_open (file = map_name (mailbox), &clear, md)) == NOTOK)
 680         return NOTOK;
 681
 682     if (!clear && map_chk (file, fd, &d1, pos, noisy)) {
 683         (void) unlink (file);
 684         (void) mbx_close (file, fd);
 685         if ((fd = map_open (file, &clear, md)) == NOTOK)
 686             return NOTOK;
 687         clear++;
 688     }
 689
 690     if (clear) {
 691         if ((td = dup (md)) == NOTOK || (fp = fdopen (td, "r")) == NULL) {
 692             if (noisy)
 693                 admonish (file, "unable to %s", td != NOTOK ? "fdopen" : "dup");
 694             if (td != NOTOK)
 695                 (void) close (td);
 696             (void) mbx_close (file, fd);
 697             return NOTOK;
 698         }
 699
 700         switch (i = mbx_read (fp, 0L, &rp, noisy)) {
 701             case NOTOK:
 702                 (void) fclose (fp);
 703                 (void) mbx_close (file, fd);
 704                 return NOTOK;
 705
 706             case OK:
 707                 break;
 708
 709             default:
 710                 d1.d_id = 0;
 711                 for (dp = rp; i-- >0; dp++) {
 712                     if (dp -> d_start == start)
 713                         dp -> d_id = id;
 714                     (void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
 715                     if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 716                         if (noisy)
 717                             admonish (file, "write error");
 718                         (void) mbx_close (file, fd);
 719                         (void) fclose (fp);
 720                         return NOTOK;
 721                     }
 722                 }
 723                 free ((char *) rp);
 724                 break;
 725         }
 726     }
 727     else {
 728         if (last == 0)
 729             last = d1.d_start;
 730         dp = &d2;
 731         dp -> d_id = id;
 732         dp -> d_size = (long) (size ? size : mbx_size (fd, start, stop));
 733         dp -> d_start = (long) start;
 734         dp -> d_stop = (long) stop;
 735         (void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
 736         if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 737             if (noisy)
 738                 admonish (file, "write error");
 739             (void) mbx_close (file, fd);
 740             return NOTOK;
 741         }
 742     }
 743
 744     dp = &d1;
 745     dp -> d_size = DRVRSN;
 746     dp -> d_start = (long) last;
 747     dp -> d_stop = (long) lseek (md, (off_t)0, 1);
 748
 749     (void) lseek (fd, (off_t)0, 0);
 750     if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
 751         if (noisy)
 752             admonish (file, "write error");
 753         (void) mbx_close (file, fd);
 754         return NOTOK;
 755     }
 756
 757     (void) mbx_close (file, fd);
 758
 759     return OK;
 760 }
 761
 762 /* \f */
 763
 764 static int  map_open (file, clear, md)
 765 char   *file;
 766 int    *clear,
 767         md;
 768 {
 769     int     mode;
 770     struct  stat st;
 771
 772     mode = fstat (md, &st) != NOTOK ? (int) (st.st_mode & 0777) : m_gmprot ();
 773     return mbx_Xopen (file, st.st_uid, st.st_gid, mode, clear);
 774 }
 775
 776 /* \f */
 777
 778 int  map_chk (file, fd, dp, pos, noisy)
 779 char   *file;
 780 int     fd,
 781         noisy;
 782 register struct drop *dp;
 783 long    pos;
 784 {
 785     long    count;
 786     struct drop d, tmpd;
 787     register struct drop    *dl;
 788
 789     if (read (fd, (char *) &tmpd, sizeof *dp) != sizeof *dp) {
 790 #ifdef  notdef
 791         admonish (NULLCP, "%s: missing or partial index", file);
 792 #endif  /* notdef */
 793         return NOTOK;
 794     }
 795 #ifndef NTOHLSWAP
 796     *dp = tmpd;         /* if ntohl(n)=(n), can use struct assign */
 797 #else
 798     dp->d_id = ntohl(tmpd.d_id);
 799     dp->d_size = ntohl(tmpd.d_size);
 800     dp->d_start = ntohl(tmpd.d_start);
 801     dp->d_stop = ntohl(tmpd.d_stop);
 802 #endif
 803
 804     if (dp -> d_size != DRVRSN) {
 805         if (noisy)
 806             admonish (NULLCP, "%s: version mismatch (%d != %d)", file,
 807                                 dp->d_size, DRVRSN);
 808         return NOTOK;
 809     }
 810
 811     if (dp -> d_stop != (long) pos) {
 812         if (noisy && pos != (long)0)
 813             admonish (NULLCP,
 814                     "%s: pointer mismatch or incomplete index (%ld!=%ld)",
 815                     file, dp -> d_stop, (long) pos);
 816         return NOTOK;
 817     }
 818
 819     if ((long) ((dp -> d_id + 1) * sizeof *dp) != (long) lseek (fd, (off_t)0, 2)) {
 820         if (noisy)
 821             admonish (NULLCP, "%s: corrupt index(1)", file);
 822         return NOTOK;
 823     }
 824
 825     dl = &d;
 826     count = (long) strlen (mmdlm2);
 827     (void) lseek (fd, (off_t) (dp -> d_id * sizeof *dp), 0);
 828     if (read (fd, (char *) dl, sizeof *dl) != sizeof *dl
 829             || (ntohl(dl -> d_stop) != dp -> d_stop
 830                 && ntohl(dl -> d_stop) + count != dp -> d_stop)) {
 831         if (noisy)
 832             admonish (NULLCP, "%s: corrupt index(2)", file);
 833         return NOTOK;
 834     }
 835
 836     return OK;
 837 }
 838 @
 839
 840
 841 1.18
 842 log
 843 @fix from mtr
 844 @
 845 text
 846 @d3 1
 847 a3 1
 848 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.17 1993/08/27 23:00:00 jromine Exp jromine $";
 849 d588 1
 850 a588 1
 851         switch (i = mbx_read (fp, (off_t)0, &rp, noisy)) {
 852 @
 853
 854
 855 1.17
 856 log
 857 @don't increment tdp twice (with NTOHLSWAP)
 858 @
 859 text
 860 @d3 1
 861 a3 1
 862 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.16 1993/08/25 17:25:08 jromine Exp jromine $";
 863 d477 1
 864 a477 2
 865     register char  *cp,
 866                    *dp;
 867 d480 2
 868 a481 4
 869     if ((dp = index (cp = r1bindex (file, '/'), '.')) == NULL)
 870         dp = cp + strlen (cp);
 871     if (cp == file)
 872         (void) sprintf (buffer, ".%.*s%s", dp - cp, cp, ".map");
 873 d483 1
 874 a483 2
 875         (void) sprintf (buffer, "%.*s.%.*s%s", cp - file, file, dp - cp,
 876                 cp, ".map");
 877 @
 878
 879
 880 1.16
 881 log
 882 @off_t fixes for BSD44
 883 @
 884 text
 885 @d3 1
 886 a3 1
 887 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.15 1992/12/15 00:20:22 jromine Exp jromine $";
 888 a536 1
 889             tdp++;
 890 @
 891
 892
 893 1.15
 894 log
 895 @endif sugar
 896 @
 897 text
 898 @d3 1
 899 a3 1
 900 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.14 1992/02/03 22:26:17 jromine Exp jromine $";
 901 d37 1
 902 a37 1
 903 long   lseek ();
 904 d81 1
 905 a81 1
 906                 if (lseek (fd, 0L, 2) == (long) NOTOK) {
 907 d126 1
 908 a126 1
 909             *clear = fstat (fd, &st) != NOTOK && st.st_size == 0L;
 910 d163 1
 911 a163 1
 912     if (lseek (fd, (long) (-count), 2) == (long) NOTOK
 913 d186 2
 914 a187 2
 915     long    ld1,
 916             ld2;
 917 d209 1
 918 a209 1
 919             pos += ld1, dp -> d_start = pos;
 920 d211 1
 921 a211 1
 922             dp -> d_start = pos, pos += (long) strlen (buffer);
 923 d227 1
 924 a227 1
 925         if (dp -> d_start != pos) {
 926 d229 2
 927 a230 2
 928             dp -> d_size = size;
 929             dp -> d_stop = pos;
 930 d273 1
 931 a273 1
 932     register long   start,
 933 d278 1
 934 a278 1
 935     off = lseek (md, 0L, 1);
 936 d282 1
 937 a282 1
 938     start = lseek (md, 0L, 1);
 939 d301 1
 940 a301 1
 941     stop = lseek (md, 0L, 1);
 942 d324 1
 943 a324 1
 944     register long   start,
 945 d331 1
 946 a331 1
 947     pos = lseek (md, 0L, 1);
 948 d340 1
 949 a340 1
 950             start = lseek (md, 0L, 1);
 951 d368 1
 952 a368 1
 953             stop = lseek (md, 0L, 1);
 954 d373 1
 955 a373 1
 956                 (void) map_write (mailbox, md, 0, 0L, start, stop, pos, size,
 957 d385 1
 958 a385 1
 959             start = lseek (md, 0L, 1);
 960 d418 2
 961 a419 2
 962             (void) lseek (fd, 0L, 2);
 963             stop = lseek (md, 0L, 1);
 964 d421 1
 965 a421 1
 966                 (void) map_write (mailbox, md, 0, 0L, start, stop, pos, size,
 967 d430 1
 968 a430 1
 969 int     mbx_size (md, start, stop)
 970 d524 1
 971 a524 1
 972     (void) lseek (md, (long) sizeof *mp, 0);
 973 d556 1
 974 a556 1
 975 long    last,
 976 d593 1
 977 a593 1
 978         switch (i = mbx_read (fp, 0L, &rp, noisy)) {
 979 d607 1
 980 a607 1
 981                     (void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
 982 d625 4
 983 a628 4
 984         dp -> d_size = size ? size : mbx_size (fd, start, stop);
 985         dp -> d_start = start;
 986         dp -> d_stop = stop;
 987         (void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
 988 d639 2
 989 a640 2
 990     dp -> d_start = last;
 991     dp -> d_stop = lseek (md, 0L, 1);
 992 d642 1
 993 a642 1
 994     (void) lseek (fd, 0L, 0);
 995 d704 2
 996 a705 2
 997     if (dp -> d_stop != pos) {
 998         if (noisy && pos != 0L)
 999 d708 1
1000 a708 1
1001                     file, dp -> d_stop, pos);
1002 d712 1
1003 a712 1
1004     if ((long) ((dp -> d_id + 1) * sizeof *dp) != lseek (fd, 0L, 2)) {
1005 d720 1
1006 a720 1
1007     (void) lseek (fd, (long) (dp -> d_id * sizeof *dp), 0);
1008 @
1009
1010
1011 1.14
1012 log
1013 @writing ">" on wrong fd
1014 @
1015 text
1016 @d3 2
1017 a4 2
1018 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.13 1992/01/31 22:09:37 jromine Exp jromine $";
1019 #endif  lint
1020 d11 1
1021 a11 1
1022 #else   MMDFONLY
1023 d15 1
1024 a15 1
1025 #endif  MMDFONLY
1026 d116 1
1027 a116 1
1028 #endif  BSD42
1029 d685 1
1030 a685 1
1031 #endif  notdef
1032 @
1033
1034
1035 1.13
1036 log
1037 @kerberos
1038 @
1039 text
1040 @d3 1
1041 a3 1
1042 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.12 1990/11/05 13:26:50 mh Exp jromine $";
1043 d398 1
1044 a398 1
1045                     (void) write (fd, ">", 1);
1046 @
1047
1048
1049 1.12
1050 log
1051 @add extra \n if UUCP maildrop
1052 @
1053 text
1054 @d3 1
1055 a3 1
1056 static char ident[] = "@@(#)$Id: dropsbr.c,v 1.11 90/04/05 15:01:09 sources Exp Locker: mh $";
1057 d166 1
1058 a166 1
1059     ldelim[count] = NULL;
1060 @
1061
1062
1063 1.11
1064 log
1065 @add ID
1066 @
1067 text
1068 @d3 1
1069 a3 1
1070 static char ident[] = "@@(#)$Id:$";
1071 d411 5
1072 @
1073
1074
1075 1.10
1076 log
1077 @NTOHL -> NTOHLSWAP
1078 @
1079 text
1080 @d2 3
1081 @
1082
1083
1084 1.9
1085 log
1086 @add NTOHL (remove NONTOHL)
1087 @
1088 text
1089 @d16 1
1090 a16 1
1091 #if     (defined(BSD42) || defined(SOCKETS)) && defined(NTOHL)
1092 d522 1
1093 a522 1
1094 #ifdef  NTOHL
1095 d680 1
1096 a680 1
1097 #ifndef NTOHL
1098 @
1099
1100
1101 1.8
1102 log
1103 @yuk.  fix ntohl() stuff so it works
1104 @
1105 text
1106 @d16 1
1107 a16 1
1108 #if     (defined(BSD42) || defined(SOCKETS)) && !defined(NONTOHL)
1109 d522 1
1110 a522 1
1111 #ifndef NONTOHL
1112 d680 1
1113 a680 1
1114 #ifdef  NONTOHL
1115 @
1116
1117
1118 1.7
1119 log
1120 @add NONTOHL define
1121 @
1122 text
1123 @d498 1
1124 a498 3
1125                            *dp,
1126                            *tmpdp,
1127                            *tmp1dp;
1128 a508 1
1129     tmpdp = (struct drop  *) calloc ((unsigned) msgp, sizeof *dp);
1130 d522 11
1131 a532 9
1132         tmp1dp = dp;
1133         for (j = 0; j < i / sizeof(*dp); j++) {
1134                 tmp1dp->d_id = ntohl(tmpdp->d_id);
1135                 tmp1dp->d_size = ntohl(tmpdp->d_size);
1136                 tmp1dp->d_start = ntohl(tmpdp->d_start);
1137                 tmp1dp->d_stop = ntohl(tmpdp->d_stop);
1138                 tmpdp++;
1139                 tmp1dp++;
1140                 }
1141 a533 1
1142         *drops = dp;
1143 a674 4
1144     dp->d_id = ntohl(tmpd.d_id);
1145     dp->d_size = ntohl(tmpd.d_size);
1146     dp->d_start = ntohl(tmpd.d_start);
1147     dp->d_stop = ntohl(tmpd.d_stop);
1148 d680 8
1149 @
1150
1151
1152 1.6
1153 log
1154 @ntohl
1155 @
1156 text
1157 @d16 1
1158 a16 2
1159 #ifndef ntohl
1160 #if     defined(BSD42) || defined(SOCKETS)
1161 a20 1
1162 #endif  ntohl
1163 @
1164
1165
1166 1.5
1167 log
1168 @fixup netinet/in.h include to be under BSD42
1169 @
1170 text
1171 @d16 1
1172 d22 1
1173 @
1174
1175
1176 1.4
1177 log
1178 @include <netinet/in.h> for ntohl macros
1179 @
1180 text
1181 @d16 1
1182 d18 4
1183 @
1184
1185
1186 1.3
1187 log
1188 @fixes for byteswapped map files
1189 @
1190 text
1191 @d16 1
1192 a16 1
1193
1194 @
1195
1196
1197 1.2
1198 log
1199 @ANSI Compilance
1200 @
1201 text
1202 @d487 1
1203 a487 1
1204     register int    i,
1205 d493 3
1206 a495 1
1207                            *dp;
1208 d506 1
1209 d519 11
1210 a529 1
1211     else
1212 d668 1
1213 a668 1
1214     struct drop d;
1215 d671 5
1216 a675 1
1217     if (read (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
1218 d684 2
1219 a685 1
1220             admonish (NULLCP, "%s: version mismatch", file);
1221 d707 2
1222 a708 2
1223             || (dl -> d_stop != dp -> d_stop
1224                 && dl -> d_stop + count != dp -> d_stop)) {
1225 @
1226
1227
1228 1.1
1229 log
1230 @Initial revision
1231 @
1232 text
1233 @d25 1
1234 @