![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ns_addr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / libc / ns|
Return to ns_addr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / libc / ns |
1.1 root 1: /*
2: * Copyright (c) 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * Includes material written at Cornell University, by J. Q. Johnson.
7: * Used by permission.
8: */
9:
10: #if defined(LIBC_SCCS) && !defined(lint)
11: static char sccsid[] = "@(#)ns_addr.c 6.2 (Berkeley) 3/9/86";
12: #endif LIBC_SCCS and not lint
13:
14: #include <sys/types.h>
15: #include <netns/ns.h>
16:
17: static struct ns_addr addr, zero_addr;
18:
19: struct ns_addr
20: ns_addr(name)
21: char *name;
22: {
23: u_long net;
24: u_short socket;
25: char separator = '.';
26: char *hostname, *socketname, *cp;
27: char buf[50];
28: extern char *index();
29:
30: addr = zero_addr;
31: strncpy(buf, name, 49);
32:
33: /*
34: * First, figure out what he intends as a field separtor.
35: * Despite the way this routine is written, the prefered
36: * form 2-272.AA001234H.01777, i.e. XDE standard.
37: * Great efforts are made to insure backward compatability.
38: */
39: if (hostname = index(buf, '#'))
40: separator = '#';
41: else {
42: hostname = index(buf, '.');
43: if ((cp = index(buf, ':')) &&
44: ( (hostname && cp < hostname) || (hostname == 0))) {
45: hostname = cp;
46: separator = ':';
47: }
48: }
49: if (hostname)
50: *hostname++ = 0;
51: Field(buf, addr.x_net.c_net, 4);
52: if (hostname == 0)
53: return (addr); /* No separator means net only */
54:
55: socketname = index(hostname, separator);
56: if (socketname) {
57: *socketname++ = 0;
58: Field(socketname, &addr.x_port, 2);
59: }
60:
61: Field(hostname, addr.x_host.c_host, 6);
62:
63: return (addr);
64: }
65:
66: static
67: Field(buf, out, len)
68: char *buf;
69: u_char *out;
70: int len;
71: {
72: register char *bp = buf;
73: int i, ibase, base16 = 0, base10 = 0, clen = 0;
74: int hb[6], *hp;
75: char *fmt;
76:
77: /*
78: * first try 2-273#2-852-151-014#socket
79: */
80: if ((*buf != '-') &&
81: (1 < (i = sscanf(buf, "%d-%d-%d-%d-%d",
82: &hb[0], &hb[1], &hb[2], &hb[3], &hb[4])))) {
83: cvtbase(1000, 256, hb, i, out, len);
84: return;
85: }
86: /*
87: * try form 8E1#0.0.AA.0.5E.E6#socket
88: */
89: if (1 < (i = sscanf(buf,"%x.%x.%x.%x.%x.%x",
90: &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
91: cvtbase(256, 256, hb, i, out, len);
92: return;
93: }
94: /*
95: * try form 8E1#0:0:AA:0:5E:E6#socket
96: */
97: if (1 < (i = sscanf(buf,"%x:%x:%x:%x:%x:%x",
98: &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
99: cvtbase(256, 256, hb, i, out, len);
100: return;
101: }
102: /*
103: * This is REALLY stretching it but there was a
104: * comma notation separting shorts -- definitely non standard
105: */
106: if (1 < (i = sscanf(buf,"%x,%x,%x",
107: &hb[0], &hb[1], &hb[2]))) {
108: hb[0] = htons(hb[0]); hb[1] = htons(hb[1]);
109: hb[2] = htons(hb[2]);
110: cvtbase(65536, 256, hb, i, out, len);
111: return;
112: }
113:
114: /* Need to decide if base 10, 16 or 8 */
115: while (*bp) switch (*bp++) {
116:
117: case '0': case '1': case '2': case '3': case '4': case '5':
118: case '6': case '7': case '-':
119: break;
120:
121: case '8': case '9':
122: base10 = 1;
123: break;
124:
125: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
126: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
127: base16 = 1;
128: break;
129:
130: case 'x': case 'X':
131: *--bp = '0';
132: base16 = 1;
133: break;
134:
135: case 'h': case 'H':
136: base16 = 1;
137: /* fall into */
138:
139: default:
140: *--bp = 0; /* Ends Loop */
141: }
142: if (base16) {
143: fmt = "%3x";
144: ibase = 4096;
145: } else if (base10 == 0 && *buf == '0') {
146: fmt = "%3o";
147: ibase = 512;
148: } else {
149: fmt = "%3d";
150: ibase = 1000;
151: }
152:
153: for (bp = buf; *bp++; ) clen++;
154: if (clen == 0) clen++;
155: if (clen > 18) clen = 18;
156: i = ((clen - 1) / 3) + 1;
157: bp = clen + buf - 3;
158: hp = hb + i - 1;
159:
160: while (hp > hb) {
161: sscanf(bp, fmt, hp);
162: bp[0] = 0;
163: hp--;
164: bp -= 3;
165: }
166: sscanf(buf, fmt, hp);
167: cvtbase(ibase, 256, hb, i, out, len);
168: }
169:
170: static
171: cvtbase(oldbase,newbase,input,inlen,result,reslen)
172: int oldbase, newbase;
173: int input[];
174: int inlen;
175: unsigned char result[];
176: int reslen;
177: {
178: int d, e;
179: long sum;
180:
181: e = 1;
182: while (e > 0 && reslen > 0) {
183: d = 0; e = 0; sum = 0;
184: /* long division: input=input/newbase */
185: while (d < inlen) {
186: sum = sum*oldbase + (long) input[d];
187: e += (sum > 0);
188: input[d++] = sum / newbase;
189: sum %= newbase;
190: }
191: result[--reslen] = sum; /* accumulate remainder */
192: }
193: for (d=0; d < reslen; d++)
194: result[d] = 0;
195: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.