home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / internet / tcpipsrc / DNS / c / resolve_0 < prev   
Text File  |  1995-02-22  |  17KB  |  724 lines
  1. /*
  2.  * Copyright (c) 1985 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. #if defined(LIBC_SCCS) && !defined(lint)
  21. static char sccsid[] = "@(#)res_comp.c    6.18 (Berkeley) 6/27/90";
  22. #endif /* LIBC_SCCS and not lint */
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <time.h>
  28.  
  29. #include "netdb.h"
  30. #include "resolve.h"
  31. #include "nameser.h"
  32. #include "in.h"
  33. #include "socket.h"
  34.  
  35. static int dn_find(u_char *exp_dn, u_char *msg,
  36.            u_char **dnptrs, u_char **lastdnptr);
  37.  
  38. /*
  39.  * Expand compressed domain name 'comp_dn' to full domain name.
  40.  * 'msg' is a pointer to the begining of the message,
  41.  * 'eomorig' points to the first location after the message,
  42.  * 'exp_dn' is a pointer to a buffer of size 'length' for the result.
  43.  * Return size of compressed name or -1 if there was an error.
  44.  */
  45. int
  46. dn_expand(msg, eomorig, comp_dn, exp_dn, length)
  47.     u_char *msg, *eomorig, *comp_dn, *exp_dn;
  48.     int length;
  49. {
  50.     register u_char *cp, *dn;
  51.     register int n, c;
  52.     u_char *eom;
  53.     int len = -1, checked = 0;
  54.  
  55.     dn = exp_dn;
  56.     cp = comp_dn;
  57.     eom = exp_dn + length;
  58.     /*
  59.      * fetch next label in domain name
  60.      */
  61.     while (n = *cp++) {
  62.         /*
  63.          * Check for indirection
  64.          */
  65.         switch (n & INDIR_MASK) {
  66.         case 0:
  67.             if (dn != exp_dn) {
  68.                 if (dn >= eom)
  69.                     return (-1);
  70.                 *dn++ = '.';
  71.             }
  72.             if (dn+n >= eom)
  73.                 return (-1);
  74.             checked += n + 1;
  75.             while (--n >= 0) {
  76.                 if ((c = *cp++) == '.') {
  77.                     if (dn + n + 2 >= eom)
  78.                         return (-1);
  79.                     *dn++ = '\\';
  80.                 }
  81.                 *dn++ = c;
  82.                 if (cp >= eomorig)    /* out of range */
  83.                     return(-1);
  84.             }
  85.             break;
  86.  
  87.         case INDIR_MASK:
  88.             if (len < 0)
  89.                 len = cp - comp_dn + 1;
  90.             cp = msg + (((n & 0x3f) << 8) | (*cp & 0xff));
  91.             if (cp < msg || cp >= eomorig)    /* out of range */
  92.                 return(-1);
  93.             checked += 2;
  94.             /*
  95.              * Check for loops in the compressed name;
  96.              * if we've looked at the whole message,
  97.              * there must be a loop.
  98.              */
  99.             if (checked >= eomorig - msg)
  100.                 return (-1);
  101.             break;
  102.  
  103.         default:
  104.             return (-1);            /* flag error */
  105.         }
  106.     }
  107.     *dn = '\0';
  108.     if (len < 0)
  109.         len = cp - comp_dn;
  110.     return (len);
  111. }
  112.  
  113. /*
  114.  * Compress domain name 'exp_dn' into 'comp_dn'.
  115.  * Return the size of the compressed name or -1.
  116.  * 'length' is the size of the array pointed to by 'comp_dn'.
  117.  * 'dnptrs' is a list of pointers to previous compressed names. dnptrs[0]
  118.  * is a pointer to the beginning of the message. The list ends with NULL.
  119.  * 'lastdnptr' is a pointer to the end of the arrary pointed to
  120.  * by 'dnptrs'. Side effect is to update the list of pointers for
  121.  * labels inserted into the message as we compress the name.
  122.  * If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
  123.  * is NULL, we don't update the list.
  124.  */
  125. int
  126. dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
  127.     u_char *exp_dn, *comp_dn;
  128.     int length;
  129.     u_char **dnptrs, **lastdnptr;
  130. {
  131.     register u_char *cp, *dn;
  132.     register int c, l;
  133.     u_char **cpp, **lpp, *sp, *eob;
  134.     u_char *msg;
  135.  
  136.     dn = exp_dn;
  137.     cp = comp_dn;
  138.     eob = cp + length;
  139.     if (dnptrs != NULL) {
  140.         if ((msg = *dnptrs++) != NULL) {
  141.             for (cpp = dnptrs; *cpp != NULL; cpp++)
  142.                 ;
  143.             lpp = cpp;    /* end of list to search */
  144.         }
  145.     } else
  146.         msg = NULL;
  147.     for (c = *dn++; c != '\0'; ) {
  148.         /* look to see if we can use pointers */
  149.         if (msg != NULL) {
  150.             if ((l = dn_find(dn-1, msg, dnptrs, lpp)) >= 0) {
  151.                 if (cp+1 >= eob)
  152.                     return (-1);
  153.                 *cp++ = (l >> 8) | INDIR_MASK;
  154.                 *cp++ = l % 256;
  155.                 return (cp - comp_dn);
  156.             }
  157.             /* not found, save it */
  158.             if (lastdnptr != NULL && cpp < lastdnptr-1) {
  159.                 *cpp++ = cp;
  160.                 *cpp = NULL;
  161.             }
  162.         }
  163.         sp = cp++;    /* save ptr to length byte */
  164.         do {
  165.             if (c == '.') {
  166.                 c = *dn++;
  167.                 break;
  168.             }
  169.             if (c == '\\') {
  170.                 if ((c = *dn++) == '\0')
  171.                     break;
  172.             }
  173.             if (cp >= eob) {
  174.                 if (msg != NULL)
  175.                     *lpp = NULL;
  176.                 return (-1);
  177.             }
  178.             *cp++ = c;
  179.         } while ((c = *dn++) != '\0');
  180.         /* catch trailing '.'s but not '..' */
  181.         if ((l = cp - sp - 1) == 0 && c == '\0') {
  182.             cp--;
  183.             break;
  184.         }
  185.         if (l <= 0 || l > MAXLABEL) {
  186.             if (msg != NULL)
  187.                 *lpp = NULL;
  188.             return (-1);
  189.         }
  190.         *sp = l;
  191.     }
  192.     if (cp >= eob) {
  193.         if (msg != NULL)
  194.             *lpp = NULL;
  195.         return (-1);
  196.     }
  197.     *cp++ = '\0';
  198.     return (cp - comp_dn);
  199. }
  200.  
  201. /*
  202.  * Skip over a compressed domain name. Return the size or -1.
  203.  */
  204. int
  205. dn_skipname(comp_dn, eom)
  206.     u_char *comp_dn, *eom;
  207. {
  208.     register u_char *cp;
  209.     register int n;
  210.  
  211.     cp = comp_dn;
  212.     while (cp < eom && (n = *cp++)) {
  213.         /*
  214.          * check for indirection
  215.          */
  216.         switch (n & INDIR_MASK) {
  217.         case 0:        /* normal case, n == len */
  218.             cp += n;
  219.             continue;
  220.         default:    /* illegal type */
  221.             return (-1);
  222.         case INDIR_MASK:    /* indirection */
  223.             cp++;
  224.         }
  225.         break;
  226.     }
  227.     return (cp - comp_dn);
  228. }
  229.  
  230. /*
  231.  * Search for expanded name from a list of previously compressed names.
  232.  * Return the offset from msg if found or -1.
  233.  * dnptrs is the pointer to the first name on the list,
  234.  * not the pointer to the start of the message.
  235.  */
  236. static int
  237. dn_find(exp_dn, msg, dnptrs, lastdnptr)
  238.     u_char *exp_dn, *msg;
  239.     u_char **dnptrs, **lastdnptr;
  240. {
  241.     register u_char *dn, *cp, **cpp;
  242.     register int n;
  243.     u_char *sp;
  244.  
  245.     for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
  246.         dn = exp_dn;
  247.         sp = cp = *cpp;
  248.         while (n = *cp++) {
  249.             /*
  250.              * check for indirection
  251.              */
  252.             switch (n & INDIR_MASK) {
  253.             case 0:        /* normal case, n == len */
  254.                 while (--n >= 0) {
  255.                     if (*dn == '.')
  256.                         goto next;
  257.                     if (*dn == '\\')
  258.                         dn++;
  259.                     if (*dn++ != *cp++)
  260.                         goto next;
  261.                 }
  262.                 if ((n = *dn++) == '\0' && *cp == '\0')
  263.                     return (sp - msg);
  264.                 if (n == '.')
  265.                     continue;
  266.                 goto next;
  267.  
  268.             default:    /* illegal type */
  269.                 return (-1);
  270.  
  271.             case INDIR_MASK:    /* indirection */
  272.                 cp = msg + (((n & 0x3f) << 8) | *cp);
  273.             }
  274.         }
  275.         if (*dn == '\0')
  276.             return (sp - msg);
  277.     next:    ;
  278.     }
  279.     return (-1);
  280. }
  281.  
  282. /*
  283.  * Routines to insert/extract short/long's. Must account for byte
  284.  * order and non-alignment problems. This code at least has the
  285.  * advantage of being portable.
  286.  *
  287.  * used by sendmail.
  288.  */
  289.  
  290. u_short
  291. _getshort(msgp)
  292.     u_char *msgp;
  293. {
  294.     register u_char *p = (u_char *) msgp;
  295. #ifdef vax
  296.     /*
  297.      * vax compiler doesn't put shorts in registers
  298.      */
  299.     register u_long u;
  300. #else
  301.     register u_short u;
  302. #endif
  303.  
  304.     u = *p++ << 8;
  305.     return ((u_short)(u | *p));
  306. }
  307.  
  308. u_long
  309. _getlong(msgp)
  310.     u_char *msgp;
  311. {
  312.     register u_char *p = (u_char *) msgp;
  313.     register u_long u;
  314.  
  315.     u = *p++; u <<= 8;
  316.     u |= *p++; u <<= 8;
  317.     u |= *p++; u <<= 8;
  318.     return (u | *p);
  319. }
  320.  
  321.  
  322. putshort(s, msgp)
  323.     register u_short s;
  324.     register u_char *msgp;
  325. {
  326.  
  327.     msgp[1] = s;
  328.     msgp[0] = s >> 8;
  329. }
  330.  
  331. putlong(l, msgp)
  332.     register u_long l;
  333.     register u_char *msgp;
  334. {
  335.  
  336.     msgp[3] = l;
  337.     msgp[2] = (l >>= 8);
  338.     msgp[1] = (l >>= 8);
  339.     msgp[0] = l >> 8;
  340. }
  341.  
  342.  
  343.  
  344. static struct cache_s {
  345.   void *key;
  346.   int type;
  347.   int len;
  348.   struct hostent *cont;
  349.   time_t expires;
  350.   time_t accessed;
  351.   } *cache = 0;
  352.  
  353. unsigned int cachesize = 0;
  354.  
  355.  
  356. static void kill_cache( struct cache_s *entry )
  357. {
  358.   if( ! entry->key ) return;
  359.   free( entry->key );
  360.   entry->cont = NULL;
  361.   entry->key = NULL;
  362. }
  363.  
  364.  
  365. static int he_size( struct hostent *he )
  366. {
  367.   int size;
  368.   char **cp;
  369.   struct mx_data **mx;
  370.  
  371.   if( !he ) return 0;
  372.   size = sizeof( struct hostent ) + 2*sizeof(char *) + ((strlen(he->h_name)+4)&~3) + sizeof(struct mx_data *);
  373.   for( cp=he->h_aliases; *cp; cp++ ) size += sizeof(char *) + strlen(*cp)+1;
  374.   for( cp=he->h_addr_list; *cp; cp++ ) size += sizeof(char *) + h