diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/util/regex.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/util/regex.c')
-rw-r--r-- | src/util/regex.c | 938 |
1 files changed, 470 insertions, 468 deletions
diff --git a/src/util/regex.c b/src/util/regex.c index 24e83cfd1..d3ab35652 100644 --- a/src/util/regex.c +++ b/src/util/regex.c | |||
@@ -42,15 +42,15 @@ | |||
42 | * bytes long. | 42 | * bytes long. |
43 | */ | 43 | */ |
44 | void | 44 | void |
45 | GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip, | 45 | GNUNET_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 | */ |
65 | void | 65 | void |
66 | GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6, | 66 | GNUNET_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,59 +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 | */ |
90 | static char * | 90 | static char * |
91 | nibble_to_regex(uint8_t value, | 91 | nibble_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 | 101 | ||
102 | case 8: | 102 | case 8: |
103 | GNUNET_asprintf(&ret, | 103 | GNUNET_asprintf (&ret, |
104 | "(%X|%X|%X|%X|%X|%X|%X|%X)", | 104 | "(%X|%X|%X|%X|%X|%X|%X|%X)", |
105 | value, | 105 | value, |
106 | value + 1, | 106 | value + 1, |
107 | value + 2, | 107 | value + 2, |
108 | value + 3, | 108 | value + 3, |
109 | value + 4, | 109 | value + 4, |
110 | value + 5, | 110 | value + 5, |
111 | value + 6, | 111 | value + 6, |
112 | value + 7); | 112 | value + 7); |
113 | return ret; | 113 | return ret; |
114 | 114 | ||
115 | case 12: | 115 | case 12: |
116 | GNUNET_asprintf(&ret, | 116 | GNUNET_asprintf (&ret, |
117 | "(%X|%X|%X|%X)", | 117 | "(%X|%X|%X|%X)", |
118 | value, | 118 | value, |
119 | value + 1, | 119 | value + 1, |
120 | value + 2, | 120 | value + 2, |
121 | value + 3); | 121 | value + 3); |
122 | return ret; | 122 | return ret; |
123 | 123 | ||
124 | case 14: | 124 | case 14: |
125 | GNUNET_asprintf(&ret, | 125 | GNUNET_asprintf (&ret, |
126 | "(%X|%X)", | 126 | "(%X|%X)", |
127 | value, | 127 | value, |
128 | value + 1); | 128 | value + 1); |
129 | return ret; | 129 | return ret; |
130 | 130 | ||
131 | case 15: | 131 | case 15: |
132 | GNUNET_asprintf(&ret, | 132 | GNUNET_asprintf (&ret, |
133 | "%X", | 133 | "%X", |
134 | value); | 134 | value); |
135 | return ret; | 135 | return ret; |
136 | 136 | ||
137 | default: | 137 | default: |
138 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 138 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
139 | _("Bad mask: %d\n"), | 139 | _ ("Bad mask: %d\n"), |
140 | mask); | 140 | mask); |
141 | GNUNET_break(0); | 141 | GNUNET_break (0); |
142 | return NULL; | 142 | return NULL; |
143 | } | 143 | } |
144 | } | 144 | } |
145 | 145 | ||
146 | 146 | ||
@@ -151,33 +151,33 @@ nibble_to_regex(uint8_t value, | |||
151 | * @param mask which bits in value are wildcards (any value)? | 151 | * @param mask which bits in value are wildcards (any value)? |
152 | */ | 152 | */ |
153 | static char * | 153 | static char * |
154 | num_to_regex(uint16_t value, | 154 | num_to_regex (uint16_t value, |
155 | uint16_t mask) | 155 | uint16_t mask) |
156 | { | 156 | { |
157 | const uint8_t *v = (const uint8_t *)&value; | 157 | const uint8_t *v = (const uint8_t *) &value; |
158 | const uint8_t *m = (const uint8_t *)&mask; | 158 | const uint8_t *m = (const uint8_t *) &mask; |
159 | char *a; | 159 | char *a; |
160 | char *b; | 160 | char *b; |
161 | char *c; | 161 | char *c; |
162 | char *d; | 162 | char *d; |
163 | char *ret; | 163 | char *ret; |
164 | 164 | ||
165 | a = nibble_to_regex(v[0] >> 4, m[0] >> 4); | 165 | a = nibble_to_regex (v[0] >> 4, m[0] >> 4); |
166 | b = nibble_to_regex(v[0] & 15, m[0] & 15); | 166 | b = nibble_to_regex (v[0] & 15, m[0] & 15); |
167 | c = nibble_to_regex(v[1] >> 4, m[1] >> 4); | 167 | c = nibble_to_regex (v[1] >> 4, m[1] >> 4); |
168 | d = nibble_to_regex(v[1] & 15, m[1] & 15); | 168 | d = nibble_to_regex (v[1] & 15, m[1] & 15); |
169 | ret = NULL; | 169 | ret = NULL; |
170 | if ((NULL != a) && | 170 | if ((NULL != a) && |
171 | (NULL != b) && | 171 | (NULL != b) && |
172 | (NULL != c) && | 172 | (NULL != c) && |
173 | (NULL != d)) | 173 | (NULL != d)) |
174 | GNUNET_asprintf(&ret, | 174 | GNUNET_asprintf (&ret, |
175 | "%s%s%s%s", | 175 | "%s%s%s%s", |
176 | a, b, c, d); | 176 | a, b, c, d); |
177 | GNUNET_free_non_null(a); | 177 | GNUNET_free_non_null (a); |
178 | GNUNET_free_non_null(b); | 178 | GNUNET_free_non_null (b); |
179 | GNUNET_free_non_null(c); | 179 | GNUNET_free_non_null (c); |
180 | GNUNET_free_non_null(d); | 180 | GNUNET_free_non_null (d); |
181 | return ret; | 181 | return ret; |
182 | } | 182 | } |
183 | 183 | ||
@@ -190,36 +190,36 @@ num_to_regex(uint16_t value, | |||
190 | * #GNUNET_NO if not | 190 | * #GNUNET_NO if not |
191 | */ | 191 | */ |
192 | static int | 192 | static int |
193 | needs_parens(const char *arg) | 193 | needs_parens (const char *arg) |
194 | { | 194 | { |
195 | size_t off; | 195 | size_t off; |
196 | size_t len; | 196 | size_t len; |
197 | unsigned int op; | 197 | unsigned int op; |
198 | 198 | ||
199 | op = 0; | 199 | op = 0; |
200 | len = strlen(arg); | 200 | len = strlen (arg); |
201 | for (off = 0; off < len; off++) | 201 | for (off = 0; off < len; off++) |
202 | { | ||
203 | switch (arg[off]) | ||
202 | { | 204 | { |
203 | switch (arg[off]) | 205 | case '(': |
204 | { | 206 | op++; |
205 | case '(': | 207 | break; |
206 | op++; | 208 | |
207 | break; | 209 | case ')': |
208 | 210 | GNUNET_assert (op > 0); | |
209 | case ')': | 211 | op--; |
210 | GNUNET_assert(op > 0); | 212 | break; |
211 | op--; | 213 | |
212 | break; | 214 | case '|': |
213 | 215 | if (0 == op) | |
214 | case '|': | 216 | return GNUNET_YES; |
215 | if (0 == op) | 217 | break; |
216 | return GNUNET_YES; | 218 | |
217 | break; | 219 | default: |
218 | 220 | break; | |
219 | default: | ||
220 | break; | ||
221 | } | ||
222 | } | 221 | } |
222 | } | ||
223 | return GNUNET_NO; | 223 | return GNUNET_NO; |
224 | } | 224 | } |
225 | 225 | ||
@@ -235,10 +235,10 @@ needs_parens(const char *arg) | |||
235 | * @return corresponding regex | 235 | * @return corresponding regex |
236 | */ | 236 | */ |
237 | static char * | 237 | static char * |
238 | compute_policy(unsigned int start, | 238 | compute_policy (unsigned int start, |
239 | unsigned int end, | 239 | unsigned int end, |
240 | unsigned int step, | 240 | unsigned int step, |
241 | const struct GNUNET_STRINGS_PortPolicy *pp) | 241 | const struct GNUNET_STRINGS_PortPolicy *pp) |
242 | { | 242 | { |
243 | unsigned int i; | 243 | unsigned int i; |
244 | char before[36]; /* 16 * 2 + 3 dots + 0-terminator */ | 244 | char before[36]; /* 16 * 2 + 3 dots + 0-terminator */ |
@@ -249,7 +249,7 @@ compute_policy(unsigned int start, | |||
249 | char middlehp[33 + 2]; /* 16 * 2 + 0-terminator + () */ | 249 | char middlehp[33 + 2]; /* 16 * 2 + 0-terminator + () */ |
250 | char middlelp[33 + 2]; /* 16 * 2 + 0-terminator + () */ | 250 | char middlelp[33 + 2]; /* 16 * 2 + 0-terminator + () */ |
251 | char afterp[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + () */ | 251 | char afterp[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + () */ |
252 | char dots[5 * strlen(DOT)]; | 252 | char dots[5 * strlen (DOT)]; |
253 | char buf[3]; | 253 | char buf[3]; |
254 | char *middle; | 254 | char *middle; |
255 | char *ret; | 255 | char *ret; |
@@ -261,248 +261,248 @@ compute_policy(unsigned int start, | |||
261 | unsigned int start_port; | 261 | unsigned int start_port; |
262 | unsigned int end_port; | 262 | unsigned int end_port; |
263 | 263 | ||
264 | GNUNET_assert(GNUNET_YES == pp->negate_portrange); | 264 | GNUNET_assert (GNUNET_YES == pp->negate_portrange); |
265 | start_port = pp->start_port; | 265 | start_port = pp->start_port; |
266 | if (1 == start_port) | 266 | if (1 == start_port) |
267 | start_port = 0; | 267 | start_port = 0; |
268 | end_port = pp->end_port; | 268 | end_port = pp->end_port; |
269 | GNUNET_assert((end - start) / step <= 0xF); | 269 | GNUNET_assert ((end - start) / step <= 0xF); |
270 | before[0] = '\0'; | 270 | before[0] = '\0'; |
271 | middlel[0] = '\0'; | 271 | middlel[0] = '\0'; |
272 | middleh[0] = '\0'; | 272 | middleh[0] = '\0'; |
273 | after[0] = '\0'; | 273 | after[0] = '\0'; |
274 | for (i = start; i <= end; i += step) | 274 | for (i = start; i <= end; i += step) |
275 | { | 275 | { |
276 | GNUNET_snprintf(buf, | 276 | GNUNET_snprintf (buf, |
277 | sizeof(buf), | 277 | sizeof(buf), |
278 | "%X|", | 278 | "%X|", |
279 | (i - start) / step); | 279 | (i - start) / step); |
280 | if (i / step < start_port / step) | 280 | if (i / step < start_port / step) |
281 | strcat(before, buf); | 281 | strcat (before, buf); |
282 | else if (i / step > end_port / step) | 282 | else if (i / step > end_port / step) |
283 | strcat(after, buf); | 283 | strcat (after, buf); |
284 | else if (i / step == start_port / step) | 284 | else if (i / step == start_port / step) |
285 | strcat(middlel, buf); | 285 | strcat (middlel, buf); |
286 | else if (i / step == end_port / step) | 286 | else if (i / step == end_port / step) |
287 | strcat(middleh, buf); | 287 | strcat (middleh, buf); |
288 | } | 288 | } |
289 | if (strlen(before) > 0) | 289 | if (strlen (before) > 0) |
290 | before[strlen(before) - 1] = '\0'; | 290 | before[strlen (before) - 1] = '\0'; |
291 | if (strlen(middlel) > 0) | 291 | if (strlen (middlel) > 0) |
292 | middlel[strlen(middlel) - 1] = '\0'; | 292 | middlel[strlen (middlel) - 1] = '\0'; |
293 | if (strlen(middleh) > 0) | 293 | if (strlen (middleh) > 0) |
294 | middleh[strlen(middleh) - 1] = '\0'; | 294 | middleh[strlen (middleh) - 1] = '\0'; |
295 | if (strlen(after) > 0) | 295 | if (strlen (after) > 0) |
296 | after[strlen(after) - 1] = '\0'; | 296 | after[strlen (after) - 1] = '\0'; |
297 | if (needs_parens(before)) | 297 | if (needs_parens (before)) |
298 | GNUNET_snprintf(beforep, | 298 | GNUNET_snprintf (beforep, |
299 | sizeof(beforep), | 299 | sizeof(beforep), |
300 | "(%s)", | 300 | "(%s)", |
301 | before); | 301 | before); |
302 | else | 302 | else |
303 | strcpy(beforep, before); | 303 | strcpy (beforep, before); |
304 | if (needs_parens(middlel)) | 304 | if (needs_parens (middlel)) |
305 | GNUNET_snprintf(middlelp, | 305 | GNUNET_snprintf (middlelp, |
306 | sizeof(middlelp), | 306 | sizeof(middlelp), |
307 | "(%s)", | 307 | "(%s)", |
308 | middlel); | 308 | middlel); |
309 | else | 309 | else |
310 | strcpy(middlelp, middlel); | 310 | strcpy (middlelp, middlel); |
311 | if (needs_parens(middleh)) | 311 | if (needs_parens (middleh)) |
312 | GNUNET_snprintf(middlehp, | 312 | GNUNET_snprintf (middlehp, |
313 | sizeof(middlehp), | 313 | sizeof(middlehp), |
314 | "(%s)", | 314 | "(%s)", |
315 | middleh); | 315 | middleh); |
316 | else | 316 | else |
317 | strcpy(middlehp, middleh); | 317 | strcpy (middlehp, middleh); |
318 | if (needs_parens(after)) | 318 | if (needs_parens (after)) |
319 | GNUNET_snprintf(afterp, | 319 | GNUNET_snprintf (afterp, |
320 | sizeof(afterp), | 320 | sizeof(afterp), |
321 | "(%s)", | 321 | "(%s)", |
322 | after); | 322 | after); |
323 | else | 323 | else |
324 | strcpy(afterp, after); | 324 | strcpy (afterp, after); |
325 | dots[0] = '\0'; | 325 | dots[0] = '\0'; |
326 | for (xstep = step / 16; xstep > 0; xstep /= 16) | 326 | for (xstep = step / 16; xstep > 0; xstep /= 16) |
327 | strcat(dots, DOT); | 327 | strcat (dots, DOT); |
328 | if (step >= 16) | 328 | if (step >= 16) |
329 | { | 329 | { |
330 | if (strlen(middlel) > 0) | 330 | if (strlen (middlel) > 0) |
331 | recl = compute_policy((start_port / step) * step, | 331 | recl = compute_policy ((start_port / step) * step, |
332 | (start_port / step) * step + step - 1, | 332 | (start_port / step) * step + step - 1, |
333 | step / 16, | 333 | step / 16, |
334 | pp); | 334 | pp); |
335 | else | 335 | else |
336 | recl = GNUNET_strdup(""); | 336 | recl = GNUNET_strdup (""); |
337 | if (strlen(middleh) > 0) | 337 | if (strlen (middleh) > 0) |
338 | rech = compute_policy((end_port / step) * step, | 338 | rech = compute_policy ((end_port / step) * step, |
339 | (end_port / step) * step + step - 1, | 339 | (end_port / step) * step + step - 1, |
340 | step / 16, | 340 | step / 16, |
341 | pp); | 341 | pp); |
342 | else | 342 | else |
343 | rech = GNUNET_strdup(""); | 343 | rech = GNUNET_strdup (""); |
344 | } | 344 | } |
345 | else | 345 | else |
346 | { | 346 | { |
347 | recl = GNUNET_strdup(""); | 347 | recl = GNUNET_strdup (""); |
348 | rech = GNUNET_strdup(""); | 348 | rech = GNUNET_strdup (""); |
349 | middlel[0] = '\0'; | 349 | middlel[0] = '\0'; |
350 | middlelp[0] = '\0'; | 350 | middlelp[0] = '\0'; |
351 | middleh[0] = '\0'; | 351 | middleh[0] = '\0'; |
352 | middlehp[0] = '\0'; | 352 | middlehp[0] = '\0'; |
353 | } | 353 | } |
354 | if (needs_parens(recl)) | 354 | if (needs_parens (recl)) |
355 | GNUNET_asprintf(&reclp, | 355 | GNUNET_asprintf (&reclp, |
356 | "(%s)", | 356 | "(%s)", |
357 | recl); | 357 | recl); |
358 | else | 358 | else |
359 | reclp = GNUNET_strdup(recl); | 359 | reclp = GNUNET_strdup (recl); |
360 | if (needs_parens(rech)) | 360 | if (needs_parens (rech)) |
361 | GNUNET_asprintf(&rechp, | 361 | GNUNET_asprintf (&rechp, |
362 | "(%s)", | 362 | "(%s)", |
363 | rech); | 363 | rech); |
364 | else | 364 | else |
365 | rechp = GNUNET_strdup(rech); | 365 | rechp = GNUNET_strdup (rech); |
366 | 366 | ||
367 | if ((strlen(middleh) > 0) && | 367 | if ((strlen (middleh) > 0) && |
368 | (strlen(rech) > 0) && | 368 | (strlen (rech) > 0) && |
369 | (strlen(middlel) > 0) && | 369 | (strlen (middlel) > 0) && |
370 | (strlen(recl) > 0)) | 370 | (strlen (recl) > 0)) |
371 | { | 371 | { |
372 | GNUNET_asprintf(&middle, | 372 | GNUNET_asprintf (&middle, |
373 | "%s%s|%s%s", | 373 | "%s%s|%s%s", |
374 | middlel, | 374 | middlel, |
375 | reclp, | 375 | reclp, |
376 | middleh, | 376 | middleh, |
377 | rechp); | 377 | rechp); |
378 | } | 378 | } |
379 | else if ((strlen(middleh) > 0) && | 379 | else if ((strlen (middleh) > 0) && |
380 | (strlen(rech) > 0)) | 380 | (strlen (rech) > 0)) |
381 | { | 381 | { |
382 | GNUNET_asprintf(&middle, | 382 | GNUNET_asprintf (&middle, |
383 | "%s%s", | 383 | "%s%s", |
384 | middleh, | 384 | middleh, |
385 | rechp); | 385 | rechp); |
386 | } | 386 | } |
387 | else if ((strlen(middlel) > 0) && | 387 | else if ((strlen (middlel) > 0) && |
388 | (strlen(recl) > 0)) | 388 | (strlen (recl) > 0)) |
389 | { | 389 | { |
390 | GNUNET_asprintf(&middle, | 390 | GNUNET_asprintf (&middle, |
391 | "%s%s", | 391 | "%s%s", |
392 | middlel, | 392 | middlel, |
393 | reclp); | 393 | reclp); |
394 | } | 394 | } |
395 | else | 395 | else |
396 | { | ||
397 | middle = GNUNET_strdup (""); | ||
398 | } | ||
399 | if ((strlen (before) > 0) && | ||
400 | (strlen (after) > 0)) | ||
401 | { | ||
402 | if (strlen (dots) > 0) | ||
396 | { | 403 | { |
397 | middle = GNUNET_strdup(""); | 404 | if (strlen (middle) > 0) |
405 | GNUNET_asprintf (&ret, | ||
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); | ||
398 | } | 416 | } |
399 | if ((strlen(before) > 0) && | 417 | else |
400 | (strlen(after) > 0)) | ||
401 | { | 418 | { |
402 | if (strlen(dots) > 0) | 419 | if (strlen (middle) > 0) |
403 | { | 420 | GNUNET_asprintf (&ret, |
404 | if (strlen(middle) > 0) | 421 | "(%s|%s|%s)", |
405 | GNUNET_asprintf(&ret, | 422 | before, |
406 | "(%s%s|%s|%s%s)", | 423 | middle, |
407 | beforep, dots, | 424 | after); |
408 | middle, | 425 | else if (1 == step) |
409 | afterp, dots); | 426 | GNUNET_asprintf (&ret, |
410 | else | 427 | "%s|%s", |
411 | GNUNET_asprintf(&ret, | 428 | before, |
412 | "(%s|%s)%s", | 429 | after); |
413 | beforep, | ||
414 | afterp, | ||
415 | dots); | ||
416 | } | ||
417 | else | 430 | else |
418 | { | 431 | GNUNET_asprintf (&ret, |
419 | if (strlen(middle) > 0) | 432 | "(%s|%s)", |
420 | GNUNET_asprintf(&ret, | 433 | before, |
421 | "(%s|%s|%s)", | 434 | after); |
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 | } | ||
436 | } | 435 | } |
437 | else if (strlen(before) > 0) | 436 | } |
437 | else if (strlen (before) > 0) | ||
438 | { | ||
439 | if (strlen (dots) > 0) | ||
438 | { | 440 | { |
439 | if (strlen(dots) > 0) | 441 | if (strlen (middle) > 0) |
440 | { | 442 | GNUNET_asprintf (&ret, |
441 | if (strlen(middle) > 0) | 443 | "(%s%s|%s)", |
442 | GNUNET_asprintf(&ret, | 444 | beforep, dots, |
443 | "(%s%s|%s)", | 445 | middle); |
444 | beforep, dots, | ||
445 | middle); | ||
446 | else | ||
447 | GNUNET_asprintf(&ret, | ||
448 | "%s%s", | ||
449 | beforep, dots); | ||
450 | } | ||
451 | else | 446 | else |
452 | { | 447 | GNUNET_asprintf (&ret, |
453 | if (strlen(middle) > 0) | 448 | "%s%s", |
454 | GNUNET_asprintf(&ret, | 449 | beforep, dots); |
455 | "(%s|%s)", | ||
456 | before, | ||
457 | middle); | ||
458 | else | ||
459 | GNUNET_asprintf(&ret, | ||
460 | "%s", | ||
461 | before); | ||
462 | } | ||
463 | } | 450 | } |
464 | else if (strlen(after) > 0) | 451 | else |
465 | { | 452 | { |
466 | if (strlen(dots) > 0) | 453 | if (strlen (middle) > 0) |
467 | { | 454 | GNUNET_asprintf (&ret, |
468 | if (strlen(middle) > 0) | 455 | "(%s|%s)", |
469 | GNUNET_asprintf(&ret, | 456 | before, |
470 | "(%s|%s%s)", | 457 | middle); |
471 | middle, | ||
472 | afterp, dots); | ||
473 | else | ||
474 | GNUNET_asprintf(&ret, | ||
475 | "%s%s", | ||
476 | afterp, dots); | ||
477 | } | ||
478 | else | 458 | else |
479 | { | 459 | GNUNET_asprintf (&ret, |
480 | if (strlen(middle) > 0) | 460 | "%s", |
481 | GNUNET_asprintf(&ret, | 461 | before); |
482 | "%s|%s", | ||
483 | middle, | ||
484 | after); | ||
485 | else | ||
486 | GNUNET_asprintf(&ret, | ||
487 | "%s", | ||
488 | after); | ||
489 | } | ||
490 | } | 462 | } |
491 | else if (strlen(middle) > 0) | 463 | } |
464 | else if (strlen (after) > 0) | ||
465 | { | ||
466 | if (strlen (dots) > 0) | ||
492 | { | 467 | { |
493 | GNUNET_asprintf(&ret, | 468 | if (strlen (middle) > 0) |
494 | "%s", | 469 | GNUNET_asprintf (&ret, |
495 | middle); | 470 | "(%s|%s%s)", |
471 | middle, | ||
472 | afterp, dots); | ||
473 | else | ||
474 | GNUNET_asprintf (&ret, | ||
475 | "%s%s", | ||
476 | afterp, dots); | ||
496 | } | 477 | } |
497 | else | 478 | else |
498 | { | 479 | { |
499 | ret = GNUNET_strdup(""); | 480 | if (strlen (middle) > 0) |
481 | GNUNET_asprintf (&ret, | ||
482 | "%s|%s", | ||
483 | middle, | ||
484 | after); | ||
485 | else | ||
486 | GNUNET_asprintf (&ret, | ||
487 | "%s", | ||
488 | after); | ||
500 | } | 489 | } |
501 | GNUNET_free(middle); | 490 | } |
502 | GNUNET_free(reclp); | 491 | else if (strlen (middle) > 0) |
503 | GNUNET_free(rechp); | 492 | { |
504 | GNUNET_free(recl); | 493 | GNUNET_asprintf (&ret, |
505 | GNUNET_free(rech); | 494 | "%s", |
495 | middle); | ||
496 | } | ||
497 | else | ||
498 | { | ||
499 | ret = GNUNET_strdup (""); | ||
500 | } | ||
501 | GNUNET_free (middle); | ||
502 | GNUNET_free (reclp); | ||
503 | GNUNET_free (rechp); | ||
504 | GNUNET_free (recl); | ||
505 | GNUNET_free (rech); | ||
506 | return ret; | 506 | return ret; |
507 | } | 507 | } |
508 | 508 | ||
@@ -517,7 +517,7 @@ compute_policy(unsigned int start, | |||
517 | * @return NULL on error | 517 | * @return NULL on error |
518 | */ | 518 | */ |
519 | static char * | 519 | static char * |
520 | port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp) | 520 | port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp) |
521 | { | 521 | { |
522 | char *reg; | 522 | char *reg; |
523 | char *ret; | 523 | char *ret; |
@@ -529,53 +529,53 @@ port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp) | |||
529 | ((1 == pp->start_port) && | 529 | ((1 == pp->start_port) && |
530 | (0xFFFF == pp->end_port) && | 530 | (0xFFFF == pp->end_port) && |
531 | (GNUNET_NO == pp->negate_portrange))) | 531 | (GNUNET_NO == pp->negate_portrange))) |
532 | return GNUNET_strdup(DOT DOT DOT DOT); | 532 | return GNUNET_strdup (DOT DOT DOT DOT); |
533 | if ((pp->start_port == pp->end_port) && | 533 | if ((pp->start_port == pp->end_port) && |
534 | (GNUNET_NO == pp->negate_portrange)) | 534 | (GNUNET_NO == pp->negate_portrange)) |
535 | { | 535 | { |
536 | GNUNET_asprintf(&ret, | 536 | GNUNET_asprintf (&ret, |
537 | "%04X", | 537 | "%04X", |
538 | pp->start_port); | 538 | pp->start_port); |
539 | return ret; | 539 | return ret; |
540 | } | 540 | } |
541 | if (pp->end_port < pp->start_port) | 541 | if (pp->end_port < pp->start_port) |
542 | return NULL; | 542 | return NULL; |
543 | 543 | ||
544 | if (GNUNET_YES == pp->negate_portrange) | 544 | if (GNUNET_YES == pp->negate_portrange) |
545 | { | 545 | { |
546 | ret = compute_policy(0, 0xFFFF, 0x1000, pp); | 546 | ret = compute_policy (0, 0xFFFF, 0x1000, pp); |
547 | } | 547 | } |
548 | else | 548 | else |
549 | { | ||
550 | cnt = pp->end_port - pp->start_port + 1; | ||
551 | reg = GNUNET_malloc (cnt * 5 + 1); | ||
552 | pos = reg; | ||
553 | for (i = 1; i <= 0xFFFF; i++) | ||
549 | { | 554 | { |
550 | cnt = pp->end_port - pp->start_port + 1; | 555 | if ((i >= pp->start_port) && (i <= pp->end_port)) |
551 | reg = GNUNET_malloc(cnt * 5 + 1); | 556 | { |
552 | pos = reg; | 557 | if (pos == reg) |
553 | for (i = 1; i <= 0xFFFF; i++) | 558 | { |
559 | GNUNET_snprintf (pos, | ||
560 | 5, | ||
561 | "%04X", | ||
562 | i); | ||
563 | } | ||
564 | else | ||
554 | { | 565 | { |
555 | if ((i >= pp->start_port) && (i <= pp->end_port)) | 566 | GNUNET_snprintf (pos, |
556 | { | 567 | 6, |
557 | if (pos == reg) | 568 | "|%04X", |
558 | { | 569 | i); |
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 | } | ||
573 | } | 570 | } |
574 | GNUNET_asprintf(&ret, | 571 | pos += strlen (pos); |
575 | "(%s)", | 572 | } |
576 | reg); | ||
577 | GNUNET_free(reg); | ||
578 | } | 573 | } |
574 | GNUNET_asprintf (&ret, | ||
575 | "(%s)", | ||
576 | reg); | ||
577 | GNUNET_free (reg); | ||
578 | } | ||
579 | return ret; | 579 | return ret; |
580 | } | 580 | } |
581 | 581 | ||
@@ -589,9 +589,9 @@ port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp) | |||
589 | * @return NULL on error, otherwise regex for the address | 589 | * @return NULL on error, otherwise regex for the address |
590 | */ | 590 | */ |
591 | static char * | 591 | static char * |
592 | address_to_regex(const void *addr, | 592 | address_to_regex (const void *addr, |
593 | const void *mask, | 593 | const void *mask, |
594 | size_t len) | 594 | size_t len) |
595 | { | 595 | { |
596 | const uint16_t *a = addr; | 596 | const uint16_t *a = addr; |
597 | const uint16_t *m = mask; | 597 | const uint16_t *m = mask; |
@@ -601,29 +601,29 @@ address_to_regex(const void *addr, | |||
601 | unsigned int i; | 601 | unsigned int i; |
602 | 602 | ||
603 | ret = NULL; | 603 | ret = NULL; |
604 | GNUNET_assert(1 != (len % 2)); | 604 | GNUNET_assert (1 != (len % 2)); |
605 | for (i = 0; i < len / 2; i++) | 605 | for (i = 0; i < len / 2; i++) |
606 | { | ||
607 | reg = num_to_regex (a[i], m[i]); | ||
608 | if (NULL == reg) | ||
606 | { | 609 | { |
607 | reg = num_to_regex(a[i], m[i]); | 610 | GNUNET_free_non_null (ret); |
608 | if (NULL == reg) | 611 | return NULL; |
609 | { | 612 | } |
610 | GNUNET_free_non_null(ret); | 613 | if (NULL == ret) |
611 | return NULL; | 614 | { |
612 | } | 615 | ret = reg; |
613 | if (NULL == ret) | 616 | } |
614 | { | 617 | else |
615 | ret = reg; | 618 | { |
616 | } | 619 | GNUNET_asprintf (&tmp, |
617 | else | 620 | "%s%s", |
618 | { | 621 | ret, reg); |
619 | GNUNET_asprintf(&tmp, | 622 | GNUNET_free (ret); |
620 | "%s%s", | 623 | GNUNET_free (reg); |
621 | ret, reg); | 624 | ret = tmp; |
622 | GNUNET_free(ret); | ||
623 | GNUNET_free(reg); | ||
624 | ret = tmp; | ||
625 | } | ||
626 | } | 625 | } |
626 | } | ||
627 | return ret; | 627 | return ret; |
628 | } | 628 | } |
629 | 629 | ||
@@ -635,28 +635,28 @@ address_to_regex(const void *addr, | |||
635 | * @return NULL on error | 635 | * @return NULL on error |
636 | */ | 636 | */ |
637 | static char * | 637 | static char * |
638 | ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4) | 638 | ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4) |
639 | { | 639 | { |
640 | char *reg; | 640 | char *reg; |
641 | char *pp; | 641 | char *pp; |
642 | char *ret; | 642 | char *ret; |
643 | 643 | ||
644 | reg = address_to_regex(&v4->network, | 644 | reg = address_to_regex (&v4->network, |
645 | &v4->netmask, | 645 | &v4->netmask, |
646 | sizeof(struct in_addr)); | 646 | sizeof(struct in_addr)); |
647 | if (NULL == reg) | 647 | if (NULL == reg) |
648 | return NULL; | 648 | return NULL; |
649 | pp = port_to_regex(&v4->pp); | 649 | pp = port_to_regex (&v4->pp); |
650 | if (NULL == pp) | 650 | if (NULL == pp) |
651 | { | 651 | { |
652 | GNUNET_free(reg); | 652 | GNUNET_free (reg); |
653 | return NULL; | 653 | return NULL; |
654 | } | 654 | } |
655 | GNUNET_asprintf(&ret, | 655 | GNUNET_asprintf (&ret, |
656 | "4-%s-%s", | 656 | "4-%s-%s", |
657 | pp, reg); | 657 | pp, reg); |
658 | GNUNET_free(pp); | 658 | GNUNET_free (pp); |
659 | GNUNET_free(reg); | 659 | GNUNET_free (reg); |
660 | return ret; | 660 | return ret; |
661 | } | 661 | } |
662 | 662 | ||
@@ -668,28 +668,28 @@ ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4) | |||
668 | * @return NULL on error | 668 | * @return NULL on error |
669 | */ | 669 | */ |
670 | static char * | 670 | static char * |
671 | ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6) | 671 | ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6) |
672 | { | 672 | { |
673 | char *reg; | 673 | char *reg; |
674 | char *pp; | 674 | char *pp; |
675 | char *ret; | 675 | char *ret; |
676 | 676 | ||
677 | reg = address_to_regex(&v6->network, | 677 | reg = address_to_regex (&v6->network, |
678 | &v6->netmask, | 678 | &v6->netmask, |
679 | sizeof(struct in6_addr)); | 679 | sizeof(struct in6_addr)); |
680 | if (NULL == reg) | 680 | if (NULL == reg) |
681 | return NULL; | 681 | return NULL; |
682 | pp = port_to_regex(&v6->pp); | 682 | pp = port_to_regex (&v6->pp); |
683 | if (NULL == pp) | 683 | if (NULL == pp) |
684 | { | 684 | { |
685 | GNUNET_free(reg); | 685 | GNUNET_free (reg); |
686 | return NULL; | 686 | return NULL; |
687 | } | 687 | } |
688 | GNUNET_asprintf(&ret, | 688 | GNUNET_asprintf (&ret, |
689 | "6-%s-%s", | 689 | "6-%s-%s", |
690 | pp, reg); | 690 | pp, reg); |
691 | GNUNET_free(pp); | 691 | GNUNET_free (pp); |
692 | GNUNET_free(reg); | 692 | GNUNET_free (reg); |
693 | return ret; | 693 | return ret; |
694 | } | 694 | } |
695 | 695 | ||
@@ -704,7 +704,7 @@ ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6) | |||
704 | * @return regular expression, NULL on error | 704 | * @return regular expression, NULL on error |
705 | */ | 705 | */ |
706 | char * | 706 | char * |
707 | GNUNET_TUN_ipv4policy2regex(const char *policy) | 707 | GNUNET_TUN_ipv4policy2regex (const char *policy) |
708 | { | 708 | { |
709 | struct GNUNET_STRINGS_IPv4NetworkPolicy *np; | 709 | struct GNUNET_STRINGS_IPv4NetworkPolicy *np; |
710 | char *reg; | 710 | char *reg; |
@@ -712,36 +712,36 @@ GNUNET_TUN_ipv4policy2regex(const char *policy) | |||
712 | char *line; | 712 | char *line; |
713 | unsigned int i; | 713 | unsigned int i; |
714 | 714 | ||
715 | np = GNUNET_STRINGS_parse_ipv4_policy(policy); | 715 | np = GNUNET_STRINGS_parse_ipv4_policy (policy); |
716 | if (NULL == np) | 716 | if (NULL == np) |
717 | return NULL; | 717 | return NULL; |
718 | reg = NULL; | 718 | reg = NULL; |
719 | 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++) |
720 | { | ||
721 | line = ipv4_to_regex (&np[i]); | ||
722 | if (NULL == line) | ||
720 | { | 723 | { |
721 | line = ipv4_to_regex(&np[i]); | 724 | GNUNET_free_non_null (reg); |
722 | if (NULL == line) | 725 | GNUNET_free (np); |
723 | { | 726 | return NULL; |
724 | GNUNET_free_non_null(reg); | 727 | } |
725 | GNUNET_free(np); | 728 | if (NULL == reg) |
726 | return NULL; | 729 | { |
727 | } | 730 | reg = line; |
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; | ||
743 | } | 731 | } |
744 | GNUNET_free(np); | 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; | ||
743 | } | ||
744 | GNUNET_free (np); | ||
745 | return reg; | 745 | return reg; |
746 | } | 746 | } |
747 | 747 | ||
@@ -756,7 +756,7 @@ GNUNET_TUN_ipv4policy2regex(const char *policy) | |||
756 | * @return regular expression, NULL on error | 756 | * @return regular expression, NULL on error |
757 | */ | 757 | */ |
758 | char * | 758 | char * |
759 | GNUNET_TUN_ipv6policy2regex(const char *policy) | 759 | GNUNET_TUN_ipv6policy2regex (const char *policy) |
760 | { | 760 | { |
761 | struct in6_addr zero; | 761 | struct in6_addr zero; |
762 | struct GNUNET_STRINGS_IPv6NetworkPolicy *np; | 762 | struct GNUNET_STRINGS_IPv6NetworkPolicy *np; |
@@ -765,37 +765,39 @@ GNUNET_TUN_ipv6policy2regex(const char *policy) | |||
765 | char *line; | 765 | char *line; |
766 | unsigned int i; | 766 | unsigned int i; |
767 | 767 | ||
768 | np = GNUNET_STRINGS_parse_ipv6_policy(policy); | 768 | np = GNUNET_STRINGS_parse_ipv6_policy (policy); |
769 | if (NULL == np) | 769 | if (NULL == np) |
770 | return NULL; | 770 | return NULL; |
771 | reg = NULL; | 771 | reg = NULL; |
772 | memset(&zero, 0, sizeof(struct in6_addr)); | 772 | memset (&zero, 0, sizeof(struct in6_addr)); |
773 | 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 |
774 | in6_addr))); | ||
775 | i++) | ||
776 | { | ||
777 | line = ipv6_to_regex (&np[i]); | ||
778 | if (NULL == line) | ||
774 | { | 779 | { |
775 | line = ipv6_to_regex(&np[i]); | 780 | GNUNET_free_non_null (reg); |
776 | if (NULL == line) | 781 | GNUNET_free (np); |
777 | { | 782 | return NULL; |
778 | GNUNET_free_non_null(reg); | 783 | } |
779 | GNUNET_free(np); | 784 | if (NULL == reg) |
780 | return NULL; | 785 | { |
781 | } | 786 | reg = line; |
782 | if (NULL == reg) | 787 | } |
783 | { | 788 | else |
784 | reg = line; | 789 | { |
785 | } | 790 | GNUNET_asprintf (&tmp, |
786 | else | 791 | "%s|(%s)", |
787 | { | 792 | reg, line); |
788 | GNUNET_asprintf(&tmp, | 793 | GNUNET_free (reg); |
789 | "%s|(%s)", | 794 | GNUNET_free (line); |
790 | reg, line); | 795 | reg = tmp; |
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; | ||
797 | } | 796 | } |
798 | GNUNET_free(np); | 797 | if (0 == memcmp (&zero, &np[i].network, sizeof(struct in6_addr))) |
798 | break; | ||
799 | } | ||
800 | GNUNET_free (np); | ||
799 | return reg; | 801 | return reg; |
800 | } | 802 | } |
801 | 803 | ||
@@ -809,12 +811,12 @@ GNUNET_TUN_ipv6policy2regex(const char *policy) | |||
809 | * @param hc corresponding hash | 811 | * @param hc corresponding hash |
810 | */ | 812 | */ |
811 | void | 813 | void |
812 | GNUNET_TUN_service_name_to_hash(const char *service_name, | 814 | GNUNET_TUN_service_name_to_hash (const char *service_name, |
813 | struct GNUNET_HashCode *hc) | 815 | struct GNUNET_HashCode *hc) |
814 | { | 816 | { |
815 | GNUNET_CRYPTO_hash(service_name, | 817 | GNUNET_CRYPTO_hash (service_name, |
816 | strlen(service_name), | 818 | strlen (service_name), |
817 | hc); | 819 | hc); |
818 | } | 820 | } |
819 | 821 | ||
820 | 822 | ||
@@ -828,16 +830,16 @@ GNUNET_TUN_service_name_to_hash(const char *service_name, | |||
828 | * @param[out] cadet_port CADET port to use | 830 | * @param[out] cadet_port CADET port to use |
829 | */ | 831 | */ |
830 | void | 832 | void |
831 | GNUNET_TUN_compute_service_cadet_port(const struct GNUNET_HashCode *desc, | 833 | GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc, |
832 | uint16_t ip_port, | 834 | uint16_t ip_port, |
833 | struct GNUNET_HashCode *cadet_port) | 835 | struct GNUNET_HashCode *cadet_port) |
834 | { | 836 | { |
835 | uint16_t be_port = htons(ip_port); | 837 | uint16_t be_port = htons (ip_port); |
836 | 838 | ||
837 | *cadet_port = *desc; | 839 | *cadet_port = *desc; |
838 | GNUNET_memcpy(cadet_port, | 840 | GNUNET_memcpy (cadet_port, |
839 | &be_port, | 841 | &be_port, |
840 | sizeof(uint16_t)); | 842 | sizeof(uint16_t)); |
841 | } | 843 | } |
842 | 844 | ||
843 | 845 | ||