1 /*
2 * Copyright (c) 1996-2003
3 * Fraunhofer Institute for Open Communication Systems (FhG Fokus).
4 * All rights reserved.
5 *
6 * Author: Hartmut Brandt <[email protected]>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $Begemot: libunimsg/netnatm/misc/straddr.c,v 1.4 2004/07/08 08:22:02 brandt Exp $
30 */
31
32 #include <sys/types.h>
33 #ifdef _KERNEL
34 #include <sys/ctype.h>
35 #include <sys/libkern.h>
36 #else
37 #include <ctype.h>
38 #include <string.h>
39 #endif
40 #include <netnatm/addr.h>
41
42 /*
43 * Convert an NSAP address from the ASCII format to the binary.
44 * ASCII format means each byte formatted as a 2-byte hex number
45 * with dots freely interspersed between the bytes.
46 * If the conversion is succesful, the function returns 0, -1
47 * on conversion errors.
48 */
49 int
uni_str2nsap(u_char * out,const char * in)50 uni_str2nsap(u_char *out, const char *in)
51 {
52 int i;
53 int c;
54
55 for(i = 0; i < 20; i++) {
56 while((c = *in++) == '.')
57 ;
58 if(!isascii(c) || !isxdigit(c))
59 return -1;
60 out[i] = isdigit(c) ? (c - '0')
61 : islower(c) ? (c - 'a' + 10)
62 : (c - 'A' + 10);
63 out[i] <<= 4;
64 c = *in++;
65 if(!isascii(c) || !isxdigit(c))
66 return -1;
67 out[i] |= isdigit(c) ? (c - '0')
68 : islower(c) ? (c - 'a' + 10)
69 : (c - 'A' + 10);
70 }
71 return *in != '\0';
72 }
73
74 /*
75 * Parse an emebedded E.164 NSAP address.
76 * If check is 0, the contents of the last 11 bytes are ignored
77 * If check is 1, the contents of all of these but the selector byte
78 * are checked to be zero. If check is 2 all 11 bytes must be 0.
79 */
80 int
uni_nsap2e164(char * e164,const u_char * nsap,int check)81 uni_nsap2e164(char *e164, const u_char *nsap, int check)
82 {
83 char *p = e164;
84 u_int d;
85 int i;
86
87 if(nsap[0] != 0x45)
88 return -1;
89 if((nsap[8] & 0xf) != 0xf)
90 return -1;
91 for(i = 1; i <= 7; i++) {
92 d = (nsap[i] >> 4) & 0xf;
93 if(d == 0x00 && p == e164)
94 continue;
95 if(d >= 0xa)
96 return -1;
97 *p++ = d + '0';
98
99 d = nsap[i] & 0xf;
100 if(d == 0x00 && p == e164)
101 continue;
102 if(d >= 0xa)
103 return -1;
104 *p++ = d + '0';
105 }
106 d = (nsap[i] >> 4) & 0xf;
107 if(d != 0x00 || p == e164) {
108 if(d >= 0xa)
109 return -1;
110 *p++ = d + '0';
111 }
112 if(p == e164)
113 return -1;
114 *p++ = 0;
115
116 if(check == 0)
117 return 0;
118 while(i < ((check == 1) ? 19 : 20)) {
119 if(nsap[i] != 0x00)
120 return -1;
121 i++;
122 }
123
124 return 0;
125 }
126
127 /*
128 * Convert a binary representation to ASCII. The standard formats are
129 * recognized and dotted. Non-standard formats get no dots altogether.
130 */
131 void
uni_prefix2str(char * out,const u_char * in,u_int len,int dotit)132 uni_prefix2str(char *out, const u_char *in, u_int len, int dotit)
133 {
134 static char hex[16] = "0123456789abcdef";
135 static int fmt[3][6] = {
136 { 1, 2, 10, 6, 1, 0 },
137 { 1, 2, 10, 6, 1, 0 },
138 { 1, 8, 4, 6, 1, 0 },
139 };
140 int f, b;
141 u_int i;
142
143 if (len > 20)
144 len = 20;
145
146 if(dotit) {
147 switch(*in) {
148
149 case 0x39: /* DCC */
150 i = 0;
151 fmt:
152 for(f = 0; fmt[i][f]; f++) {
153 if (len == 0)
154 goto done;
155 if(f != 0)
156 *out++ = '.';
157 for(b = 0; b < fmt[i][f]; b++) {
158 if (len-- == 0)
159 goto done;
160 *out++ = hex[(*in >> 4) & 0xf];
161 *out++ = hex[*in & 0xf];
162 in++;
163 }
164 }
165 done:
166 *out = '\0';
167 return;
168
169 case 0x47: /* ICD */
170 i = 1;
171 goto fmt;
172
173 case 0x45: /* E.164 */
174 i = 2;
175 goto fmt;
176 }
177 }
178
179 /* undotted */
180 for(i = 0; i < len; i++) {
181 *out++ = hex[(*in >> 4) & 0xf];
182 *out++ = hex[*in & 0xf];
183 in++;
184 }
185 *out = '\0';
186 }
187
188 void
uni_nsap2str(char * out,const u_char * in,int dotit)189 uni_nsap2str(char *out, const u_char *in, int dotit)
190 {
191 uni_prefix2str(out, in, 20, dotit);
192 }
193
194 /*
195 * Make an embedded E.164 NSAP address from a NSAP address.
196 * The E.164 address is a string of digits, at least one digit and
197 * not more than 15 digits long. The NSAP address will start with
198 * byte 0x45 and then a 8 byte field, which contains the right
199 * justified E.164 address in BCD coding, filled with a 0xf to the
200 * right. The rest of the address is zero.
201 * The function returns 0 if everything is ok, -1 in case of a wrong
202 * E.164 address.
203 */
204 int
uni_e1642nsap(u_char * nsap,const char * e164)205 uni_e1642nsap(u_char *nsap, const char *e164)
206 {
207 size_t len;
208 int fill;
209 u_int i;
210
211 if((len = strlen(e164)) > 15 || len == 0)
212 return -1;
213 for(i = 0; i < len; i++)
214 if(!isdigit(e164[i]))
215 return -1;
216
217 *nsap++ = 0x45;
218 fill = (15 - len) / 2;
219 while(fill--)
220 *nsap++ = 0x00;
221 if((len & 1) == 0) {
222 *nsap++ = *e164++ - '0';
223 len--;
224 }
225 while(len > 1) {
226 len -= 2;
227 *nsap = (*e164++ - '0') << 4;
228 *nsap++ |= *e164 - '0';
229 }
230 *nsap++ = ((*e164++ - '0') << 4) | 0xf;
231 for(fill = 0; fill < 11; fill++)
232 *nsap++ = 0;
233
234 return 0;
235 }
236