bbc.c

早期freebsd实现

/*  */

pgmread (pd, child_id, bb)
int     pd,
        child_id;
register struct bboard  *bb;
{
    int     i,
            j,
            n;
    TYPESIG (*estat) (), (*hstat) (), (*istat) (), (*qstat) (), (*tstat) ();
    char    buffer[BUFSIZ];
    struct bbcount *selected;

    estat = signal (SIGEMT, sigser);
    hstat = signal (SIGHUP, hupser);
    istat = signal (SIGINT, SIG_IGN);
    qstat = signal (SIGQUIT, SIG_IGN);
    tstat = signal (SIGTERM, sigser);

    while ((n = read (pd, buffer, sizeof buffer)) == NOTOK && errno == EINTR)
	continue;
    (void) close (pd);
    (void) pidXwait (child_id, mshproc);

    (void) signal (SIGEMT, estat);
    (void) signal (SIGHUP, hstat);
    (void) signal (SIGINT, istat);
    (void) signal (SIGQUIT, qstat);
    (void) signal (SIGTERM, tstat);

    if (n <= 0)
	return;
    if (sscanf (buffer, "%d %d", &i, &j) != 2 || i <= 0 || j <= 0)
	return;

    if ((selected = seek_count (bbc, bb -> bb_name)) == NULL) {
	bbc = add_count (bbc, bb -> bb_name, i);
	changed++;
    }
    else
	if (archivesw) {
	    if (i > selected -> count) {
		selected -> count = i;
		changed++;
	    }
	}
	else {
	    if (bb -> bb_maxima > j && i >= j)/* bbl... */
		i = bb -> bb_maxima;
	    if (i != selected -> count) {
		selected -> count = i;
		changed++;
	    }
	}
}


/* ARGSUSED */

TYPESIG	sigser (i)
int     i;
{
#ifndef	BSD42
    (void) signal (i, sigser);
#endif	not BSD42
    quitting++;
}


/* ARGSUSED */

TYPESIG	hupser (i)
int	i;
{
    static int armed = 0;

#ifndef	BSD42
    (void) signal (i, hupser);
#endif

    if (!armed++)		/* tick tock... */
	alarm ((unsigned int) 30);
}

/*  */

rcinit (rc)
register char  *rc;
{
    int     state;
    register char  *cp;
    char    key[NAMESZ],
            value[BUFSIZ];
    register FILE  *bbrc;

    if ((cp = rc ? rc : getenv ("MHBBRC")) && *cp) {
	rcfile = path (cp, TFILE);
	if (*cp != '/')
	    (void) m_putenv ("MHBBRC", rcfile);
    }
    else
	rcfile = concat (mypath, "/", RCFILE, NULLCP);

    if ((bbrc = fopen (rcfile, "r")) == NULL)
	if (cp && *cp)
	    adios (rcfile, "unable to read");
	else
	    return;

    for (state = FLD;;) {
	switch (state = m_getfld (state, key, value, sizeof value, bbrc)) {
	    case FLD: 
	    case FLDEOF: 
		make_lower (key, key);
		bbc = add_count (bbc, key, atoi (value));
		if (state == FLDEOF)
		    break;
		continue;

	    default: 
		admonish (NULLCP, "bad format: %s", rcfile);
	    case FILEEOF:
		break;
	}

	break;
    }

    if (ferror (bbrc) && !feof (bbrc))
	admonish (rcfile, "error reading");
    (void) fclose (bbrc);
}

/*  */

rcend () {
    TYPESIG (*hstat) (), (*istat) (), (*qstat) (), (*tstat) ();
    register FILE *bbrc;

    if (!changed)
	return;

    hstat = signal (SIGHUP, SIG_IGN);
    istat = signal (SIGINT, SIG_IGN);
    qstat = signal (SIGQUIT, SIG_IGN);
    tstat = signal (SIGTERM, SIG_IGN);

    if ((bbrc = fopen (rcfile, "w")) == NULL)
	adios (rcfile, "unable to write");
    rcput (bbrc, bbc);

    if (ferror (bbrc))
	adios (rcfile, "error writing");
    (void) fclose (bbrc);

    (void) signal (SIGHUP, hstat);
    (void) signal (SIGINT, istat);
    (void) signal (SIGQUIT, qstat);
    (void) signal (SIGTERM, tstat);

    changed = 0;
}


