Back to index

glibc  2.9
Defines | Functions | Variables
res_debug.c File Reference
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <netdb.h>
#include <resolv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

Go to the source code of this file.

Defines

#define SPRINTF(x)   sprintf x

Functions

void fp_resstat (const res_state statp, FILE *file)
static void do_section (const res_state statp, ns_msg *handle, ns_sect section, int pflag, FILE *file)
void res_pquery (const res_state statp, const u_char *msg, int len, FILE *file)
const u_charp_cdnname (const u_char *cp, const u_char *msg, int len, FILE *file)
 libresolv_hidden_def (p_cdnname) const
const u_charp_fqnname (u_char *cp, u_char *msg, int msglen, char *name, int namelen) const
 libresolv_hidden_def (p_fqnname) const
 libresolv_hidden_proto (__p_class_syms) const
 libresolv_hidden_data_def (__p_class_syms) const
 libresolv_hidden_proto (__p_type_syms) const
 libresolv_hidden_data_def (__p_type_syms) const
int sym_ston (const struct res_sym *syms, const char *name, int *success)
const char * sym_ntos (const struct res_sym *syms, int number, int *success)
 libresolv_hidden_def (sym_ntos) const
const char * p_type (int type)
 libresolv_hidden_def (p_type) const
const char * p_class (int class)
 libresolv_hidden_def (p_class) const
 libresolv_hidden_def (p_option) const
const char * p_rcode (int rcode)
 libresolv_hidden_def (p_rcode)
static const char * precsize_ntoa (u_int8_t prec)
static u_int8_t precsize_aton (const char **strptr)
static u_int32_t latlon2ul (const char **latlonstrptr, int *which)
int loc_aton (char *ascii, u_char *binary) const
const char * loc_ntoa (u_char *binary, char *ascii) const
 libresolv_hidden_def (loc_ntoa)
 libresolv_hidden_def (__dn_count_labels)

Variables

const char *_res_sectioncodes[] attribute_hidden

Define Documentation

#define SPRINTF (   x)    sprintf x

Definition at line 118 of file res_debug.c.


Function Documentation

static void do_section ( const res_state  statp,
ns_msg handle,
ns_sect  section,
int  pflag,
FILE file 
) [static]

Definition at line 138 of file res_debug.c.

