head	1.19;
access;
symbols;
locks; strict;
comment	@ * @;


1.19
date	95.12.07.18.59.08;	author jromine;	state Exp;
branches;
next	1.18;

1.18
date	95.12.06.21.09.05;	author jromine;	state Exp;
branches;
next	1.17;

1.17
date	93.08.27.23.00.00;	author jromine;	state Exp;
branches;
next	1.16;

1.16
date	93.08.25.17.25.08;	author jromine;	state Exp;
branches;
next	1.15;

1.15
date	92.12.15.00.20.22;	author jromine;	state Exp;
branches;
next	1.14;

1.14
date	92.02.03.22.26.17;	author jromine;	state Exp;
branches;
next	1.13;

1.13
date	92.01.31.22.09.37;	author jromine;	state Exp;
branches;
next	1.12;

1.12
date	90.11.05.13.26.50;	author mh;	state Exp;
branches;
next	1.11;

1.11
date	90.04.05.15.01.09;	author sources;	state Exp;
branches;
next	1.10;

1.10
date	90.04.02.14.20.04;	author sources;	state Exp;
branches;
next	1.9;

1.9
date	90.03.23.16.38.59;	author sources;	state Exp;
branches;
next	1.8;

1.8
date	90.03.16.14.50.27;	author sources;	state Exp;
branches;
next	1.7;

1.7
date	90.03.16.10.27.41;	author sources;	state Exp;
branches;
next	1.6;

1.6
date	90.03.16.09.43.56;	author sources;	state Exp;
branches;
next	1.5;

1.5
date	90.03.12.10.19.22;	author sources;	state Exp;
branches;
next	1.4;

1.4
date	90.03.12.10.13.31;	author sources;	state Exp;
branches;
next	1.3;

1.3
date	90.02.08.14.09.55;	author sources;	state Exp;
branches;
next	1.2;

1.2
date	90.02.06.13.18.17;	author sources;	state Exp;
branches;
next	1.1;

1.1
date	90.02.06.13.18.04;	author sources;	state Exp;
branches;
next	;


desc
@@


1.19
log
@64bit fix: call mbx_read with 0L not (off_t)0
@
text
@/* dropsbr.c - write to a mailbox */
#ifndef	lint
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.18 1995/12/06 21:09:05 jromine Exp jromine $";
#endif	/* lint */

#include <stdio.h>
#ifndef	MMDFONLY
#include "../h/mh.h"
#include "../h/dropsbr.h"
#include "../zotnet/mts.h"
#else	/* MMDFONLY */
#include "dropsbr.h"
#include "strings.h"
#include "mmdfonly.h"
#endif	/* MMDFONLY */
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#if     (defined(BSD42) || defined(SOCKETS)) && defined(NTOHLSWAP)
#include <netinet/in.h>
#else
#define	ntohl(n) (n)
#endif


#define	MMDF	1
#define	UUCP	2

/*  */

static	int	mbx_style = MMDF;

static int	mbx_create(), mbx_chk(), map_open();

extern int  errno;

off_t   lseek ();

/*  */

int     mbx_mmdf () {
    int     style = mbx_style;

    mbx_style = MMDF;
    return style;
}


int     mbx_uucp () {
    int     style = mbx_style;

    mbx_style = UUCP;
    return style;
}

/*  */

int     mbx_open (file, uid, gid, mode)
char   *file;
int     uid,
        gid,
	mode;
{
    int     clear,
            fd;

    if ((fd = mbx_Xopen (file, uid, gid, mode, &clear)) == NOTOK)
	return fd;

    if (!clear)
	switch (mbx_style) {
	    case MMDF: 
	    default: 
		if (mbx_chk (fd) == NOTOK) {
		    (void) close (fd);
		    return NOTOK;
		}
		break;

	    case UUCP: 
		if (lseek (fd, (off_t)0, 2) == (off_t) NOTOK) {
		    (void) close (fd);
		    return NOTOK;
		}
		break;
	}

    return fd;
}

/*  */

