![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_dump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named|
Return to db_dump.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named |
1.1 ! root 1: /* ! 2: * Copyright (c) 1986 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that the above copyright notice and this paragraph are ! 7: * duplicated in all such forms and that any documentation, ! 8: * advertising materials, and other materials related to such ! 9: * distribution and use acknowledge that the software was developed ! 10: * by the University of California, Berkeley. The name of the ! 11: * University may not be used to endorse or promote products derived ! 12: * from this software without specific prior written permission. ! 13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 16: */ ! 17: ! 18: #ifndef lint ! 19: static char sccsid[] = "@(#)db_dump.c 4.21 (Berkeley) 6/18/88"; ! 20: #endif /* not lint */ ! 21: ! 22: #include <sys/param.h> ! 23: #include <sys/time.h> ! 24: #include <sys/stat.h> ! 25: #include <netinet/in.h> ! 26: #include <netdb.h> ! 27: #include <stdio.h> ! 28: #include <syslog.h> ! 29: #include <arpa/nameser.h> ! 30: #include "ns.h" ! 31: #include "db.h" ! 32: ! 33: extern char *p_type(), *p_class(); ! 34: ! 35: #ifdef DUMPFILE ! 36: char *dumpfile = DUMPFILE; ! 37: #else ! 38: char *dumpfile = "/usr/tmp/named_dump.db"; ! 39: #endif ! 40: ! 41: extern char *cache_file; ! 42: ! 43: /* ! 44: * Dump current cache in a format similar to RFC 883. ! 45: * ! 46: * We try to be careful and determine whether the operation succeeded ! 47: * so that the new cache file can be installed. ! 48: */ ! 49: ! 50: #define DB_ROOT_TIMBUF 3600 ! 51: ! 52: doachkpt() ! 53: { ! 54: extern int errno; ! 55: FILE *fp; ! 56: char tmpcheckfile[256]; ! 57: ! 58: /* nowhere to checkpoint cache... */ ! 59: if (cache_file == NULL) { ! 60: #ifdef DEBUG ! 61: if (debug >= 3) ! 62: fprintf(ddt,"doachkpt(to where?)\n"); ! 63: #endif ! 64: return; ! 65: } ! 66: ! 67: #ifdef DEBUG ! 68: if (debug >= 3) ! 69: fprintf(ddt,"doachkpt()\n"); ! 70: #endif ! 71: ! 72: (void) sprintf(tmpcheckfile, "%s.chk", cache_file); ! 73: if ((fp = fopen(tmpcheckfile, "w")) == NULL) { ! 74: #ifdef DEBUG ! 75: if (debug >= 3) ! 76: fprintf(ddt,"doachkpt(can't open %s for write)\n", tmpcheckfile); ! 77: #endif ! 78: return; ! 79: } ! 80: ! 81: (void) gettime(&tt); ! 82: fprintf(fp, "; Dumped at %s", ctime(&tt.tv_sec)); ! 83: fflush(fp); ! 84: if (ferror(fp)) { ! 85: #ifdef DEBUG ! 86: if (debug >= 3) ! 87: fprintf(ddt,"doachkpt(write to checkpoint file failed)\n"); ! 88: #endif ! 89: return; ! 90: } ! 91: ! 92: if (fcachetab != NULL) { ! 93: int n; ! 94: if ((n = scan_root(hashtab)) < MINROOTS) { ! 95: syslog(LOG_ERR, "%d root hints... (too low)", n); ! 96: fprintf(fp, "; ---- Root hint cache dump ----\n"); ! 97: (void) db_dump(fcachetab, fp, DB_Z_CACHE, ""); ! 98: } ! 99: } ! 100: ! 101: if (hashtab != NULL) { ! 102: fprintf(fp, "; ---- Cache dump ----\n"); ! 103: if (db_dump(hashtab, fp, DB_Z_CACHE, "") == NODBFILE) { ! 104: #ifdef DEBUG ! 105: if (debug >= 3) ! 106: fprintf(ddt,"doachkpt(checkpoint failed)\n"); ! 107: #endif ! 108: (void) fclose(fp); ! 109: return; ! 110: } ! 111: } ! 112: ! 113: (void) fsync(fileno(fp)); ! 114: if (fclose(fp) == EOF) { ! 115: #ifdef DEBUG ! 116: if (debug >= 3) ! 117: fprintf(ddt,"doachkpt(close failed)\n"); ! 118: #endif ! 119: return; ! 120: } ! 121: ! 122: if (rename(tmpcheckfile, cache_file)) { ! 123: #ifdef DEBUG ! 124: if (debug >= 3) ! 125: fprintf(ddt,"doachkpt(install %s to %s failed, %d)\n", ! 126: tmpcheckfile,cache_file, errno); ! 127: #endif ! 128: } ! 129: } ! 130: ! 131: /* ! 132: * What we do is scan the root hint cache to make sure there are at least ! 133: * MINROOTS root pointers with non-0 TTL's so that the checkpoint will not ! 134: * lose the root. Failing this, all pointers are written out w/ TTL ~0 ! 135: * (root pointers timed out and prime_cache() not done or failed). ! 136: */ ! 137: #define TIMBUF 300 ! 138: ! 139: int ! 140: scan_root(htp) ! 141: struct hashbuf *htp; ! 142: { ! 143: register struct databuf *dp; ! 144: register struct namebuf *np; ! 145: struct timeval soon; ! 146: int roots = 0; ! 147: ! 148: #ifdef DEBUG ! 149: if (debug) ! 150: fprintf(ddt,"scan_root(0x%x)\n", htp); ! 151: #endif ! 152: ! 153: /* metric by which we determine whether a root NS pointer is still */ ! 154: /* valid (will be written out if we do a dump). we also add some */ ! 155: /* time buffer for safety... */ ! 156: (void) gettime(&soon); ! 157: soon.tv_sec += TIMBUF; ! 158: ! 159: for (np = htp->h_tab[0]; np != NULL; np = np->n_next) { ! 160: if (np->n_dname[0] == '\0') { ! 161: dp = np->n_data; ! 162: while (dp != NULL) { ! 163: if (dp->d_type == T_NS && ! 164: dp->d_ttl > soon.tv_sec) { ! 165: roots++; ! 166: if (roots >= MINROOTS) ! 167: return (roots); ! 168: } ! 169: dp = dp->d_next; ! 170: } ! 171: } ! 172: } ! 173: return (roots); ! 174: } ! 175: ! 176: #ifdef notdef ! 177: mark_cache(htp, ttl) ! 178: struct hashbuf *htp; ! 179: int ttl; ! 180: { ! 181: register struct databuf *dp; ! 182: register struct namebuf *np; ! 183: struct namebuf **npp, **nppend; ! 184: struct timeval soon; ! 185: ! 186: #ifdef DEBUG ! 187: if (debug) ! 188: fprintf(ddt,"mark_cache()\n"); ! 189: #endif ! 190: ! 191: (void) gettime(&soon); ! 192: soon.tv_sec += TIMBUF; ! 193: ! 194: npp = htp->h_tab; ! 195: nppend = npp + htp->h_size; ! 196: while (npp < nppend) { ! 197: for (np = *npp++; np != NULL; np = np->n_next) { ! 198: if (np->n_data == NULL) ! 199: continue; ! 200: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 201: if (dp->d_ttl < soon.tv_sec) ! 202: dp->d_ttl = ttl; ! 203: } ! 204: } ! 205: } ! 206: ! 207: npp = htp->h_tab; ! 208: nppend = npp + htp->h_size; ! 209: while (npp < nppend) { ! 210: for (np = *npp++; np != NULL; np = np->n_next) { ! 211: if (np->n_hash == NULL) ! 212: continue; ! 213: mark_cache(np->n_hash, ttl); ! 214: } ! 215: } ! 216: } ! 217: #endif notdef ! 218: ! 219: /* ! 220: * Dump current data base in a format similar to RFC 883. ! 221: */ ! 222: ! 223: doadump() ! 224: { ! 225: FILE *fp; ! 226: ! 227: #ifdef DEBUG ! 228: if (debug >= 3) ! 229: fprintf(ddt,"doadump()\n"); ! 230: #endif ! 231: ! 232: if ((fp = fopen(dumpfile, "w")) == NULL) ! 233: return; ! 234: gettime(&tt); ! 235: fprintf(fp, "; Dumped at %s", ctime(&tt.tv_sec)); ! 236: fprintf(fp, "; --- Cache & Data ---\n"); ! 237: if (hashtab != NULL) ! 238: (void) db_dump(hashtab, fp, DB_Z_ALL, ""); ! 239: fprintf(fp, "; --- Hints ---\n"); ! 240: if (fcachetab != NULL) ! 241: (void) db_dump(fcachetab, fp, DB_Z_ALL, ""); ! 242: (void) fclose(fp); ! 243: } ! 244: ! 245: /* Create a disk database to back up zones ! 246: */ ! 247: zonedump(zp) ! 248: register struct zoneinfo *zp; ! 249: { ! 250: FILE *fp; ! 251: char *fname; ! 252: struct hashbuf *htp; ! 253: char *op; ! 254: struct stat st; ! 255: ! 256: /* Only dump zone if there is a cache specified */ ! 257: if (zp->z_source && *(zp->z_source)) { ! 258: #ifdef DEBUG ! 259: if (debug) ! 260: fprintf(ddt, "zonedump(%s)\n", zp->z_source); ! 261: #endif ! 262: ! 263: if ((fp = fopen(zp->z_source, "w")) == NULL) ! 264: return; ! 265: if (op = index(zp->z_origin, '.')) ! 266: op++; ! 267: gettime(&tt); ! 268: htp = hashtab; ! 269: if (nlookup(zp->z_origin, &htp, &fname, 0) != NULL) { ! 270: db_dump(htp, fp, zp-zones, (op == NULL ? "" : op)); ! 271: #ifdef ALLOW_UPDATES ! 272: zp->hasChanged = 0; /* Checkpointed */ ! 273: #endif ALLOW_UPDATES ! 274: } ! 275: (void) fclose(fp); ! 276: if (stat(zp->z_source, &st) == 0) ! 277: zp->z_ftime = st.st_mtime; ! 278: } ! 279: #ifdef DEBUG ! 280: else if (debug) ! 281: fprintf(ddt, "zonedump: no zone to dump\n"); ! 282: #endif ! 283: } ! 284: ! 285: int ! 286: db_dump(htp, fp, zone, origin) ! 287: int zone; ! 288: struct hashbuf *htp; ! 289: FILE *fp; ! 290: char *origin; ! 291: { ! 292: register struct databuf *dp; ! 293: register struct namebuf *np; ! 294: struct namebuf **npp, **nppend; ! 295: char dname[MAXDNAME]; ! 296: u_long n; ! 297: u_long addr; ! 298: u_short i; ! 299: int j; ! 300: register u_char *cp; ! 301: char *proto; ! 302: extern char *inet_ntoa(), *p_protocal(), *p_service(); ! 303: int found_data, tab, printed_origin = 0; ! 304: ! 305: npp = htp->h_tab; ! 306: nppend = npp + htp->h_size; ! 307: while (npp < nppend) { ! 308: for (np = *npp++; np != NULL; np = np->n_next) { ! 309: if (np->n_data == NULL) ! 310: continue; ! 311: /* Blecch - can't tell if there is data here for the ! 312: * right zone, so can't print name yet ! 313: */ ! 314: found_data = 0; ! 315: /* we want a snapshot in time... */ ! 316: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 317: /* Is the data for this zone? */ ! 318: if (zone != DB_Z_ALL && dp->d_zone != zone) ! 319: continue; ! 320: if (dp->d_zone == DB_Z_CACHE && ! 321: dp->d_ttl <= tt.tv_sec && ! 322: (dp->d_flags & DB_F_HINT) == 0) ! 323: continue; ! 324: if (!printed_origin) { ! 325: fprintf(fp, "$ORIGIN %s.\n", origin); ! 326: printed_origin++; ! 327: } ! 328: tab = 0; ! 329: if (!found_data) { ! 330: if (np->n_dname[0] == 0) { ! 331: if (origin[0] == 0) ! 332: fprintf(fp, ".\t"); ! 333: else ! 334: fprintf(fp, ".%s.\t", origin); /* ??? */ ! 335: } else ! 336: fprintf(fp, "%s\t", np->n_dname); ! 337: if (strlen(np->n_dname) < 8) ! 338: tab = 1; ! 339: found_data++; ! 340: } else { ! 341: (void) putc('\t', fp); ! 342: tab = 1; ! 343: } ! 344: if (dp->d_zone == DB_Z_CACHE) { ! 345: if (dp->d_flags & DB_F_HINT && ! 346: (long)(dp->d_ttl - tt.tv_sec) < DB_ROOT_TIMBUF) ! 347: fprintf(fp, "%d\t", DB_ROOT_TIMBUF); ! 348: else ! 349: fprintf(fp, "%d\t", ! 350: (int)(dp->d_ttl - tt.tv_sec)); ! 351: } else if (dp->d_ttl != 0 && ! 352: dp->d_ttl != zones[dp->d_zone].z_minimum) ! 353: fprintf(fp, "%d\t", (int)dp->d_ttl); ! 354: else if (tab) ! 355: (void) putc('\t', fp); ! 356: fprintf(fp, "%s\t%s\t", p_class(dp->d_class), ! 357: p_type(dp->d_type)); ! 358: cp = (u_char *)dp->d_data; ! 359: /* ! 360: * Print type specific data ! 361: */ ! 362: switch (dp->d_type) { ! 363: case T_A: ! 364: switch (dp->d_class) { ! 365: case C_IN: ! 366: GETLONG(n, cp); ! 367: n = htonl(n); ! 368: fprintf(fp, "%s", ! 369: inet_ntoa(*(struct in_addr *)&n)); ! 370: break; ! 371: } ! 372: if (dp->d_nstime) ! 373: fprintf(fp, "\t; %d", dp->d_nstime); ! 374: fprintf(fp, "\n"); ! 375: break; ! 376: case T_CNAME: ! 377: case T_MB: ! 378: case T_MG: ! 379: case T_MR: ! 380: case T_PTR: ! 381: if (cp[0] == '\0') ! 382: fprintf(fp, ".\n"); ! 383: else ! 384: fprintf(fp, "%s.\n", cp); ! 385: break; ! 386: ! 387: case T_NS: ! 388: cp = (u_char *)dp->d_data; ! 389: if (cp[0] == '\0') ! 390: fprintf(fp, ".\t"); ! 391: else ! 392: fprintf(fp, "%s.", cp); ! 393: if (dp->d_nstime) ! 394: fprintf(fp, "\t; %d???", dp->d_nstime); ! 395: fprintf(fp, "\n"); ! 396: break; ! 397: ! 398: case T_HINFO: ! 399: if (n = *cp++) { ! 400: fprintf(fp, "\"%.*s\"", (int)n, cp); ! 401: cp += n; ! 402: } else ! 403: fprintf(fp, "\"\""); ! 404: if (n = *cp++) ! 405: fprintf(fp, " \"%.*s\"", (int)n, cp); ! 406: else ! 407: fprintf(fp, "\"\""); ! 408: (void) putc('\n', fp); ! 409: break; ! 410: ! 411: case T_SOA: ! 412: fprintf(fp, "%s.", cp); ! 413: cp += strlen(cp) + 1; ! 414: fprintf(fp, " %s. (\n", cp); ! 415: cp += strlen(cp) + 1; ! 416: GETLONG(n, cp); ! 417: fprintf(fp, "\t\t%lu", n); ! 418: GETLONG(n, cp); ! 419: fprintf(fp, " %lu", n); ! 420: GETLONG(n, cp); ! 421: fprintf(fp, " %lu", n); ! 422: GETLONG(n, cp); ! 423: fprintf(fp, " %lu", n); ! 424: GETLONG(n, cp); ! 425: fprintf(fp, " %lu )\n", n); ! 426: break; ! 427: ! 428: case T_MX: ! 429: GETSHORT(n, cp); ! 430: fprintf(fp,"%lu", n); ! 431: fprintf(fp," %s.\n", cp); ! 432: break; ! 433: ! 434: ! 435: case T_UINFO: ! 436: fprintf(fp, "\"%s\"\n", cp); ! 437: break; ! 438: ! 439: case T_UID: ! 440: case T_GID: ! 441: if (dp->d_size == sizeof(u_long)) { ! 442: GETLONG(n, cp); ! 443: fprintf(fp, "%lu\n", n); ! 444: } ! 445: break; ! 446: ! 447: case T_WKS: ! 448: GETLONG(addr, cp); ! 449: addr = htonl(addr); ! 450: fprintf(fp,"%s ", ! 451: inet_ntoa(*(struct in_addr *)&addr)); ! 452: proto = p_protocal(*cp); /* protocal */ ! 453: cp += sizeof(char); ! 454: fprintf(fp, "%s ", proto); ! 455: i = 0; ! 456: while(cp < (u_char *)dp->d_data + dp->d_size) { ! 457: j = *cp++; ! 458: do { ! 459: if(j & 0200) ! 460: fprintf(fp," %s", ! 461: p_service(i, proto)); ! 462: j <<= 1; ! 463: } while(++i & 07); ! 464: } ! 465: fprintf(fp,"\n"); ! 466: break; ! 467: ! 468: case T_MINFO: ! 469: fprintf(fp, "%s.", cp); ! 470: cp += strlen(cp) + 1; ! 471: fprintf(fp, " %s.\n", cp); ! 472: break; ! 473: #ifdef ALLOW_T_UNSPEC ! 474: case T_UNSPEC: ! 475: /* Dump binary data out in an ASCII-encoded ! 476: format */ ! 477: { ! 478: /* Allocate more than enough space: ! 479: * actually need 5/4 size + 20 or so ! 480: */ ! 481: int TmpSize = 2 * dp->d_size + 30; ! 482: char *TmpBuf = (char *) malloc(TmpSize); ! 483: if (TmpBuf == NULL) { ! 484: #ifdef DEBUG ! 485: if (debug) ! 486: fprintf(ddt, "Dump T_UNSPEC: malloc returned NULL\n"); ! 487: #endif DEBUG ! 488: syslog(LOG_ERR, "Dump T_UNSPEC: malloc: %m"); ! 489: } ! 490: if (btoa(cp, dp->d_size, TmpBuf, ! 491: TmpSize) == CONV_OVERFLOW) { ! 492: #ifdef DEBUG ! 493: if (debug) ! 494: fprintf(ddt, "Dump T_UNSPEC: Output buffer overflow\n"); ! 495: #endif DEBUG ! 496: syslog(LOG_ERR, "Dump T_UNSPEC: Output buffer overflow\n"); ! 497: } else ! 498: fprintf(fp, "%s\n", TmpBuf); ! 499: } ! 500: break; ! 501: #endif ALLOW_T_UNSPEC ! 502: default: ! 503: fprintf(fp, "???\n"); ! 504: } ! 505: } ! 506: } ! 507: } ! 508: if (ferror(fp)) ! 509: return(NODBFILE); ! 510: ! 511: npp = htp->h_tab; ! 512: nppend = npp + htp->h_size; ! 513: while (npp < nppend) { ! 514: for (np = *npp++; np != NULL; np = np->n_next) { ! 515: if (np->n_hash == NULL) ! 516: continue; ! 517: getname(np, dname, sizeof(dname)); ! 518: if (db_dump(np->n_hash, fp, zone, dname) == NODBFILE) ! 519: return(NODBFILE); ! 520: } ! 521: } ! 522: return(OK); ! 523: } ! 524: ! 525: /* These next two routines will be moveing to res_debug.c */ ! 526: /* They are currently here for ease of distributing the WKS record fix */ ! 527: char * ! 528: p_protocal(num) ! 529: int num; ! 530: { ! 531: static char number[8]; ! 532: struct protoent *pp; ! 533: extern struct protoent *cgetprotobynumber(); ! 534: ! 535: pp = cgetprotobynumber(num); ! 536: if(pp == 0) { ! 537: (void) sprintf(number, "%d", num); ! 538: return(number); ! 539: } ! 540: return(pp->p_name); ! 541: } ! 542: ! 543: char * ! 544: p_service(port, proto) ! 545: u_short port; ! 546: char *proto; ! 547: { ! 548: static char number[8]; ! 549: struct servent *ss; ! 550: extern struct servent *cgetservbyport(); ! 551: ! 552: ss = cgetservbyport(htons(port), proto); ! 553: if(ss == 0) { ! 554: (void) sprintf(number, "%d", port); ! 555: return(number); ! 556: } ! 557: return(ss->s_name); ! 558: } ! 559: ! 560: #ifdef ALLOW_T_UNSPEC ! 561: /* ! 562: * Subroutines to convert between 8 bit binary bytes and printable ASCII. ! 563: * Computes the number of bytes, and three kinds of simple checksums. ! 564: * Incoming bytes are collected into 32-bit words, then printed in base 85: ! 565: * exp(85,5) > exp(2,32) ! 566: * The ASCII characters used are between '!' and 'u'; ! 567: * 'z' encodes 32-bit zero; 'x' is used to mark the end of encoded data. ! 568: * ! 569: * Originally by Paul Rutter (philabs!per) and Joe Orost (petsd!joe) for ! 570: * the atob/btoa programs, released with the compress program, in mod.sources. ! 571: * Modified by Mike Schwartz 8/19/86 for use in BIND. ! 572: */ ! 573: ! 574: /* Make sure global variable names are unique */ ! 575: #define Ceor T_UNSPEC_Ceor ! 576: #define Csum T_UNSPEC_Csum ! 577: #define Crot T_UNSPEC_Crot ! 578: #define word T_UNSPEC_word ! 579: #define bcount T_UNSPEC_bcount ! 580: ! 581: static long int Ceor, Csum, Crot, word, bcount; ! 582: ! 583: #define EN(c) ((int) ((c) + '!')) ! 584: #define DE(c) ((c) - '!') ! 585: #define AddToBuf(bufp, c) **bufp = c; (*bufp)++; ! 586: #define streq(s0, s1) strcmp(s0, s1) == 0 ! 587: #define times85(x) ((((((x<<2)+x)<<2)+x)<<2)+x) ! 588: ! 589: ! 590: /* Decode ASCII-encoded byte c into binary representation and ! 591: * place into *bufp, advancing bufp ! 592: */ ! 593: static int ! 594: byte_atob(c, bufp) ! 595: register c; ! 596: char **bufp; ! 597: { ! 598: if (c == 'z') { ! 599: if (bcount != 0) ! 600: return(CONV_BADFMT); ! 601: else { ! 602: putbyte(0, bufp); ! 603: putbyte(0, bufp); ! 604: putbyte(0, bufp); ! 605: putbyte(0, bufp); ! 606: } ! 607: } else if ((c >= '!') && (c < ('!' + 85))) { ! 608: if (bcount == 0) { ! 609: word = DE(c); ! 610: ++bcount; ! 611: } else if (bcount < 4) { ! 612: word = times85(word); ! 613: word += DE(c); ! 614: ++bcount; ! 615: } else { ! 616: word = times85(word) + DE(c); ! 617: putbyte((int)((word >> 24) & 255), bufp); ! 618: putbyte((int)((word >> 16) & 255), bufp); ! 619: putbyte((int)((word >> 8) & 255), bufp); ! 620: putbyte((int)(word & 255), bufp); ! 621: word = 0; ! 622: bcount = 0; ! 623: } ! 624: } else ! 625: return(CONV_BADFMT); ! 626: return(CONV_SUCCESS); ! 627: } ! 628: ! 629: /* Compute checksum info and place c into *bufp, advancing bufp */ ! 630: static ! 631: putbyte(c, bufp) ! 632: register c; ! 633: char **bufp; ! 634: { ! 635: Ceor ^= c; ! 636: Csum += c; ! 637: Csum += 1; ! 638: if ((Crot & 0x80000000)) { ! 639: Crot <<= 1; ! 640: Crot += 1; ! 641: } else { ! 642: Crot <<= 1; ! 643: } ! 644: Crot += c; ! 645: AddToBuf(bufp, c); ! 646: } ! 647: ! 648: /* Read the ASCII-encoded data from inbuf, of length inbuflen, and convert ! 649: it into T_UNSPEC (binary data) in outbuf, not to exceed outbuflen bytes; ! 650: outbuflen must be divisible by 4. (Note: this is because outbuf is filled ! 651: in 4 bytes at a time. If the actual data doesn't end on an even 4-byte ! 652: boundary, there will be no problem...it will be padded with 0 bytes, and ! 653: numbytes will indicate the correct number of bytes. The main point is ! 654: that since the buffer is filled in 4 bytes at a time, even if there is ! 655: not a full 4 bytes of data at the end, there has to be room to 0-pad the ! 656: data, so the buffer must be of size divisible by 4). Place the number of ! 657: output bytes in numbytes, and return a failure/success status */ ! 658: int ! 659: atob(inbuf, inbuflen, outbuf, outbuflen, numbytes) ! 660: char *inbuf; ! 661: int inbuflen; ! 662: char *outbuf; ! 663: int outbuflen; ! 664: int *numbytes; ! 665: { ! 666: int inc, nb; ! 667: long int oeor, osum, orot; ! 668: char *inp, *outp = outbuf, *endoutp = &outbuf[outbuflen]; ! 669: ! 670: if ( (outbuflen % 4) != 0) ! 671: return(CONV_BADBUFLEN); ! 672: Ceor = Csum = Crot = word = bcount = 0; ! 673: for (inp = inbuf, inc = 0; inc < inbuflen; inp++, inc++) { ! 674: if (outp > endoutp) ! 675: return(CONV_OVERFLOW); ! 676: if (*inp == 'x') { ! 677: inp +=2; ! 678: break; ! 679: } else { ! 680: if (byte_atob(*inp, &outp) == CONV_BADFMT) ! 681: return(CONV_BADFMT); ! 682: } ! 683: } ! 684: ! 685: /* Get byte count and checksum information from end of buffer */ ! 686: if(sscanf(inp, "%ld %lx %lx %lx", numbytes, &oeor, &osum, &orot) != 4) ! 687: return(CONV_BADFMT); ! 688: if ((oeor != Ceor) || (osum != Csum) || (orot != Crot)) ! 689: return(CONV_BADCKSUM); ! 690: return(CONV_SUCCESS); ! 691: } ! 692: ! 693: /* Encode binary byte c into ASCII representation and place into *bufp, ! 694: advancing bufp */ ! 695: static ! 696: byte_btoa(c, bufp) ! 697: register c; ! 698: char **bufp; ! 699: { ! 700: Ceor ^= c; ! 701: Csum += c; ! 702: Csum += 1; ! 703: if ((Crot & 0x80000000)) { ! 704: Crot <<= 1; ! 705: Crot += 1; ! 706: } else { ! 707: Crot <<= 1; ! 708: } ! 709: Crot += c; ! 710: ! 711: word <<= 8; ! 712: word |= c; ! 713: if (bcount == 3) { ! 714: if (word == 0) { ! 715: AddToBuf(bufp, 'z'); ! 716: } else { ! 717: register int tmp = 0; ! 718: register long int tmpword = word; ! 719: ! 720: if (tmpword < 0) { ! 721: /* Because some don't support unsigned long */ ! 722: tmp = 32; ! 723: tmpword -= (long)(85 * 85 * 85 * 85 * 32); ! 724: } ! 725: if (tmpword < 0) { ! 726: tmp = 64; ! 727: tmpword -= (long)(85 * 85 * 85 * 85 * 32); ! 728: } ! 729: AddToBuf(bufp, ! 730: EN((tmpword / (long)(85 * 85 * 85 * 85)) + tmp)); ! 731: tmpword %= (long)(85 * 85 * 85 * 85); ! 732: AddToBuf(bufp, EN(tmpword / (85 * 85 * 85))); ! 733: tmpword %= (85 * 85 * 85); ! 734: AddToBuf(bufp, EN(tmpword / (85 * 85))); ! 735: tmpword %= (85 * 85); ! 736: AddToBuf(bufp, EN(tmpword / 85)); ! 737: tmpword %= 85; ! 738: AddToBuf(bufp, EN(tmpword)); ! 739: } ! 740: bcount = 0; ! 741: } else { ! 742: bcount += 1; ! 743: } ! 744: } ! 745: ! 746: ! 747: /* ! 748: * Encode the binary data from inbuf, of length inbuflen, into a ! 749: * null-terminated ASCII representation in outbuf, not to exceed outbuflen ! 750: * bytes. Return success/failure status ! 751: */ ! 752: int ! 753: btoa(inbuf, inbuflen, outbuf, outbuflen) ! 754: char *inbuf; ! 755: int inbuflen; ! 756: char *outbuf; ! 757: int outbuflen; ! 758: { ! 759: long int inc, nb; ! 760: long int oeor, osum, orot; ! 761: char *inp, *outp = outbuf, *endoutp = &outbuf[outbuflen -1]; ! 762: ! 763: Ceor = Csum = Crot = word = bcount = 0; ! 764: for (inp = inbuf, inc = 0; inc < inbuflen; inp++, inc++) { ! 765: byte_btoa((unsigned char) (*inp), &outp); ! 766: if (outp >= endoutp) ! 767: return(CONV_OVERFLOW); ! 768: } ! 769: while (bcount != 0) { ! 770: byte_btoa(0, &outp); ! 771: if (outp >= endoutp) ! 772: return(CONV_OVERFLOW); ! 773: } ! 774: /* Put byte count and checksum information at end of buffer, delimited ! 775: by 'x' */ ! 776: (void) sprintf(outp, "x %ld %lx %lx %lx", inbuflen, Ceor, Csum, Crot); ! 777: if (&outp[strlen(outp) - 1] >= endoutp) ! 778: return(CONV_OVERFLOW); ! 779: else ! 780: return(CONV_SUCCESS); ! 781: } ! 782: #endif ALLOW_T_UNSPEC
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.