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