{
       int n, sflag, rrnum;
       static int buflen = 2048;
       char *buf;
       ns_opcode opcode;
       ns_rr rr;

       /*
        * Print answer records.
        */
       sflag = (statp->pfcode & pflag);
       if (statp->pfcode && !sflag)
              return;

       buf = malloc(buflen);
       if (buf == NULL) {
              fprintf(file, ";; memory allocation failure\n");
              return;
       }

       opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
       rrnum = 0;
       for (;;) {
              if (ns_parserr(handle, section, rrnum, &rr)) {
                     if (errno != ENODEV)
                            fprintf(file, ";; ns_parserr: %s\n",
                                   strerror(errno));
                     else if (rrnum > 0 && sflag != 0 &&
                             (statp->pfcode & RES_PRF_HEAD1))
                            putc('\n', file);
                     goto cleanup;
              }
              if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
                     fprintf(file, ";; %s SECTION:\n",
                            p_section(section, opcode));
              if (section == ns_s_qd)
                     fprintf(file, ";;\t%s, type = %s, class = %s\n",
                            ns_rr_name(rr),
                            p_type(ns_rr_type(rr)),
                            p_class(ns_rr_class(rr)));
              else {
                     n = ns_sprintrr(handle, &rr, NULL, NULL,
                                   buf, buflen);
                     if (n < 0) {
                            if (errno == ENOSPC) {
                                   free(buf);
                                   buf = NULL;
                                   if (buflen < 131072)
                                          buf = malloc(buflen += 1024);
                                   if (buf == NULL) {
                                          fprintf(file,
                                          ";; memory allocation failure\n");
                                         return;
                                   }
                                   continue;
                            }
                            fprintf(file, ";; ns_sprintrr: %s\n",
                                   strerror(errno));
                            goto cleanup;
                     }
                     fputs(buf, file);
                     fputc('\n', file);
              }
              rrnum++;
       }
 cleanup:
       free(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void fp_resstat ( const res_state  statp,
FILE file 
)

Definition at line 127 of file res_debug.c.

                                              {
       u_long mask;

       fprintf(file, ";; res options:");
       for (mask = 1;  mask != 0;  mask <<= 1)
              if (statp->options & mask)
                     fprintf(file, " %s", p_option(mask));
       putc('\n', file);
}

Here is the call graph for this function:

static u_int32_t latlon2ul ( const char **  latlonstrptr,
int which 
) [static]

Definition at line 687 of file res_debug.c.

{
       const char *cp;
       u_int32_t retval;
       int deg = 0, min = 0, secs = 0, secsfrac = 0;

       cp = *latlonstrptr;

       while (isdigit(*cp))
              deg = deg * 10 + (*cp++ - '0');

       while (isspace(*cp))
              cp++;

       if (!(isdigit(*cp)))
              goto fndhemi;

       while (isdigit(*cp))
              min = min * 10 + (*cp++ - '0');

       while (isspace(*cp))
              cp++;

       if (!(isdigit(*cp)))
              goto fndhemi;

       while (isdigit(*cp))
              secs = secs * 10 + (*cp++ - '0');

       if (*cp == '.') {           /* decimal seconds */
              cp++;
              if (isdigit(*cp)) {
                     secsfrac = (*cp++ - '0') * 100;
                     if (isdigit(*cp)) {
                            secsfrac += (*cp++ - '0') * 10;
                            if (isdigit(*cp)) {
                                   secsfrac += (*cp++ - '0');
                            }
                     }
              }
       }

       while (!isspace(*cp))       /* if any trailing garbage */
              cp++;

       while (isspace(*cp))
              cp++;

 fndhemi:
       switch (*cp) {
       case 'N': case 'n':
       case 'E': case 'e':
              retval = ((unsigned)1<<31)
                     + (((((deg * 60) + min) * 60) + secs) * 1000)
                     + secsfrac;
              break;
       case 'S': case 's':
       case 'W': case 'w':
              retval = ((unsigned)1<<31)
                     - (((((deg * 60) + min) * 60) + secs) * 1000)
                     - secsfrac;
              break;
       default:
              retval = 0;   /* invalid value -- indicates error */
              break;
       }

       switch (*cp) {
       case 'N': case 'n':
       case 'S': case 's':
              *which = 1;   /* latitude */
              break;
       case 'E': case 'e':
       case 'W': case 'w':
              *which = 2;   /* longitude */
              break;
       default:
              *which = 0;   /* error */
              break;
       }

       cp++;                /* skip the hemisphere */

       while (!isspace(*cp))       /* if any trailing garbage */
              cp++;

       while (isspace(*cp)) /* move to next field */
              cp++;

       *latlonstrptr = cp;

       return (retval);
}

Here is the caller graph for this function:

libresolv_hidden_data_def ( __p_class_syms  ) const

Definition at line 361 of file res_debug.c.

                                                                   {
       {ns_s_qd,     "QUERY"},
       {ns_s_an,     "ANSWER"},
       {ns_s_ns,     "AUTHORITY"},
       {ns_s_ar,     "ADDITIONAL"},
       {0,             (char *)0}
};
libresolv_hidden_data_def ( __p_type_syms  ) const

Definition at line 455 of file res_debug.c.

                                                         {
       {ns_r_noerror,       "NOERROR",           "no error"},
       {ns_r_formerr,       "FORMERR",           "format error"},
       {ns_r_servfail,      "SERVFAIL",          "server failed"},
       {ns_r_nxdomain,      "NXDOMAIN",          "no such domain name"},
       {ns_r_notimpl,       "NOTIMP",            "not implemented"},
       {ns_r_refused,       "REFUSED",           "refused"},
       {ns_r_yxdomain,      "YXDOMAIN",          "domain name exists"},
       {ns_r_yxrrset,       "YXRRSET",           "rrset exists"},
       {ns_r_nxrrset,       "NXRRSET",           "rrset doesn't exist"},
       {ns_r_notauth,       "NOTAUTH",           "not authoritative"},
       {ns_r_notzone,       "NOTZONE",           "Not in zone"},
       {ns_r_max,    "",                  ""},
       {ns_r_badsig, "BADSIG",            "bad signature"},
       {ns_r_badkey, "BADKEY",            "bad key"},
       {ns_r_badtime,       "BADTIME",           "bad time"},
       {0,           NULL,                NULL}
};

Definition at line 299 of file res_debug.c.

                                                          {
       return (p_cdnname(cp, msg, PACKETSZ, file));
}

Definition at line 329 of file res_debug.c.

                                                          {
       char name[MAXDNAME];
       const u_char *n;

       n = p_fqnname(cp, msg, MAXCDNAME, name, sizeof name);
       if (n == NULL)
              return (NULL);
       fputs(name, file);
       return (n);
}

Here is the call graph for this function:

Definition at line 510 of file res_debug.c.

                                                               {
       static char unname[20];

       for ((void)NULL; syms->name != 0; syms++) {
              if (number == syms->number) {
                     if (success)
                            *success = 1;
                     return (syms->humanname);
              }
       }
       sprintf(unname, "%d", number);            /* XXX nonreentrant */
       if (success)
              *success = 0;
       return (unname);
}

Definition at line 536 of file res_debug.c.

                                   {
       const struct res_sym *symbols;

       switch (opcode) {
       case ns_o_update:
              symbols = __p_update_section_syms;
              break;
       default:
              symbols = __p_default_section_syms;
              break;
       }
       return (sym_ntos(symbols, section, (int *)0));
}

Definition at line 563 of file res_debug.c.

                        {
       static char nbuf[40];

       switch (option) {
       case RES_INIT:              return "init";
       case RES_DEBUG:             return "debug";
       case RES_AAONLY:     return "aaonly(unimpl)";
       case RES_USEVC:             return "usevc";
       case RES_PRIMARY:    return "primry(unimpl)";
       case RES_IGNTC:             return "igntc";
       case RES_RECURSE:    return "recurs";
       case RES_DEFNAMES:   return "defnam";
       case RES_STAYOPEN:   return "styopn";
       case RES_DNSRCH:     return "dnsrch";
       case RES_INSECURE1:  return "insecure1";
       case RES_INSECURE2:  return "insecure2";
       case RES_USE_INET6:  return "inet6";
       case RES_ROTATE:     return "rotate";
       case RES_NOCHECKNAME:       return "no-check-names";
       case RES_USEBSTRING: return "ip6-bytstring";
                            /* XXX nonreentrant */
       default:             sprintf(nbuf, "?0x%lx?", (u_long)option);
                            return (nbuf);
       }
}

Definition at line 594 of file res_debug.c.

                        {
       static char nbuf[40];              /* XXX nonreentrant */

       if (ns_format_ttl(value, nbuf, sizeof nbuf) < 0)
              sprintf(nbuf, "%u", value);
       return (nbuf);
}

Here is the call graph for this function:

Definition at line 615 of file res_debug.c.

  { 1, 10, 100, 1000, 10000, 100000,
    1000000,10000000,100000000,1000000000};

Definition at line 1000 of file res_debug.c.

                                  {
       int i, len, count;

       len = strlen(name);
       for (i = 0, count = 0; i < len; i++) {
              /* XXX need to check for \. or use named's nlabels(). */
              if (name[i] == '.')
                     count++;
       }

       /* don't count initial wildcard */
       if (name[0] == '*')
              if (count)
                     count--;

       /* don't count the null label for root. */
       /* if terminating '.' not found, must adjust */
       /* count to include last label */
       if (len > 0 && name[len-1] != '.')
              count++;
       return (count);
}

Here is the call graph for this function:

libresolv_hidden_def ( __dn_count_labels  )

Definition at line 1027 of file res_debug.c.

                           {
       /* XXX nonreentrant */
       static char output[15];            /* YYYYMMDDHHMMSS and null */
       time_t clock = secs;
       struct tm *time;

#ifdef HAVE_TIME_R
       struct tm timebuf;

       time = gmtime_r(&clock, &timebuf);
#else
       time = gmtime(&clock);
#endif
       time->tm_year += 1900;
       time->tm_mon += 1;
       sprintf(output, "%04d%02d%02d%02d%02d%02d",
              time->tm_year, time->tm_mon, time->tm_mday,
              time->tm_hour, time->tm_min, time->tm_sec);
       return (output);
}

Here is the call graph for this function:

libresolv_hidden_proto ( __p_class_syms  ) const

Definition at line 351 of file res_debug.c.

                                        {
       {C_IN,        "IN"},
       {C_CHAOS,     "CHAOS"},
       {C_HS,        "HS"},
       {C_HS,        "HESIOD"},
       {C_ANY,              "ANY"},
       {C_NONE,      "NONE"},
       {C_IN,               (char *)0}
};
libresolv_hidden_proto ( __p_type_syms  ) const

Definition at line 406 of file res_debug.c.

                                       {
       {ns_t_a,      "A",          "address"},
       {ns_t_ns,     "NS",         "name server"},
       {ns_t_md,     "MD",         "mail destination (deprecated)"},
       {ns_t_mf,     "MF",         "mail forwarder (deprecated)"},
       {ns_t_cname,  "CNAME",      "canonical name"},
       {ns_t_soa,    "SOA",        "start of authority"},
       {ns_t_mb,     "MB",         "mailbox"},
       {ns_t_mg,     "MG",         "mail group member"},
       {ns_t_mr,     "MR",         "mail rename"},
       {ns_t_null,   "NULL",              "null"},
       {ns_t_wks,    "WKS",        "well-known service (deprecated)"},
       {ns_t_ptr,    "PTR",        "domain name pointer"},
       {ns_t_hinfo,  "HINFO",      "host information"},
       {ns_t_minfo,  "MINFO",      "mailbox information"},
       {ns_t_mx,     "MX",         "mail exchanger"},
       {ns_t_txt,    "TXT",        "text"},
       {ns_t_rp,     "RP",         "responsible person"},
       {ns_t_afsdb,  "AFSDB",      "DCE or AFS server"},
       {ns_t_x25,    "X25",        "X25 address"},
       {ns_t_isdn,   "ISDN",              "ISDN address"},
       {ns_t_rt,     "RT",         "router"},
       {ns_t_nsap,   "NSAP",              "nsap address"},
       {ns_t_nsap_ptr,      "NSAP_PTR",   "domain name pointer"},
       {ns_t_sig,    "SIG",        "signature"},
       {ns_t_key,    "KEY",        "key"},
       {ns_t_px,     "PX",         "mapping information"},
       {ns_t_gpos,   "GPOS",              "geographical position (withdrawn)"},
       {ns_t_aaaa,   "AAAA",              "IPv6 address"},
       {ns_t_loc,    "LOC",        "location"},
       {ns_t_nxt,    "NXT",        "next valid name (unimplemented)"},
       {ns_t_eid,    "EID",        "endpoint identifier (unimplemented)"},
       {ns_t_nimloc, "NIMLOC",     "NIMROD locator (unimplemented)"},
       {ns_t_srv,    "SRV",        "server selection"},
       {ns_t_atma,   "ATMA",              "ATM address (unimplemented)"},
       {ns_t_dname,  "DNAME",      "Non-terminal DNAME (for IPv6)"},
       {ns_t_tsig,   "TSIG",              "transaction signature"},
       {ns_t_ixfr,   "IXFR",              "incremental zone transfer"},
       {ns_t_axfr,   "AXFR",              "zone transfer"},
       {ns_t_zxfr,   "ZXFR",              "compressed zone transfer"},
       {ns_t_mailb,  "MAILB",      "mailbox-related data (deprecated)"},
       {ns_t_maila,  "MAILA",      "mail agent (deprecated)"},
       {ns_t_naptr,  "NAPTR",      "URN Naming Authority"},
       {ns_t_kx,     "KX",         "Key Exchange"},
       {ns_t_cert,   "CERT",              "Certificate"},
       {ns_t_any,    "ANY",        "\"any\""},
       {0,           NULL,         NULL}
};
int loc_aton ( char *  ascii,
u_char binary 
) const

Definition at line 784 of file res_debug.c.

{
       const char *cp, *maxcp;
       u_char *bcp;

       u_int32_t latit = 0, longit = 0, alt = 0;
       u_int32_t lltemp1 = 0, lltemp2 = 0;
       int altmeters = 0, altfrac = 0, altsign = 1;
       u_int8_t hp = 0x16;  /* default = 1e6 cm = 10000.00m = 10km */
       u_int8_t vp = 0x13;  /* default = 1e3 cm = 10.00m */
       u_int8_t siz = 0x12; /* default = 1e2 cm = 1.00m */
       int which1 = 0, which2 = 0;

       cp = ascii;
       maxcp = cp + strlen(ascii);

       lltemp1 = latlon2ul(&cp, &which1);

       lltemp2 = latlon2ul(&cp, &which2);

       switch (which1 + which2) {
       case 3:                     /* 1 + 2, the only valid combination */
              if ((which1 == 1) && (which2 == 2)) { /* normal case */
                     latit = lltemp1;
                     longit = lltemp2;
              } else if ((which1 == 2) && (which2 == 1)) { /* reversed */
                     longit = lltemp1;
                     latit = lltemp2;
              } else {      /* some kind of brokenness */
                     return (0);
              }
              break;
       default:             /* we didn't get one of each */
              return (0);
       }

       /* altitude */
       if (*cp == '-') {
              altsign = -1;
              cp++;
       }

       if (*cp == '+')
              cp++;

       while (isdigit(*cp))
              altmeters = altmeters * 10 + (*cp++ - '0');

       if (*cp == '.') {           /* decimal meters */
              cp++;
              if (isdigit(*cp)) {
                     altfrac = (*cp++ - '0') * 10;
                     if (isdigit(*cp)) {
                            altfrac += (*cp++ - '0');
                     }
              }
       }

       alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));

       while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */
              cp++;

       while (isspace(*cp) && (cp < maxcp))
              cp++;

       if (cp >= maxcp)
              goto defaults;

       siz = precsize_aton(&cp);

       while (!isspace(*cp) && (cp < maxcp))     /* if trailing garbage or m */
              cp++;

       while (isspace(*cp) && (cp < maxcp))
              cp++;

       if (cp >= maxcp)
              goto defaults;

       hp = precsize_aton(&cp);

       while (!isspace(*cp) && (cp < maxcp))     /* if trailing garbage or m */
              cp++;

       while (isspace(*cp) && (cp < maxcp))
              cp++;

       if (cp >= maxcp)
              goto defaults;

       vp = precsize_aton(&cp);

 defaults:

       bcp = binary;
       *bcp++ = (u_int8_t) 0;      /* version byte */
       *bcp++ = siz;
       *bcp++ = hp;
       *bcp++ = vp;
       PUTLONG(latit,bcp);
       PUTLONG(longit,bcp);
       PUTLONG(alt,bcp);

       return (16);         /* size of RR in octets */
}

