BadVPN – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 DO NOT EDIT THIS FILE!
3 This file was automatically generated by the bproto generator.
4 */
5  
6 #include <stdint.h>
7 #include <string.h>
8  
9 #include <misc/debug.h>
10 #include <misc/byteorder.h>
11 #include <bproto/BProto.h>
12  
13  
14 #define addr_SIZEtype (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint8_s))
15 #define addr_SIZEip_port (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (2))
16 #define addr_SIZEipv4_addr (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (4))
17 #define addr_SIZEipv6_addr (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (16))
18  
19 typedef struct {
20 uint8_t *out;
21 int used;
22 int type_count;
23 int ip_port_count;
24 int ipv4_addr_count;
25 int ipv6_addr_count;
26 } addrWriter;
27  
28 static void addrWriter_Init (addrWriter *o, uint8_t *out);
29 static int addrWriter_Finish (addrWriter *o);
30 static void addrWriter_Addtype (addrWriter *o, uint8_t v);
31 static uint8_t * addrWriter_Addip_port (addrWriter *o);
32 static uint8_t * addrWriter_Addipv4_addr (addrWriter *o);
33 static uint8_t * addrWriter_Addipv6_addr (addrWriter *o);
34  
35 typedef struct {
36 uint8_t *buf;
37 int buf_len;
38 int type_start;
39 int type_span;
40 int type_pos;
41 int ip_port_start;
42 int ip_port_span;
43 int ip_port_pos;
44 int ipv4_addr_start;
45 int ipv4_addr_span;
46 int ipv4_addr_pos;
47 int ipv6_addr_start;
48 int ipv6_addr_span;
49 int ipv6_addr_pos;
50 } addrParser;
51  
52 static int addrParser_Init (addrParser *o, uint8_t *buf, int buf_len);
53 static int addrParser_GotEverything (addrParser *o);
54 static int addrParser_Gettype (addrParser *o, uint8_t *v);
55 static void addrParser_Resettype (addrParser *o);
56 static void addrParser_Forwardtype (addrParser *o);
57 static int addrParser_Getip_port (addrParser *o, uint8_t **data);
58 static void addrParser_Resetip_port (addrParser *o);
59 static void addrParser_Forwardip_port (addrParser *o);
60 static int addrParser_Getipv4_addr (addrParser *o, uint8_t **data);
61 static void addrParser_Resetipv4_addr (addrParser *o);
62 static void addrParser_Forwardipv4_addr (addrParser *o);
63 static int addrParser_Getipv6_addr (addrParser *o, uint8_t **data);
64 static void addrParser_Resetipv6_addr (addrParser *o);
65 static void addrParser_Forwardipv6_addr (addrParser *o);
66  
67 void addrWriter_Init (addrWriter *o, uint8_t *out)
68 {
69 o->out = out;
70 o->used = 0;
71 o->type_count = 0;
72 o->ip_port_count = 0;
73 o->ipv4_addr_count = 0;
74 o->ipv6_addr_count = 0;
75 }
76  
77 int addrWriter_Finish (addrWriter *o)
78 {
79 ASSERT(o->used >= 0)
80 ASSERT(o->type_count == 1)
81 ASSERT(o->ip_port_count >= 0 && o->ip_port_count <= 1)
82 ASSERT(o->ipv4_addr_count >= 0 && o->ipv4_addr_count <= 1)
83 ASSERT(o->ipv6_addr_count >= 0 && o->ipv6_addr_count <= 1)
84  
85 return o->used;
86 }
87  
88 void addrWriter_Addtype (addrWriter *o, uint8_t v)
89 {
90 ASSERT(o->used >= 0)
91 ASSERT(o->type_count == 0)
92  
93  
94 struct BProto_header_s header;
95 header.id = htol16(1);
96 header.type = htol16(BPROTO_TYPE_UINT8);
97 memcpy(o->out + o->used, &header, sizeof(header));
98 o->used += sizeof(struct BProto_header_s);
99  
100 struct BProto_uint8_s data;
101 data.v = htol8(v);
102 memcpy(o->out + o->used, &data, sizeof(data));
103 o->used += sizeof(struct BProto_uint8_s);
104  
105 o->type_count++;
106 }
107  
108 uint8_t * addrWriter_Addip_port (addrWriter *o)
109 {
110 ASSERT(o->used >= 0)
111 ASSERT(o->ip_port_count == 0)
112  
113  
114 struct BProto_header_s header;
115 header.id = htol16(2);
116 header.type = htol16(BPROTO_TYPE_CONSTDATA);
117 memcpy(o->out + o->used, &header, sizeof(header));
118 o->used += sizeof(struct BProto_header_s);
119  
120 struct BProto_data_header_s data;
121 data.len = htol32(2);
122 memcpy(o->out + o->used, &data, sizeof(data));
123 o->used += sizeof(struct BProto_data_header_s);
124  
125 uint8_t *dest = (o->out + o->used);
126 o->used += (2);
127  
128 o->ip_port_count++;
129  
130 return dest;
131 }
132  
133 uint8_t * addrWriter_Addipv4_addr (addrWriter *o)
134 {
135 ASSERT(o->used >= 0)
136 ASSERT(o->ipv4_addr_count == 0)
137  
138  
139 struct BProto_header_s header;
140 header.id = htol16(3);
141 header.type = htol16(BPROTO_TYPE_CONSTDATA);
142 memcpy(o->out + o->used, &header, sizeof(header));
143 o->used += sizeof(struct BProto_header_s);
144  
145 struct BProto_data_header_s data;
146 data.len = htol32(4);
147 memcpy(o->out + o->used, &data, sizeof(data));
148 o->used += sizeof(struct BProto_data_header_s);
149  
150 uint8_t *dest = (o->out + o->used);
151 o->used += (4);
152  
153 o->ipv4_addr_count++;
154  
155 return dest;
156 }
157  
158 uint8_t * addrWriter_Addipv6_addr (addrWriter *o)
159 {
160 ASSERT(o->used >= 0)
161 ASSERT(o->ipv6_addr_count == 0)
162  
163  
164 struct BProto_header_s header;
165 header.id = htol16(4);
166 header.type = htol16(BPROTO_TYPE_CONSTDATA);
167 memcpy(o->out + o->used, &header, sizeof(header));
168 o->used += sizeof(struct BProto_header_s);
169  
170 struct BProto_data_header_s data;
171 data.len = htol32(16);
172 memcpy(o->out + o->used, &data, sizeof(data));
173 o->used += sizeof(struct BProto_data_header_s);
174  
175 uint8_t *dest = (o->out + o->used);
176 o->used += (16);
177  
178 o->ipv6_addr_count++;
179  
180 return dest;
181 }
182  
183 int addrParser_Init (addrParser *o, uint8_t *buf, int buf_len)
184 {
185 ASSERT(buf_len >= 0)
186  
187 o->buf = buf;
188 o->buf_len = buf_len;
189 o->type_start = o->buf_len;
190 o->type_span = 0;
191 o->type_pos = 0;
192 o->ip_port_start = o->buf_len;
193 o->ip_port_span = 0;
194 o->ip_port_pos = 0;
195 o->ipv4_addr_start = o->buf_len;
196 o->ipv4_addr_span = 0;
197 o->ipv4_addr_pos = 0;
198 o->ipv6_addr_start = o->buf_len;
199 o->ipv6_addr_span = 0;
200 o->ipv6_addr_pos = 0;
201  
202 int type_count = 0;
203 int ip_port_count = 0;
204 int ipv4_addr_count = 0;
205 int ipv6_addr_count = 0;
206  
207 int pos = 0;
208 int left = o->buf_len;
209  
210 while (left > 0) {
211 int entry_pos = pos;
212  
213 if (!(left >= sizeof(struct BProto_header_s))) {
214 return 0;
215 }
216 struct BProto_header_s header;
217 memcpy(&header, o->buf + pos, sizeof(header));
218 pos += sizeof(struct BProto_header_s);
219 left -= sizeof(struct BProto_header_s);
220 uint16_t type = ltoh16(header.type);
221 uint16_t id = ltoh16(header.id);
222  
223 switch (type) {
224 case BPROTO_TYPE_UINT8: {
225 if (!(left >= sizeof(struct BProto_uint8_s))) {
226 return 0;
227 }
228 pos += sizeof(struct BProto_uint8_s);
229 left -= sizeof(struct BProto_uint8_s);
230  
231 switch (id) {
232 case 1:
233 if (o->type_start == o->buf_len) {
234 o->type_start = entry_pos;
235 }
236 o->type_span = pos - o->type_start;
237 type_count++;
238 break;
239 default:
240 return 0;
241 }
242 } break;
243 case BPROTO_TYPE_UINT16: {
244 if (!(left >= sizeof(struct BProto_uint16_s))) {
245 return 0;
246 }
247 pos += sizeof(struct BProto_uint16_s);
248 left -= sizeof(struct BProto_uint16_s);
249  
250 switch (id) {
251 default:
252 return 0;
253 }
254 } break;
255 case BPROTO_TYPE_UINT32: {
256 if (!(left >= sizeof(struct BProto_uint32_s))) {
257 return 0;
258 }
259 pos += sizeof(struct BProto_uint32_s);
260 left -= sizeof(struct BProto_uint32_s);
261  
262 switch (id) {
263 default:
264 return 0;
265 }
266 } break;
267 case BPROTO_TYPE_UINT64: {
268 if (!(left >= sizeof(struct BProto_uint64_s))) {
269 return 0;
270 }
271 pos += sizeof(struct BProto_uint64_s);
272 left -= sizeof(struct BProto_uint64_s);
273  
274 switch (id) {
275 default:
276 return 0;
277 }
278 } break;
279 case BPROTO_TYPE_DATA:
280 case BPROTO_TYPE_CONSTDATA:
281 {
282 if (!(left >= sizeof(struct BProto_data_header_s))) {
283 return 0;
284 }
285 struct BProto_data_header_s val;
286 memcpy(&val, o->buf + pos, sizeof(val));
287 pos += sizeof(struct BProto_data_header_s);
288 left -= sizeof(struct BProto_data_header_s);
289  
290 uint32_t payload_len = ltoh32(val.len);
291 if (!(left >= payload_len)) {
292 return 0;
293 }
294 pos += payload_len;
295 left -= payload_len;
296  
297 switch (id) {
298 case 2:
299 if (!(type == BPROTO_TYPE_CONSTDATA)) {
300 return 0;
301 }
302 if (!(payload_len == (2))) {
303 return 0;
304 }
305 if (o->ip_port_start == o->buf_len) {
306 o->ip_port_start = entry_pos;
307 }
308 o->ip_port_span = pos - o->ip_port_start;
309 ip_port_count++;
310 break;
311 case 3:
312 if (!(type == BPROTO_TYPE_CONSTDATA)) {
313 return 0;
314 }
315 if (!(payload_len == (4))) {
316 return 0;
317 }
318 if (o->ipv4_addr_start == o->buf_len) {
319 o->ipv4_addr_start = entry_pos;
320 }
321 o->ipv4_addr_span = pos - o->ipv4_addr_start;
322 ipv4_addr_count++;
323 break;
324 case 4:
325 if (!(type == BPROTO_TYPE_CONSTDATA)) {
326 return 0;
327 }
328 if (!(payload_len == (16))) {
329 return 0;
330 }
331 if (o->ipv6_addr_start == o->buf_len) {
332 o->ipv6_addr_start = entry_pos;
333 }
334 o->ipv6_addr_span = pos - o->ipv6_addr_start;
335 ipv6_addr_count++;
336 break;
337 default:
338 return 0;
339 }
340 } break;
341 default:
342 return 0;
343 }
344 }
345  
346 if (!(type_count == 1)) {
347 return 0;
348 }
349 if (!(ip_port_count <= 1)) {
350 return 0;
351 }
352 if (!(ipv4_addr_count <= 1)) {
353 return 0;
354 }
355 if (!(ipv6_addr_count <= 1)) {
356 return 0;
357 }
358  
359 return 1;
360 }
361  
362 int addrParser_GotEverything (addrParser *o)
363 {
364 return (
365 o->type_pos == o->type_span
366 &&
367 o->ip_port_pos == o->ip_port_span
368 &&
369 o->ipv4_addr_pos == o->ipv4_addr_span
370 &&
371 o->ipv6_addr_pos == o->ipv6_addr_span
372 );
373 }
374  
375 int addrParser_Gettype (addrParser *o, uint8_t *v)
376 {
377 ASSERT(o->type_pos >= 0)
378 ASSERT(o->type_pos <= o->type_span)
379  
380 int left = o->type_span - o->type_pos;
381  
382 while (left > 0) {
383 ASSERT(left >= sizeof(struct BProto_header_s))
384 struct BProto_header_s header;
385 memcpy(&header, o->buf + o->type_start + o->type_pos, sizeof(header));
386 o->type_pos += sizeof(struct BProto_header_s);
387 left -= sizeof(struct BProto_header_s);
388 uint16_t type = ltoh16(header.type);
389 uint16_t id = ltoh16(header.id);
390  
391 switch (type) {
392 case BPROTO_TYPE_UINT8: {
393 ASSERT(left >= sizeof(struct BProto_uint8_s))
394 struct BProto_uint8_s val;
395 memcpy(&val, o->buf + o->type_start + o->type_pos, sizeof(val));
396 o->type_pos += sizeof(struct BProto_uint8_s);
397 left -= sizeof(struct BProto_uint8_s);
398  
399 if (id == 1) {
400 *v = ltoh8(val.v);
401 return 1;
402 }
403 } break;
404 case BPROTO_TYPE_UINT16: {
405 ASSERT(left >= sizeof(struct BProto_uint16_s))
406 o->type_pos += sizeof(struct BProto_uint16_s);
407 left -= sizeof(struct BProto_uint16_s);
408 } break;
409 case BPROTO_TYPE_UINT32: {
410 ASSERT(left >= sizeof(struct BProto_uint32_s))
411 o->type_pos += sizeof(struct BProto_uint32_s);
412 left -= sizeof(struct BProto_uint32_s);
413 } break;
414 case BPROTO_TYPE_UINT64: {
415 ASSERT(left >= sizeof(struct BProto_uint64_s))
416 o->type_pos += sizeof(struct BProto_uint64_s);
417 left -= sizeof(struct BProto_uint64_s);
418 } break;
419 case BPROTO_TYPE_DATA:
420 case BPROTO_TYPE_CONSTDATA:
421 {
422 ASSERT(left >= sizeof(struct BProto_data_header_s))
423 struct BProto_data_header_s val;
424 memcpy(&val, o->buf + o->type_start + o->type_pos, sizeof(val));
425 o->type_pos += sizeof(struct BProto_data_header_s);
426 left -= sizeof(struct BProto_data_header_s);
427  
428 uint32_t payload_len = ltoh32(val.len);
429 ASSERT(left >= payload_len)
430 o->type_pos += payload_len;
431 left -= payload_len;
432 } break;
433 default:
434 ASSERT(0);
435 }
436 }
437  
438 return 0;
439 }
440  
441 void addrParser_Resettype (addrParser *o)
442 {
443 o->type_pos = 0;
444 }
445  
446 void addrParser_Forwardtype (addrParser *o)
447 {
448 o->type_pos = o->type_span;
449 }
450  
451 int addrParser_Getip_port (addrParser *o, uint8_t **data)
452 {
453 ASSERT(o->ip_port_pos >= 0)
454 ASSERT(o->ip_port_pos <= o->ip_port_span)
455  
456 int left = o->ip_port_span - o->ip_port_pos;
457  
458 while (left > 0) {
459 ASSERT(left >= sizeof(struct BProto_header_s))
460 struct BProto_header_s header;
461 memcpy(&header, o->buf + o->ip_port_start + o->ip_port_pos, sizeof(header));
462 o->ip_port_pos += sizeof(struct BProto_header_s);
463 left -= sizeof(struct BProto_header_s);
464 uint16_t type = ltoh16(header.type);
465 uint16_t id = ltoh16(header.id);
466  
467 switch (type) {
468 case BPROTO_TYPE_UINT8: {
469 ASSERT(left >= sizeof(struct BProto_uint8_s))
470 o->ip_port_pos += sizeof(struct BProto_uint8_s);
471 left -= sizeof(struct BProto_uint8_s);
472 } break;
473 case BPROTO_TYPE_UINT16: {
474 ASSERT(left >= sizeof(struct BProto_uint16_s))
475 o->ip_port_pos += sizeof(struct BProto_uint16_s);
476 left -= sizeof(struct BProto_uint16_s);
477 } break;
478 case BPROTO_TYPE_UINT32: {
479 ASSERT(left >= sizeof(struct BProto_uint32_s))
480 o->ip_port_pos += sizeof(struct BProto_uint32_s);
481 left -= sizeof(struct BProto_uint32_s);
482 } break;
483 case BPROTO_TYPE_UINT64: {
484 ASSERT(left >= sizeof(struct BProto_uint64_s))
485 o->ip_port_pos += sizeof(struct BProto_uint64_s);
486 left -= sizeof(struct BProto_uint64_s);
487 } break;
488 case BPROTO_TYPE_DATA:
489 case BPROTO_TYPE_CONSTDATA:
490 {
491 ASSERT(left >= sizeof(struct BProto_data_header_s))
492 struct BProto_data_header_s val;
493 memcpy(&val, o->buf + o->ip_port_start + o->ip_port_pos, sizeof(val));
494 o->ip_port_pos += sizeof(struct BProto_data_header_s);
495 left -= sizeof(struct BProto_data_header_s);
496  
497 uint32_t payload_len = ltoh32(val.len);
498 ASSERT(left >= payload_len)
499 uint8_t *payload = o->buf + o->ip_port_start + o->ip_port_pos;
500 o->ip_port_pos += payload_len;
501 left -= payload_len;
502  
503 if (type == BPROTO_TYPE_CONSTDATA && id == 2) {
504 *data = payload;
505 return 1;
506 }
507 } break;
508 default:
509 ASSERT(0);
510 }
511 }
512  
513 return 0;
514 }
515  
516 void addrParser_Resetip_port (addrParser *o)
517 {
518 o->ip_port_pos = 0;
519 }
520  
521 void addrParser_Forwardip_port (addrParser *o)
522 {
523 o->ip_port_pos = o->ip_port_span;
524 }
525  
526 int addrParser_Getipv4_addr (addrParser *o, uint8_t **data)
527 {
528 ASSERT(o->ipv4_addr_pos >= 0)
529 ASSERT(o->ipv4_addr_pos <= o->ipv4_addr_span)
530  
531 int left = o->ipv4_addr_span - o->ipv4_addr_pos;
532  
533 while (left > 0) {
534 ASSERT(left >= sizeof(struct BProto_header_s))
535 struct BProto_header_s header;
536 memcpy(&header, o->buf + o->ipv4_addr_start + o->ipv4_addr_pos, sizeof(header));
537 o->ipv4_addr_pos += sizeof(struct BProto_header_s);
538 left -= sizeof(struct BProto_header_s);
539 uint16_t type = ltoh16(header.type);
540 uint16_t id = ltoh16(header.id);
541  
542 switch (type) {
543 case BPROTO_TYPE_UINT8: {
544 ASSERT(left >= sizeof(struct BProto_uint8_s))
545 o->ipv4_addr_pos += sizeof(struct BProto_uint8_s);
546 left -= sizeof(struct BProto_uint8_s);
547 } break;
548 case BPROTO_TYPE_UINT16: {
549 ASSERT(left >= sizeof(struct BProto_uint16_s))
550 o->ipv4_addr_pos += sizeof(struct BProto_uint16_s);
551 left -= sizeof(struct BProto_uint16_s);
552 } break;
553 case BPROTO_TYPE_UINT32: {
554 ASSERT(left >= sizeof(struct BProto_uint32_s))
555 o->ipv4_addr_pos += sizeof(struct BProto_uint32_s);
556 left -= sizeof(struct BProto_uint32_s);
557 } break;
558 case BPROTO_TYPE_UINT64: {
559 ASSERT(left >= sizeof(struct BProto_uint64_s))
560 o->ipv4_addr_pos += sizeof(struct BProto_uint64_s);
561 left -= sizeof(struct BProto_uint64_s);
562 } break;
563 case BPROTO_TYPE_DATA:
564 case BPROTO_TYPE_CONSTDATA:
565 {
566 ASSERT(left >= sizeof(struct BProto_data_header_s))
567 struct BProto_data_header_s val;
568 memcpy(&val, o->buf + o->ipv4_addr_start + o->ipv4_addr_pos, sizeof(val));
569 o->ipv4_addr_pos += sizeof(struct BProto_data_header_s);
570 left -= sizeof(struct BProto_data_header_s);
571  
572 uint32_t payload_len = ltoh32(val.len);
573 ASSERT(left >= payload_len)
574 uint8_t *payload = o->buf + o->ipv4_addr_start + o->ipv4_addr_pos;
575 o->ipv4_addr_pos += payload_len;
576 left -= payload_len;
577  
578 if (type == BPROTO_TYPE_CONSTDATA && id == 3) {
579 *data = payload;
580 return 1;
581 }
582 } break;
583 default:
584 ASSERT(0);
585 }
586 }
587  
588 return 0;
589 }
590  
591 void addrParser_Resetipv4_addr (addrParser *o)
592 {
593 o->ipv4_addr_pos = 0;
594 }
595  
596 void addrParser_Forwardipv4_addr (addrParser *o)
597 {
598 o->ipv4_addr_pos = o->ipv4_addr_span;
599 }
600  
601 int addrParser_Getipv6_addr (addrParser *o, uint8_t **data)
602 {
603 ASSERT(o->ipv6_addr_pos >= 0)
604 ASSERT(o->ipv6_addr_pos <= o->ipv6_addr_span)
605  
606 int left = o->ipv6_addr_span - o->ipv6_addr_pos;
607  
608 while (left > 0) {
609 ASSERT(left >= sizeof(struct BProto_header_s))
610 struct BProto_header_s header;
611 memcpy(&header, o->buf + o->ipv6_addr_start + o->ipv6_addr_pos, sizeof(header));
612 o->ipv6_addr_pos += sizeof(struct BProto_header_s);
613 left -= sizeof(struct BProto_header_s);
614 uint16_t type = ltoh16(header.type);
615 uint16_t id = ltoh16(header.id);
616  
617 switch (type) {
618 case BPROTO_TYPE_UINT8: {
619 ASSERT(left >= sizeof(struct BProto_uint8_s))
620 o->ipv6_addr_pos += sizeof(struct BProto_uint8_s);
621 left -= sizeof(struct BProto_uint8_s);
622 } break;
623 case BPROTO_TYPE_UINT16: {
624 ASSERT(left >= sizeof(struct BProto_uint16_s))
625 o->ipv6_addr_pos += sizeof(struct BProto_uint16_s);
626 left -= sizeof(struct BProto_uint16_s);
627 } break;
628 case BPROTO_TYPE_UINT32: {
629 ASSERT(left >= sizeof(struct BProto_uint32_s))
630 o->ipv6_addr_pos += sizeof(struct BProto_uint32_s);
631 left -= sizeof(struct BProto_uint32_s);
632 } break;
633 case BPROTO_TYPE_UINT64: {
634 ASSERT(left >= sizeof(struct BProto_uint64_s))
635 o->ipv6_addr_pos += sizeof(struct BProto_uint64_s);
636 left -= sizeof(struct BProto_uint64_s);
637 } break;
638 case BPROTO_TYPE_DATA:
639 case BPROTO_TYPE_CONSTDATA:
640 {
641 ASSERT(left >= sizeof(struct BProto_data_header_s))
642 struct BProto_data_header_s val;
643 memcpy(&val, o->buf + o->ipv6_addr_start + o->ipv6_addr_pos, sizeof(val));
644 o->ipv6_addr_pos += sizeof(struct BProto_data_header_s);
645 left -= sizeof(struct BProto_data_header_s);
646  
647 uint32_t payload_len = ltoh32(val.len);
648 ASSERT(left >= payload_len)
649 uint8_t *payload = o->buf + o->ipv6_addr_start + o->ipv6_addr_pos;
650 o->ipv6_addr_pos += payload_len;
651 left -= payload_len;
652  
653 if (type == BPROTO_TYPE_CONSTDATA && id == 4) {
654 *data = payload;
655 return 1;
656 }
657 } break;
658 default:
659 ASSERT(0);
660 }
661 }
662  
663 return 0;
664 }
665  
666 void addrParser_Resetipv6_addr (addrParser *o)
667 {
668 o->ipv6_addr_pos = 0;
669 }
670  
671 void addrParser_Forwardipv6_addr (addrParser *o)
672 {
673 o->ipv6_addr_pos = o->ipv6_addr_span;
674 }
675