int	mbx_Xopen (file, uid, gid, mode, clear)
char   *file;
int	uid,
	gid,
	mode,
       *clear;
{
    register int j;
    int	    count,
            fd;
    struct stat st;

    for (*clear = 0, count = 4, j = 0; count > 0; count--)
	if ((fd = lkopen (file, 6)) == NOTOK)
	    switch (errno) {
		case ENOENT: 
		    if (mbx_create (file, uid, gid, mode) == NOTOK)
			return NOTOK;
		    (*clear)++;
		    break;

#ifdef	BSD42
		case EWOULDBLOCK:
#endif	/* BSD42 */
		case ETXTBSY: 
		    j = errno;
		    sleep (5);
		    break;

		default: 
		    return NOTOK;
	    }
	else {
	    *clear = fstat (fd, &st) != NOTOK && st.st_size == (off_t)0;
	    break;
	}

    errno = j;
    return fd;
}

/*  */

static int  mbx_create (file, uid, gid, mode)
char   *file;
int     uid,
        gid,
	mode;
{
    int     fd;

    if ((fd = creat (file, 0600)) == NOTOK)
	return NOTOK;

    (void) close (fd);
    (void) chown (file, uid, gid);
    (void) chmod (file, mode);

    return OK;
}


static int  mbx_chk (fd)
int     fd;
{
    int     count;
    char    ldelim[BUFSIZ];

    count = strlen (mmdlm2);

    if (lseek (fd, (off_t) (-count), 2) == (off_t) NOTOK
	    || read (fd, ldelim, count) != count)
	return NOTOK;
    ldelim[count] = 0;

    if (strcmp (ldelim, mmdlm2)
	    && write (fd, "\n", 1) != 1
	    && write (fd, mmdlm2, count) != count)
	return NOTOK;

    return OK;
}

/*  */

int	mbx_read (fp, pos, drops, noisy)
register FILE  *fp;
register long	pos;
struct drop **drops;
int	noisy;
{
    register int    len,
                    size;
    register long     ld1,
		    ld2;
    register char  *bp;
    char    buffer[BUFSIZ];
    register struct drop   *cp,
                           *dp,
                           *ep,
                           *pp;

    pp = (struct drop  *) calloc ((unsigned) (len = MAXFOLDER), sizeof *dp);
    if (pp == NULL) {
	if (noisy)
	    admonish (NULLCP, "unable to allocate drop storage");
	return NOTOK;
    }

    ld1 = (long) strlen (mmdlm1);
    ld2 = (long) strlen (mmdlm2);

    (void) fseek (fp, pos, 0);
    for (ep = (dp = pp) + len - 1; fgets (buffer, sizeof buffer, fp);) {
	size = 0;
	if (strcmp (buffer, mmdlm1) == 0)
	    pos += ld1, dp -> d_start = (long) pos;
	else {
	    dp -> d_start = (long)pos , pos += (long) strlen (buffer);
	    for (bp = buffer; *bp; bp++, size++)
		if (*bp == '\n')
		    size++;
	}

	while (fgets (buffer, sizeof buffer, fp) != NULL)
	    if (strcmp (buffer, mmdlm2) == 0)
		break;
	    else {
		pos += (long) strlen (buffer);
		for (bp = buffer; *bp; bp++, size++)
		    if (*bp == '\n')
			size++;
	    }

	if (dp -> d_start != (long) pos) {
	    dp -> d_id = 0;
	    dp -> d_size = (long) size;
	    dp -> d_stop = (long) pos;
	    dp++;
	}
	pos += ld2;

	if (dp >= ep) {
	    register int    curlen = dp - pp;

	    cp = (struct drop  *) realloc ((char *) pp,
		                    (unsigned) (len += MAXFOLDER) * sizeof *pp);
	    if (cp == NULL) {
		if (noisy)
		    admonish (NULLCP, "unable to allocate drop storage");
		free ((char *) pp);
		return 0;
	    }
	    dp = cp + curlen, ep = (pp = cp) + len - 1;
	}
    }

    if (dp == pp)
	free ((char *) pp);
    else
	*drops = pp;
    return (dp - pp);
}