Here is the call graph for this function:

const char* loc_ntoa ( u_char binary,
char *  ascii 
) const

Definition at line 895 of file res_debug.c.

{
       static const char error[] = "?";
       static char tmpbuf[sizeof
"1000 60 60.000 N 1000 60 60.000 W -12345678.00m 90000000.00m 90000000.00m 90000000.00m"];
       const u_char *cp = binary;

       int latdeg, latmin, latsec, latsecfrac;
       int longdeg, longmin, longsec, longsecfrac;
       char northsouth, eastwest;
       int altmeters, altfrac, altsign;

       const u_int32_t referencealt = 100000 * 100;

       int32_t latval, longval, altval;
       u_int32_t templ;
       u_int8_t sizeval, hpval, vpval, versionval;

       char *sizestr, *hpstr, *vpstr;

       versionval = *cp++;

       if (ascii == NULL)
              ascii = tmpbuf;

       if (versionval) {
              (void) sprintf(ascii, "; error: unknown LOC RR version");
              return (ascii);
       }

       sizeval = *cp++;

       hpval = *cp++;
       vpval = *cp++;

       GETLONG(templ, cp);
       latval = (templ - ((unsigned)1<<31));

       GETLONG(templ, cp);
       longval = (templ - ((unsigned)1<<31));

       GETLONG(templ, cp);
       if (templ < referencealt) { /* below WGS 84 spheroid */
              altval = referencealt - templ;
              altsign = -1;
       } else {
              altval = templ - referencealt;
              altsign = 1;
       }

       if (latval < 0) {
              northsouth = 'S';
              latval = -latval;
       } else
              northsouth = 'N';

       latsecfrac = latval % 1000;
       latval = latval / 1000;
       latsec = latval % 60;
       latval = latval / 60;
       latmin = latval % 60;
       latval = latval / 60;
       latdeg = latval;

       if (longval < 0) {
              eastwest = 'W';
              longval = -longval;
       } else
              eastwest = 'E';

       longsecfrac = longval % 1000;
       longval = longval / 1000;
       longsec = longval % 60;
       longval = longval / 60;
       longmin = longval % 60;
       longval = longval / 60;
       longdeg = longval;

       altfrac = altval % 100;
       altmeters = (altval / 100) * altsign;

       if ((sizestr = strdup(precsize_ntoa(sizeval))) == NULL)
              sizestr = (char *) error;
       if ((hpstr = strdup(precsize_ntoa(hpval))) == NULL)
              hpstr = (char *) error;
       if ((vpstr = strdup(precsize_ntoa(vpval))) == NULL)
              vpstr = (char *) error;

       sprintf(ascii,
             "%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %d.%.2dm %sm %sm %sm",
              latdeg, latmin, latsec, latsecfrac, northsouth,
              longdeg, longmin, longsec, longsecfrac, eastwest,
              altmeters, altfrac, sizestr, hpstr, vpstr);

       if (sizestr != (char *) error)
              free(sizestr);
       if (hpstr != (char *) error)
              free(hpstr);
       if (vpstr != (char *) error)
              free(vpstr);

       return (ascii);
}

