aboutsummaryrefslogtreecommitdiff
path: root/src/util/regex.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/regex.c')
-rw-r--r--src/util/regex.c970
1 files changed, 489 insertions, 481 deletions
diff --git a/src/util/regex.c b/src/util/regex.c
index 70bf5c485..24e83cfd1 100644
--- a/src/util/regex.c
+++ b/src/util/regex.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file src/tun/regex.c 21 * @file src/tun/regex.c
22 * @brief functions to convert IP networks to regexes 22 * @brief functions to convert IP networks to regexes
@@ -42,15 +42,15 @@
42 * bytes long. 42 * bytes long.
43 */ 43 */
44void 44void
45GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip, 45GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip,
46 uint16_t port, 46 uint16_t port,
47 char *rxstr) 47 char *rxstr)
48{ 48{
49 GNUNET_snprintf (rxstr, 49 GNUNET_snprintf(rxstr,
50 GNUNET_TUN_IPV4_REGEXLEN, 50 GNUNET_TUN_IPV4_REGEXLEN,
51 "4-%04X-%08X", 51 "4-%04X-%08X",
52 (unsigned int) port, 52 (unsigned int)port,
53 ntohl (ip->s_addr)); 53 ntohl(ip->s_addr));
54} 54}
55 55
56 56
@@ -63,21 +63,21 @@ GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
63 * bytes long. 63 * bytes long.
64 */ 64 */
65void 65void
66GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6, 66GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6,
67 uint16_t port, 67 uint16_t port,
68 char *rxstr) 68 char *rxstr)
69{ 69{
70 const uint32_t *addr; 70 const uint32_t *addr;
71 71
72 addr = (const uint32_t *) ipv6; 72 addr = (const uint32_t *)ipv6;
73 GNUNET_snprintf (rxstr, 73 GNUNET_snprintf(rxstr,
74 GNUNET_TUN_IPV6_REGEXLEN, 74 GNUNET_TUN_IPV6_REGEXLEN,
75 "6-%04X-%08X%08X%08X%08X", 75 "6-%04X-%08X%08X%08X%08X",
76 (unsigned int) port, 76 (unsigned int)port,
77 ntohl (addr[0]), 77 ntohl(addr[0]),
78 ntohl (addr[1]), 78 ntohl(addr[1]),
79 ntohl (addr[2]), 79 ntohl(addr[2]),
80 ntohl (addr[3])); 80 ntohl(addr[3]));
81} 81}
82 82
83 83
@@ -88,54 +88,59 @@ GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
88 * @param mask which bits in value are wildcards (any value)? 88 * @param mask which bits in value are wildcards (any value)?
89 */ 89 */
90static char * 90static char *
91nibble_to_regex (uint8_t value, 91nibble_to_regex(uint8_t value,
92 uint8_t mask) 92 uint8_t mask)
93{ 93{
94 char *ret; 94 char *ret;
95 95
96 value &= mask; 96 value &= mask;
97 switch (mask) 97 switch (mask)
98 { 98 {
99 case 0: 99 case 0:
100 return GNUNET_strdup (DOT); 100 return GNUNET_strdup(DOT);
101 case 8: 101
102 GNUNET_asprintf (&ret, 102 case 8:
103 "(%X|%X|%X|%X|%X|%X|%X|%X)", 103 GNUNET_asprintf(&ret,
104 value, 104 "(%X|%X|%X|%X|%X|%X|%X|%X)",
105 value + 1, 105 value,
106 value + 2, 106 value + 1,
107 value + 3, 107 value + 2,
108 value + 4, 108 value + 3,
109 value + 5, 109 value + 4,
110 value + 6, 110 value + 5,
111 value + 7); 111 value + 6,
112 return ret; 112 value + 7);
113 case 12: 113 return ret;
114 GNUNET_asprintf (&ret, 114
115 "(%X|%X|%X|%X)", 115 case 12:
116 value, 116 GNUNET_asprintf(&ret,
117 value + 1, 117 "(%X|%X|%X|%X)",
118 value + 2, 118 value,
119 value + 3); 119 value + 1,
120 return ret; 120 value + 2,
121 case 14: 121 value + 3);
122 GNUNET_asprintf (&ret, 122 return ret;
123 "(%X|%X)", 123
124 value, 124 case 14:
125 value + 1); 125 GNUNET_asprintf(&ret,
126 return ret; 126 "(%X|%X)",
127 case 15: 127 value,
128 GNUNET_asprintf (&ret, 128 value + 1);
129 "%X", 129 return ret;
130 value); 130
131 return ret; 131 case 15:
132 default: 132 GNUNET_asprintf(&ret,
133 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 133 "%X",
134 _("Bad mask: %d\n"), 134 value);
135 mask); 135 return ret;
136 GNUNET_break (0); 136
137 return NULL; 137 default:
138 } 138 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
139 _("Bad mask: %d\n"),
140 mask);
141 GNUNET_break(0);
142 return NULL;
143 }
139} 144}
140 145
141 146
@@ -146,33 +151,33 @@ nibble_to_regex (uint8_t value,
146 * @param mask which bits in value are wildcards (any value)? 151 * @param mask which bits in value are wildcards (any value)?
147 */ 152 */
148static char * 153static char *
149num_to_regex (uint16_t value, 154num_to_regex(uint16_t value,
150 uint16_t mask) 155 uint16_t mask)
151{ 156{
152 const uint8_t *v = (const uint8_t *) &value; 157 const uint8_t *v = (const uint8_t *)&value;
153 const uint8_t *m = (const uint8_t *) &mask; 158 const uint8_t *m = (const uint8_t *)&mask;
154 char *a; 159 char *a;
155 char *b; 160 char *b;
156 char *c; 161 char *c;
157 char *d; 162 char *d;
158 char *ret; 163 char *ret;
159 164
160 a = nibble_to_regex (v[0] >> 4, m[0] >> 4); 165 a = nibble_to_regex(v[0] >> 4, m[0] >> 4);
161 b = nibble_to_regex (v[0] & 15, m[0] & 15); 166 b = nibble_to_regex(v[0] & 15, m[0] & 15);
162 c = nibble_to_regex (v[1] >> 4, m[1] >> 4); 167 c = nibble_to_regex(v[1] >> 4, m[1] >> 4);
163 d = nibble_to_regex (v[1] & 15, m[1] & 15); 168 d = nibble_to_regex(v[1] & 15, m[1] & 15);
164 ret = NULL; 169 ret = NULL;
165 if ( (NULL != a) && 170 if ((NULL != a) &&
166 (NULL != b) && 171 (NULL != b) &&
167 (NULL != c) && 172 (NULL != c) &&
168 (NULL != d) ) 173 (NULL != d))
169 GNUNET_asprintf (&ret, 174 GNUNET_asprintf(&ret,
170 "%s%s%s%s", 175 "%s%s%s%s",
171 a, b, c, d); 176 a, b, c, d);
172 GNUNET_free_non_null (a); 177 GNUNET_free_non_null(a);
173 GNUNET_free_non_null (b); 178 GNUNET_free_non_null(b);
174 GNUNET_free_non_null (c); 179 GNUNET_free_non_null(c);
175 GNUNET_free_non_null (d); 180 GNUNET_free_non_null(d);
176 return ret; 181 return ret;
177} 182}
178 183
@@ -185,33 +190,36 @@ num_to_regex (uint16_t value,
185 * #GNUNET_NO if not 190 * #GNUNET_NO if not
186 */ 191 */
187static int 192static int
188needs_parens (const char *arg) 193needs_parens(const char *arg)
189{ 194{
190 size_t off; 195 size_t off;
191 size_t len; 196 size_t len;
192 unsigned int op; 197 unsigned int op;
193 198
194 op = 0; 199 op = 0;
195 len = strlen (arg); 200 len = strlen(arg);
196 for (off=0;off<len;off++) 201 for (off = 0; off < len; off++)
197 {
198 switch (arg[off])
199 { 202 {
200 case '(': 203 switch (arg[off])
201 op++; 204 {
202 break; 205 case '(':
203 case ')': 206 op++;
204 GNUNET_assert (op > 0); 207 break;
205 op--; 208
206 break; 209 case ')':
207 case '|': 210 GNUNET_assert(op > 0);
208 if (0 == op) 211 op--;
209 return GNUNET_YES; 212 break;
210 break; 213
211 default: 214 case '|':
212 break; 215 if (0 == op)
216 return GNUNET_YES;
217 break;
218
219 default:
220 break;
221 }
213 } 222 }
214 }
215 return GNUNET_NO; 223 return GNUNET_NO;
216} 224}
217 225
@@ -227,21 +235,21 @@ needs_parens (const char *arg)
227 * @return corresponding regex 235 * @return corresponding regex
228 */ 236 */
229static char * 237static char *
230compute_policy (unsigned int start, 238compute_policy(unsigned int start,
231 unsigned int end, 239 unsigned int end,
232 unsigned int step, 240 unsigned int step,
233 const struct GNUNET_STRINGS_PortPolicy *pp) 241 const struct GNUNET_STRINGS_PortPolicy *pp)
234{ 242{
235 unsigned int i; 243 unsigned int i;
236 char before[36]; /* 16 * 2 + 3 dots + 0-terminator */ 244 char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
237 char middlel[33]; /* 16 * 2 + 0-terminator */ 245 char middlel[33]; /* 16 * 2 + 0-terminator */
238 char middleh[33]; /* 16 * 2 + 0-terminator */ 246 char middleh[33]; /* 16 * 2 + 0-terminator */
239 char after[36]; /* 16 * 2 + 3 dots + 0-terminator */ 247 char after[36]; /* 16 * 2 + 3 dots + 0-terminator */
240 char beforep[36+2]; /* 16 * 2 + 3 dots + 0-terminator + ()*/ 248 char beforep[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + ()*/
241 char middlehp[33+2]; /* 16 * 2 + 0-terminator + () */ 249 char middlehp[33 + 2]; /* 16 * 2 + 0-terminator + () */
242 char middlelp[33+2]; /* 16 * 2 + 0-terminator + () */ 250 char middlelp[33 + 2]; /* 16 * 2 + 0-terminator + () */
243 char afterp[36+2]; /* 16 * 2 + 3 dots + 0-terminator + () */ 251 char afterp[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + () */
244 char dots[5 * strlen (DOT)]; 252 char dots[5 * strlen(DOT)];
245 char buf[3]; 253 char buf[3];
246 char *middle; 254 char *middle;
247 char *ret; 255 char *ret;
@@ -253,248 +261,248 @@ compute_policy (unsigned int start,
253 unsigned int start_port; 261 unsigned int start_port;
254 unsigned int end_port; 262 unsigned int end_port;
255 263
256 GNUNET_assert (GNUNET_YES == pp->negate_portrange); 264 GNUNET_assert(GNUNET_YES == pp->negate_portrange);
257 start_port = pp->start_port; 265 start_port = pp->start_port;
258 if (1 == start_port) 266 if (1 == start_port)
259 start_port = 0; 267 start_port = 0;
260 end_port = pp->end_port; 268 end_port = pp->end_port;
261 GNUNET_assert ((end - start) / step <= 0xF); 269 GNUNET_assert((end - start) / step <= 0xF);
262 before[0] = '\0'; 270 before[0] = '\0';
263 middlel[0] = '\0'; 271 middlel[0] = '\0';
264 middleh[0] = '\0'; 272 middleh[0] = '\0';
265 after[0] = '\0'; 273 after[0] = '\0';
266 for (i=start;i<=end;i+=step) 274 for (i = start; i <= end; i += step)
267 { 275 {
268 GNUNET_snprintf (buf, 276 GNUNET_snprintf(buf,
269 sizeof (buf), 277 sizeof(buf),
270 "%X|", 278 "%X|",
271 (i - start) / step); 279 (i - start) / step);
272 if (i / step < start_port / step) 280 if (i / step < start_port / step)
273 strcat (before, buf); 281 strcat(before, buf);
274 else if (i / step > end_port / step) 282 else if (i / step > end_port / step)
275 strcat (after, buf); 283 strcat(after, buf);
276 else if (i / step == start_port / step) 284 else if (i / step == start_port / step)
277 strcat (middlel, buf); 285 strcat(middlel, buf);
278 else if (i / step == end_port / step) 286 else if (i / step == end_port / step)
279 strcat (middleh, buf); 287 strcat(middleh, buf);
280 } 288 }
281 if (strlen (before) > 0) 289 if (strlen(before) > 0)
282 before[strlen (before)-1] = '\0'; 290 before[strlen(before) - 1] = '\0';
283 if (strlen (middlel) > 0) 291 if (strlen(middlel) > 0)
284 middlel[strlen (middlel)-1] = '\0'; 292 middlel[strlen(middlel) - 1] = '\0';
285 if (strlen (middleh) > 0) 293 if (strlen(middleh) > 0)
286 middleh[strlen (middleh)-1] = '\0'; 294 middleh[strlen(middleh) - 1] = '\0';
287 if (strlen (after) > 0) 295 if (strlen(after) > 0)
288 after[strlen (after)-1] = '\0'; 296 after[strlen(after) - 1] = '\0';
289 if (needs_parens (before)) 297 if (needs_parens(before))
290 GNUNET_snprintf (beforep, 298 GNUNET_snprintf(beforep,
291 sizeof (beforep), 299 sizeof(beforep),
292 "(%s)", 300 "(%s)",
293 before); 301 before);
294 else 302 else
295 strcpy (beforep, before); 303 strcpy(beforep, before);
296 if (needs_parens (middlel)) 304 if (needs_parens(middlel))
297 GNUNET_snprintf (middlelp, 305 GNUNET_snprintf(middlelp,
298 sizeof (middlelp), 306 sizeof(middlelp),
299 "(%s)", 307 "(%s)",
300 middlel); 308 middlel);
301 else 309 else
302 strcpy (middlelp, middlel); 310 strcpy(middlelp, middlel);
303 if (needs_parens (middleh)) 311 if (needs_parens(middleh))
304 GNUNET_snprintf (middlehp, 312 GNUNET_snprintf(middlehp,
305 sizeof (middlehp), 313 sizeof(middlehp),
306 "(%s)", 314 "(%s)",
307 middleh); 315 middleh);
308 else 316 else
309 strcpy (middlehp, middleh); 317 strcpy(middlehp, middleh);
310 if (needs_parens (after)) 318 if (needs_parens(after))
311 GNUNET_snprintf (afterp, 319 GNUNET_snprintf(afterp,
312 sizeof (afterp), 320 sizeof(afterp),
313 "(%s)", 321 "(%s)",
314 after); 322 after);
315 else 323 else
316 strcpy (afterp, after); 324 strcpy(afterp, after);
317 dots[0] = '\0'; 325 dots[0] = '\0';
318 for (xstep=step/16;xstep>0;xstep/=16) 326 for (xstep = step / 16; xstep > 0; xstep /= 16)
319 strcat (dots, DOT); 327 strcat(dots, DOT);
320 if (step >= 16) 328 if (step >= 16)
321 { 329 {
322 if (strlen (middlel) > 0) 330 if (strlen(middlel) > 0)
323 recl = compute_policy ((start_port / step) * step, 331 recl = compute_policy((start_port / step) * step,
324 (start_port / step) * step + step - 1, 332 (start_port / step) * step + step - 1,
325 step / 16, 333 step / 16,
326 pp); 334 pp);
327 else 335 else
328 recl = GNUNET_strdup (""); 336 recl = GNUNET_strdup("");
329 if (strlen (middleh) > 0) 337 if (strlen(middleh) > 0)
330 rech = compute_policy ((end_port / step) * step, 338 rech = compute_policy((end_port / step) * step,
331 (end_port / step) * step + step - 1, 339 (end_port / step) * step + step - 1,
332 step / 16, 340 step / 16,
333 pp); 341 pp);
334 else 342 else
335 rech = GNUNET_strdup (""); 343 rech = GNUNET_strdup("");
336 } 344 }
337 else
338 {
339 recl = GNUNET_strdup ("");
340 rech = GNUNET_strdup ("");
341 middlel[0] = '\0';
342 middlelp[0] = '\0';
343 middleh[0] = '\0';
344 middlehp[0] = '\0';
345 }
346 if (needs_parens (recl))
347 GNUNET_asprintf (&reclp,
348 "(%s)",
349 recl);
350 else 345 else
351 reclp = GNUNET_strdup (recl); 346 {
352 if (needs_parens (rech)) 347 recl = GNUNET_strdup("");
353 GNUNET_asprintf (&rechp, 348 rech = GNUNET_strdup("");
354 "(%s)", 349 middlel[0] = '\0';
355 rech); 350 middlelp[0] = '\0';
351 middleh[0] = '\0';
352 middlehp[0] = '\0';
353 }
354 if (needs_parens(recl))
355 GNUNET_asprintf(&reclp,
356 "(%s)",
357 recl);
356 else 358 else
357 rechp = GNUNET_strdup (rech); 359 reclp = GNUNET_strdup(recl);
358 360 if (needs_parens(rech))
359 if ( (strlen (middleh) > 0) && 361 GNUNET_asprintf(&rechp,
360 (strlen (rech) > 0) && 362 "(%s)",
361 (strlen (middlel) > 0) && 363 rech);
362 (strlen (recl) > 0) )
363 {
364 GNUNET_asprintf (&middle,
365 "%s%s|%s%s",
366 middlel,
367 reclp,
368 middleh,
369 rechp);
370 }
371 else if ( (strlen (middleh) > 0) &&
372 (strlen (rech) > 0) )
373 {
374 GNUNET_asprintf (&middle,
375 "%s%s",
376 middleh,
377 rechp);
378 }
379 else if ( (strlen (middlel) > 0) &&
380 (strlen (recl) > 0) )
381 {
382 GNUNET_asprintf (&middle,
383 "%s%s",
384 middlel,
385 reclp);
386 }
387 else 364 else
388 { 365 rechp = GNUNET_strdup(rech);
389 middle = GNUNET_strdup (""); 366
390 } 367 if ((strlen(middleh) > 0) &&
391 if ( (strlen(before) > 0) && 368 (strlen(rech) > 0) &&
392 (strlen(after) > 0) ) 369 (strlen(middlel) > 0) &&
393 { 370 (strlen(recl) > 0))
394 if (strlen (dots) > 0)
395 { 371 {
396 if (strlen (middle) > 0) 372 GNUNET_asprintf(&middle,
397 GNUNET_asprintf (&ret, 373 "%s%s|%s%s",
398 "(%s%s|%s|%s%s)", 374 middlel,
399 beforep, dots, 375 reclp,
400 middle, 376 middleh,
401 afterp, dots); 377 rechp);
402 else
403 GNUNET_asprintf (&ret,
404 "(%s|%s)%s",
405 beforep,
406 afterp,
407 dots);
408 } 378 }
409 else 379 else if ((strlen(middleh) > 0) &&
380 (strlen(rech) > 0))
410 { 381 {
411 if (strlen (middle) > 0) 382 GNUNET_asprintf(&middle,
412 GNUNET_asprintf (&ret, 383 "%s%s",
413 "(%s|%s|%s)", 384 middleh,
414 before, 385 rechp);
415 middle,
416 after);
417 else if (1 == step)
418 GNUNET_asprintf (&ret,
419 "%s|%s",
420 before,
421 after);
422 else
423 GNUNET_asprintf (&ret,
424 "(%s|%s)",
425 before,
426 after);
427 } 386 }
428 } 387 else if ((strlen(middlel) > 0) &&
429 else if (strlen (before) > 0) 388 (strlen(recl) > 0))
430 {
431 if (strlen (dots) > 0)
432 { 389 {
433 if (strlen (middle) > 0) 390 GNUNET_asprintf(&middle,
434 GNUNET_asprintf (&ret, 391 "%s%s",
435 "(%s%s|%s)", 392 middlel,
436 beforep, dots, 393 reclp);
437 middle);
438 else
439 GNUNET_asprintf (&ret,
440 "%s%s",
441 beforep, dots);
442 } 394 }
443 else 395 else
396 {
397 middle = GNUNET_strdup("");
398 }
399 if ((strlen(before) > 0) &&
400 (strlen(after) > 0))
444 { 401 {
445 if (strlen (middle) > 0) 402 if (strlen(dots) > 0)
446 GNUNET_asprintf (&ret, 403 {
447 "(%s|%s)", 404 if (strlen(middle) > 0)
448 before, 405 GNUNET_asprintf(&ret,
449 middle); 406 "(%s%s|%s|%s%s)",
407 beforep, dots,
408 middle,
409 afterp, dots);
410 else
411 GNUNET_asprintf(&ret,
412 "(%s|%s)%s",
413 beforep,
414 afterp,
415 dots);
416 }
450 else 417 else
451 GNUNET_asprintf (&ret, 418 {
452 "%s", 419 if (strlen(middle) > 0)
453 before); 420 GNUNET_asprintf(&ret,
421 "(%s|%s|%s)",
422 before,
423 middle,
424 after);
425 else if (1 == step)
426 GNUNET_asprintf(&ret,
427 "%s|%s",
428 before,
429 after);
430 else
431 GNUNET_asprintf(&ret,
432 "(%s|%s)",
433 before,
434 after);
435 }
454 } 436 }
455 } 437 else if (strlen(before) > 0)
456 else if (strlen (after) > 0)
457 {
458 if (strlen (dots) > 0)
459 { 438 {
460 if (strlen (middle) > 0) 439 if (strlen(dots) > 0)
461 GNUNET_asprintf (&ret, 440 {
462 "(%s|%s%s)", 441 if (strlen(middle) > 0)
463 middle, 442 GNUNET_asprintf(&ret,
464 afterp, dots); 443 "(%s%s|%s)",
444 beforep, dots,
445 middle);
446 else
447 GNUNET_asprintf(&ret,
448 "%s%s",
449 beforep, dots);
450 }
465 else 451 else
466 GNUNET_asprintf (&ret, 452 {
467 "%s%s", 453 if (strlen(middle) > 0)
468 afterp, dots); 454 GNUNET_asprintf(&ret,
455 "(%s|%s)",
456 before,
457 middle);
458 else
459 GNUNET_asprintf(&ret,
460 "%s",
461 before);
462 }
469 } 463 }
470 else 464 else if (strlen(after) > 0)
471 { 465 {
472 if (strlen (middle) > 0) 466 if (strlen(dots) > 0)
473 GNUNET_asprintf (&ret, 467 {
474 "%s|%s", 468 if (strlen(middle) > 0)
475 middle, 469 GNUNET_asprintf(&ret,
476 after); 470 "(%s|%s%s)",
471 middle,
472 afterp, dots);
473 else
474 GNUNET_asprintf(&ret,
475 "%s%s",
476 afterp, dots);
477 }
477 else 478 else
478 GNUNET_asprintf (&ret, 479 {
479 "%s", 480 if (strlen(middle) > 0)
480 after); 481 GNUNET_asprintf(&ret,
482 "%s|%s",
483 middle,
484 after);
485 else
486 GNUNET_asprintf(&ret,
487 "%s",
488 after);
489 }
490 }
491 else if (strlen(middle) > 0)
492 {
493 GNUNET_asprintf(&ret,
494 "%s",
495 middle);
481 } 496 }
482 }
483 else if (strlen (middle) > 0)
484 {
485 GNUNET_asprintf (&ret,
486 "%s",
487 middle);
488 }
489 else 497 else
490 { 498 {
491 ret = GNUNET_strdup (""); 499 ret = GNUNET_strdup("");
492 } 500 }
493 GNUNET_free (middle); 501 GNUNET_free(middle);
494 GNUNET_free (reclp); 502 GNUNET_free(reclp);
495 GNUNET_free (rechp); 503 GNUNET_free(rechp);
496 GNUNET_free (recl); 504 GNUNET_free(recl);
497 GNUNET_free (rech); 505 GNUNET_free(rech);
498 return ret; 506 return ret;
499} 507}
500 508
@@ -509,7 +517,7 @@ compute_policy (unsigned int start,
509 * @return NULL on error 517 * @return NULL on error
510 */ 518 */
511static char * 519static char *
512port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp) 520port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp)
513{ 521{
514 char *reg; 522 char *reg;
515 char *ret; 523 char *ret;
@@ -517,57 +525,57 @@ port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
517 unsigned int i; 525 unsigned int i;
518 unsigned int cnt; 526 unsigned int cnt;
519 527
520 if ( (0 == pp->start_port) || 528 if ((0 == pp->start_port) ||
521 ( (1 == pp->start_port) && 529 ((1 == pp->start_port) &&
522 (0xFFFF == pp->end_port) && 530 (0xFFFF == pp->end_port) &&
523 (GNUNET_NO == pp->negate_portrange)) ) 531 (GNUNET_NO == pp->negate_portrange)))
524 return GNUNET_strdup (DOT DOT DOT DOT); 532 return GNUNET_strdup(DOT DOT DOT DOT);
525 if ( (pp->start_port == pp->end_port) && 533 if ((pp->start_port == pp->end_port) &&
526 (GNUNET_NO == pp->negate_portrange)) 534 (GNUNET_NO == pp->negate_portrange))
527 { 535 {
528 GNUNET_asprintf (&ret, 536 GNUNET_asprintf(&ret,
529 "%04X", 537 "%04X",
530 pp->start_port); 538 pp->start_port);
531 return ret; 539 return ret;
532 } 540 }
533 if (pp->end_port < pp->start_port) 541 if (pp->end_port < pp->start_port)
534 return NULL; 542 return NULL;
535 543
536 if (GNUNET_YES == pp->negate_portrange) 544 if (GNUNET_YES == pp->negate_portrange)
537 { 545 {
538 ret = compute_policy (0, 0xFFFF, 0x1000, pp); 546 ret = compute_policy(0, 0xFFFF, 0x1000, pp);
539 } 547 }
540 else 548 else
541 {
542 cnt = pp->end_port - pp->start_port + 1;
543 reg = GNUNET_malloc (cnt * 5 + 1);
544 pos = reg;
545 for (i=1;i<=0xFFFF;i++)
546 { 549 {
547 if ( (i >= pp->start_port) && (i <= pp->end_port) ) 550 cnt = pp->end_port - pp->start_port + 1;
548 { 551 reg = GNUNET_malloc(cnt * 5 + 1);
549 if (pos == reg) 552 pos = reg;
553 for (i = 1; i <= 0xFFFF; i++)
550 { 554 {
551 GNUNET_snprintf (pos, 555 if ((i >= pp->start_port) && (i <= pp->end_port))
552 5, 556 {
553 "%04X", 557 if (pos == reg)
554 i); 558 {
559 GNUNET_snprintf(pos,
560 5,
561 "%04X",
562 i);
563 }
564 else
565 {
566 GNUNET_snprintf(pos,
567 6,
568 "|%04X",
569 i);
570 }
571 pos += strlen(pos);
572 }
555 } 573 }
556 else 574 GNUNET_asprintf(&ret,
557 { 575 "(%s)",
558 GNUNET_snprintf (pos, 576 reg);
559 6, 577 GNUNET_free(reg);
560 "|%04X",
561 i);
562 }
563 pos += strlen (pos);
564 }
565 } 578 }
566 GNUNET_asprintf (&ret,
567 "(%s)",
568 reg);
569 GNUNET_free (reg);
570 }
571 return ret; 579 return ret;
572} 580}
573 581
@@ -581,9 +589,9 @@ port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
581 * @return NULL on error, otherwise regex for the address 589 * @return NULL on error, otherwise regex for the address
582 */ 590 */
583static char * 591static char *
584address_to_regex (const void *addr, 592address_to_regex(const void *addr,
585 const void *mask, 593 const void *mask,
586 size_t len) 594 size_t len)
587{ 595{
588 const uint16_t *a = addr; 596 const uint16_t *a = addr;
589 const uint16_t *m = mask; 597 const uint16_t *m = mask;
@@ -593,29 +601,29 @@ address_to_regex (const void *addr,
593 unsigned int i; 601 unsigned int i;
594 602
595 ret = NULL; 603 ret = NULL;
596 GNUNET_assert (1 != (len % 2)); 604 GNUNET_assert(1 != (len % 2));
597 for (i=0;i<len / 2;i++) 605 for (i = 0; i < len / 2; i++)
598 {
599 reg = num_to_regex (a[i], m[i]);
600 if (NULL == reg)
601 {
602 GNUNET_free_non_null (ret);
603 return NULL;
604 }
605 if (NULL == ret)
606 {
607 ret = reg;
608 }
609 else
610 { 606 {
611 GNUNET_asprintf (&tmp, 607 reg = num_to_regex(a[i], m[i]);
612 "%s%s", 608 if (NULL == reg)
613 ret, reg); 609 {
614 GNUNET_free (ret); 610 GNUNET_free_non_null(ret);
615 GNUNET_free (reg); 611 return NULL;
616 ret = tmp; 612 }
613 if (NULL == ret)
614 {
615 ret = reg;
616 }
617 else
618 {
619 GNUNET_asprintf(&tmp,
620 "%s%s",
621 ret, reg);
622 GNUNET_free(ret);
623 GNUNET_free(reg);
624 ret = tmp;
625 }
617 } 626 }
618 }
619 return ret; 627 return ret;
620} 628}
621 629
@@ -627,28 +635,28 @@ address_to_regex (const void *addr,
627 * @return NULL on error 635 * @return NULL on error
628 */ 636 */
629static char * 637static char *
630ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4) 638ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
631{ 639{
632 char *reg; 640 char *reg;
633 char *pp; 641 char *pp;
634 char *ret; 642 char *ret;
635 643
636 reg = address_to_regex (&v4->network, 644 reg = address_to_regex(&v4->network,
637 &v4->netmask, 645 &v4->netmask,
638 sizeof (struct in_addr)); 646 sizeof(struct in_addr));
639 if (NULL == reg) 647 if (NULL == reg)
640 return NULL; 648 return NULL;
641 pp = port_to_regex (&v4->pp); 649 pp = port_to_regex(&v4->pp);
642 if (NULL == pp) 650 if (NULL == pp)
643 { 651 {
644 GNUNET_free (reg); 652 GNUNET_free(reg);
645 return NULL; 653 return NULL;
646 } 654 }
647 GNUNET_asprintf (&ret, 655 GNUNET_asprintf(&ret,
648 "4-%s-%s", 656 "4-%s-%s",
649 pp, reg); 657 pp, reg);
650 GNUNET_free (pp); 658 GNUNET_free(pp);
651 GNUNET_free (reg); 659 GNUNET_free(reg);
652 return ret; 660 return ret;
653} 661}
654 662
@@ -660,28 +668,28 @@ ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
660 * @return NULL on error 668 * @return NULL on error
661 */ 669 */
662static char * 670static char *
663ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6) 671ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
664{ 672{
665 char *reg; 673 char *reg;
666 char *pp; 674 char *pp;
667 char *ret; 675 char *ret;
668 676
669 reg = address_to_regex (&v6->network, 677 reg = address_to_regex(&v6->network,
670 &v6->netmask, 678 &v6->netmask,
671 sizeof (struct in6_addr)); 679 sizeof(struct in6_addr));
672 if (NULL == reg) 680 if (NULL == reg)
673 return NULL; 681 return NULL;
674 pp = port_to_regex (&v6->pp); 682 pp = port_to_regex(&v6->pp);
675 if (NULL == pp) 683 if (NULL == pp)
676 { 684 {
677 GNUNET_free (reg); 685 GNUNET_free(reg);
678 return NULL; 686 return NULL;
679 } 687 }
680 GNUNET_asprintf (&ret, 688 GNUNET_asprintf(&ret,
681 "6-%s-%s", 689 "6-%s-%s",
682 pp, reg); 690 pp, reg);
683 GNUNET_free (pp); 691 GNUNET_free(pp);
684 GNUNET_free (reg); 692 GNUNET_free(reg);
685 return ret; 693 return ret;
686} 694}
687 695
@@ -696,7 +704,7 @@ ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
696 * @return regular expression, NULL on error 704 * @return regular expression, NULL on error
697 */ 705 */
698char * 706char *
699GNUNET_TUN_ipv4policy2regex (const char *policy) 707GNUNET_TUN_ipv4policy2regex(const char *policy)
700{ 708{
701 struct GNUNET_STRINGS_IPv4NetworkPolicy *np; 709 struct GNUNET_STRINGS_IPv4NetworkPolicy *np;
702 char *reg; 710 char *reg;
@@ -704,36 +712,36 @@ GNUNET_TUN_ipv4policy2regex (const char *policy)
704 char *line; 712 char *line;
705 unsigned int i; 713 unsigned int i;
706 714
707 np = GNUNET_STRINGS_parse_ipv4_policy (policy); 715 np = GNUNET_STRINGS_parse_ipv4_policy(policy);
708 if (NULL == np) 716 if (NULL == np)
709 return NULL; 717 return NULL;
710 reg = NULL; 718 reg = NULL;
711 for (i=0; (0 == i) || (0 != np[i].network.s_addr); i++) 719 for (i = 0; (0 == i) || (0 != np[i].network.s_addr); i++)
712 {
713 line = ipv4_to_regex (&np[i]);
714 if (NULL == line)
715 {
716 GNUNET_free_non_null (reg);
717 GNUNET_free (np);
718 return NULL;
719 }
720 if (NULL == reg)
721 {
722 reg = line;
723 }
724 else
725 { 720 {
726 GNUNET_asprintf (&tmp, 721 line = ipv4_to_regex(&np[i]);
727 "%s|(%s)", 722 if (NULL == line)
728 reg, line); 723 {
729 GNUNET_free (reg); 724 GNUNET_free_non_null(reg);
730 GNUNET_free (line); 725 GNUNET_free(np);
731 reg = tmp; 726 return NULL;
727 }
728 if (NULL == reg)
729 {
730 reg = line;
731 }
732 else
733 {
734 GNUNET_asprintf(&tmp,
735 "%s|(%s)",
736 reg, line);
737 GNUNET_free(reg);
738 GNUNET_free(line);
739 reg = tmp;
740 }
741 if (0 == np[i].network.s_addr)
742 break;
732 } 743 }
733 if (0 == np[i].network.s_addr) 744 GNUNET_free(np);
734 break;
735 }
736 GNUNET_free (np);
737 return reg; 745 return reg;
738} 746}
739 747
@@ -748,7 +756,7 @@ GNUNET_TUN_ipv4policy2regex (const char *policy)
748 * @return regular expression, NULL on error 756 * @return regular expression, NULL on error
749 */ 757 */
750char * 758char *
751GNUNET_TUN_ipv6policy2regex (const char *policy) 759GNUNET_TUN_ipv6policy2regex(const char *policy)
752{ 760{
753 struct in6_addr zero; 761 struct in6_addr zero;
754 struct GNUNET_STRINGS_IPv6NetworkPolicy *np; 762 struct GNUNET_STRINGS_IPv6NetworkPolicy *np;
@@ -757,37 +765,37 @@ GNUNET_TUN_ipv6policy2regex (const char *policy)
757 char *line; 765 char *line;
758 unsigned int i; 766 unsigned int i;
759 767
760 np = GNUNET_STRINGS_parse_ipv6_policy (policy); 768 np = GNUNET_STRINGS_parse_ipv6_policy(policy);
761 if (NULL == np) 769 if (NULL == np)
762 return NULL; 770 return NULL;
763 reg = NULL; 771 reg = NULL;
764 memset (&zero, 0, sizeof (struct in6_addr)); 772 memset(&zero, 0, sizeof(struct in6_addr));
765 for (i=0; (0 == i) || (0 != memcmp (&zero, &np[i].network, sizeof (struct in6_addr))); i++) 773 for (i = 0; (0 == i) || (0 != memcmp(&zero, &np[i].network, sizeof(struct in6_addr))); i++)
766 {
767 line = ipv6_to_regex (&np[i]);
768 if (NULL == line)
769 { 774 {
770 GNUNET_free_non_null (reg); 775 line = ipv6_to_regex(&np[i]);
771 GNUNET_free (np); 776 if (NULL == line)
772 return NULL; 777 {
773 } 778 GNUNET_free_non_null(reg);
774 if (NULL == reg) 779 GNUNET_free(np);
775 { 780 return NULL;
776 reg = line; 781 }
777 } 782 if (NULL == reg)
778 else 783 {
779 { 784 reg = line;
780 GNUNET_asprintf (&tmp, 785 }
781 "%s|(%s)", 786 else
782 reg, line); 787 {
783 GNUNET_free (reg); 788 GNUNET_asprintf(&tmp,
784 GNUNET_free (line); 789 "%s|(%s)",
785 reg = tmp; 790 reg, line);
791 GNUNET_free(reg);
792 GNUNET_free(line);
793 reg = tmp;
794 }
795 if (0 == memcmp(&zero, &np[i].network, sizeof(struct in6_addr)))
796 break;
786 } 797 }
787 if (0 == memcmp (&zero, &np[i].network, sizeof (struct in6_addr))) 798 GNUNET_free(np);
788 break;
789 }
790 GNUNET_free (np);
791 return reg; 799 return reg;
792} 800}
793 801
@@ -801,12 +809,12 @@ GNUNET_TUN_ipv6policy2regex (const char *policy)
801 * @param hc corresponding hash 809 * @param hc corresponding hash
802 */ 810 */
803void 811void
804GNUNET_TUN_service_name_to_hash (const char *service_name, 812GNUNET_TUN_service_name_to_hash(const char *service_name,
805 struct GNUNET_HashCode *hc) 813 struct GNUNET_HashCode *hc)
806{ 814{
807 GNUNET_CRYPTO_hash (service_name, 815 GNUNET_CRYPTO_hash(service_name,
808 strlen (service_name), 816 strlen(service_name),
809 hc); 817 hc);
810} 818}
811 819
812 820
@@ -820,16 +828,16 @@ GNUNET_TUN_service_name_to_hash (const char *service_name,
820 * @param[out] cadet_port CADET port to use 828 * @param[out] cadet_port CADET port to use
821 */ 829 */
822void 830void
823GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc, 831GNUNET_TUN_compute_service_cadet_port(const struct GNUNET_HashCode *desc,
824 uint16_t ip_port, 832 uint16_t ip_port,
825 struct GNUNET_HashCode *cadet_port) 833 struct GNUNET_HashCode *cadet_port)
826{ 834{
827 uint16_t be_port = htons (ip_port); 835 uint16_t be_port = htons(ip_port);
828 836
829 *cadet_port = *desc; 837 *cadet_port = *desc;
830 GNUNET_memcpy (cadet_port, 838 GNUNET_memcpy(cadet_port,
831 &be_port, 839 &be_port,
832 sizeof (uint16_t)); 840 sizeof(uint16_t));
833} 841}
834 842
835 843