/*  */

int	mbx_write (mailbox, md, fp, id, last, pos, stop, mapping, noisy)
char   *mailbox;
register FILE *fp;
int     md,
	id,
	mapping,
	noisy;
long	last;
register long	pos,
		stop;
{
    register int    i,
                    j,
                    size;
    long   	    start,
                    off;
    register char  *cp;
    char    buffer[BUFSIZ];

    off = (long) lseek (md, (off_t)0, 1);
    j = strlen (mmdlm1);
    if (write (md, mmdlm1, j) != j)
	return NOTOK;
    start = (long) lseek (md, (off_t)0, 1);
    size = 0;

    (void) fseek (fp, pos, 0);
    while (fgets (buffer, sizeof buffer, fp) != NULL && pos < stop) {
	i = strlen (buffer);
	for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++)
	    continue;
	for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++)
	    continue;
	if (write (md, buffer, i) != i)
	    return NOTOK;
	pos += (long) i;
	if (mapping)
	    for (cp = buffer; i-- > 0; size++)
		if (*cp++ == '\n')
		    size++;
    }

    stop = (long) lseek (md, (off_t)0, 1);
    j = strlen (mmdlm2);
    if (write (md, mmdlm2, j) != j)
	return NOTOK;
    if (mapping)
	(void) map_write (mailbox, md, id, last, start, stop, off, size, noisy);

    return OK;
}

/*  */

int     mbx_copy (mailbox, md, fd, mapping, text, noisy)
char   *mailbox;
int     md,
        fd,
	mapping,
	noisy;
char   *text;
{
    register int    i,
                    j,
                    size;
    long           start,
                    stop,
                    pos;
    register char  *cp;
    char    buffer[BUFSIZ];
    register FILE  *fp;

    pos = (long) lseek (md, (off_t)0, 1);
    size = 0;

    switch (mbx_style) {
	case MMDF: 
	default: 
	    j = strlen (mmdlm1);
	    if (write (md, mmdlm1, j) != j)
		return NOTOK;
	    start = (long) lseek (md, (off_t)0, 1);

	    if (text) {
		i = strlen (text);
		if (write (md, text, i) != i)
		    return NOTOK;
		for (cp = text; *cp++; size++)
		    if (*cp == '\n')
			size++;
	    }
		    
	    while ((i = read (fd, buffer, sizeof buffer)) > 0) {
		for (j = 0;
			(j = stringdex (mmdlm1, buffer)) >= 0;
			buffer[j]++)
		    continue;
		for (j = 0;
			(j = stringdex (mmdlm2, buffer)) >= 0;
			buffer[j]++)
		    continue;
		if (write (md, buffer, i) != i)
		    return NOTOK;
		if (mapping)
		    for (cp = buffer; i-- > 0; size++)
			if (*cp++ == '\n')
			    size++;
	    }

	    stop = (long) lseek (md, (off_t)0, 1);
	    j = strlen (mmdlm2);
	    if (write (md, mmdlm2, j) != j)
		return NOTOK;
	    if (mapping)
		(void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
			    noisy);

	    return (i != NOTOK ? OK : NOTOK);

	case UUCP: 		/* I hate this... */
	    if ((j = dup (fd)) == NOTOK)
		return NOTOK;
	    if ((fp = fdopen (j, "r")) == NULL) {
		(void) close (j);
		return NOTOK;
	    }
	    start = (long) lseek (md, (off_t)0, 1);

	    if (text) {
		i = strlen (text);
		if (write (md, text, i) != i)
		    return NOTOK;
		for (cp = text; *cp++; size++)
		    if (*cp == '\n')
			size++;
	    }
		    
	    for (j = 0; fgets (buffer, sizeof buffer, fp) != NULL; j++) {
		if (j != 0 && strncmp (buffer, "From ", 5) == 0) {
		    (void) write (md, ">", 1);
		    size++;
		}
		i = strlen (buffer);
		if (write (md, buffer, i) != i) {
		    (void) fclose (fp);
		    return NOTOK;
		}
		if (mapping)
		    for (cp = buffer; i-- > 0; size++)
			if (*cp++ == '\n')
			    size++;
	    }
	    if (write (md, "\n", 1) != 1) {
		(void) fclose (fp);
		return NOTOK;
	    }
	    if (mapping) size += 2;

	    (void) fclose (fp);
	    (void) (long) lseek (fd, (off_t)0, 2);
	    stop = (long) lseek (md, (off_t)0, 1);
	    if (mapping)
		(void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
			    noisy);

	    return OK;
    }
}

