Line data Source code
1 : /*
2 : * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
3 : * Copyright (c) 1996,1999 by Internet Software Consortium.
4 : *
5 : * Permission to use, copy, modify, and distribute this software for any
6 : * purpose with or without fee is hereby granted, provided that the above
7 : * copyright notice and this permission notice appear in all copies.
8 : *
9 : * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
10 : * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 : * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
12 : * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 : * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 : * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15 : * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 : *
17 : * src/backend/utils/adt/inet_net_pton.c
18 : */
19 :
20 : #if defined(LIBC_SCCS) && !defined(lint)
21 : static const char rcsid[] = "Id: inet_net_pton.c,v 1.4.2.3 2004/03/17 00:40:11 marka Exp $";
22 : #endif
23 :
24 : #include "postgres.h"
25 :
26 : #include <sys/socket.h>
27 : #include <netinet/in.h>
28 : #include <arpa/inet.h>
29 : #include <assert.h>
30 : #include <ctype.h>
31 :
32 : #include "utils/builtins.h" /* pgrminclude ignore */ /* needed on some
33 : * platforms */
34 : #include "utils/inet.h"
35 :
36 :
37 : static int inet_net_pton_ipv4(const char *src, u_char *dst);
38 : static int inet_cidr_pton_ipv4(const char *src, u_char *dst, size_t size);
39 : static int inet_net_pton_ipv6(const char *src, u_char *dst);
40 : static int inet_cidr_pton_ipv6(const char *src, u_char *dst, size_t size);
41 :
42 :
43 : /*
44 : * int
45 : * pg_inet_net_pton(af, src, dst, size)
46 : * convert network number from presentation to network format.
47 : * accepts hex octets, hex strings, decimal octets, and /CIDR.
48 : * "size" is in bytes and describes "dst".
49 : * return:
50 : * number of bits, either imputed classfully or specified with /CIDR,
51 : * or -1 if some failure occurred (check errno). ENOENT means it was
52 : * not a valid network specification.
53 : * author:
54 : * Paul Vixie (ISC), June 1996
55 : *
56 : * Changes:
57 : * I added the inet_cidr_pton function (also from Paul) and changed
58 : * the names to reflect their current use.
59 : *
60 : */
61 : int
62 4634 : pg_inet_net_pton(int af, const char *src, void *dst, size_t size)
63 : {
64 4634 : switch (af)
65 : {
66 3736 : case PGSQL_AF_INET:
67 : return size == -1 ?
68 4822 : inet_net_pton_ipv4(src, dst) :
69 1086 : inet_cidr_pton_ipv4(src, dst, size);
70 898 : case PGSQL_AF_INET6:
71 : return size == -1 ?
72 1186 : inet_net_pton_ipv6(src, dst) :
73 288 : inet_cidr_pton_ipv6(src, dst, size);
74 0 : default:
75 0 : errno = EAFNOSUPPORT;
76 0 : return -1;
77 : }
78 : }
79 :
80 : /*
81 : * static int
82 : * inet_cidr_pton_ipv4(src, dst, size)
83 : * convert IPv4 network number from presentation to network format.
84 : * accepts hex octets, hex strings, decimal octets, and /CIDR.
85 : * "size" is in bytes and describes "dst".
86 : * return:
87 : * number of bits, either imputed classfully or specified with /CIDR,
88 : * or -1 if some failure occurred (check errno). ENOENT means it was
89 : * not an IPv4 network specification.
90 : * note:
91 : * network byte order assumed. this means 192.5.5.240/28 has
92 : * 0b11110000 in its fourth octet.
93 : * author:
94 : * Paul Vixie (ISC), June 1996
95 : */
96 : static int
97 1086 : inet_cidr_pton_ipv4(const char *src, u_char *dst, size_t size)
98 : {
99 : static const char xdigits[] = "0123456789abcdef";
100 : static const char digits[] = "0123456789";
101 : int n,
102 : ch,
103 1086 : tmp = 0,
104 : dirty,
105 : bits;
106 1086 : const u_char *odst = dst;
107 :
108 1086 : ch = *src++;
109 1086 : if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
110 0 : && isxdigit((unsigned char) src[1]))
111 : {
112 : /* Hexadecimal: Eat nybble string. */
113 0 : if (size <= 0U)
114 0 : goto emsgsize;
115 0 : dirty = 0;
116 0 : src++; /* skip x or X. */
117 0 : while ((ch = *src++) != '\0' && isxdigit((unsigned char) ch))
118 : {
119 0 : if (isupper((unsigned char) ch))
120 0 : ch = tolower((unsigned char) ch);
121 0 : n = strchr(xdigits, ch) - xdigits;
122 0 : assert(n >= 0 && n <= 15);
123 0 : if (dirty == 0)
124 0 : tmp = n;
125 : else
126 0 : tmp = (tmp << 4) | n;
127 0 : if (++dirty == 2)
128 : {
129 0 : if (size-- <= 0U)
130 0 : goto emsgsize;
131 0 : *dst++ = (u_char) tmp;
132 0 : dirty = 0;
133 : }
134 : }
135 0 : if (dirty)
136 : { /* Odd trailing nybble? */
137 0 : if (size-- <= 0U)
138 0 : goto emsgsize;
139 0 : *dst++ = (u_char) (tmp << 4);
140 : }
141 : }
142 1086 : else if (isdigit((unsigned char) ch))
143 : {
144 : /* Decimal: eat dotted digit string. */
145 : for (;;)
146 : {
147 3570 : tmp = 0;
148 : do
149 : {
150 6788 : n = strchr(digits, ch) - digits;
151 6788 : assert(n >= 0 && n <= 9);
152 6788 : tmp *= 10;
153 6788 : tmp += n;
154 6788 : if (tmp > 255)
155 0 : goto enoent;
156 13076 : } while ((ch = *src++) != '\0' &&
157 6788 : isdigit((unsigned char) ch));
158 3570 : if (size-- <= 0U)
159 0 : goto emsgsize;
160 3570 : *dst++ = (u_char) tmp;
161 3570 : if (ch == '\0' || ch == '/')
162 : break;
163 2484 : if (ch != '.')
164 0 : goto enoent;
165 2484 : ch = *src++;
166 2484 : if (!isdigit((unsigned char) ch))
167 0 : goto enoent;
168 : }
169 : }
170 : else
171 0 : goto enoent;
172 :
173 1086 : bits = -1;
174 1086 : if (ch == '/' && isdigit((unsigned char) src[0]) && dst > odst)
175 : {
176 : /* CIDR width specifier. Nothing can follow it. */
177 586 : ch = *src++; /* Skip over the /. */
178 586 : bits = 0;
179 : do
180 : {
181 1022 : n = strchr(digits, ch) - digits;
182 1022 : assert(n >= 0 && n <= 9);
183 1022 : bits *= 10;
184 1022 : bits += n;
185 1022 : } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
186 586 : if (ch != '\0')
187 0 : goto enoent;
188 586 : if (bits > 32)
189 0 : goto emsgsize;
190 : }
191 :
192 : /* Fiery death and destruction unless we prefetched EOS. */
193 1086 : if (ch != '\0')
194 0 : goto enoent;
195 :
196 : /* If nothing was written to the destination, we found no address. */
197 1086 : if (dst == odst)
198 0 : goto enoent;
199 : /* If no CIDR spec was given, infer width from net class. */
200 1086 : if (bits == -1)
201 : {
202 500 : if (*odst >= 240) /* Class E */
203 192 : bits = 32;
204 308 : else if (*odst >= 224) /* Class D */
205 0 : bits = 8;
206 308 : else if (*odst >= 192) /* Class C */
207 30 : bits = 24;
208 278 : else if (*odst >= 128) /* Class B */
209 0 : bits = 16;
210 : else
211 : /* Class A */
212 278 : bits = 8;
213 : /* If imputed mask is narrower than specified octets, widen. */
214 500 : if (bits < ((dst - odst) * 8))
215 248 : bits = (dst - odst) * 8;
216 :
217 : /*
218 : * If there are no additional bits specified for a class D address
219 : * adjust bits to 4.
220 : */
221 500 : if (bits == 8 && *odst == 224)
222 0 : bits = 4;
223 : }
224 : /* Extend network to cover the actual mask. */
225 1134 : while (bits > ((dst - odst) * 8))
226 : {
227 48 : if (size-- <= 0U)
228 0 : goto emsgsize;
229 48 : *dst++ = '\0';
230 : }
231 1086 : return bits;
232 :
233 0 : enoent:
234 0 : errno = ENOENT;
235 0 : return -1;
236 :
237 0 : emsgsize:
238 0 : errno = EMSGSIZE;
239 0 : return -1;
240 : }
241 :
242 : /*
243 : * int
244 : * inet_net_pton_ipv4(af, src, dst, *bits)
245 : * convert network address from presentation to network format.
246 : * accepts inet_pton()'s input for this "af" plus trailing "/CIDR".
247 : * "dst" is assumed large enough for its "af". "bits" is set to the
248 : * /CIDR prefix length, which can have defaults (like /32 for IPv4).
249 : * return:
250 : * -1 if an error occurred (inspect errno; ENOENT means bad format).
251 : * 0 if successful conversion occurred.
252 : * note:
253 : * 192.5.5.1/28 has a nonzero host part, which means it isn't a network
254 : * as called for by inet_cidr_pton() but it can be a host address with
255 : * an included netmask.
256 : * author:
257 : * Paul Vixie (ISC), October 1998
258 : */
259 : static int
260 2650 : inet_net_pton_ipv4(const char *src, u_char *dst)
261 : {
262 : static const char digits[] = "0123456789";
263 2650 : const u_char *odst = dst;
264 : int n,
265 : ch,
266 : tmp,
267 : bits;
268 2650 : size_t size = 4;
269 :
270 : /* Get the mantissa. */
271 10240 : while (ch = *src++, isdigit((unsigned char) ch))
272 : {
273 10240 : tmp = 0;
274 : do
275 : {
276 23258 : n = strchr(digits, ch) - digits;
277 23258 : assert(n >= 0 && n <= 9);
278 23258 : tmp *= 10;
279 23258 : tmp += n;
280 23258 : if (tmp > 255)
281 0 : goto enoent;
282 23258 : } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
283 10240 : if (size-- == 0)
284 0 : goto emsgsize;
285 10240 : *dst++ = (u_char) tmp;
286 10240 : if (ch == '\0' || ch == '/')
287 : break;
288 7590 : if (ch != '.')
289 0 : goto enoent;
290 : }
291 :
292 : /* Get the prefix length if any. */
293 2650 : bits = -1;
294 2650 : if (ch == '/' && isdigit((unsigned char) src[0]) && dst > odst)
295 : {
296 : /* CIDR width specifier. Nothing can follow it. */
297 926 : ch = *src++; /* Skip over the /. */
298 926 : bits = 0;
299 : do
300 : {
301 1482 : n = strchr(digits, ch) - digits;
302 1482 : assert(n >= 0 && n <= 9);
303 1482 : bits *= 10;
304 1482 : bits += n;
305 1482 : } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
306 926 : if (ch != '\0')
307 0 : goto enoent;
308 926 : if (bits > 32)
309 0 : goto emsgsize;
310 : }
311 :
312 : /* Fiery death and destruction unless we prefetched EOS. */
313 2650 : if (ch != '\0')
314 0 : goto enoent;
315 :
316 : /* Prefix length can default to /32 only if all four octets spec'd. */
317 2650 : if (bits == -1)
318 : {
319 1724 : if (dst - odst == 4)
320 1724 : bits = 32;
321 : else
322 0 : goto enoent;
323 : }
324 :
325 : /* If nothing was written to the destination, we found no address. */
326 2650 : if (dst == odst)
327 0 : goto enoent;
328 :
329 : /* If prefix length overspecifies mantissa, life is bad. */
330 2650 : if ((bits / 8) > (dst - odst))
331 0 : goto enoent;
332 :
333 : /* Extend address to four octets. */
334 3010 : while (size-- > 0)
335 360 : *dst++ = 0;
336 :
337 2650 : return bits;
338 :
339 0 : enoent:
340 0 : errno = ENOENT;
341 0 : return -1;
342 :
343 0 : emsgsize:
344 0 : errno = EMSGSIZE;
345 0 : return -1;
346 : }
347 :
348 : static int
349 478 : getbits(const char *src, int *bitsp)
350 : {
351 : static const char digits[] = "0123456789";
352 : int n;
353 : int val;
354 : char ch;
355 :
356 478 : val = 0;
357 478 : n = 0;
358 1432 : while ((ch = *src++) != '\0')
359 : {
360 : const char *pch;
361 :
362 954 : pch = strchr(digits, ch);
363 954 : if (pch != NULL)
364 : {
365 954 : if (n++ != 0 && val == 0) /* no leading zeros */
366 0 : return 0;
367 954 : val *= 10;
368 954 : val += (pch - digits);
369 954 : if (val > 128) /* range */
370 0 : return 0;
371 954 : continue;
372 : }
373 0 : return 0;
374 : }
375 478 : if (n == 0)
376 0 : return 0;
377 478 : *bitsp = val;
378 478 : return 1;
379 : }
380 :
381 : static int
382 18 : getv4(const char *src, u_char *dst, int *bitsp)
383 : {
384 : static const char digits[] = "0123456789";
385 18 : u_char *odst = dst;
386 : int n;
387 : u_int val;
388 : char ch;
389 :
390 18 : val = 0;
391 18 : n = 0;
392 144 : while ((ch = *src++) != '\0')
393 : {
394 : const char *pch;
395 :
396 138 : pch = strchr(digits, ch);
397 138 : if (pch != NULL)
398 : {
399 72 : if (n++ != 0 && val == 0) /* no leading zeros */
400 0 : return 0;
401 72 : val *= 10;
402 72 : val += (pch - digits);
403 72 : if (val > 255) /* range */
404 0 : return 0;
405 72 : continue;
406 : }
407 66 : if (ch == '.' || ch == '/')
408 : {
409 66 : if (dst - odst > 3) /* too many octets? */
410 0 : return 0;
411 66 : *dst++ = val;
412 66 : if (ch == '/')
413 12 : return getbits(src, bitsp);
414 54 : val = 0;
415 54 : n = 0;
416 54 : continue;
417 : }
418 0 : return 0;
419 : }
420 6 : if (n == 0)
421 0 : return 0;
422 6 : if (dst - odst > 3) /* too many octets? */
423 0 : return 0;
424 6 : *dst++ = val;
425 6 : return 1;
426 : }
427 :
428 : static int
429 610 : inet_net_pton_ipv6(const char *src, u_char *dst)
430 : {
431 610 : return inet_cidr_pton_ipv6(src, dst, 16);
432 : }
433 :
434 : #define NS_IN6ADDRSZ 16
435 : #define NS_INT16SZ 2
436 : #define NS_INADDRSZ 4
437 :
438 : static int
439 898 : inet_cidr_pton_ipv6(const char *src, u_char *dst, size_t size)
440 : {
441 : static const char xdigits_l[] = "0123456789abcdef",
442 : xdigits_u[] = "0123456789ABCDEF";
443 : u_char tmp[NS_IN6ADDRSZ],
444 : *tp,
445 : *endp,
446 : *colonp;
447 : const char *xdigits,
448 : *curtok;
449 : int ch,
450 : saw_xdigit;
451 : u_int val;
452 : int digits;
453 : int bits;
454 :
455 898 : if (size < NS_IN6ADDRSZ)
456 0 : goto emsgsize;
457 :
458 898 : memset((tp = tmp), '\0', NS_IN6ADDRSZ);
459 898 : endp = tp + NS_IN6ADDRSZ;
460 898 : colonp = NULL;
461 : /* Leading :: requires some special handling. */
462 898 : if (*src == ':')
463 48 : if (*++src != ':')
464 0 : goto enoent;
465 898 : curtok = src;
466 898 : saw_xdigit = 0;
467 898 : val = 0;
468 898 : digits = 0;
469 898 : bits = -1;
470 19866 : while ((ch = *src++) != '\0')
471 : {
472 : const char *pch;
473 :
474 19458 : if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
475 4568 : pch = strchr((xdigits = xdigits_u), ch);
476 19458 : if (pch != NULL)
477 : {
478 14890 : val <<= 4;
479 14890 : val |= (pch - xdigits);
480 14890 : if (++digits > 4)
481 0 : goto enoent;
482 14890 : saw_xdigit = 1;
483 14890 : continue;
484 : }
485 4568 : if (ch == ':')
486 : {
487 4084 : curtok = src;
488 4084 : if (!saw_xdigit)
489 : {
490 720 : if (colonp)
491 6 : goto enoent;
492 714 : colonp = tp;
493 714 : continue;
494 : }
495 3364 : else if (*src == '\0')
496 0 : goto enoent;
497 3364 : if (tp + NS_INT16SZ > endp)
498 0 : goto enoent;
499 3364 : *tp++ = (u_char) (val >> 8) & 0xff;
500 3364 : *tp++ = (u_char) val & 0xff;
501 3364 : saw_xdigit = 0;
502 3364 : digits = 0;
503 3364 : val = 0;
504 3364 : continue;
505 : }
506 502 : if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
507 18 : getv4(curtok, tp, &bits) > 0)
508 : {
509 18 : tp += NS_INADDRSZ;
510 18 : saw_xdigit = 0;
511 18 : break; /* '\0' was seen by inet_pton4(). */
512 : }
513 466 : if (ch == '/' && getbits(src, &bits) > 0)
514 466 : break;
515 0 : goto enoent;
516 : }
517 892 : if (saw_xdigit)
518 : {
519 754 : if (tp + NS_INT16SZ > endp)
520 0 : goto enoent;
521 754 : *tp++ = (u_char) (val >> 8) & 0xff;
522 754 : *tp++ = (u_char) val & 0xff;
523 : }
524 892 : if (bits == -1)
525 414 : bits = 128;
526 :
527 892 : endp = tmp + 16;
528 :
529 892 : if (colonp != NULL)
530 : {
531 : /*
532 : * Since some memmove()'s erroneously fail to handle overlapping
533 : * regions, we'll do the shift by hand.
534 : */
535 708 : const int n = tp - colonp;
536 : int i;
537 :
538 708 : if (tp == endp)
539 0 : goto enoent;
540 4512 : for (i = 1; i <= n; i++)
541 : {
542 3804 : endp[-i] = colonp[n - i];
543 3804 : colonp[n - i] = 0;
544 : }
545 708 : tp = endp;
546 : }
547 892 : if (tp != endp)
548 0 : goto enoent;
549 :
550 : /*
551 : * Copy out the result.
552 : */
553 892 : memcpy(dst, tmp, NS_IN6ADDRSZ);
554 :
555 892 : return bits;
556 :
557 6 : enoent:
558 6 : errno = ENOENT;
559 6 : return -1;
560 :
561 0 : emsgsize:
562 0 : errno = EMSGSIZE;
563 0 : return -1;
564 : }
|
