1 | /***************************************
2 | $Revision: 1.11 $
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 <stdlib.h>
31 | #include <strings.h>
32 | #include <libgen.h>
33 | #include <glib.h>
34 |
35 | #include "isnic.h"
36 | #include "bitmask.h"
37 | #include "which_keytypes.h"
38 | #include "memwrap.h"
39 |
40 |
41 | #define DOMAINNAME "^[ ]*[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*[ ]*$"
42 |
43 | #define LEN_MIN 0
44 | #define LEN_MAX 32
45 |
46 | #define NETLEN 16
47 | #define NETQUADS 4
48 | #define NETQUAD_MIN 0
49 | #define NETQUAD_MAX 255
50 |
51 | #define ASNUM_MIN 1
52 | #define ASNUM_MAX 65535
53 | #define ASNUM_NUMOFFSET 2 /* XXX - (This is really kludgy!) Offset to the number bit of ASNUM */
54 |
55 | #define VALIDIP6 "^[0-9A-F]{1,4}(:[0-9A-F]{1,4}){7}$"
56 | /*
57 | XXX Why doesn't this work?
58 | #define NET "^([0-9]{1,3}.){4}$"
59 | */
60 | #define NET "^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}$"
61 |
62 | #define ASNUM "^AS[1-9]+[0-9]*$"
63 |
64 | #define NETNAME "^[A-Z][A-Z0-9-]*$"
65 |
66 | #define MAINTAINER "^[A-Z][A-Z0-9-]*$"
67 |
68 | #define LIMERICK "^LIM-[A-Z0-9-]+$"
69 |
70 | #define KEYCERT "^PGPKEY-[0-9A-F]{8}$"
71 |
72 | #define ASMACRO "^AS-[A-Z]+$"
73 |
74 | #define ROUTESETNAME "^RS-[A-Z0-9-]*$"
75 |
76 | #define ASSETNAME "^AS-[A-Z0-9-]*$"
77 |
78 | #define AUTONICPREFIXREGULAR "^AUTO-"
79 |
80 | /*
81 | XXX This seems to be the same as the Perl code. But I don't see where a " " is allowed for.
82 | I.e. Perl -> ^[a-zA-Z][\w\-\.\'\|\`]*$
83 | Does \w include [ ;:,?/}{()+*#] ?
84 | #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`-]*$"
85 | */
86 | #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`;:,?/}{()+*#&-]*$"
87 |
88 | #define PHONE_A "^[ ]*[+][0-9 ]*[(]{0,1}[0-9 -]+[)]{0,1}[0-9 -]*(ext\\.){0,1}[0-9 ]*$"
89 |
90 | #define VALIDIP4PREFIX
91 |
92 | #define EMAIL "^[.a-zA-Z0-9--]*@[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*$"
93 |
94 |
95 | /*+ Keytype strings +*/
96 | char * const Keytypes[] = {
97 | "name",
98 | "nic_hdl",
99 | "email",
100 | "mntner",
101 | "key_cert",
102 | "iprange",
103 | "ipprefix",
104 | "ip6prefix",
105 | "netname",
106 | "net6name",
107 | "autnum",
108 | "assetname",
109 | "routesetname",
110 | "domain",
111 | "hostname",
112 | "limerick",
113 | NULL
114 | }; /* Keytypes[] */
115 |
116 | /*+ Peerword strings +*/
117 | const char * Peerword[] = {
118 | "EGP",
119 | "BGP",
120 | "BGP4",
121 | "IDRP",
122 | "IGP",
123 | "HELLO",
124 | "IGRP",
125 | "EIGRP",
126 | "OSPF",
127 | "ISIS",
128 | "RIP",
129 | "RIP2",
130 | "OTHER",
131 | ""
132 | }; /* Peerword[] */
133 |
134 | static int matching(char *string, char left_c, char right_c) {
135 | int result;
136 |
137 | int i;
138 | int length;
139 | int count=0;
140 |
141 | length = strlen(string);
142 |
143 | for(i=0; i < length; i++) {
144 | /*
145 | switch ((int)string[i]) {
146 | case left_c:
147 | break;
148 |
149 | case right_c:
150 | count--;
151 | break;
152 |
153 | default:
154 | }
155 | */
156 | if (string[i] == left_c) {
157 | count++;
158 | }
159 | if (string[i] == right_c) {
160 | count--;
161 | }
162 | }
163 |
164 | if (count == 0) {
165 | /* Matching characters */
166 | result=1;
167 | }
168 | else {
169 | /* Non-matching characters */
170 | result=0;
171 | }
172 |
173 | return result;
174 |
175 | } /* matching() */
176 |
177 |
178 | static int perform_regex_test(const char *pattern, char *string) {
179 | int match;
180 |
181 | char *re;
182 |
183 | re = regcmp(pattern, (char*)0);
184 | if (regex(re, string) == NULL) {
185 | match = 0;
186 | }
187 | else {
188 | match = 1;
189 | }
190 |
191 | wr_free(re);
192 |
193 | return match;
194 | } /* perform_regex_test() */
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 | wr_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 | wr_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 | wr_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 |
635 | static int isparen(char *string) {
636 | /*
637 | printf("isparen\n");
638 | */
639 | int result='-';
640 |
641 | result=matching(string, '(', ')');
642 |
643 | return result;
644 | }
645 |
646 | static int isphone_b(char *string) {
647 | /*
648 | printf("isphone_b\n");
649 | */
650 | int result='-';
651 |
652 | result = isparen(string);
653 |
654 | return result;
655 | }
656 |
657 | static int isphone_ab(char *string) {
658 | /*
659 | printf("isphone_ab\n");
660 | */
661 | int result='-';
662 |
663 | /* Note: the different logic here because I use 0 to be a match and 1 to not be a match.
664 | The Perl code uses the opposite. - ottrey */
665 | result = !(!isphone_a(string) && !isphone_b(string));
666 |
667 | return result;
668 | }
669 |
670 | static int isphone(char *string) {
671 | /*
672 | printf("isphone\n");
673 | */
674 | int result='-';
675 |
676 | return result;
677 | }
678 |
679 | static int isemail(char *string) {
680 | /*
681 | printf("isemail\n");
682 | */
683 | int result='-';
684 |
685 | result = perform_regex_test(EMAIL, string);
686 |
687 | return result;
688 | }
689 |
690 | static int isbrace(char *string) {
691 | /*
692 | printf("isbrace\n");
693 | */
694 | int result='-';
695 |
696 | result=matching(string, '{', '}');
697 |
698 | return result;
699 | }
700 |
701 |
702 |
703 |
704 |
705 |
706 |
707 |
708 |
709 |
710 |
711 |
712 |
713 | /* ****** The new bunch ******* */
714 | static int wk_is_name(char *key) {
715 |
716 | /* Everything matches to name */
717 | return 1;
718 |
719 | } /* wk_is_name() */
720 |
721 | static int wk_is_nic_hdl(char *key) {
722 |
723 | return isnichandle(key);
724 |
725 | } /* wk_is_nic_hdl() */
726 |
727 | static int wk_is_email(char *key) {
728 |
729 | return isemail(key);
730 |
731 | } /* wk_is_email() */
732 |
733 | static int wk_is_mntner(char *key) {
734 |
735 | return ismaintainer(key);
736 |
737 | } /* wk_is_mntner() */
738 |
739 | static int wk_is_key_cert(char *key) {
740 | int result=1;
741 |
742 | result = perform_regex_test(KEYCERT, key);
743 |
744 | return result;
745 |
746 | } /* wk_is_key_cert() */
747 |
748 | static int wk_is_iprange(char *key) {
749 | int result=1;
750 |
751 | /* XXX This is not very strict - but will cut out a lot of invalids */
752 | /* XXX And has been given a bad name and does a few things. */
753 | /* XXX This needs work. */
754 | #define IPRANGE "^[0-9./ -]*$"
755 | result = perform_regex_test(IPRANGE, key);
756 |
757 | return result;
758 |
759 | } /* wk_is_iprange() */
760 |
761 | static int wk_is_ipprefix(char *key) {
762 | int result=1;
763 |
764 | /* XXX INSERT check here! */
765 | return result;
766 |
767 | } /* wk_is_iprange() */
768 |
769 | static int wk_is_ip6prefix(char *key) {
770 |
771 | return isipv6prefix_a(key);
772 |
773 | } /* wk_is_ip6prefix() */
774 |
775 | static int wk_is_netname(char *key) {
776 |
777 | return isnetname(key);
778 |
779 | } /* wk_is_netname() */
780 |
781 | /* XXX Note: This function uses the same call as wk_is_netname(). */
782 | static int wk_is_net6name(char *key) {
783 |
784 | return isnetname(key);
785 |
786 | } /* wk_is_netname() */
787 |
788 | static int wk_is_autnum(char *key) {
789 |
790 | return isasnum(key);
791 |
792 | } /* wk_is_autnum() */
793 |
794 | static int wk_is_assetname(char *key) {
795 | int result=1;
796 |
797 | result = perform_regex_test(ASSETNAME, key);
798 |
799 | return result;
800 |
801 | } /* wk_is_assetname() */
802 |
803 | static int wk_is_routesetname(char *key) {
804 | int result=1;
805 |
806 | result = perform_regex_test(ROUTESETNAME, key);
807 |
808 | return result;
809 |
810 | } /* wk_is_routesetname() */
811 |
812 | static int wk_is_domain(char *key) {
813 |
814 | return isdomname(key);
815 |
816 | } /* wk_is_domname() */
817 |
818 | static int wk_is_hostname(char *key) {
819 |
820 | /* XXX Why is there a hostname & a domainname? */
821 | /* Answer - hostname can be a domainname or an IP */
822 | return (isdomname(key) || wk_is_iprange(key));
823 |
824 | } /* wk_is_hostname() */
825 |
826 | static int wk_is_limerick(char *key) {
827 |
828 | return islimerick(key);
829 |
830 | } /* wk_is_limerick() */
831 |
832 |
833 | /* WK_to_string() */
834 | /*++++++++++++++++++++++++++++++++++++++
835 | Convert the which keytypes bitmap into a string.
836 |
837 | mask_t wk The which keytypes mask to be converted.
838 |
839 | More:
840 | +html+ <PRE>
841 | Authors:
842 | ottrey
843 | +html+ </PRE><DL COMPACT>
844 | +html+ <DT>Online References:
845 | +html+ <DD><UL>
846 | +html+ </UL></DL>
847 |
848 | ++++++++++++++++++++++++++++++++++++++*/
849 | char *WK_to_string(mask_t wk) {
850 |
851 | return MA_to_string(wk, Keytypes);
852 |
853 | } /* WK_to_string() */
854 |
855 |
856 | /* WK_new() */
857 | /*++++++++++++++++++++++++++++++++++++++
858 | Create a new which keytypes bitmap.
859 |
860 | char *key The key to be examined.
861 |
862 | More:
863 | +html+ <PRE>
864 | Authors:
865 | ottrey
866 | +html+ </PRE><DL COMPACT>
867 | +html+ <DT>Online References:
868 | +html+ <DD><UL>
869 | +html+ </UL></DL>
870 |
871 | ++++++++++++++++++++++++++++++++++++++*/
872 | mask_t WK_new(char *key) {
873 | mask_t wk;
874 |
875 | wk = MA_new(MA_END);
876 |
877 | MA_set(&wk, WK_NAME, wk_is_name(key));
878 | MA_set(&wk, WK_NIC_HDL, wk_is_nic_hdl(key));
879 | MA_set(&wk, WK_EMAIL, wk_is_email(key));
880 | MA_set(&wk, WK_MNTNER, wk_is_mntner(key));
881 | MA_set(&wk, WK_KEY_CERT, wk_is_key_cert(key));
882 | MA_set(&wk, WK_IPRANGE, wk_is_iprange(key));
883 | MA_set(&wk, WK_IPPREFIX, wk_is_ipprefix(key));
884 | MA_set(&wk, WK_IP6PREFIX, wk_is_ip6prefix(key));
885 | MA_set(&wk, WK_NETNAME, wk_is_netname(key));
886 | MA_set(&wk, WK_NET6NAME, wk_is_net6name(key));
887 | MA_set(&wk, WK_AUTNUM, wk_is_autnum(key));
888 | MA_set(&wk, WK_ASSETNAME, wk_is_assetname(key));
889 | MA_set(&wk, WK_ROUTESETNAME, wk_is_routesetname(key));
890 | MA_set(&wk, WK_DOMAIN, wk_is_domain(key));
891 | MA_set(&wk, WK_HOSTNAME, wk_is_hostname(key));
892 | MA_set(&wk, WK_LIMERICK, wk_is_limerick(key));
893 |
894 | return wk;
895 |
896 | } /* WK_new() */