43BSD/etc/named/db_load.c - annotate

Return to db_load.c CVS log
Up to [CSRG BSD Unix] / 43BSD / etc / named
Annotation of 43BSD/etc/named/db_load.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)db_load.c  4.3 (Berkeley) 5/30/86";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1986 Regents of the University of California
        !             7:  *     All Rights Reserved
        !             8:  */
        !             9: 
        !            10: /*
        !            11:  * Load data base from ascii backupfile.  Format similar to RFC 883.
        !            12:  */
        !            13: 
        !            14: #include <sys/types.h>
        !            15: #include <sys/time.h>
        !            16: #include <netinet/in.h>
        !            17: #include <stdio.h>
        !            18: #include <syslog.h>
        !            19: #include <ctype.h>
        !            20: #include <netdb.h>
        !            21: #include <arpa/nameser.h>
        !            22: #include "ns.h"
        !            23: #include "db.h"
        !            24: 
        !            25: extern char *index();
        !            26: 
        !            27: /*
        !            28:  * Map class and type names to number
        !            29:  */
        !            30: struct map {
        !            31:        char    token[8];
        !            32:        int     val;
        !            33: };
        !            34: 
        !            35: struct map m_class[] = {
        !            36:        "in",           C_IN,
        !            37:        "any",          C_ANY,
        !            38: };
        !            39: #define NCLASS (sizeof(m_class)/sizeof(struct map))
        !            40: 
        !            41: struct map m_type[] = {
        !            42:        "a",            T_A,
        !            43:        "ns",           T_NS,
        !            44:        "cname",        T_CNAME,
        !            45:        "soa",          T_SOA,
        !            46:        "mb",           T_MB,
        !            47:        "mg",           T_MG,
        !            48:        "mr",           T_MR,
        !            49:        "null",         T_NULL,
        !            50:        "wks",          T_WKS,
        !            51:        "ptr",          T_PTR,
        !            52:        "hinfo",        T_HINFO,
        !            53:        "minfo",        T_MINFO,
        !            54:        "mx",           T_MX,
        !            55:        "uinfo",        T_UINFO,
        !            56:        "uid",          T_UID,
        !            57:        "gid",          T_GID,
        !            58:        "any",          T_ANY,
        !            59: };
        !            60: #define NTYPE (sizeof(m_type)/sizeof(struct map))
        !            61: 
        !            62: /*
        !            63:  * Parser token values
        !            64:  */
        !            65: #define CURRENT        1
        !            66: #define DOT    2
        !            67: #define AT     3
        !            68: #define DNAME  4
        !            69: #define INCLUDE        5
        !            70: #define ORIGIN 6
        !            71: 
        !            72: int    lineno = 1;             /* current line number */
        !            73: 
        !            74: /*
        !            75:  * Load the database from 'filename'. Origin is appended to all domain
        !            76:  * names in the file.
        !            77:  */
        !            78: db_load(filename, in_origin, zone)
        !            79:        char *filename, *in_origin;
        !            80:        int zone;
        !            81: {
        !            82:        register char *cp;
        !            83:        register struct map *mp;
        !            84:        char domain[MAXDNAME];
        !            85:        char origin[MAXDNAME];
        !            86:        char buf[BUFSIZ];
        !            87:        char data[MAXDATA];
        !            88:        char *op;
        !            89:        int class, type, ttl;
        !            90:        struct databuf *dp;
        !            91:        FILE *fp;
        !            92:        int slineno, i;
        !            93:        long n;
        !            94: 
        !            95: #ifdef DEBUG
        !            96:        if (debug)
        !            97:                fprintf(ddt,"db_load(%s, %s, %d)\n", filename, in_origin, zone);
        !            98: #endif
        !            99: 
        !           100:        (void) strcpy(origin, in_origin);
        !           101:        if ((fp = fopen(filename, "r")) == NULL) {
        !           102:                syslog(LOG_ERR, "%s: %m", filename);
        !           103:                return (NODBFILE);
        !           104:        }
        !           105:        lineno = 1;
        !           106:        domain[0] = '\0';
        !           107:        class = C_IN;
        !           108:        while ((n = gettoken(fp)) != EOF) {
        !           109:                switch ((int)n) {
        !           110:                case INCLUDE:
        !           111:                        if (!getword(buf, sizeof(buf), fp)) /* file name */
        !           112:                                break;
        !           113:                        slineno = lineno;
        !           114:                        (void) db_load(buf, origin, zone);
        !           115:                        lineno = slineno;
        !           116:                        continue;
        !           117: 
        !           118:                case ORIGIN:
        !           119:                        (void) strcpy(buf, origin);
        !           120:                        if (!getword(origin, sizeof(origin), fp))
        !           121:                                break;
        !           122:                        makename(origin, buf);
        !           123:                        continue;
        !           124: 
        !           125:                case DNAME:
        !           126:                        if (!getword(domain, sizeof(domain), fp))
        !           127:                                break;
        !           128:                        n = strlen(domain) - 1;
        !           129:                        if (domain[n] == '.')
        !           130:                                domain[n] = '\0';
        !           131:                        else if (*origin) {
        !           132:                                (void) strcat(domain, ".");
        !           133:                                (void) strcat(domain, origin);
        !           134:                        }
        !           135:                        goto gotdomain;
        !           136: 
        !           137:                case AT:
        !           138:                        (void) strcpy(domain, origin);
        !           139:                        goto gotdomain;
        !           140: 
        !           141:                case DOT:
        !           142:                        domain[0] = '\0';
        !           143:                        /* fall thru ... */
        !           144:                case CURRENT:
        !           145:                gotdomain:
        !           146:                        if (!getword(buf, sizeof(buf), fp))
        !           147:                                break;
        !           148:                        cp = buf;
        !           149:                        if (isdigit(*cp)) {
        !           150:                                n = 0;
        !           151:                                do
        !           152:                                        n = n * 10 + (*cp++ - '0');
        !           153:                                while (isdigit(*cp));
        !           154:                                if (zone == 0) {
        !           155:                                    if (gettimeofday(&tt,
        !           156:                                        (struct timezone *)0) < 0)
        !           157:                                        syslog(LOG_ERR,
        !           158:                                           "gettimeofday failed: %m");
        !           159:                                        n += (long) tt.tv_sec;
        !           160:                                }
        !           161:                                ttl = n;
        !           162:                                if (!getword(buf, sizeof(buf), fp))
        !           163:                                        break;
        !           164:                        } else
        !           165:                                ttl = 0;
        !           166:                        for (mp = m_class; mp < m_class+NCLASS; mp++)
        !           167:                                if (!cistrcmp(buf, mp->token)) {
        !           168:                                        class = mp->val;
        !           169:                                        (void) getword(buf, sizeof(buf), fp);
        !           170:                                        break;
        !           171:                                }
        !           172:                        for (mp = m_type; mp < m_type+NTYPE; mp++)
        !           173:                                if (!cistrcmp(buf, mp->token)) {
        !           174:                                        type = mp->val;
        !           175:                                        goto fndtype;
        !           176:                                }
        !           177: #ifdef DEBUG
        !           178:                        if (debug)
        !           179:                                fprintf(ddt,"Unknown type: %s.\n", buf);
        !           180: #endif
        !           181:                        break;
        !           182:                fndtype:
        !           183:                        if (!getword(buf, sizeof(buf), fp))
        !           184:                                break;
        !           185: #ifdef DEBUG
        !           186:                        if (debug >= 3)
        !           187:                            fprintf(ddt,"d='%s',c=%d,t=%d, ttl=%d, data='%s'\n",
        !           188:                                        domain, class, type, ttl, buf);
        !           189: #endif
        !           190:                        /*
        !           191:                         * Convert the ascii data 'buf' to the proper format
        !           192:                         * based on the type and pack into 'data'.
        !           193:                         */
        !           194:                        switch (type) {
        !           195:                        case T_A:
        !           196:                                n = ntohl((u_long)inet_addr((char *)buf));
        !           197:                                putlong((u_long)n, data);
        !           198:                                n = sizeof(u_long);
        !           199:                                break;
        !           200: 
        !           201:                        case T_HINFO:
        !           202:                                n = strlen(buf);
        !           203:                                if (n > 255) {
        !           204:                                    syslog(LOG_WARNING, "CPU too large (%d)",n);
        !           205:                                    n = 255;
        !           206:                                }
        !           207:                                data[0] = n;
        !           208:                                bcopy(buf, (char *)data + 1, (int)n);
        !           209:                                n++;
        !           210:                                if (!getword(buf, sizeof(buf), fp))
        !           211:                                        break;
        !           212:                                i = strlen(buf);
        !           213:                                if (i > 255) {
        !           214:                                    syslog(LOG_WARNING, "OS too large (%d)", i);
        !           215:                                    i = 255;
        !           216:                                }
        !           217:                                data[n] = i;
        !           218:                                bcopy(buf, data + n + 1, i);
        !           219:                                n += i + 1;
        !           220:                                break;
        !           221: 
        !           222:                        case T_SOA:
        !           223:                        case T_MINFO:
        !           224:                                (void) strcpy(data, buf);
        !           225:                                makename(data, origin);
        !           226:                                cp = data + strlen(data) + 1;
        !           227:                                if (!getword(cp, sizeof(data) - (cp - data),fp))
        !           228:                                        break;
        !           229:                                makename(cp, origin);
        !           230:                                cp += strlen(cp) + 1;
        !           231:                                if (type == T_MINFO) {
        !           232:                                        n = cp - data;
        !           233:                                        break;
        !           234:                                }
        !           235:                                if (getnonblank(fp) != '(')
        !           236:                                        goto err;
        !           237:                                putlong((u_long)(zones[zone].z_serial =
        !           238:                                    getnum(fp)), cp);
        !           239:                                cp += sizeof(u_long);
        !           240:                                putlong((u_long)(zones[zone].z_refresh =
        !           241:                                    getnum(fp)), cp);
        !           242:                                cp += sizeof(u_long);
        !           243:                                putlong((u_long)(zones[zone].z_retry =
        !           244:                                    getnum(fp)), cp);
        !           245:                                cp += sizeof(u_long);
        !           246:                                putlong ((u_long)(zones[zone].z_expire =
        !           247:                                    getnum(fp)), cp);
        !           248:                                cp += sizeof(u_long);
        !           249:                                putlong ((u_long)(zones[zone].z_minimum =
        !           250:                                    getnum(fp)), cp);
        !           251:                                cp += sizeof(u_long);
        !           252:                                n = cp - data;
        !           253:                                if (getnonblank(fp) != ')')
        !           254:                                        goto err;
        !           255:                                endline(fp);
        !           256:                                break;
        !           257: 
        !           258:                        case T_UID:
        !           259:                        case T_GID:
        !           260:                                n = 0;
        !           261:                                cp = buf;
        !           262:                                while (isdigit(*cp))
        !           263:                                        n = n * 10 + (*cp++ - '0');
        !           264:                                if (cp == buf)
        !           265:                                        goto err;
        !           266:                                putlong((u_long)n, data);
        !           267:                                n = sizeof(long);
        !           268:                                break;
        !           269: 
        !           270:                        case T_WKS:
        !           271:                                /* Address */
        !           272:                                n = ntohl((u_long)inet_addr((char *)buf));
        !           273:                                putlong((u_long)n, data);
        !           274:                                data[sizeof(u_long)] = getprotocol(fp);
        !           275:                                /* Protocol */
        !           276:                                n = sizeof(u_long) + sizeof(char);
        !           277:                                /* Services */
        !           278:                                n = getservices((int)n, data, fp);
        !           279:                                break;
        !           280: 
        !           281:                        case T_NS:
        !           282:                        case T_CNAME:
        !           283:                        case T_MB:
        !           284:                        case T_MG:
        !           285:                        case T_MR:
        !           286:                        case T_PTR:
        !           287:                                (void) strcpy(data, buf);
        !           288:                                makename(data, origin);
        !           289:                                n = strlen(data) + 1;
        !           290:                                break;
        !           291: 
        !           292:                        case T_UINFO:
        !           293:                                cp = index(buf, '&');
        !           294:                                bzero(data, sizeof(data));
        !           295:                                if ( cp != NULL) {
        !           296:                                        (void) strncpy(data, buf, cp - buf);
        !           297:                                        op = index(domain, '.');
        !           298:                                        if ( op != NULL)
        !           299:                                            (void) strncat(data,
        !           300:                                                domain,op-domain);
        !           301:                                        else
        !           302:                                                (void) strcat(data, domain);
        !           303:                                        (void) strcat(data, ++cp);
        !           304:                                } else
        !           305:                                        (void) strcpy(data, buf);
        !           306:                                n = strlen(data) + 1;
        !           307:                                break;
        !           308:                        case T_MX:
        !           309:                                n = 0;
        !           310:                                cp = buf;
        !           311:                                while (isdigit(*cp))
        !           312:                                        n = n * 10 + (*cp++ - '0');
        !           313:                                /* catch bad values */
        !           314:                                if ((cp == buf) || (n & ~0xffff))
        !           315:                                        goto err;
        !           316: 
        !           317:                                putshort((u_short)n, data);
        !           318:                                cp = data + sizeof(u_short);
        !           319: 
        !           320:                                if (!getword(buf, sizeof(buf), fp))
        !           321:                                            break;
        !           322:                                (void) strcpy(cp,buf);
        !           323:                                makename(cp, origin);
        !           324:                                /* get pointer to place in data */
        !           325:                                cp += strlen(cp) +1;
        !           326: 
        !           327:                                /* now save length */
        !           328:                                n = (cp - data);
        !           329:                                break;
        !           330: 
        !           331:                        default:
        !           332:                                goto err;
        !           333:                        }
        !           334:                        dp = savedata(class, type, (u_long)ttl, data, (int)n);
        !           335:                        dp->d_zone = zone;
        !           336:                        if ((n = db_update(domain, dp, dp, DB_NODATA)) < 0) {
        !           337: #ifdef DEBUG
        !           338:                                if (debug && (n != DATAEXISTS))
        !           339:                                        fprintf(ddt,"update failed\n");
        !           340: #endif
        !           341:                        }
        !           342:                        continue;
        !           343:                }
        !           344:        err:
        !           345:                syslog(LOG_ERR, "%s: line %d: database format error (%s)",
        !           346:                        filename, lineno, buf);
        !           347:                (void) fclose(fp);
        !           348:                return (-1);
        !           349:        }
        !           350:        (void) fclose(fp);
        !           351:        return (OK);
        !           352: }
        !           353: 
        !           354: int gettoken(fp)
        !           355:        register FILE *fp;
        !           356: {
        !           357:        register int c;
        !           358:        char op[32];
        !           359: 
        !           360:        for (;;) {
        !           361:                c = getc(fp);
        !           362:        top:
        !           363:                switch (c) {
        !           364:                case EOF:
        !           365:                        return (EOF);
        !           366: 
        !           367:                case '$':
        !           368:                        if (!getword(op, sizeof(op), fp))
        !           369:                                return (EOF);
        !           370:                        if (!cistrcmp("include", op))
        !           371:                                return (INCLUDE);
        !           372:                        if (!cistrcmp("origin", op))
        !           373:                                return (ORIGIN);
        !           374:                        printf("Unknown $ option: %s\n", op);
        !           375:                        /* fall through... */
        !           376: 
        !           377:                case ';':
        !           378:                        while ((c = getc(fp)) != EOF && c != '\n')
        !           379:                                ;
        !           380:                        goto top;
        !           381: 
        !           382:                case ' ':
        !           383:                case '\t':
        !           384:                        return (CURRENT);
        !           385: 
        !           386:                case '.':
        !           387:                        return (DOT);
        !           388: 
        !           389:                case '@':
        !           390:                        return (AT);
        !           391: 
        !           392:                case '\n':
        !           393:                        lineno++;
        !           394:                        continue;
        !           395: 
        !           396:                default:
        !           397:                        (void) ungetc(c, fp);
        !           398:                        return (DNAME);
        !           399:                }
        !           400:        }
        !           401: }
        !           402: 
        !           403: /*
        !           404:  * Get next word, skipping blanks & comments.
        !           405:  */
        !           406: getword(buf, size, fp)
        !           407:        char *buf;
        !           408:        int size;
        !           409:        FILE *fp;
        !           410: {
        !           411:        register char *cp;
        !           412:        register int c;
        !           413: 
        !           414:        for (cp = buf; (c = getc(fp)) != EOF; ) {
        !           415:                if (isspace(c)) {
        !           416:                        if (c == '\n')
        !           417:                                lineno++;
        !           418:                        if (cp != buf)
        !           419:                                break;
        !           420:                        continue;
        !           421:                }
        !           422:                if (c == ';') {
        !           423:                        while ((c = getc(fp)) != EOF && c != '\n')
        !           424:                                ;
        !           425:                        if (c == '\n')
        !           426:                                lineno++;
        !           427:                        if (cp != buf)
        !           428:                                break;
        !           429:                        continue;
        !           430:                }
        !           431:                if (c == '"') {
        !           432:                        while ((c = getc(fp)) != EOF && c != '"' && c != '\n') {
        !           433:                                if (c == '\\') {
        !           434:                                        if ((c = getc(fp)) == EOF)
        !           435:                                                c = '\\';
        !           436:                                        if (c == '\n')
        !           437:                                                lineno++;
        !           438:                                }
        !           439:                                if (cp >= buf+size-1)
        !           440:                                        break;
        !           441:                                *cp++ = c;
        !           442:                        }
        !           443:                        if (c == '\n') {
        !           444:                                lineno++;
        !           445:                                break;
        !           446:                        }
        !           447:                        continue;
        !           448:                }
        !           449:                if (c == '\\') {
        !           450:                        if ((c = getc(fp)) == EOF)
        !           451:                                c = '\\';
        !           452:                        if (c == '\n')
        !           453:                                lineno++;
        !           454:                }
        !           455:                if (cp >= buf+size-1)
        !           456:                        break;
        !           457:                *cp++ = c;
        !           458:        }
        !           459:        *cp = '\0';
        !           460:        return (cp != buf);
        !           461: }
        !           462: 
        !           463: getw_b_nl(buf, size, fp)
        !           464:        char *buf;
        !           465:        int size;
        !           466:        FILE *fp;
        !           467: {
        !           468:        register char *cp;
        !           469:        register int c;
        !           470: 
        !           471:        for (cp = buf; (c = getc(fp)) != EOF; ) {
        !           472:                if (isspace(c)) {
        !           473:                        if (c == '\n') {
        !           474:                                *cp = '\0';
        !           475:                                return (0);
        !           476:                        }
        !           477:                        if (cp != buf)
        !           478:                                break;
        !           479:                        continue;
        !           480:                }
        !           481:                if (c == ';') {
        !           482:                        while ((c = getc(fp)) != EOF && c != '\n')
        !           483:                                ;
        !           484:                        if (c == '\n')
        !           485:                                lineno++;
        !           486:                        if (cp != buf)
        !           487:                                break;
        !           488:                        continue;
        !           489:                }
        !           490:                if (cp >= buf+size-1)
        !           491:                        break;
        !           492:                *cp++ = c;
        !           493:        }
        !           494:        *cp = '\0';
        !           495:        return (cp != buf);
        !           496: }
        !           497: 
        !           498: getnum(fp)
        !           499:        FILE *fp;
        !           500: {
        !           501:        register int c, n;
        !           502:        int seendigit = 0;
        !           503:        int seendecimal = 0;
        !           504: 
        !           505:        for (n = 0; (c = getc(fp)) != EOF; ) {
        !           506:                if (isspace(c)) {
        !           507:                        if (c == '\n')
        !           508:                                lineno++;
        !           509:                        if (seendigit)
        !           510:                                break;
        !           511:                        continue;
        !           512:                }
        !           513:                if (c == ';') {
        !           514:                        while ((c = getc(fp)) != EOF && c != '\n')
        !           515:                                ;
        !           516:                        if (c == '\n')
        !           517:                                lineno++;
        !           518:                        if (seendigit)
        !           519:                                break;
        !           520:                        continue;
        !           521:                }
        !           522:                if (!isdigit(c)) {
        !           523:                        if (c != '.') {
        !           524:                                syslog(LOG_ERR, "line %d: expected a number",
        !           525:                                lineno);
        !           526:                                exit(1);
        !           527:                        }
        !           528:                        if (!seendigit)
        !           529:                                n = 1;
        !           530:                        if (seendecimal) {
        !           531:                                syslog(LOG_ERR, "line %d: expected a number",
        !           532:                                lineno);
        !           533:                                exit(1);
        !           534:                        } else {
        !           535:                                n = n * 1000 ;
        !           536:                                seendigit = 1;
        !           537:                                seendecimal = 1;
        !           538:                        }
        !           539:                        continue;
        !           540:                }
        !           541:                n = n * 10 + (c - '0');
        !           542:                seendigit = 1;
        !           543:        }
        !           544:        return (n);
        !           545: }
        !           546: 
        !           547: getnonblank(fp)
        !           548:        FILE *fp;
        !           549: {
        !           550:        register int c;
        !           551: 
        !           552:        while ( (c = getc(fp)) != EOF ) {
        !           553:                if (isspace(c)) {
        !           554:                        if (c == '\n')
        !           555:                                lineno++;
        !           556:                        continue;
        !           557:                }
        !           558:                if (c == ';') {
        !           559:                        while ((c = getc(fp)) != EOF && c != '\n')
        !           560:                                ;
        !           561:                        if (c == '\n')
        !           562:                                lineno++;
        !           563:                        continue;
        !           564:                }
        !           565:                return(c);
        !           566:        }
        !           567:        syslog(LOG_ERR, "line %d: unexpected EOF", lineno);
        !           568:        return (EOF);
        !           569: }
        !           570: 
        !           571: /*
        !           572:  * Take name and fix it according to following rules:
        !           573:  * "." means root.
        !           574:  * "@" means current origin.
        !           575:  * "name." means no changes.
        !           576:  * "name" means append origin.
        !           577:  */
        !           578: makename(name, origin)
        !           579:        char *name, *origin;
        !           580: {
        !           581:        int n;
        !           582: 
        !           583:        if (origin[0] == '.')
        !           584:                origin++;
        !           585:        n = strlen(name);
        !           586:        if (n == 1) {
        !           587:                if (name[0] == '.') {
        !           588:                        name[0] = '\0';
        !           589:                        return;
        !           590:                }
        !           591:                if (name[0] == '@') {
        !           592:                        (void) strcpy(name, origin);
        !           593:                        return;
        !           594:                }
        !           595:        }
        !           596:        if (n > 0) {
        !           597:                if (name[n - 1] == '.')
        !           598:                        name[n - 1] = '\0';
        !           599:                else if (origin[0] != '\0') {
        !           600:                        name[n] = '.';
        !           601:                        (void) strcpy(name + n + 1, origin);
        !           602:                }
        !           603:        }
        !           604: }
        !           605: 
        !           606: endline(fp)
        !           607:      register FILE *fp;
        !           608: {
        !           609:      register int c;
        !           610:      while (c = getc(fp))
        !           611:        if ((c == EOF) || (c == '\n')) {
        !           612:            (void) ungetc(c,fp);
        !           613:            break;
        !           614:        }
        !           615: }
        !           616: 
        !           617: #define MAXPORT 256
        !           618: #define MAXLEN 24
        !           619: 
        !           620: getprotocol(fp)
        !           621:     FILE *fp;
        !           622: {
        !           623:        int  k;
        !           624:        char b[MAXLEN];
        !           625:        struct protoent *proto;
        !           626: 
        !           627:        (void) getword(b, sizeof(b), fp);
        !           628:                
        !           629:        proto = getprotobyname(b);      
        !           630:        if(proto == NULL) {
        !           631:                k = 0;
        !           632:                (void) sscanf(b,"%d",&k);
        !           633:        }
        !           634:        else
        !           635:                k = proto->p_proto;
        !           636:        return(k);
        !           637: }
        !           638: 
        !           639: int getservices(n, data, fp)
        !           640:     int n;
        !           641:     char *data;
        !           642:     FILE *fp;
        !           643: {
        !           644:        int j, ch;
        !           645:        u_short k;
        !           646:        int maxl;
        !           647:        int bracket, eol;
        !           648:        char b[MAXLEN];
        !           649:        char bm[MAXPORT/8];
        !           650:        struct servent *service;
        !           651: 
        !           652:        for (j = 0; j < MAXPORT/8; j++)
        !           653:                bm[j] = 0;
        !           654:        maxl = 0;
        !           655:        bracket = eol = 0;
        !           656:        while (1) {
        !           657:                if (!getw_b_nl(b, sizeof(b), fp) && (!bracket)) {
        !           658:                        if (strlen(b) == 0)
        !           659:                                break;
        !           660:                        eol++;
        !           661:                }       
        !           662:                if ( b[0] == '(') {
        !           663:                        bracket++;
        !           664:                        continue;
        !           665:                }
        !           666:                if ( b[0] == ')') {
        !           667:                        bracket = 0;
        !           668:                        while ((ch = getc(fp)) != EOF && ch != '\n')
        !           669:                                ;
        !           670:                        break;
        !           671:                }
        !           672:                service = getservbyname(b, (char *)NULL);
        !           673:                if (service == NULL) {
        !           674:                        k=0;
        !           675:                        (void) sscanf(b,"%d",&k);
        !           676:                        if (k == 0)
        !           677:                                continue;
        !           678:                }
        !           679:                else
        !           680:                        k = ntohs((u_short)service->s_port);
        !           681:                if ((k < MAXPORT) && (k)) {
        !           682:                        bm[k/8] |= (0x80>>(k%8));
        !           683:                        if (k > maxl)
        !           684:                                maxl=k;
        !           685:                }
        !           686:                else
        !           687:                        syslog(LOG_WARNING,"port no.(%d) too big\n",k);
        !           688:                if(eol)
        !           689:                        break;
        !           690:        }
        !           691:        maxl = maxl/8+1;
        !           692:        bcopy(bm, data+n, maxl);
        !           693:        return(maxl+n);
        !           694: }
unix.superglobalmegacorp.com
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.