Return to active.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / nntp / server

Annotation of 43BSD/contrib/nntp/server/active.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char    *sccsid = "@(#)active.c 1.2     (Berkeley) 3/20/86";
                      3: #endif
                      4: 
                      5: #include "common.h"
                      6: 
                      7: /*
                      8:  * Routines to deal with the active file
                      9:  */
                     10: 
                     11: extern int     act_cmp();
                     12: 
                     13: /*
                     14:  * read_groups -- read the active file into memory, sort it,
                     15:  *     and return the number of newsgroups read in.
                     16:  *     If FASTFORK is true, this can be called by interrupt,
                     17:  *     and may have to free up the old storage.  We decide
                     18:  *     this by the fact that "num_groups" will be non-zero if
                     19:  *     we're here on an interrupt.
                     20:  *
                     21:  *     Parameters:     None.
                     22:  *
                     23:  *     Returns:        Number of newsgroups read into
                     24:  *                     memory.
                     25:  *                     Zero on error.
                     26:  *
                     27:  *     Side effects:   Reads newsgroups into "group_array"
                     28:  *                     and sorts them.
                     29:  */
                     30: 
                     31: read_groups()
                     32: {
                     33:        char            line[MAX_STRLEN];
                     34:        register int    i;
                     35:        register FILE   *act_fp;
                     36:        char            *malloc();
                     37: 
                     38:        i = 0;
                     39: 
                     40:        /* If we're here on an interrupt, free up all the */
                     41:        /* previous groups */
                     42: 
                     43:        if (num_groups != 0)
                     44:                for (i = 0; i < num_groups; ++i)
                     45:                        free(group_array[i]);
                     46: 
                     47:        act_fp = fopen(ACTIVE_FILE, "r");
                     48:        if (act_fp == NULL)
                     49:                return(0);
                     50: 
                     51:        while (i < MAX_GROUPS && fgets(line, sizeof(line), act_fp) != NULL) {
                     52:                if ((group_array[i] = malloc(strlen(line)+1)) == NULL) {
                     53:                        (void) fclose(act_fp);
                     54:                        return(0);
                     55:                }
                     56:                (void) strcpy(group_array[i++], line);
                     57:        }
                     58: 
                     59:        if (i == MAX_GROUPS) {
                     60:                syslog(LOG_ERR, "read_active: active file >= %d groups", i);
                     61:                syslog(LOG_ERR, "warning: recompile with MAX_GROUPS larger");
                     62:        }
                     63: 
                     64:        (void) fclose(act_fp);
                     65: 
                     66:        qsort((char *) group_array, i, sizeof(char *), act_cmp);
                     67: 
                     68:        return(i);
                     69: }
                     70: 
                     71: 
                     72: act_cmp(ptr1, ptr2)
                     73: char    **ptr1, **ptr2;
                     74: {
                     75:        return(strcmp(*ptr1, *ptr2));
                     76: }
                     77: 
                     78: /*
                     79:  * find_group -- find a given newsgroup and return
                     80:  *     the low and high message numbers in the group
                     81:  *     (space provided by user).
                     82:  *
                     83:  *     Parameters:     "group" is the name of the group
                     84:  *                     we're searching for.
                     85:  *                     "num_groups" is the total number
                     86:  *                     of groups in the group array.
                     87:  *                     "low_msg" and "high_msg" are
                     88:  *                     pointers to where we're supposed
                     89:  *                     to put the low and high message numbers.
                     90:  *
                     91:  *     Returns:        0 if all goes well,
                     92:  *                     -1 if we can't find the group.
                     93:  *
                     94:  *     Side effects:   None.
                     95:  */
                     96: 
                     97: find_group(group, num_groups, low_msg, high_msg)
                     98: char   *group;
                     99: int    num_groups;
                    100: int    *low_msg, *high_msg;
                    101: {
                    102:        char    kludgebuf[MAX_STRLEN];
                    103:        int     cond;
                    104:        int     low, high;
                    105:        int     length;
                    106:        register int mid;
                    107: 
                    108:        low = 0;
                    109:        high = num_groups-1;
                    110:        (void) strcpy(kludgebuf, group);
                    111:        (void) strcat(kludgebuf, " ");
                    112:        length = strlen(kludgebuf);
                    113: 
                    114:        while (low <= high) {
                    115:                mid = (low + high) / 2;
                    116:                if ((cond = strncmp(kludgebuf, group_array[mid], length)) < 0)
                    117:                        high = mid - 1;
                    118:                else if (cond > 0)
                    119:                        low = mid + 1;
                    120:                else {
                    121:                        (void) sscanf(group_array[mid], "%s %d %d",
                    122:                                kludgebuf, high_msg, low_msg);
                    123:                        return(0);
                    124:                }
                    125:        }
                    126:        return(-1);
                    127: }

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