Here is the call graph for this function:

const u_char* p_cdnname ( const u_char cp,
const u_char msg,
int  len,
FILE file 
)

Definition at line 287 of file res_debug.c.

                                                                    {
       char name[MAXDNAME];
       int n;

       if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0)
              return (NULL);
       if (name[0] == '\0')
              putc('.', file);
       else
              fputs(name, file);
       return (cp + n);
}

Here is the call graph for this function:

const char* p_class ( int  class)

Definition at line 560 of file res_debug.c.

                   {
       return (sym_ntos(__p_class_syms, class, (int *)0));
}
const u_char* p_fqnname ( u_char cp,
u_char msg,
int  msglen,
char *  name,
int  namelen 
) const

Definition at line 310 of file res_debug.c.

{
       int n, newlen;

       if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0)
              return (NULL);
       newlen = strlen(name);
       if (newlen == 0 || name[newlen - 1] != '.') {
              if (newlen + 1 >= namelen)  /* Lack space for final dot */
                     return (NULL);
              else
                     strcpy(name + newlen, ".");
       }
       return (cp + n);
}

Here is the call graph for this function:

const char* p_rcode ( int  rcode)

Definition at line 612 of file res_debug.c.

                   {
       return (sym_ntos(__p_rcode_syms, rcode, (int *)0));
}
const char* p_type ( int  type)

