netaddrstr2.cpp@ 56290

Last change on this file since 56290 was 56290, checked in by vboxsync, 10 years ago
IPRT: Updated (C) year.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.4 KB

Line
1	/* $Id: netaddrstr2.cpp 56290 2015-06-09 14:01:31Z vboxsync $ */
2	/** @file
3	* IPRT - Network Address String Handling.
4	*/
5
6	/*
7	* Copyright (C) 2013-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#include "internal/iprt.h"
31	#include <iprt/net.h>
32
33	#include <iprt/asm.h>
34	#include <iprt/mem.h>
35	#include <iprt/string.h>
36	#include <iprt/stream.h>
37	#include "internal/string.h"
38
39
40	DECLHIDDEN(int) rtNetStrToIPv4AddrEx(const char *pcszAddr, PRTNETADDRIPV4 pAddr,
41	char **ppszNext)
42	{
43	char *pszNext;
44	int rc;
45
46	AssertPtrReturn(pcszAddr, VERR_INVALID_PARAMETER);
47	AssertPtrReturn(pAddr, VERR_INVALID_PARAMETER);
48
49	rc = RTStrToUInt8Ex(pcszAddr, &pszNext, 10, &pAddr->au8[0]);
50	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
51	return VERR_INVALID_PARAMETER;
52	if (*pszNext++ != '.')
53	return VERR_INVALID_PARAMETER;
54
55	rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[1]);
56	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
57	return VERR_INVALID_PARAMETER;
58	if (*pszNext++ != '.')
59	return VERR_INVALID_PARAMETER;
60
61	rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[2]);
62	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
63	return VERR_INVALID_PARAMETER;
64	if (*pszNext++ != '.')
65	return VERR_INVALID_PARAMETER;
66
67	rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[3]);
68	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES && rc != VWRN_TRAILING_CHARS)
69	return VERR_INVALID_PARAMETER;
70
71	if (ppszNext != NULL)
72	*ppszNext = pszNext;
73	return VINF_SUCCESS;
74	}
75
76
77	RTDECL(int) RTNetStrToIPv4AddrEx(const char *pcszAddr, PRTNETADDRIPV4 pAddr,
78	char **ppszNext)
79	{
80	return rtNetStrToIPv4AddrEx(pcszAddr, pAddr, ppszNext);
81	}
82	RT_EXPORT_SYMBOL(RTNetStrToIPv4AddrEx);
83
84
85	RTDECL(int) RTNetStrToIPv4Addr(const char *pcszAddr, PRTNETADDRIPV4 pAddr)
86	{
87	char *pszNext;
88	int rc;
89
90	AssertPtrReturn(pcszAddr, VERR_INVALID_PARAMETER);
91	AssertPtrReturn(pAddr, VERR_INVALID_PARAMETER);
92
93	pcszAddr = RTStrStripL(pcszAddr);
94	rc = rtNetStrToIPv4AddrEx(pcszAddr, pAddr, &pszNext);
95	if (rc != VINF_SUCCESS)
96	return VERR_INVALID_PARAMETER;
97
98	pszNext = RTStrStripL(pszNext);
99	if (*pszNext != '\0')
100	return VERR_INVALID_PARAMETER;
101
102	return VINF_SUCCESS;
103	}
104	RT_EXPORT_SYMBOL(RTNetStrToIPv4Addr);
105
106
107	RTDECL(bool) RTNetIsIPv4AddrStr(const char *pcszAddr)
108	{
109	RTNETADDRIPV4 addrIPv4;
110	char *pszNext;
111	int rc;
112
113	if (pcszAddr == NULL)
114	return false;
115
116	rc = rtNetStrToIPv4AddrEx(pcszAddr, &addrIPv4, &pszNext);
117	if (rc != VINF_SUCCESS)
118	return false;
119
120	if (*pszNext != '\0')
121	return false;
122
123	return true;
124	}
125	RT_EXPORT_SYMBOL(RTNetIsIPv4AddrStr);
126
127
128	static int rtNetStrToHexGroup(const char pcszValue, char *ppszNext,
129	uint16_t *pu16)
130	{
131	char *pszNext;
132	int rc;
133
134	rc = RTStrToUInt16Ex(pcszValue, &pszNext, 16, pu16);
135	if (RT_FAILURE(rc))
136	return rc;
137
138	if ( rc != VINF_SUCCESS
139	&& rc != VWRN_TRAILING_CHARS
140	&& rc != VWRN_TRAILING_SPACES)
141	{
142	return -rc; /* convert warning to error */
143	}
144
145	/* parser always accepts 0x prefix */
146	if (pcszValue[0] == '0' && (pcszValue[1] == 'x' \|\| pcszValue[1] == 'X'))
147	{
148	if (pu16)
149	*pu16 = 0;
150	if (ppszNext)
151	ppszNext = (/ UNCONST / char )pcszValue + 1; /* to 'x' */
152	return VWRN_TRAILING_CHARS;
153	}
154
155	/* parser accepts leading zeroes "000000f" */
156	if (pszNext - pcszValue > 4)
157	return VERR_PARSE_ERROR;
158
159	if (ppszNext)
160	*ppszNext = pszNext;
161	return rc;
162	}
163
164
165	/*
166	* This function deals only with the hex-group IPv6 address syntax
167	* proper (with possible embedded IPv4).
168	*/
169	DECLHIDDEN(int) rtNetStrToIPv6AddrBase(const char *pcszAddr, PRTNETADDRIPV6 pAddrResult,
170	char **ppszNext)
171	{
172	RTNETADDRIPV6 ipv6;
173	RTNETADDRIPV4 ipv4;
174	const char *pcszPos;
175	char *pszNext;
176	int iGroup;
177	uint16_t u16;
178	int rc;
179
180	memset(&ipv6, 0, sizeof(ipv6));
181
182	pcszPos = pcszAddr;
183
184	if (pcszPos[0] == ':') /* compressed zero run at the beginning? */
185	{
186	if (pcszPos[1] != ':')
187	return VERR_PARSE_ERROR;
188
189	pcszPos += 2; /* skip over "::" */
190	pszNext = (/* UNCONST / char )pcszPos;
191	iGroup = 1;
192	}
193	else
194	{
195	/*
196	* Scan forward until we either get complete address or find
197	* "::" compressed zero run.
198	*/
199	for (iGroup = 0; iGroup < 8; ++iGroup)
200	{
201	/* check for embedded IPv4 at the end */
202	if (iGroup == 6)
203	{
204	rc = rtNetStrToIPv4AddrEx(pcszPos, &ipv4, &pszNext);
205	if (rc == VINF_SUCCESS)
206	{
207	ipv6.au32[3] = ipv4.au32[0];
208	iGroup = 8; /* filled 6 and 7 */
209	break; /* we are done */
210	}
211	}
212
213	rc = rtNetStrToHexGroup(pcszPos, &pszNext, &u16);
214	if (RT_FAILURE(rc))
215	return VERR_PARSE_ERROR;
216
217	ipv6.au16[iGroup] = RT_H2N_U16(u16);
218
219	if (iGroup == 7)
220	pcszPos = pszNext;
221	else
222	{
223	/* skip the colon that delimits this group */
224	if (*pszNext != ':')
225	return VERR_PARSE_ERROR;
226	pcszPos = pszNext + 1;
227
228	/* compressed zero run? */
229	if (*pcszPos == ':')
230	{
231	++pcszPos; /* skip over :: */
232	pszNext += 2; /* skip over :: (in case we are done) */
233	iGroup += 2; /* current field and the zero in the next */
234	break;
235	}
236	}
237	}
238	}
239
240	if (iGroup != 8)
241	{
242	/*
243	* iGroup is the first group that can be filled by the part of
244	* the address after "::".
245	*/
246	RTNETADDRIPV6 ipv6Tail;
247	const int iMaybeStart = iGroup;
248	int j;
249
250	memset(&ipv6Tail, 0, sizeof(ipv6Tail));
251
252	/*
253	* We try to accept longest match; we'll shift if necessary.
254	* Unlike the first loop, a failure to parse a group doesn't
255	* mean invalid address.
256	*/
257	for (; iGroup < 8; ++iGroup)
258	{
259	/* check for embedded IPv4 at the end */
260	if (iGroup <= 6)
261	{
262	rc = rtNetStrToIPv4AddrEx(pcszPos, &ipv4, &pszNext);
263	if (rc == VINF_SUCCESS)
264	{
265	ipv6Tail.au16[iGroup] = ipv4.au16[0];
266	ipv6Tail.au16[iGroup + 1] = ipv4.au16[1];
267	iGroup = iGroup + 2; /* these two are done */
268	break; /* the rest is trailer */
269	}
270	}
271
272	rc = rtNetStrToHexGroup(pcszPos, &pszNext, &u16);
273	if (RT_FAILURE(rc))
274	break;
275
276	ipv6Tail.au16[iGroup] = RT_H2N_U16(u16);
277
278	if (iGroup == 7)
279	pcszPos = pszNext;
280	else
281	{
282	if (*pszNext != ':')
283	{
284	++iGroup; /* this one is done */
285	break; /* the rest is trailer */
286	}
287
288	pcszPos = pszNext + 1;
289	}
290	}
291
292	for (j = 7, --iGroup; iGroup >= iMaybeStart; --j, --iGroup)
293	ipv6.au16[j] = ipv6Tail.au16[iGroup];
294	}
295
296	if (pAddrResult != NULL)
297	memcpy(pAddrResult, &ipv6, sizeof(ipv6));
298	if (ppszNext != NULL)
299	*ppszNext = pszNext;
300	return VINF_SUCCESS;
301	}
302
303
304	DECLHIDDEN(int) rtNetStrToIPv6AddrEx(const char *pcszAddr, PRTNETADDRIPV6 pAddr,
305	char ppszZone, char ppszNext)
306	{
307	char pszNext, pszZone;
308	int rc;
309
310	rc = rtNetStrToIPv6AddrBase(pcszAddr, pAddr, &pszNext);
311	if (RT_FAILURE(rc))
312	return rc;
313
314	if (pszNext != '%') / is there a zone id? */
315	{
316	pszZone = NULL;
317	}
318	else
319	{
320	pszZone = pszNext + 1; /* skip '%' zone id delimiter */
321	if (*pszZone == '\0')
322	return VERR_PARSE_ERROR; /* empty zone id */
323
324	/*
325	* XXX: this is speculative as zone id syntax is
326	* implementation dependent, so we kinda guess here (accepting
327	* unreserved characters from URI syntax).
328	*/
329	for (pszNext = pszZone; *pszNext != '\0'; ++pszNext)
330	{
331	const char c = *pszNext;
332	if ( !('0' <= c && c <= '9')
333	&& !('a' <= c && c <= 'z')
334	&& !('A' <= c && c <= 'Z')
335	&& c != '_'
336	&& c != '.'
337	&& c != '-'
338	&& c != '~')
339	{
340	break;
341	}
342	}
343	}
344
345	if (ppszZone != NULL)
346	*ppszZone = pszZone;
347	if (ppszNext != NULL)
348	*ppszNext = pszNext;
349
350	if (pszNext == '\0') / all input string consumed */
351	return VINF_SUCCESS;
352	else
353	{
354	while (pszNext == ' ' \|\| pszNext == '\t')
355	++pszNext;
356	if (*pszNext == '\0')
357	return VWRN_TRAILING_SPACES;
358	else
359	return VWRN_TRAILING_CHARS;
360	}
361	}
362
363
364	RTDECL(int) RTNetStrToIPv6AddrEx(const char *pcszAddr, PRTNETADDRIPV6 pAddr,
365	char **ppszNext)
366	{
367	AssertPtrReturn(pcszAddr, VERR_INVALID_PARAMETER);
368	AssertPtrReturn(pAddr, VERR_INVALID_PARAMETER);
369
370	return rtNetStrToIPv6AddrBase(pcszAddr, pAddr, ppszNext);
371	}
372	RT_EXPORT_SYMBOL(RTNetStrToIPv6AddrEx);
373
374
375	RTDECL(int) RTNetStrToIPv6Addr(const char *pcszAddr, PRTNETADDRIPV6 pAddr,
376	char **ppszZone)
377	{
378	int rc;
379
380	AssertPtrReturn(pcszAddr, VERR_INVALID_PARAMETER);
381	AssertPtrReturn(pAddr, VERR_INVALID_PARAMETER);
382	AssertPtrReturn(ppszZone, VERR_INVALID_PARAMETER);
383
384	pcszAddr = RTStrStripL(pcszAddr);
385	rc = rtNetStrToIPv6AddrEx(pcszAddr, pAddr, ppszZone, NULL);
386	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES)
387	return VERR_INVALID_PARAMETER;
388
389	return VINF_SUCCESS;
390	}
391	RT_EXPORT_SYMBOL(RTNetStrToIPv6Addr);
392
393
394	RTDECL(bool) RTNetIsIPv6AddrStr(const char *pcszAddr)
395	{
396	RTNETADDRIPV6 addrIPv6;
397	int rc;
398
399	if (pcszAddr == NULL)
400	return false;
401
402	rc = rtNetStrToIPv6AddrEx(pcszAddr, &addrIPv6, NULL, NULL);
403	if (rc != VINF_SUCCESS)
404	return false;
405
406	return true;
407	}
408	RT_EXPORT_SYMBOL(RTNetIsIPv6AddrStr);

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/net/netaddrstr2.cpp@ 56290

Download in other formats: