1 | /***************************************
2 | $Revision: 1.9 $
3 |
4 | Example code: Determine which keys to look for.
5 |
6 | This is based on the C code that was reversed engineered from existing Perl
7 | code. (~ottrey/which_table/which_table.c)
8 |
9 | ******************/ /******************
10 | Copyright (c) 1999 RIPE NCC
11 |
12 | All Rights Reserved
13 |
14 | Permission to use, copy, modify, and distribute this software and its
15 | documentation for any purpose and without fee is hereby granted,
16 | provided that the above copyright notice appear in all copies and that
17 | both that copyright notice and this permission notice appear in
18 | supporting documentation, and that the name of the author not be
19 | used in advertising or publicity pertaining to distribution of the
20 | software without specific, written prior permission.
21 |
22 | THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
23 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
24 | AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
25 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
26 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
27 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
28 | ***************************************/
29 | #include <stdio.h>
30 | #include <strings.h>
31 | #include <libgen.h>
32 | #include <glib.h>
33 |
34 | #include "isnic.h"
35 | #include "bitmask.h"
36 | #include "which_keytypes.h"
37 |
38 |
39 | #define DOMAINNAME "^[ ]*[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*[ ]*$"
40 |
41 | #define LEN_MIN 0
42 | #define LEN_MAX 32
43 |
44 | #define NETLEN 16
45 | #define NETQUADS 4
46 | #define NETQUAD_MIN 0
47 | #define NETQUAD_MAX 255
48 |
49 | #define ASNUM_MIN 1
50 | #define ASNUM_MAX 65535
51 | #define ASNUM_NUMOFFSET 2 /* XXX - (This is really kludgy!) Offset to the number bit of ASNUM */
52 |
53 | #define VALIDIP6 "^[0-9A-F]{1,4}(:[0-9A-F]{1,4}){7}$"
54 | /*
55 | XXX Why doesn't this work?
56 | #define NET "^([0-9]{1,3}.){4}$"
57 | */
58 | #define NET "^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}$"
59 |
60 | #define ASNUM "^AS[1-9]+[0-9]*$"
61 |
62 | #define NETNAME "^[A-Z][A-Z0-9-]*$"
63 |
64 | #define MAINTAINER "^[A-Z][A-Z0-9-]*$"
65 |
66 | #define LIMERICK "^LIM-[A-Z0-9-]+$"
67 |
68 | #define KEYCERT "^PGPKEY-[0-9A-F]{8}$"
69 |
70 | #define ASMACRO "^AS-[A-Z]+$"
71 |
72 | #define ROUTESETNAME "^RS-[A-Z0-9-]*$"
73 |
74 | #define ASSETNAME "^AS-[A-Z0-9-]*$"
75 |
76 | #define AUTONICPREFIXREGULAR "^AUTO-"
77 |
78 | /*
79 | XXX This seems to be the same as the Perl code. But I don't see where a " " is allowed for.
80 | I.e. Perl -> ^[a-zA-Z][\w\-\.\'\|\`]*$
81 | Does \w include [ ;:,?/}{()+*#] ?
82 | #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`-]*$"
83 | */
84 | #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`;:,?/}{()+*#&-]*$"
85 |
86 | #define PHONE_A "^[ ]*[+][0-9 ]*[(]{0,1}[0-9 -]+[)]{0,1}[0-9 -]*(ext\\.){0,1}[0-9 ]*$"
87 |
88 | #define VALIDIP4PREFIX
89 |
90 | #define EMAIL "^[.a-zA-Z0-9--]*@[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*$"
91 |
92 |
93 | /*+ Keytype strings +*/
94 | char * const Keytypes[] = {
95 | "name",
96 | "nic_hdl",
97 | "email",
98 | "mntner",
99 | "key_cert",
100 | "iprange",
101 | "ipprefix",
102 | "ip6prefix",
103 | "netname",
104 | "net6name",
105 | "autnum",
106 | "assetname",
107 | "routesetname",
108 | "domain",
109 | "hostname",
110 | "limerick",
111 | NULL
112 | }; /* Keytypes[] */
113 |
114 | /*+ Peerword strings +*/
115 | const char * Peerword[] = {
116 | "EGP",
117 | "BGP",
118 | "BGP4",
119 | "IDRP",
120 | "IGP",
121 | "HELLO",
122 | "IGRP",
123 | "EIGRP",
124 | "OSPF",
125 | "ISIS",
126 | "RIP",
127 | "RIP2",
128 | "OTHER",
129 | ""
130 | }; /* Peerword[] */
131 |
132 | static int matching(char *string, char left_c, char right_c) {
133 | int result;
134 |
135 | int i;
136 | int length;
137 | int count=0;
138 |
139 | length = strlen(string);
140 |
141 | for(i=0; i < length; i++) {
142 | /*
143 | switch ((int)string[i]) {
144 | case left_c:
145 | break;
146 |
147 | case right_c:
148 | count--;
149 | break;
150 |
151 | default:
152 | }
153 | */
154 | if (string[i] == left_c) {
155 | count++;
156 | }
157 | if (string[i] == right_c) {
158 | count--;
159 | }
160 | }
161 |
162 | if (count == 0) {
163 | /* Matching characters */
164 | result=1;
165 | }
166 | else {
167 | /* Non-matching characters */
168 | result=0;
169 | }
170 |
171 | return result;
172 |
173 | } /* matching() */
174 |
175 |
176 | static int perform_regex_test(const char *pattern, char *string) {
177 | char *return_value;
178 | int match;
179 |
180 | char *re;
181 |
182 | re = regcmp(pattern, (char*)0);
183 | if (regex(re, string) == NULL) {
184 | match = 0;
185 | }
186 | else {
187 | match = 1;
188 | }
189 |
190 | free(re);
191 |
192 | return match;
193 |
194 | }
195 |
196 | static int isipv6prefix_a(char *string) {
197 | /*
198 | printf("isipv6prefix\n");
199 | */
200 | int result='-';
201 |
202 | result = perform_regex_test(VALIDIP6, string);
203 |
204 | return result;
205 | }
206 |
207 | static int isipv6prefix(char *string) {
208 | /*
209 | printf("isipv6prefix\n");
210 | */
211 | int result='-';
212 |
213 | return result;
214 | }
215 |
216 | static int islen(char *string) {
217 | /*
218 | printf("islen\n");
219 | */
220 | int result='-';
221 | int length;
222 |
223 | length = strlen(string);
224 |
225 | if ((length <= LEN_MAX) && (length >= LEN_MIN)) {
226 | /* A valid length */
227 | result=1;
228 | }
229 | else if (length < 0) {
230 | /* An invalid length */
231 | result=-1;
232 | }
233 | else {
234 | /* An invalid length */
235 | result=0;
236 | }
237 |
238 | return result;
239 | }
240 |
241 | static int isnet(char *string) {
242 | /*
243 | printf("isnet\n");
244 | */
245 | int result='-';
246 | int i;
247 | int quad_value;
248 | gchar **quad_value_strs;
249 |
250 | /* First check if the string is in quad form */
251 | result = perform_regex_test(NET, string);
252 |
253 | /* Then check if the quad values are between NETQUAD_MIN and NETQUAD_MAX */
254 | if (result == 1) {
255 | quad_value_strs = g_strsplit(string, ".", 0);
256 | for (i=0; quad_value_strs[i] != NULL; i++) {
257 | quad_value = atoi(quad_value_strs[i]);
258 | if ((quad_value < NETQUAD_MIN) || (quad_value > NETQUAD_MAX)) {
259 | /* an invalid value */
260 | result=0;
261 | break;
262 | }
263 | }
264 | }
265 |
266 | return result;
267 | }
268 |
269 | static int isasnum(char *string) {
270 | /*
271 | printf("isasnum\n");
272 | */
273 | int result='-';
274 | int as_value;
275 |
276 | /* First check if the string matches an ASNUM */
277 | result = perform_regex_test(ASNUM, string);
278 |
279 | /* Then check if the value is between ASNUM_MIN and ASNUM_MAX */
280 | if (result == 1) {
281 | as_value = atoi(string+ASNUM_NUMOFFSET);
282 | if ((as_value < ASNUM_MIN) || (as_value > ASNUM_MAX)) {
283 | /* an invalid value */
284 | result=0;
285 | }
286 | }
287 |
288 | return result;
289 | }
290 |
291 | static int isnetname(char *string) {
292 | /*
293 | printf("isnetname\n");
294 | */
295 | int result='-';
296 |
297 | result = perform_regex_test(NETNAME, string);
298 |
299 | return result;
300 | }
301 |
302 | static int ismaintainer(char *string) {
303 | /*
304 | printf("ismaintainer\n");
305 | */
306 | int result='-';
307 |
308 | result = perform_regex_test(MAINTAINER, string);
309 |
310 | return result;
311 | }
312 |
313 | static int islimerick(char *string) {
314 | /*
315 | printf("islimerick\n");
316 | */
317 | int result='-';
318 |
319 | result = perform_regex_test(LIMERICK, string);
320 |
321 | return result;
322 | }
323 |
324 | /*******************************************************
325 | # the problem is as follows:
326 | #
327 | # we can never find out which NIC handles are possible on the
328 | # globe since we don't know that they exist
329 | #
330 | # we want to solve this with once with DNS :
331 | #
332 | # RIPE.registries.int CNAME whois.ripe.net
333 | # InterNIC.registries.int CNAME whois.internic.net
334 | # and so on...
335 |
336 | #
337 | # 1) it first does a basic syntax check
338 | #
339 | # notes:
340 | #
341 | # - catches InterNIC handles
342 | # - catches the JP|JP-JP APNIC exceptions
343 | # - limits the number of initials to three with a good reason:
344 | # we have a much better chance to find syntax errors like:
345 | # RIPE-DK13 and other problems like this
346 | #
347 | # 2) checks for valid suffixes
348 | # - all 'source:' attribute values from sites that we mirror
349 | # are allowed
350 | # - country codes are allowed for APNIC compatibility
351 | # - APNIC AP|CC-AU exceptions are handled correctly
352 | # - -ORG organization InterNIC handles
353 | # - -ARIN ARIN handles
354 | # - -ORG-ARIN ARIN handles
355 | ********************************************************/
356 | static int isnichandle_joao(char *nichdl) {
357 |
358 | char *regexp, *match;
359 | char ret[1024];
360 | char *suffix;
361 |
362 | int i;
363 |
364 | /* set ret to the empty string *.
365 | ret[0]='\0';
366 | /** Return if there are any lower case characters */
367 |
368 | regexp = regcmp("[a-z]",(char *)0);
369 | match = regex(regexp,nichdl);
370 | free(regexp);
371 | if (match) return 0;
372 |
373 | /*
374 | # Japanese NIC handles
375 | #
376 | # leading zeros in the number part *are* allowed
377 | #
378 | # e.g. AB021JP AB199JP-JP
379 | #
380 | */
381 | regexp = regcmp("[A-Z]{2}[0-9]{3}JP(-JP){0,1}",(char *)0);
382 | match = regex(regexp,nichdl);
383 | free(regexp);
384 | if (match) return 1;
385 |
386 | /*
387 | # Standard NIC handles
388 | #
389 | # leading zeros in the number part are *not* allowed
390 | #
391 | # InterNIC - TBQ, IP4
392 | # RIPE format - AB1-RIPE
393 | # APNIC use two letter country code suffix
394 | # Austraila have used -1-AU, -2-AU, -CC-AU suffix.
395 | # Internic used -ORG suffix
396 | # ARIN use -ARIN suffix
397 | # ARIN also use -ORG-ARIN suffix
398 | #
399 | */
400 | regexp = regcmp("^[A-Z]{2,4}([1-9][0-9]{0,5}){0,1}((-[^ ]+){0,1})$0$",(char *)0);
401 | match = regex(regexp,nichdl,ret);
402 |
403 | free(regexp);
404 |
405 | if (match == NULL) {
406 | return 0;
407 | } else {
408 | if (ret[0] == '\0') {
409 | return 1;
410 | } else {
411 | /* strip leading '-' */
412 | suffix = ret+1;
413 | /* suffix of local sources */
414 | for (i=0;i<=NUM_NICPOSTFIX;i++) {
415 | if ( !strcmp(suffix,nicpostfix[i]) ) {
416 | return 1;
417 | }
418 | }
419 | /* country codes */
420 | for (i=0;i<NUM_COUNTRIES;i++) {
421 | if ( !strcmp(suffix,countries[i]) ) {
422 | return 1;
423 | }
424 | }
425 | /* special suffix */
426 | for (i=0;i<NUM_SPECIAL;i++) {
427 | if ( !strcmp(suffix,special[i]) ) {
428 | return 1;
429 | }
430 | }
431 | }
432 | }
433 | return 0;
434 | } /* isnichandle_joao() */
435 |
436 |
437 | static int isnichandle(char *string) {
438 | return isnichandle_joao(string);
439 | }
440 |
441 | static int isaskeyword(char *string) {
442 | /*
443 | printf("isaskeyword\n");
444 | */
445 | int result='-';
446 |
447 | return result;
448 | }
449 |
450 | static int isasmacro(char *string) {
451 | /*
452 | printf("isasmacro\n");
453 | */
454 | int result='-';
455 |
456 | result = perform_regex_test(ASMACRO, string);
457 |
458 | return result;
459 | }
460 |
461 | static int isclnskeyword(char *string) {
462 | /*
463 | printf("isclnskeyword\n");
464 | */
465 | int result='-';
466 |
467 | return result;
468 | }
469 |
470 | static int ispeerkeyword(char *string) {
471 | /*
472 | printf("ispeerkeyword\n");
473 | */
474 | int result='-';
475 | int i;
476 |
477 | result=0;
478 | for (i=0; Peerword[i] != ""; i++) {
479 | if ( strcmp(Peerword[i], string) == 0 ) {
480 | result=1;
481 | break;
482 | }
483 | }
484 |
485 | return result;
486 | }
487 |
488 | static int isnetlist(char *string) {
489 | /*
490 | printf("isnetlist\n");
491 | */
492 | int result='-';
493 |
494 | return result;
495 | }
496 |
497 | static int iscommunity(char *string) {
498 | /*
499 | printf("iscommunity\n");
500 | */
501 | int result='-';
502 |
503 | return result;
504 | }
505 |
506 | static int isaspref(char *string) {
507 | /*
508 | printf("isaspref\n");
509 | */
510 | int result='-';
511 |
512 | return result;
513 | }
514 |
515 | static int isnetnum(char *string) {
516 | /*
517 | printf("isnetnum\n");
518 | */
519 | int result='-';
520 |
521 | /* XXX - I don't see the difference between isnet and isnetnum */
522 | result=isnet(string);
523 |
524 | return result;
525 | }
526 |
527 | static int isipaddr(char *string) {
528 | /*
529 | printf("isipaddr\n");
530 | */
531 | int result='-';
532 |
533 | return result;
534 | }
535 |
536 | static int ismask(char *string) {
537 | /*
538 | printf("ismask\n");
539 | */
540 | int result='-';
541 |
542 | return result;
543 | }
544 |
545 | static int isclnsprefix(char *string) {
546 | /*
547 | printf("isclnsprefix\n");
548 | */
549 | int result='-';
550 |
551 | return result;
552 | }
553 |
554 | static int issubdomname(char *string) {
555 | /*
556 | printf("issubdomname\n");
557 | */
558 | int result='-';
559 |
560 | result = perform_regex_test(DOMAINNAME, string);
561 |
562 | return result;
563 | }
564 |
565 | static int isdomname(char *string) {
566 | /*
567 | printf("isdomname\n");
568 | */
569 | int result='-';
570 |
571 | result = perform_regex_test(DOMAINNAME, string);
572 |
573 | return result;
574 | }
575 |
576 | /*
577 | I split the isname up into isname_a & isname_b. And created isname_ab to join them together.
578 | - So I can test it properly. -ottrey
579 | */
580 | static int isname_a(char *string) {
581 | /*
582 | printf("isname_a\n");
583 | */
584 | int result='-';
585 |
586 | result = perform_regex_test(AUTONICPREFIXREGULAR, string);
587 |
588 | return result;
589 | }
590 |
591 | static int isname_b(char *string) {
592 | /*
593 | printf("isname_b\n");
594 | */
595 | int result='-';
596 |
597 | result = perform_regex_test(NAME_B, string);
598 |
599 | return result;
600 | }
601 |
602 | static int isname_ab(char *string) {
603 | /*
604 | printf("isname_ab\n");
605 | */
606 | int result='-';
607 |
608 | /* Note: the different logic here because I use 0 to be a match and 1 to not be a match.
609 | The Perl code uses the opposite. - ottrey */
610 | result = !(isname_a(string) && !isname_b(string));
611 |
612 | return result;
613 | }
614 |
615 | static int isname(char *string) {
616 | /*
617 | printf("isname\n");
618 | */
619 | int result='-';
620 |
621 | return result;
622 | }
623 |
624 | static int isphone_a(char *string) {
625 | /*
626 | printf("isphone_a\n");
627 | */
628 | int result='-';
629 |
630 | result = perform_regex_test(PHONE_A, string);
631 |
632 | return result;
633 | }
634 | static int isphone_b(char *string) {
635 | /*
636 | printf("isphone_b\n");
637 | */
638 | int result='-';
639 |
640 | result = isparen(string);
641 |
642 | return result;
643 | }
644 | static int isphone_ab(char *string) {
645 | /*
646 | printf("isphone_ab\n");
647 | */
648 | int result='-';
649 |
650 | /* Note: the different logic here because I use 0 to be a match and 1 to not be a match.
651 | The Perl code uses the opposite. - ottrey */
652 | result = !(!isphone_a(string) && !isphone_b(string));
653 |
654 | return result;
655 | }
656 | static int isphone(char *string) {
657 | /*
658 | printf("isphone\n");
659 | */
660 | int result='-';
661 |
662 | return result;
663 | }
664 |
665 | static int isemail(char *string) {
666 | /*
667 | printf("isemail\n");
668 | */
669 | int result='-';
670 |
671 | result = perform_regex_test(EMAIL, string);
672 |
673 | return result;
674 | }
675 |
676 | static int isbrace(char *string) {
677 | /*
678 | printf("isbrace\n");
679 | */
680 | int result='-';
681 |
682 | result=matching(string, '{', '}');
683 |
684 | return result;
685 | }
686 |
687 | static int isparen(char *string) {
688 | /*
689 | printf("isparen\n");
690 | */
691 | int result='-';
692 |
693 | result=matching(string, '(', ')');
694 |
695 | return result;
696 | }
697 |
698 |
699 |
700 |
701 |
702 |
703 |
704 |
705 |
706 |
707 |
708 |
709 |
710 | /* ****** The new bunch ******* */
711 | static int wk_is_name(char *key) {
712 |
713 | /* Everything matches to name */
714 | return 1;
715 |
716 | } /* wk_is_name() */
717 |
718 | static int wk_is_nic_hdl(char *key) {
719 |
720 | return isnichandle(key);
721 |
722 | } /* wk_is_nic_hdl() */
723 |
724 | static int wk_is_email(char *key) {
725 |
726 | return isemail(key);
727 |
728 | } /* wk_is_email() */
729 |
730 | static int wk_is_mntner(char *key) {
731 |
732 | return ismaintainer(key);
733 |
734 | } /* wk_is_mntner() */
735 |
736 | static int wk_is_key_cert(char *key) {
737 | int result=1;
738 |
739 | result = perform_regex_test(KEYCERT, key);
740 |
741 | return result;
742 |
743 | } /* wk_is_key_cert() */
744 |
745 | static int wk_is_iprange(char *key) {
746 | int result=1;
747 |
748 | /* XXX This is not very strict - but will cut out a lot of invalids */
749 | /* XXX And has been given a bad name and does a few things. */
750 | /* XXX This needs work. */
751 | #define IPRANGE "^[0-9./ -]*$"
752 | result = perform_regex_test(IPRANGE, key);
753 |
754 | return result;
755 |
756 | } /* wk_is_iprange() */
757 |
758 | static int wk_is_ipprefix(char *key) {
759 | int result=1;
760 |
761 | /* XXX INSERT check here! */
762 | return result;
763 |
764 | } /* wk_is_iprange() */
765 |
766 | static int wk_is_ip6prefix(char *key) {
767 |
768 | return isipv6prefix_a(key);
769 |
770 | } /* wk_is_ip6prefix() */
771 |
772 | static int wk_is_netname(char *key) {
773 |
774 | return isnetname(key);
775 |
776 | } /* wk_is_netname() */
777 |
778 | /* XXX Note: This function uses the same call as wk_is_netname(). */
779 | static int wk_is_net6name(char *key) {
780 |
781 | return isnetname(key);
782 |
783 | } /* wk_is_netname() */
784 |
785 | static int wk_is_autnum(char *key) {
786 |
787 | return isasnum(key);
788 |
789 | } /* wk_is_autnum() */
790 |
791 | static int wk_is_assetname(char *key) {
792 | int result=1;
793 |
794 | result = perform_regex_test(ASSETNAME, key);
795 |
796 | return result;
797 |
798 | } /* wk_is_assetname() */
799 |
800 | static int wk_is_routesetname(char *key) {
801 | int result=1;
802 |
803 | result = perform_regex_test(ROUTESETNAME, key);
804 |
805 | return result;
806 |
807 | } /* wk_is_routesetname() */
808 |
809 | static int wk_is_domain(char *key) {
810 |
811 | return isdomname(key);
812 |
813 | } /* wk_is_domname() */
814 |
815 | static int wk_is_hostname(char *key) {
816 |
817 | /* XXX Why is there a hostname & a domainname? */
818 | /* Answer - hostname can be a domainname or an IP */
819 | return (isdomname(key) || wk_is_iprange(key));
820 |
821 | } /* wk_is_hostname() */
822 |
823 | static int wk_is_limerick(char *key) {
824 |
825 | return islimerick(key);
826 |
827 | } /* wk_is_limerick() */
828 |
829 |
830 | /* WK_to_string() */
831 | /*++++++++++++++++++++++++++++++++++++++
832 | Convert the which keytypes bitmap into a string.
833 |
834 | mask_t wk The which keytypes mask to be converted.
835 |
836 | More:
837 | +html+ <PRE>
838 | Authors:
839 | ottrey
840 | +html+ </PRE><DL COMPACT>
841 | +html+ <DT>Online References:
842 | +html+ <DD><UL>
843 | +html+ </UL></DL>
844 |
845 | ++++++++++++++++++++++++++++++++++++++*/
846 | char *WK_to_string(mask_t wk) {
847 |
848 | return MA_to_string(wk, Keytypes);
849 |
850 | } /* WK_to_string() */
851 |
852 |
853 | /* WK_new() */
854 | /*++++++++++++++++++++++++++++++++++++++
855 | Create a new which keytypes bitmap.
856 |
857 | char *key The key to be examined.
858 |
859 | More:
860 | +html+ <PRE>
861 | Authors:
862 | ottrey
863 | +html+ </PRE><DL COMPACT>
864 | +html+ <DT>Online References:
865 | +html+ <DD><UL>
866 | +html+ </UL></DL>
867 |
868 | ++++++++++++++++++++++++++++++++++++++*/
869 | mask_t WK_new(char *key) {
870 | mask_t wk;
871 |
872 | wk = MA_new(MA_END);
873 |
874 | MA_set(&wk, WK_NAME, wk_is_name(key));
875 | MA_set(&wk, WK_NIC_HDL, wk_is_nic_hdl(key));
876 | MA_set(&wk, WK_EMAIL, wk_is_email(key));
877 | MA_set(&wk, WK_MNTNER, wk_is_mntner(key));
878 | MA_set(&wk, WK_KEY_CERT, wk_is_key_cert(key));
879 | MA_set(&wk, WK_IPRANGE, wk_is_iprange(key));
880 | MA_set(&wk, WK_IPPREFIX, wk_is_ipprefix(key));
881 | MA_set(&wk, WK_IP6PREFIX, wk_is_ip6prefix(key));
882 | MA_set(&wk, WK_NETNAME, wk_is_netname(key));
883 | MA_set(&wk, WK_NET6NAME, wk_is_net6name(key));
884 | MA_set(&wk, WK_AUTNUM, wk_is_autnum(key));
885 | MA_set(&wk, WK_ASSETNAME, wk_is_assetname(key));
886 | MA_set(&wk, WK_ROUTESETNAME, wk_is_routesetname(key));
887 | MA_set(&wk, WK_DOMAIN, wk_is_domain(key));
888 | MA_set(&wk, WK_HOSTNAME, wk_is_hostname(key));
889 | MA_set(&wk, WK_LIMERICK, wk_is_limerick(key));
890 |
891 | return wk;
892 |
893 | } /* WK_new() */