rcput (bbrc, p)
register FILE *bbrc;
register struct bbcount *p;
{
    if (p == NULL)
	return;

    fprintf (bbrc, "%s: %d\n", p -> key, p -> count);
    rcput (bbrc, p -> left);
    rcput (bbrc, p -> right);
}

/*  */

#ifdef	SIGTSTP
static TYPESIG  tstpser (sig)
int	sig;
{
    int	    pid;
#if defined(BSD42) && !defined(WAITINT)
    union wait w;
#else
    int	w;
#endif

    rcend ();

#ifdef SVR4
    waitpid(tstpid, &w, WUNTRACED);
#else
    while ((pid = wait3 (&w, WUNTRACED, (struct rusage *) 0)) != NOTOK
	    && pid != tstpid)
	continue;
#endif

    (void) signal (SIGTSTP, SIG_DFL);
#ifdef	BSD42
    (void) sigsetmask (sigblock (0) & ~sigmask (SIGTSTP));
#endif	BSD42

    (void) kill (getpid (), sig);

#ifdef	BSD42
    (void) sigblock (sigmask (SIGTSTP));
#endif	BSD42
    (void) signal (SIGTSTP, tstpser);
}
#endif	SIGTSTP

/*  */
static	void	bbreset (bb, i)
register struct bboard  *bb;
int i;
{
    struct bbcount *selected;

    bb -> bb_count = i;
    if ((selected = seek_count (bbc, bb -> bb_name)) == NULL)
	bbc = add_count (bbc, bb -> bb_name, i);
    else
	selected -> count = i;

    changed++;
}

struct bbcount *add_count (p, w, i)
register struct bbcount *p;
register char   *w;
int     i;
{
    int     cond;

    if (p == NULL) {
	p = (struct bbcount *) malloc (sizeof *p);
	if (p == NULL)
	    adios (NULLCP,"insufficient memory");
	p -> key = getcpy (w);
	p -> count = i;
	p -> left = p -> right = NULL;
    }
    else
	if ((cond = strcmp (w, p -> key)) < 0)
	    p -> left = add_count (p -> left, w, i);
	else
	    if (cond > 0)
		p -> right = add_count (p -> right, w, i);

    return p;
}


struct bbcount *seek_count (p, w)
register struct bbcount *p;
register char   *w;
{
    int     cond;

    if (p == NULL || (cond = strcmp (w, p -> key)) == 0)
	return p;
    else
	return seek_count (cond < 0 ? p -> left : p -> right, w);
}

/*  */

default_bboards () {
    register char  *cp,
                  **ap;
#ifdef	UCL
    register int    i = bbp;
#endif	UCL

    if (bbl != NULL)
	return;

    if (!archivesw && ((cp = m_find ("bboards")) != NULL)) {
#ifndef	BPOP
	for (ap = brkstring (cp = getcpy (cp), " ", "\n"); *ap; ap++)
#else	BPOP
	for (ap = getip (cp); *ap; ap++)
#endif	BPOP
#ifndef	UCL
	    add_bb (*ap, OK);
#else	UCL
	    bbs[bbp++] = *ap;
	bbs[bbp] = NULL;
	while (i < bbp)
	    add_bb (bbs[i++], OK);
#endif	UCL
#ifndef	BPOP
	free (cp);
#endif	not BPOP
	if (oops)
	    advise (NULLCP, "please fix the %s: entry in your %s file",
		"bboards", mh_profile);
    }
    else {
#ifdef	UCL
	bbs[bbp++] = "system";
	bbs[bbp] = NULL;
#endif	UCL
#ifndef	NNTP
	add_bb ("system", NOTOK);
#else	NNTP
	add_bb ("general", NOTOK);
#ifdef	UCI
	add_bb ("ics.system", NOTOK);
	add_bb ("ics.general", NOTOK);
#endif	UCI
#endif	NNTP
    }
#ifdef	UCL
    bbs[bbp] = NULL;
#endif	UCL

    if (bbl == NULL)
	done (1);
}

/*  */