/*  */

int 	mbx_size (md, start, stop)
int	md;
long	start,
	stop;
{
    register int    i,
                    fd;
    register long   pos;
    register FILE  *fp;

    if ((fd = dup (md)) == NOTOK || (fp = fdopen (fd, "r")) == NULL) {
	if (fd != NOTOK)
	    (void) close (fd);
	return NOTOK;
    }

    (void) fseek (fp, start, 0);
    for (i = 0, pos = stop - start; pos-- > 0; i++)
	if (fgetc (fp) == '\n')
	    i++;

    (void) fclose (fp);

    return i;
}

/*  */

int     mbx_close (mailbox, md)
char   *mailbox;
int     md;
{
    (void) lkclose (md, mailbox);

    return OK;
}

/*  */

/* This function is performed implicitly by getbbent.c:

		bb -> bb_map = map_name (bb -> bb_file);
*/

char    *map_name (file)
register char	*file;
{
    register char  *cp;
    static char buffer[BUFSIZ];

    if ((cp = r1bindex (file, '/')) == file)
	(void) sprintf (buffer, ".%s.map", cp);
    else
	(void) sprintf (buffer, "%.*s.%s.map", cp - file, file, cp);

    return buffer;
}

/*  */

int	map_read (file, pos, drops, noisy)
char   *file;
long	pos;
struct drop **drops;
int	noisy;
{
    register int    i, j,
                    md,
                    msgp;
    register char  *cp;
    struct drop d;
    register struct drop   *mp,
                           *dp;

    if ((md = open (cp = map_name (file), 0)) == NOTOK
	    || map_chk (cp, md, mp = &d, pos, noisy)) {
	if (md != NOTOK)
	    (void) close (md);
	return 0;
    }

    msgp = mp -> d_id;
    dp = (struct drop  *) calloc ((unsigned) (msgp + 1), sizeof *dp);
    if (dp == NULL) {
	(void) close (md);
	return 0;
    }

    bcopy ((char *) mp, (char *) dp, sizeof *dp);

    (void) lseek (md, (off_t) sizeof *mp, 0);
    if ((i = read (md, (char *) (dp + 1), msgp * sizeof *dp)) < sizeof *dp) {
	i = 0;
	free ((char *) dp);
    }
    else {
#ifdef	NTOHLSWAP
	register struct drop *tdp;
	for (j = 0, tdp = dp; j < i / sizeof(*dp); j++, tdp++) {
	    tdp->d_id = ntohl(tdp->d_id);
	    tdp->d_size = ntohl(tdp->d_size);
	    tdp->d_start = ntohl(tdp->d_start);
	    tdp->d_stop = ntohl(tdp->d_stop);
	}
#endif
	*drops = dp;
    }

    (void) close (md);

    return (i / sizeof *dp);
}

/*  */

int     map_write (mailbox, md, id, last, start, stop, pos, size, noisy)
register char   *mailbox;
int     md,
        id,
	size,
	noisy;