Definition at line 533 of file res_debug.c.

                 {
       return (sym_ntos(__p_type_syms, type, (int *)0));
}
static u_int8_t precsize_aton ( const char **  strptr) [static]

Definition at line 646 of file res_debug.c.

{
       unsigned int mval = 0, cmval = 0;
       u_int8_t retval = 0;
       const char *cp;
       int exponent;
       int mantissa;

       cp = *strptr;

       while (isdigit(*cp))
              mval = mval * 10 + (*cp++ - '0');

       if (*cp == '.') {           /* centimeters */
              cp++;
              if (isdigit(*cp)) {
                     cmval = (*cp++ - '0') * 10;
                     if (isdigit(*cp)) {
                            cmval += (*cp++ - '0');
                     }
              }
       }
       cmval = (mval * 100) + cmval;

       for (exponent = 0; exponent < 9; exponent++)
              if (cmval < poweroften[exponent+1])
                     break;

       mantissa = cmval / poweroften[exponent];
       if (mantissa > 9)
              mantissa = 9;

       retval = (mantissa << 4) | exponent;

       *strptr = cp;

       return (retval);
}

Here is the caller graph for this function:

static const char* precsize_ntoa ( u_int8_t  prec) [static]

Definition at line 629 of file res_debug.c.

{
       static char retbuf[sizeof "90000000.00"]; /* XXX nonreentrant */
       unsigned long val;
       int mantissa, exponent;

       mantissa = (int)((prec >> 4) & 0x0f) % 10;
       exponent = (int)((prec >> 0) & 0x0f) % 10;

       val = mantissa * poweroften[exponent];

       (void) sprintf(retbuf, "%ld.%.2ld", val/100, val%100);
       return (retbuf);
}