add_bb (s, hush)
register char   *s;
int     hush;
{
    register struct bboard  *bb;
    static struct bboard   *tail = NULL;

    make_lower (s, s);
    if ((bb = getbbaux (s)) == NULL)
	if (hush == OK)
	    return;
	else
	    adios (NULLCP, "no such bboard as '%s'", s);

    if (bb -> bb_flags & BB_SEEN) {
	if (hush == OK) {
	    admonish (NULLCP, "duplicate bboard '%s'", s);
	    oops++;
	}
	return;
    }
    bb -> bb_flags |= BB_SEEN;

    if (tail != NULL)
	tail -> bb_link = bb;
    if (bbl == NULL)
	bbl = bb;
    tail = bb;
}

/*  */

#ifdef	BPOP
static struct bboard   *Bhead = NULL;
static struct bboard   *Btail = NULL;

static int xtnd2 (s)
char   *s;
{
    int     maxima;
    char    name[BUFSIZ];
    register struct bboard *bb;

    if (sscanf (s, "%s %d", name, &maxima) != 2)
	adios (NULLCP, "XTND2 botch: %s", s);

    if ((bb = (struct bboard   *) calloc (1, sizeof *bb)) == NULL)
	adios (NULLCP, "insufficient memory");
    bb -> bb_name = getcpy (name);
#ifdef	NNTP
    if (index(name, '.')) {
	char *cp;
	bb -> bb_aka = getip (name);
	for (cp = *bb -> bb_aka; *cp; cp++)
	    if (*cp == '.')
		*cp = '-';
    } else {
#endif
    if ((bb -> bb_aka = (char **) calloc (1, sizeof *bb -> bb_aka)) == NULL)
	adios (NULLCP, "insufficient memory");
    *bb -> bb_aka = NULL;
#ifdef	NNTP
    }
#endif	NNTP
    bb -> bb_file = bb -> bb_archive = bb -> bb_info = bb -> bb_map = "";
    bb -> bb_passwd = "";
#ifndef	NNTP
    if ((bb -> bb_leader = (char **) calloc (1, sizeof *bb -> bb_leader))
	    == NULL)
	adios (NULLCP, "insufficient memory");
    *bb -> bb_leader = NULL;
#else	NNTP
    bb -> bb_leader = getip ("usenet");
#endif	NNTP
    bb -> bb_addr = bb -> bb_request = bb -> bb_relay = "";
    if ((bb -> bb_dist = (char **) calloc (1, sizeof *bb -> bb_dist)) == NULL)
	adios (NULLCP, "insufficient memory");
    *bb -> bb_dist = NULL;
    bb -> bb_flags = BB_REMOTE;
    bb -> bb_count = 0;
    bb -> bb_maxima = maxima;
    bb -> bb_date = "";
    bb -> bb_next = bb -> bb_link = bb -> bb_chain = NULL;

    if (Btail != NULL)
	Btail -> bb_chain = bb;
    if (Bhead == NULL)
	Bhead = bb;
    Btail = bb;

    return OK;
}

/*  */

static int xtnd3 (s)
char   *s;
{
    static int  bbs_int = 0;
    static struct bboard   *bb;

    switch (bbs_int++) {
	case 0: 
	    for (bb = Bhead; bb; bb = bb -> bb_chain)
		if (strcmp (bb -> bb_name, s) == 0)
		    break;
	    if (bb == NULL)
		adios (NULLCP, "XTND3 botch");

	    free (bb -> bb_name);
	    bb -> bb_name = getcpy (s);
	    break;
	case 1: 
	    if (bb -> bb_aka)
		free ((char *) bb -> bb_aka);
	    bb -> bb_aka = getip (s);
	    break;
	case 2: 
	    bb -> bb_file = getcpy (s);
	    break;
	case 3: 
	    bb -> bb_archive = getcpy (s);
	    break;
	case 4: 
	    bb -> bb_info = getcpy (s);
	    break;
	case 5: 
	    bb -> bb_map = getcpy (s);
	    break;
	case 6: 
	    bb -> bb_passwd = getcpy (s);
	    break;
	case 7: 
	    if (bb -> bb_leader)
		free ((char *) bb -> bb_leader);
	    bb -> bb_leader = getip (s);
	    break;
	case 8: 
	    bb -> bb_addr = getcpy (s);
	    break;
	case 9: 
	    bb -> bb_request = getcpy (s);
	    break;
	case 10: 
	    bb -> bb_relay = getcpy (s);
	    break;
	case 11: 
	    if (bb -> bb_dist)
		free ((char *) bb -> bb_dist);
	    bb -> bb_dist = getip (s);
	    break;
	case 12: 
	    bb -> bb_flags = bb -> bb_maxima = 0;
	    (void) sscanf (s, "%o %d", &bb -> bb_flags, &bb -> bb_maxima);
	    bb -> bb_flags |= BB_REMOTE;
	    break;
	case 13: 
	    bb -> bb_date = getcpy (s);
	    bbs_int = 0;
	    break;
    }

    return OK;
}