long   last,
	start,
        stop,
        pos;
{
    register int    i;
    int     clear,
            fd,
            td;
    char   *file;
    register struct drop   *dp;
    struct drop    d1,
		   d2,
                  *rp;
    register FILE *fp;

    if ((fd = map_open (file = map_name (mailbox), &clear, md)) == NOTOK)
	return NOTOK;

    if (!clear && map_chk (file, fd, &d1, pos, noisy)) {
	(void) unlink (file);
	(void) mbx_close (file, fd);
	if ((fd = map_open (file, &clear, md)) == NOTOK)
	    return NOTOK;
	clear++;
    }

    if (clear) {
	if ((td = dup (md)) == NOTOK || (fp = fdopen (td, "r")) == NULL) {
	    if (noisy)
		admonish (file, "unable to %s", td != NOTOK ? "fdopen" : "dup");
	    if (td != NOTOK)
		(void) close (td);
	    (void) mbx_close (file, fd);
	    return NOTOK;
	}

	switch (i = mbx_read (fp, 0L, &rp, noisy)) {
	    case NOTOK:
		(void) fclose (fp);
		(void) mbx_close (file, fd);
		return NOTOK;

	    case OK:
		break;

	    default:
		d1.d_id = 0;
		for (dp = rp; i-- >0; dp++) {
		    if (dp -> d_start == start)
			dp -> d_id = id;
		    (void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
		    if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
			if (noisy)
			    admonish (file, "write error");
			(void) mbx_close (file, fd);
			(void) fclose (fp);
			return NOTOK;
		    }
		}
		free ((char *) rp);
		break;
	}
    }
    else {
	if (last == 0)
	    last = d1.d_start;
	dp = &d2;
	dp -> d_id = id;
	dp -> d_size = (long) (size ? size : mbx_size (fd, start, stop));
	dp -> d_start = (long) start;
	dp -> d_stop = (long) stop;
	(void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
	if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
	    if (noisy)
		admonish (file, "write error");
	    (void) mbx_close (file, fd);
	    return NOTOK;
	}
    }

    dp = &d1;
    dp -> d_size = DRVRSN;
    dp -> d_start = (long) last;
    dp -> d_stop = (long) lseek (md, (off_t)0, 1);

    (void) lseek (fd, (off_t)0, 0);
    if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
	if (noisy)
	    admonish (file, "write error");
	(void) mbx_close (file, fd);
	return NOTOK;
    }

    (void) mbx_close (file, fd);

    return OK;
}

/*  */

static int  map_open (file, clear, md)
char   *file;
int    *clear,
	md;
{
    int	    mode;
    struct  stat st;

    mode = fstat (md, &st) != NOTOK ? (int) (st.st_mode & 0777) : m_gmprot ();
    return mbx_Xopen (file, st.st_uid, st.st_gid, mode, clear);
}

/*  */

int  map_chk (file, fd, dp, pos, noisy)
char   *file;
int     fd,
	noisy;
register struct drop *dp;
long	pos;
{
    long    count;
    struct drop d, tmpd;
    register struct drop    *dl;

    if (read (fd, (char *) &tmpd, sizeof *dp) != sizeof *dp) {
#ifdef	notdef
	admonish (NULLCP, "%s: missing or partial index", file);
#endif	/* notdef */
	return NOTOK;
    }
#ifndef	NTOHLSWAP
    *dp = tmpd;		/* if ntohl(n)=(n), can use struct assign */
#else
    dp->d_id = ntohl(tmpd.d_id);
    dp->d_size = ntohl(tmpd.d_size);
    dp->d_start = ntohl(tmpd.d_start);
    dp->d_stop = ntohl(tmpd.d_stop);
#endif
    
    if (dp -> d_size != DRVRSN) {
	if (noisy)
	    admonish (NULLCP, "%s: version mismatch (%d != %d)", file,
				dp->d_size, DRVRSN);
	return NOTOK;
    }

    if (dp -> d_stop != (long) pos) {
	if (noisy && pos != (long)0)
	    admonish (NULLCP,
		    "%s: pointer mismatch or incomplete index (%ld!=%ld)", 
		    file, dp -> d_stop, (long) pos);
	return NOTOK;
    }

    if ((long) ((dp -> d_id + 1) * sizeof *dp) != (long) lseek (fd, (off_t)0, 2)) {
	if (noisy)
	    admonish (NULLCP, "%s: corrupt index(1)", file);
	return NOTOK;
    }

    dl = &d;
    count = (long) strlen (mmdlm2);
    (void) lseek (fd, (off_t) (dp -> d_id * sizeof *dp), 0);
    if (read (fd, (char *) dl, sizeof *dl) != sizeof *dl
	    || (ntohl(dl -> d_stop) != dp -> d_stop
		&& ntohl(dl -> d_stop) + count != dp -> d_stop)) {
	if (noisy)
	    admonish (NULLCP, "%s: corrupt index(2)", file);
	return NOTOK;
    }

    return OK;
}
@