Here is the caller graph for this function:

void res_pquery ( const res_state  statp,
const u_char msg,
int  len,
FILE file 
)

Definition at line 215 of file res_debug.c.

                                                                          {
       ns_msg handle;
       int qdcount, ancount, nscount, arcount;
       u_int opcode, rcode, id;

       if (ns_initparse(msg, len, &handle) < 0) {
              fprintf(file, ";; ns_initparse: %s\n", strerror(errno));
              return;
       }
       opcode = ns_msg_getflag(handle, ns_f_opcode);
       rcode = ns_msg_getflag(handle, ns_f_rcode);
       id = ns_msg_id(handle);
       qdcount = ns_msg_count(handle, ns_s_qd);
       ancount = ns_msg_count(handle, ns_s_an);
       nscount = ns_msg_count(handle, ns_s_ns);
       arcount = ns_msg_count(handle, ns_s_ar);

       /*
        * Print header fields.
        */
       if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEADX) || rcode)
              fprintf(file,
                     ";; ->>HEADER<<- opcode: %s, status: %s, id: %d\n",
                     _res_opcodes[opcode], p_rcode(rcode), id);
       if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEADX))
              putc(';', file);
       if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEAD2)) {
              fprintf(file, "; flags:");
              if (ns_msg_getflag(handle, ns_f_qr))
                     fprintf(file, " qr");
              if (ns_msg_getflag(handle, ns_f_aa))
                     fprintf(file, " aa");
              if (ns_msg_getflag(handle, ns_f_tc))
                     fprintf(file, " tc");
              if (ns_msg_getflag(handle, ns_f_rd))
                     fprintf(file, " rd");
              if (ns_msg_getflag(handle, ns_f_ra))
                     fprintf(file, " ra");
              if (ns_msg_getflag(handle, ns_f_z))
                     fprintf(file, " ??");
              if (ns_msg_getflag(handle, ns_f_ad))
                     fprintf(file, " ad");
              if (ns_msg_getflag(handle, ns_f_cd))
                     fprintf(file, " cd");
       }
       if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEAD1)) {
              fprintf(file, "; %s: %d",
                     p_section(ns_s_qd, opcode), qdcount);
              fprintf(file, ", %s: %d",
                     p_section(ns_s_an, opcode), ancount);
              fprintf(file, ", %s: %d",
                     p_section(ns_s_ns, opcode), nscount);
              fprintf(file, ", %s: %d",
                     p_section(ns_s_ar, opcode), arcount);
       }
       if ((!statp->pfcode) || (statp->pfcode &
              (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
              putc('\n',file);
       }
       /*
        * Print the various sections.
        */
       do_section(statp, &handle, ns_s_qd, RES_PRF_QUES, file);
       do_section(statp, &handle, ns_s_an, RES_PRF_ANS, file);
       do_section(statp, &handle, ns_s_ns, RES_PRF_AUTH, file);
       do_section(statp, &handle, ns_s_ar, RES_PRF_ADD, file);
       if (qdcount == 0 && ancount == 0 &&
           nscount == 0 && arcount == 0)
              putc('\n', file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* sym_ntos ( const struct res_sym syms,
int  number,
int success 
)

Definition at line 494 of file res_debug.c.

                                                               {
       static char unname[20];

       for ((void)NULL; syms->name != 0; syms++) {
              if (number == syms->number) {
                     if (success)
                            *success = 1;
                     return (syms->name);
              }
       }

       sprintf(unname, "%d", number);            /* XXX nonreentrant */
       if (success)
              *success = 0;
       return (unname);
}
int sym_ston ( const struct res_sym syms,
const char *  name,
int success 
)

Definition at line 480 of file res_debug.c.

                                                                     {
       for ((void)NULL; syms->name != 0; syms++) {
              if (strcasecmp (name, syms->name) == 0) {
                     if (success)
                            *success = 1;
                     return (syms->number);
              }
       }
       if (success)
              *success = 0;
       return (syms->number);             /* The default value. */
}

Here is the call graph for this function:


Variable Documentation

Initial value:
 {
       {S_ZONE,      "ZONE"},
       {S_PREREQ,    "PREREQUISITE"},
       {S_UPDATE,    "UPDATE"},
       {S_ADDT,      "ADDITIONAL"},
       {0,             (char *)0}
}

Definition at line 374 of file res_debug.c.