diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/util/regex.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/util/regex.c')
-rw-r--r-- | src/util/regex.c | 970 |
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 | */ |
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,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 | */ |
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 | 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 | */ |
148 | static char * | 153 | static char * |
149 | num_to_regex (uint16_t value, | 154 | num_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 | */ |
187 | static int | 192 | static int |
188 | needs_parens (const char *arg) | 193 | needs_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 | */ |
229 | static char * | 237 | static char * |
230 | compute_policy (unsigned int start, | 238 | compute_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 | */ |
511 | static char * | 519 | static char * |
512 | port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp) | 520 | port_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 | */ |
583 | static char * | 591 | static char * |
584 | address_to_regex (const void *addr, | 592 | address_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 | */ |
629 | static char * | 637 | static char * |
630 | ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4) | 638 | ipv4_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 | */ |
662 | static char * | 670 | static char * |
663 | ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6) | 671 | ipv6_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 | */ |
698 | char * | 706 | char * |
699 | GNUNET_TUN_ipv4policy2regex (const char *policy) | 707 | GNUNET_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 | */ |
750 | char * | 758 | char * |
751 | GNUNET_TUN_ipv6policy2regex (const char *policy) | 759 | GNUNET_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 | */ |
803 | void | 811 | void |
804 | GNUNET_TUN_service_name_to_hash (const char *service_name, | 812 | GNUNET_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 | */ |
822 | void | 830 | void |
823 | GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc, | 831 | GNUNET_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 | ||