1.18
log
@fix from mtr
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.17 1993/08/27 23:00:00 jromine Exp jromine $";
d588 1
a588 1
	switch (i = mbx_read (fp, (off_t)0, &rp, noisy)) {
@


1.17
log
@don't increment tdp twice (with NTOHLSWAP)
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.16 1993/08/25 17:25:08 jromine Exp jromine $";
d477 1
a477 2
    register char  *cp,
                   *dp;
d480 2
a481 4
    if ((dp = index (cp = r1bindex (file, '/'), '.')) == NULL)
	dp = cp + strlen (cp);
    if (cp == file)
	(void) sprintf (buffer, ".%.*s%s", dp - cp, cp, ".map");
d483 1
a483 2
	(void) sprintf (buffer, "%.*s.%.*s%s", cp - file, file, dp - cp,
		cp, ".map");
@


1.16
log
@off_t fixes for BSD44
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.15 1992/12/15 00:20:22 jromine Exp jromine $";
a536 1
	    tdp++;
@


1.15
log
@endif sugar
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.14 1992/02/03 22:26:17 jromine Exp jromine $";
d37 1
a37 1
long   lseek ();
d81 1
a81 1
		if (lseek (fd, 0L, 2) == (long) NOTOK) {
d126 1
a126 1
	    *clear = fstat (fd, &st) != NOTOK && st.st_size == 0L;
d163 1
a163 1
    if (lseek (fd, (long) (-count), 2) == (long) NOTOK
d186 2
a187 2
    long    ld1,
            ld2;
d209 1
a209 1
	    pos += ld1, dp -> d_start = pos;
d211 1
a211 1
	    dp -> d_start = pos, pos += (long) strlen (buffer);
d227 1
a227 1
	if (dp -> d_start != pos) {
d229 2
a230 2
	    dp -> d_size = size;
	    dp -> d_stop = pos;
d273 1
a273 1
    register long   start,
d278 1
a278 1
    off = lseek (md, 0L, 1);
d282 1
a282 1
    start = lseek (md, 0L, 1);
d301 1
a301 1
    stop = lseek (md, 0L, 1);
d324 1
a324 1
    register long   start,
d331 1
a331 1
    pos = lseek (md, 0L, 1);
d340 1
a340 1
	    start = lseek (md, 0L, 1);
d368 1
a368 1
	    stop = lseek (md, 0L, 1);
d373 1
a373 1
		(void) map_write (mailbox, md, 0, 0L, start, stop, pos, size,
d385 1
a385 1
	    start = lseek (md, 0L, 1);
d418 2
a419 2
	    (void) lseek (fd, 0L, 2);
	    stop = lseek (md, 0L, 1);
d421 1
a421 1
		(void) map_write (mailbox, md, 0, 0L, start, stop, pos, size,
d430 1
a430 1
int	mbx_size (md, start, stop)
d524 1
a524 1
    (void) lseek (md, (long) sizeof *mp, 0);
d556 1
a556 1
long    last,
d593 1
a593 1
	switch (i = mbx_read (fp, 0L, &rp, noisy)) {
d607 1
a607 1
		    (void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
d625 4
a628 4
	dp -> d_size = size ? size : mbx_size (fd, start, stop);
	dp -> d_start = start;
	dp -> d_stop = stop;
	(void) lseek (fd, (long) (++d1.d_id * sizeof *dp), 0);
d639 2
a640 2
    dp -> d_start = last;
    dp -> d_stop = lseek (md, 0L, 1);
d642 1
a642 1
    (void) lseek (fd, 0L, 0);
d704 2
a705 2
    if (dp -> d_stop != pos) {
	if (noisy && pos != 0L)
d708 1
a708 1
		    file, dp -> d_stop, pos);
d712 1
a712 1
    if ((long) ((dp -> d_id + 1) * sizeof *dp) != lseek (fd, 0L, 2)) {
d720 1
a720 1
    (void) lseek (fd, (long) (dp -> d_id * sizeof *dp), 0);
@


1.14
log
@writing ">" on wrong fd
@
text
@d3 2
a4 2
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.13 1992/01/31 22:09:37 jromine Exp jromine $";
#endif	lint
d11 1
a11 1
#else	MMDFONLY
d15 1
a15 1
#endif	MMDFONLY
d116 1
a116 1
#endif	BSD42
d685 1
a685 1
#endif	notdef
@


1.13
log
@kerberos
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.12 1990/11/05 13:26:50 mh Exp jromine $";
d398 1
a398 1
		    (void) write (fd, ">", 1);
@


1.12
log
@add extra \n if UUCP maildrop
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dropsbr.c,v 1.11 90/04/05 15:01:09 sources Exp Locker: mh $";
d166 1
a166 1
    ldelim[count] = NULL;
@


1.11
log
@add ID
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id:$";
d411 5
@


1.10
log
@NTOHL -> NTOHLSWAP
@
text
@d2 3
@


1.9
log
@add NTOHL (remove NONTOHL)
@
text
@d16 1
a16 1
#if     (defined(BSD42) || defined(SOCKETS)) && defined(NTOHL)
d522 1
a522 1
#ifdef	NTOHL
d680 1
a680 1
#ifndef	NTOHL
@


1.8
log
@yuk.  fix ntohl() stuff so it works
@
text
@d16 1
a16 1
#if     (defined(BSD42) || defined(SOCKETS)) && !defined(NONTOHL)
d522 1
a522 1
#ifndef	NONTOHL
d680 1
a680 1
#ifdef	NONTOHL
@


1.7
log
@add NONTOHL define
@
text
@d498 1
a498 3
                           *dp,
			   *tmpdp,
			   *tmp1dp;
a508 1
    tmpdp = (struct drop  *) calloc ((unsigned) msgp, sizeof *dp);
d522 11
a532 9
	tmp1dp = dp;
	for (j = 0; j < i / sizeof(*dp); j++) {
		tmp1dp->d_id = ntohl(tmpdp->d_id);
		tmp1dp->d_size = ntohl(tmpdp->d_size);
		tmp1dp->d_start = ntohl(tmpdp->d_start);
		tmp1dp->d_stop = ntohl(tmpdp->d_stop);
		tmpdp++;
		tmp1dp++;
		}
a533 1
	*drops = dp;
a674 4
    dp->d_id = ntohl(tmpd.d_id);
    dp->d_size = ntohl(tmpd.d_size);
    dp->d_start = ntohl(tmpd.d_start);
    dp->d_stop = ntohl(tmpd.d_stop);
d680 8
@


1.6
log
@ntohl
@
text
@d16 1
a16 2
#ifndef	ntohl
#if     defined(BSD42) || defined(SOCKETS)
a20 1
#endif	ntohl
@


1.5
log
@fixup netinet/in.h include to be under BSD42
@
text
@d16 1
d22 1
@


1.4
log
@include <netinet/in.h> for ntohl macros
@
text
@d16 1
d18 4
@


1.3
log
@fixes for byteswapped map files
@
text
@d16 1
a16 1

@


1.2
log
@ANSI Compilance
@
text
@d487 1
a487 1
    register int    i,
d493 3
a495 1
                           *dp;
d506 1
d519 11
a529 1
    else
d668 1
a668 1
    struct drop d;
d671 5
a675 1
    if (read (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
d684 2
a685 1
	    admonish (NULLCP, "%s: version mismatch", file);
d707 2
a708 2
	    || (dl -> d_stop != dp -> d_stop
		&& dl -> d_stop + count != dp -> d_stop)) {
@


1.1
log
@Initial revision
@
text
@d25 1
@