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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
res_debug.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

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