static char **getip (s)
char   *s;
{
    register char **ap,
                  **p,
                  **q;

    for (p = ap = brkstring (getcpy (s), " ", "\n"); *p; p++)
	continue;

    q = (char **) calloc ((unsigned) (p - ap + 1), sizeof *q);
    if (q == NULL)
	adios (NULLCP, "insufficient memory");

    for (p = ap, ap = q; *p; *q++ = *p++)
	continue;
    *q = NULL;

    return ap;
}

/*  */

static struct bboard   *rover = NULL;

struct bboard  *getbbpop () {
    int     snoop;
    char   *cp,
           *pass = NULL;
    register struct bboard *bb;

    if (didpop != NOTOK && ((bb = getbbent ()) || !host))
	return bb;

    if (Bhead == NULL) {
	snoop = (cp = getenv ("MHPOPDEBUG")) && *cp;
	if (rpop) {
	    if (user == NULL)
		user = getusr ();
	    pass = getusr ();
	}
	else
	    if (strcmp (user, popbbuser) == 0)
		pass = user;
	    else
		ruserpass (host, &user, &pass);
	if (didpop != NOTOK)
	    didpop = DONE;

	if (pop_init (host, user, pass, snoop, rpop) == NOTOK)
	    adios (NULLCP, "%s", response);
	if (rpop)
	    (void) setuid (getuid ());
	if (pop_xtnd (xtnd2, "bboards") == NOTOK)
	    adios (NULLCP, "%s", response);
	if (topicsw && verbosw)	/* could optimize here */
	    for (bb = Bhead; bb; bb = bb -> bb_chain)
		if (pop_xtnd (xtnd3, "x-bboards %s", bb -> bb_name) == NOTOK)
		    adios (NULLCP, "%s", response);
	rover = Bhead;
    }

    if (bb = rover)
	rover = rover -> bb_chain;
    return bb;
}

#define	getbbent	getbbpop
#endif	BPOP

/*  */

struct bboard *getbbaux (s)
register char	*s;
{
#ifdef	BPOP
    int	    nlatch = host ? 1 : 0;
#endif	BPOP
    register char  **ap;
    register struct bbcount *selected;
    register struct bboard *bb;
    static struct bboard   *head = NULL,
                           *tail = NULL;

    for (bb = head; bb; bb = bb -> bb_next) {
	if (strcmp (bb -> bb_name, s) == 0)
	    return bb;
	for (ap = bb -> bb_aka; *ap; ap++)
	    if (strcmp (*ap, s) == 0)
		return bb;
    }

#ifdef	BPOP
one_more_time: ;
#endif	BPOP
    while (bb = getbbent ()) {
	if ((selected = seek_count (bbc, bb -> bb_name)) != NULL)
	    bb -> bb_count = selected -> count;

#ifdef	BPOP
	if (!(bb -> bb_flags & BB_REMOTE))
#endif	BPOP
	if ((bb = getbbcpy (bb)) == NULL)
	    adios (NULLCP, "insufficient memory");
	if (tail != NULL)
	    tail -> bb_next = bb;
	if (head == NULL)
	    head = bb;
	tail = bb;

	if (strcmp (bb -> bb_name, s) == 0) {
found_it: ;
	    bb -> bb_flags &= ~BB_SEEN;
	    return bb;
	}
	for (ap = bb -> bb_aka; *ap; ap++)
	    if (strcmp (*ap, s) == 0)
		goto found_it;
    }

#ifdef	BPOP
    if (nlatch && pop_xtnd (xtnd2, "bboards %s", s) != NOTOK) {
	rover = Bhead;
	nlatch = 0;
	goto one_more_time;
    }
#endif	BPOP

    return NULL;
}


struct bboard *getbbvis () {
    register struct bboard *bb;

    while (bb = getbbent ())
	if (!(bb -> bb_flags & BB_INVIS)
		&& (access (bb -> bb_file, 04) != NOTOK || errno != EACCES))
	    break;

    return bb;
}