开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
res_debug.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：17k
源码类别：

VxWorks

开发平台：

C/C++

res_debug.c：源码内容
  1. /* res_debug.c - outputs to the console resolver debug messages */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1985, 1990, 1993
  8.  *    The Regents of the University of California.  All rights reserved.
  9.  * 
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  *  This product includes software developed by the University of
  21.  *  California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  * 
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  39.  * 
  40.  * Permission to use, copy, modify, and distribute this software for any
  41.  * purpose with or without fee is hereby granted, provided that the above
  42.  * copyright notice and this permission notice appear in all copies, and that
  43.  * the name of Digital Equipment Corporation not be used in advertising or
  44.  * publicity pertaining to distribution of the document or software without
  45.  * specific, written prior permission.
  46.  * 
  47.  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  48.  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  49.  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  50.  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  51.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  52.  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  53.  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  54.  * SOFTWARE.
  55.  */
  57. /*
  58. modification history
  59. --------------------
  60. 01c,17sep01,vvv fixed compilation warnings
  61. 01b,29apr97,jag Changed T_NULL to T_NULL_RR to fix conflict with loadCoffLib.h
  62. 01a,02feb97,jag Changed _p_query to dnsDebug.
  63. */
  67. #include <resolvLib.h>
  69. #include <stdio.h>
  70. #include <string.h>
  72. void __fp_query();
  73. char *__p_class(), *__p_time(), *__p_type();
  74. char *p_cdname(), *p_fqname(), *p_rr();
  76. char *_res_opcodes[] = {
  77. "QUERY",
  78. "IQUERY",
  79. "CQUERYM",
  80. "CQUERYU",
  81. "4",
  82. "5",
  83. "6",
  84. "7",
  85. "8",
  86. "UPDATEA",
  87. "UPDATED",
  88. "UPDATEDA",
  89. "UPDATEM",
  90. "UPDATEMA",
  91. "ZONEINIT",
  92. "ZONEREF",
  93. };
  95. char *_res_resultcodes[] = {
  96. "NOERROR",
  97. "FORMERR",
  98. "SERVFAIL",
  99. "NXDOMAIN",
  100. "NOTIMP",
  101. "REFUSED",
  102. "6",
  103. "7",
  104. "8",
  105. "9",
  106. "10",
  107. "11",
  108. "12",
  109. "13",
  110. "14",
  111. "NOCHANGE",
  112. };
  114. static char retbuf[16];
  116. static char *
  117. dewks(wks)
  118. int wks;
  119. {
  120. switch (wks) {
  121. case 5: return("rje");
  122. case 7: return("echo");
  123. case 9: return("discard");
  124. case 11: return("systat");
  125. case 13: return("daytime");
  126. case 15: return("netstat");
  127. case 17: return("qotd");
  128. case 19: return("chargen");
  129. case 20: return("ftp-data");
  130. case 21: return("ftp");
  131. case 23: return("telnet");
  132. case 25: return("smtp");
  133. case 37: return("time");
  134. case 39: return("rlp");
  135. case 42: return("name");
  136. case 43: return("whois");
  137. case 53: return("domain");
  138. case 57: return("apts");
  139. case 59: return("apfs");
  140. case 67: return("bootps");
  141. case 68: return("bootpc");
  142. case 69: return("tftp");
  143. case 77: return("rje");
  144. case 79: return("finger");
  145. case 87: return("link");
  146. case 95: return("supdup");
  147. case 100: return("newacct");
  148. case 101: return("hostnames");
  149. case 102: return("iso-tsap");
  150. case 103: return("x400");
  151. case 104: return("x400-snd");
  152. case 105: return("csnet-ns");
  153. case 109: return("pop-2");
  154. case 111: return("sunrpc");
  155. case 113: return("auth");
  156. case 115: return("sftp");
  157. case 117: return("uucp-path");
  158. case 119: return("nntp");
  159. case 121: return("erpc");
  160. case 123: return("ntp");
  161. case 133: return("statsrv");
  162. case 136: return("profile");
  163. case 144: return("NeWS");
  164. case 161: return("snmp");
  165. case 162: return("snmp-trap");
  166. case 170: return("print-srv");
  167. default: (void) sprintf(retbuf, "%d", wks); return(retbuf);
  168. }
  169. }
  171. static char *
  172. deproto(protonum)
  173. int protonum;
  174. {
  175. switch (protonum) {
  176. case 1: return("icmp");
  177. case 2: return("igmp");
  178. case 3: return("ggp");
  179. case 5: return("st");
  180. case 6: return("tcp");
  181. case 7: return("ucl");
  182. case 8: return("egp");
  183. case 9: return("igp");
  184. case 11: return("nvp-II");
  185. case 12: return("pup");
  186. case 16: return("chaos");
  187. case 17: return("udp");
  188. default: (void) sprintf(retbuf, "%d", protonum); return(retbuf);
  189. }
  190. }
  192. static char *
  193. do_rrset(msg, cp, cnt, pflag, file, hs)
  194. int cnt, pflag;
  195. char *cp,*msg, *hs;
  196. FILE *file;
  197. {
  198. int n;
  199. int sflag;
  200. /*
  201.  * Print  answer records
  202.  */
  203. sflag = (_res.pfcode & pflag);
  204. if ((n = ntohs(cnt))) {
  205. if ((!_res.pfcode) || ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
  206. fprintf(file, hs);
  207. while (--n >= 0) {
  208. cp = p_rr(cp, msg, file);
  209. if ((cp-msg) > PACKETSZ)
  210. return (NULL);
  211. }
  212. if ((!_res.pfcode) || ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
  213. putc('n', file);
  214. }
  215. return(cp);
  216. }
  218. #ifdef ORG_RESOLVER
  219. __p_query(msg)
  220. char *msg;
  221. #else
  222. void dnsDebug 
  223.     (
  224.     char *msg
  225.     )
  226. #endif /* ORG_RESOLVER */
  227. {
  228. __fp_query(msg, stdout);
  229. }
  231. #ifdef ORG_RESOLVER
  232. /*
  233.  * Print the current options.
  234.  * This is intended to be primarily a debugging routine.
  235.  */
  236. void
  237. __fp_resstat(statp, file)
  238. struct __res_state *statp;
  239. FILE *file;
  240. {
  241. int bit;
  243. fprintf(file, ";; res options:");
  244. if (!statp)
  245. statp = &_res;
  246. for (bit = 0;  bit < 32;  bit++) { /* XXX 32 - bad assumption! */
  247. if (statp->options & (1<<bit))
  248. fprintf(file, " %s", p_option(1<<bit));
  249. }
  250. putc('n', file);
  251. }
  252. #endif /* ORG_RESOLVER */
  254. /*
  255.  * Print the contents of a query.
  256.  * This is intended to be primarily a debugging routine.
  257.  */
  258. void
  259. __fp_query(msg,file)
  260. char *msg;
  261. FILE *file;
  262. {
  263. register char *cp;
  264. register HEADER *hp;
  265. register int n;
  267. /*
  268.  * Print header fields.
  269.  */
  270. hp = (HEADER *)msg;
  271. cp = msg + sizeof(HEADER);
  272. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX) || hp->rcode) {
  273. fprintf(file,";; ->>HEADER<<- opcode: %s, status: %s, id: %d",
  274. _res_opcodes[hp->opcode],
  275. _res_resultcodes[hp->rcode],
  276. ntohs(hp->id));
  277. putc('n', file);
  278. }
  279. putc(';', file);
  280. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD2)) {
  281. fprintf(file,"; flags:");
  282. if (hp->qr)
  283. fprintf(file," qr");
  284. if (hp->aa)
  285. fprintf(file," aa");
  286. if (hp->tc)
  287. fprintf(file," tc");
  288. if (hp->rd)
  289. fprintf(file," rd");
  290. if (hp->ra)
  291. fprintf(file," ra");
  292. if (hp->pr)
  293. fprintf(file," pr");
  294. }
  295. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD1)) {
  296. fprintf(file,"; Ques: %d", ntohs(hp->qdcount));
  297. fprintf(file,", Ans: %d", ntohs(hp->ancount));
  298. fprintf(file,", Auth: %d", ntohs(hp->nscount));
  299. fprintf(file,", Addit: %d", ntohs(hp->arcount));
  300. }
  301. #if 1
  302. if ((!_res.pfcode) || (_res.pfcode & 
  303. (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
  304. putc('n',file);
  305. }
  306. #endif
  307. /*
  308.  * Print question records.
  309.  */
  310. if ((n = ntohs(hp->qdcount))) {
  311. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
  312. fprintf(file,";; QUESTIONS:n");
  313. while (--n >= 0) {
  314. fprintf(file,";;t");
  315. cp = p_cdname(cp, msg, file);
  316. if (cp == NULL)
  317. return;
  318. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
  319. fprintf(file, ", type = %s",
  320. __p_type(_getshort(cp)));
  321. cp += sizeof(uint16_t);
  322. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
  323. fprintf(file, ", class = %sn",
  324. __p_class(_getshort(cp)));
  325. cp += sizeof(uint16_t);
  326. putc('n', file);
  327. }
  328. }
  329. /*
  330.  * Print authoritative answer records
  331.  */
  332. cp = do_rrset(msg, cp, hp->ancount, RES_PRF_ANS, file,
  333.       ";; ANSWERS:n");
  334. if (cp == NULL)
  335. return;
  337. /*
  338.  * print name server records
  339.  */
  340. cp = do_rrset(msg, cp, hp->nscount, RES_PRF_AUTH, file,
  341.       ";; AUTHORITY RECORDS:n");
  342. if (!cp)
  343. return;
  345. /*
  346.  * print additional records
  347.  */
  348. cp = do_rrset(msg, cp, hp->arcount, RES_PRF_ADD, file,
  349.       ";; ADDITIONAL RECORDS:n");
  350. if (!cp)
  351. return;
  352. }
  354. char *
  355. p_cdname(cp, msg, file)
  356. char *cp, *msg;
  357. FILE *file;
  358. {
  359. char name[MAXDNAME];
  360. int n;
  362. if ((n = resolvDNExpand((u_char *)msg, (u_char *)cp + MAXCDNAME,
  363.    (u_char *)cp, (u_char *)name, sizeof(name))) < 0)
  364. return (NULL);
  365. if (name[0] == '')
  366. putc('.', file);
  367. else
  368. fputs(name, file);
  369. return (cp + n);
  370. }
  372. char *
  373. p_fqname(cp, msg, file)
  374. char *cp, *msg;
  375. FILE *file;
  376. {
  377. char name[MAXDNAME];
  378. int n;
  380. if ((n = resolvDNExpand((u_char *)msg, (u_char *)cp + MAXCDNAME,
  381.    (u_char *)cp, (u_char *)name, sizeof(name))) < 0)
  382. return (NULL);
  383. if (name[0] == '') {
  384. putc('.', file);
  385. } else {
  386. fputs(name, file);
  387. if (name[strlen(name) - 1] != '.')
  388. putc('.', file);
  389. }
  390. return (cp + n);
  391. }
  393. /*
  394.  * Print resource record fields in human readable form.
  395.  */
  396. char *
  397. p_rr(cp, msg, file)
  398. char *cp, *msg;
  399. FILE *file;
  400. {
  401. int type, class, dlen, n, c;
  402. struct in_addr inaddr;
  403. char *cp1, *cp2;
  404. uint32_t tmpttl, t;
  405. int lcnt;
  407. if ((cp = p_fqname(cp, msg, file)) == NULL)
  408. return (NULL); /* compression error */
  409. type = _getshort(cp);
  410. cp += sizeof(uint16_t);
  411. class = _getshort(cp);
  412. cp += sizeof(uint16_t);
  413. tmpttl = _getlong(cp);
  414. cp += sizeof(uint32_t);
  415. dlen = _getshort(cp);
  416. cp += sizeof(uint16_t);
  417. cp1 = cp;
  418. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_TTLID))
  419. fprintf(file, "t%lu", tmpttl);
  420. if ((!_res.pfcode) || (_res.pfcode & RES_PRF_CLASS))
  421. fprintf(file, "t%s", __p_class(class));
  422. fprintf(file, "t%s", __p_type(type));
  423. /*
  424.  * Print type specific data, if appropriate
  425.  */
  426. switch (type) {
  427. case T_A:
  428. switch (class) {
  429. case C_IN:
  430. case C_HS:
  431. bcopy(cp, (char *)&inaddr, sizeof(inaddr));
  432. if (dlen == 4) {
  433. fprintf(file,"t%s", inet_ntoa(inaddr));
  434. cp += dlen;
  435. } else if (dlen == 7) {
  436. char *address;
  437. u_char protocol;
  438. u_short port;
  440. address = inet_ntoa(inaddr);
  441. cp += sizeof(inaddr);
  442. protocol = *(u_char*)cp;
  443. cp += sizeof(u_char);
  444. port = _getshort(cp);
  445. cp += sizeof(uint16_t);
  446. fprintf(file, "t%st; proto %d, port %d",
  447. address, protocol, port);
  448. }
  449. break;
  450. default:
  451. cp += dlen;
  452. }
  453. break;
  454. case T_CNAME:
  455. case T_MB:
  456. case T_MG:
  457. case T_MR:
  458. case T_NS:
  459. case T_PTR:
  460. putc('t', file);
  461. cp = p_fqname(cp, msg, file);
  462. break;
  464. case T_HINFO:
  465. if ((n = *cp++)) {
  466. fprintf(file,"t%.*s", n, cp);
  467. cp += n;
  468. }
  469. if ((n = *cp++)) {
  470. fprintf(file,"t%.*s", n, cp);
  471. cp += n;
  472. }
  473. break;
  475. case T_SOA:
  476. putc('t', file);
  477. cp = p_fqname(cp, msg, file); /* origin */
  478. putc(' ', file);
  479. cp = p_fqname(cp, msg, file); /* mail addr */
  480. fputs(" (n", file);
  481. t = _getlong(cp);  cp += sizeof(uint32_t);
  482. fprintf(file,"ttt%lut; serialn", t);
  483. t = _getlong(cp);  cp += sizeof(uint32_t);
  484. fprintf(file,"ttt%lut; refresh (%s)n", t, __p_time(t));
  485. t = _getlong(cp);  cp += sizeof(uint32_t);
  486. fprintf(file,"ttt%lut; retry (%s)n", t, __p_time(t));
  487. t = _getlong(cp);  cp += sizeof(uint32_t);
  488. fprintf(file,"ttt%lut; expire (%s)n", t, __p_time(t));
  489. t = _getlong(cp);  cp += sizeof(uint32_t);
  490. fprintf(file,"ttt%lu )t; minimum (%s)", t, __p_time(t));
  491. break;
  493. case T_MX:
  494. case T_AFSDB:
  495. fprintf(file,"t%d ", _getshort(cp));
  496. cp += sizeof(uint16_t);
  497. cp = p_fqname(cp, msg, file);
  498. break;
  500.    case T_TXT:
  501. (void) fputs("t"", file);
  502. cp2 = cp1 + dlen;
  503. while (cp < cp2) {
  504. if ((n = (unsigned char) *cp++)) {
  505. for (c = n; c > 0 && cp < cp2; c--)
  506. if (*cp == 'n') {
  507.     (void) putc('\', file);
  508.     (void) putc(*cp++, file);
  509. } else
  510.     (void) putc(*cp++, file);
  511. }
  512. }
  513. putc('"', file);
  514.    break;
  516. case T_MINFO:
  517. case T_RP:
  518. putc('t', file);
  519. cp = p_fqname(cp, msg, file);
  520. putc(' ', file);
  521. cp = p_fqname(cp, msg, file);
  522. break;
  524. case T_UINFO:
  525. putc('t', file);
  526. fputs(cp, file);
  527. cp += dlen;
  528. break;
  530. case T_UID:
  531. case T_GID:
  532. if (dlen == 4) {
  533. fprintf(file,"t%lu", _getlong(cp));
  534. cp += sizeof(uint32_t);
  535. }
  536. break;
  538. case T_WKS:
  539. if (dlen < sizeof(uint32_t) + 1)
  540. break;
  541. bcopy(cp, (char *)&inaddr, sizeof(inaddr));
  542. cp += sizeof(uint32_t);
  543. fprintf(file, "t%s %s ( ",
  544. inet_ntoa(inaddr),
  545. deproto((int) *cp));
  546. cp += sizeof(u_char);
  547. n = 0;
  548. lcnt = 0;
  549. while (cp < cp1 + dlen) {
  550. c = *cp++;
  551. do {
  552.   if (c & 0200) {
  553. if (lcnt == 0) {
  554. fputs("nttt", file);
  555. lcnt = 5;
  556. }
  557. fputs(dewks(n), file);
  558. putc(' ', file);
  559. lcnt--;
  560. }
  561.   c <<= 1;
  562. } while (++n & 07);
  563. }
  564. putc(')', file);
  565. break;
  567. #ifdef ALLOW_T_UNSPEC
  568. case T_UNSPEC:
  569. {
  570. int NumBytes = 8;
  571. char *DataPtr;
  572. int i;
  574. if (dlen < NumBytes) NumBytes = dlen;
  575. fprintf(file, "tFirst %d bytes of hex data:",
  576. NumBytes);
  577. for (i = 0, DataPtr = cp; i < NumBytes; i++, DataPtr++)
  578. fprintf(file, " %x", *DataPtr);
  579. cp += dlen;
  580. }
  581. break;
  582. #endif /* ALLOW_T_UNSPEC */
  584. default:
  585. fprintf(file,"t?%d?", type);
  586. cp += dlen;
  587. }
  588. #if 0
  589. fprintf(file, "t; dlen=%d, ttl %sn", dlen, __p_time(tmpttl));
  590. #else
  591. putc('n', file);
  592. #endif
  593. if (cp - cp1 != dlen) {
  594. fprintf(file,";; packet size error (found %d, dlen was %d)n",
  595. cp - cp1, dlen);
  596. cp = NULL;
  597. }
  598. return (cp);
  599. }
  601. static char nbuf[40];
  603. /*
  604.  * Return a string for the type
  605.  */
  606. char *
  607. __p_type(type)
  608. int type;
  609. {
  610. switch (type) {
  611. case T_A:
  612. return("A");
  613. case T_NS: /* authoritative server */
  614. return("NS");
  615. case T_CNAME: /* canonical name */
  616. return("CNAME");
  617. case T_SOA: /* start of authority zone */
  618. return("SOA");
  619. case T_MB: /* mailbox domain name */
  620. return("MB");
  621. case T_MG: /* mail group member */
  622. return("MG");
  623. case T_MR: /* mail rename name */
  624. return("MR");
  625. case T_NULL_RR: /* null resource record */
  626. return("NULL");
  627. case T_WKS: /* well known service */
  628. return("WKS");
  629. case T_PTR: /* domain name pointer */
  630. return("PTR");
  631. case T_HINFO: /* host information */
  632. return("HINFO");
  633. case T_MINFO: /* mailbox information */
  634. return("MINFO");
  635. case T_MX: /* mail routing info */
  636. return("MX");
  637. case T_TXT: /* text */
  638. return("TXT");
  639. case T_RP: /* responsible person */
  640. return("RP");
  641. case T_AFSDB: /* AFS cell database */
  642. return("AFSDB");
  643. case T_AXFR: /* zone transfer */
  644. return("AXFR");
  645. case T_MAILB: /* mail box */
  646. return("MAILB");
  647. case T_MAILA: /* mail address */
  648. return("MAILA");
  649. case T_ANY: /* matches any type */
  650. return("ANY");
  651. case T_UINFO:
  652. return("UINFO");
  653. case T_UID:
  654. return("UID");
  655. case T_GID:
  656. return("GID");
  657. #ifdef ALLOW_T_UNSPEC
  658. case T_UNSPEC:
  659. return("UNSPEC");
  660. #endif /* ALLOW_T_UNSPEC */
  662. default:
  663. (void)sprintf(nbuf, "%d", type);
  664. return(nbuf);
  665. }
  666. }
  668. /*
  669.  * Return a mnemonic for class
  670.  */
  671. char *
  672. __p_class(class)
  673. int class;
  674. {
  676. switch (class) {
  677. case C_IN: /* internet class */
  678. return("IN");
  679. case C_HS: /* hesiod class */
  680. return("HS");
  681. case C_ANY: /* matches any class */
  682. return("ANY");
  683. default:
  684. (void)sprintf(nbuf, "%d", class);
  685. return(nbuf);
  686. }
  687. }
  689. /*
  690.  * Return a mnemonic for an option
  691.  */
  692. #ifdef ORG_RESOLVER /* used only if ORG_RESOLVER defined */
  693. static char *
  694. p_option(option)
  695. u_long option;
  696. {
  697. switch (option) {
  698. case RES_INIT: return "init";
  699. case RES_DEBUG: return "debug";
  700. case RES_AAONLY: return "aaonly";
  701. case RES_USEVC: return "usevc";
  702. case RES_PRIMARY: return "primry";
  703. case RES_IGNTC: return "igntc";
  704. case RES_RECURSE: return "recurs";
  705. case RES_DEFNAMES: return "defnam";
  706. case RES_STAYOPEN: return "styopn";
  707. case RES_DNSRCH: return "dnsrch";
  708. default: sprintf(nbuf, "?0x%lx?", option); return nbuf;
  709. }
  710. }
  711. #endif
  713. /*
  714.  * Return a mnemonic for a time to live
  715.  */
  716. char *
  717. __p_time(value)
  718. uint32_t value;
  719. {
  720. int secs, mins, hours, days;
  721. register char *p;
  723. if (value == 0) {
  724. strcpy(nbuf, "0 secs");
  725. return(nbuf);
  726. }
  728. secs = value % 60;
  729. value /= 60;
  730. mins = value % 60;
  731. value /= 60;
  732. hours = value % 24;
  733. value /= 24;
  734. days = value;
  735. value = 0;
  737. #define PLURALIZE(x) x, (x == 1) ? "" : "s"
  738. p = nbuf;
  739. if (days) {
  740. (void)sprintf(p, "%d day%s", PLURALIZE(days));
  741. while (*++p);
  742. }
  743. if (hours) {
  744. if (days)
  745. *p++ = ' ';
  746. (void)sprintf(p, "%d hour%s", PLURALIZE(hours));
  747. while (*++p);
  748. }
  749. if (mins) {
  750. if (days || hours)
  751. *p++ = ' ';
  752. (void)sprintf(p, "%d min%s", PLURALIZE(mins));
  753. while (*++p);
  754. }
  755. if (secs || ! (days || hours || mins)) {
  756. if (days || hours || mins)
  757. *p++ = ' ';
  758. (void)sprintf(p, "%d sec%s", PLURALIZE(secs));
  759. }
  760. return(nbuf);
  761. }