BSD 4_3_Net_1 release

[unix-history] / lib / libc / ns / ns_addr.c

/*
* Copyright (c) 1986 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley.  The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* This code is derived from software contributed to Berkeley by
* J.Q. Johnson at Cornell University.
*/

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)ns_addr.c   6.4 (Berkeley) 8/12/88";
#endif /* LIBC_SCCS and not lint */

#include <sys/types.h>
#include <netns/ns.h>

static struct ns_addr addr, zero_addr;

struct ns_addr 
ns_addr(name)
       char *name;
{
       char separator = '.';
       char *hostname, *socketname, *cp;
       char buf[50];
       extern char *index();

       addr = zero_addr;
       (void)strncpy(buf, name, 49);

       /*
        * First, figure out what he intends as a field separtor.
        * Despite the way this routine is written, the prefered
        * form  2-272.AA001234H.01777, i.e. XDE standard.
        * Great efforts are made to insure backward compatability.
        */
       if (hostname = index(buf, '#'))
               separator = '#';
       else {
               hostname = index(buf, '.');
               if ((cp = index(buf, ':')) &&
                   ( (hostname && cp < hostname) || (hostname == 0))) {
                       hostname = cp;
                       separator = ':';
               }
       }
       if (hostname)
               *hostname++ = 0;
       Field(buf, addr.x_net.c_net, 4);
       if (hostname == 0)
               return (addr);  /* No separator means net only */

       socketname = index(hostname, separator);
       if (socketname) {
               *socketname++ = 0;
               Field(socketname, (u_char *)&addr.x_port, 2);
       }

       Field(hostname, addr.x_host.c_host, 6);

       return (addr);
}

static
Field(buf, out, len)
char *buf;
u_char *out;
int len;
{
       register char *bp = buf;
       int i, ibase, base16 = 0, base10 = 0, clen = 0;
       int hb[6], *hp;
       char *fmt;

       /*
        * first try 2-273#2-852-151-014#socket
        */
       if ((*buf != '-') &&
           (1 < (i = sscanf(buf, "%d-%d-%d-%d-%d",
                       &hb[0], &hb[1], &hb[2], &hb[3], &hb[4])))) {
               cvtbase(1000L, 256, hb, i, out, len);
               return;
       }
       /*
        * try form 8E1#0.0.AA.0.5E.E6#socket
        */
       if (1 < (i = sscanf(buf,"%x.%x.%x.%x.%x.%x",
                       &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
               cvtbase(256L, 256, hb, i, out, len);
               return;
       }
       /*
        * try form 8E1#0:0:AA:0:5E:E6#socket
        */
       if (1 < (i = sscanf(buf,"%x:%x:%x:%x:%x:%x",
                       &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
               cvtbase(256L, 256, hb, i, out, len);
               return;
       }
       /*
        * This is REALLY stretching it but there was a
        * comma notation separting shorts -- definitely non standard
        */
       if (1 < (i = sscanf(buf,"%x,%x,%x",
                       &hb[0], &hb[1], &hb[2]))) {
               hb[0] = htons(hb[0]); hb[1] = htons(hb[1]);
               hb[2] = htons(hb[2]);
               cvtbase(65536L, 256, hb, i, out, len);
               return;
       }

       /* Need to decide if base 10, 16 or 8 */
       while (*bp) switch (*bp++) {

       case '0': case '1': case '2': case '3': case '4': case '5':
       case '6': case '7': case '-':
               break;

       case '8': case '9':
               base10 = 1;
               break;

       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
       case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
               base16 = 1;
               break;
       
       case 'x': case 'X':
               *--bp = '0';
               base16 = 1;
               break;

       case 'h': case 'H':
               base16 = 1;
               /* fall into */

       default:
               *--bp = 0; /* Ends Loop */
       }
       if (base16) {
               fmt = "%3x";
               ibase = 4096;
       } else if (base10 == 0 && *buf == '0') {
               fmt = "%3o";
               ibase = 512;
       } else {
               fmt = "%3d";
               ibase = 1000;
       }

       for (bp = buf; *bp++; ) clen++;
       if (clen == 0) clen++;
       if (clen > 18) clen = 18;
       i = ((clen - 1) / 3) + 1;
       bp = clen + buf - 3;
       hp = hb + i - 1;

       while (hp > hb) {
               (void)sscanf(bp, fmt, hp);
               bp[0] = 0;
               hp--;
               bp -= 3;
       }
       (void)sscanf(buf, fmt, hp);
       cvtbase((long)ibase, 256, hb, i, out, len);
}

static
cvtbase(oldbase,newbase,input,inlen,result,reslen)
       long oldbase;
       int newbase;
       int input[];
       int inlen;
       unsigned char result[];
       int reslen;
{
       int d, e;
       long sum;

       e = 1;
       while (e > 0 && reslen > 0) {
               d = 0; e = 0; sum = 0;
               /* long division: input=input/newbase */
               while (d < inlen) {
                       sum = sum*oldbase + (long) input[d];
                       e += (sum > 0);
                       input[d++] = sum / newbase;
                       sum %= newbase;
               }
               result[--reslen] = sum; /* accumulate remainder */
       }
       for (d=0; d < reslen; d++)
               result[d] = 0;
}