modules/wk/which_keytypes.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. perform_regex_test
  2. isdomname
  3. isname_a
  4. isname_b
  5. isname_ab
  6. wk_is_name
  7. wk_is_domain
  8. wk_is_iprange
  9. wk_is_hostname
  10. WK_to_string
  11. WK_new

   1 /***************************************
   2   $Revision: 1.16 $
   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 "memwrap.h"
  38 
  39 #define  WK_IMPL
  40 #include "which_keytypes.h"
  41 
  42 
  43 
  44 #define DOMAINNAME "^[ ]*[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*[ ]*$"
  45 /* add a constraint: there must be at least one character in the domain name
  46    because the TLD must not be composed of digits only */
  47 #define DOMAINALPHA  "[a-zA-Z]"
  48 
  49 #define VALIDIP6PREFIX "^[0-9A-F:]*:[0-9A-F:/]*$"     /* at least one colon */
  50 /* "^[0-9A-F]{1,4}(:[0-9A-F]{1,4}){7}$"*/
  51 
  52 #define NET "^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}$"
  53 
  54 #define ASNUM "^AS[1-9]+[0-9]{0,4}$"
  55 
  56 #define ASRANGE "^AS[0-9]{1,5}[ ]*([-][ ]*AS[0-9]{1,5}){0,1}$"   /* [ ]*(-[ ]*AS[0-9]+)?   */
  57 
  58 #define NETNAME "^[A-Z][A-Z0-9-]*$"
  59 
  60 #define MAINTAINER "^[A-Z][A-Z0-9-]*$"
  61 
  62 #define LIMERICK "^LIM-[A-Z0-9-]+$"
  63 
  64 #define KEYCERT "^PGPKEY-[0-9A-F]{8}$"
  65 
  66 #define ROUTESETNAME "^RS-[A-Z0-9-_]*$"
  67 
  68 #define ASSETNAME "^AS-[A-Z0-9-_]*$"
  69 
  70 #define AUTONICPREFIXREGULAR "^AUTO-"
  71 
  72 #define IPRANGE "^[0-9]{1,3}(\\.[0-9]{1,3}){0,3}[ ]*-[ ]*[0-9]{1,3}(\\.[0-9]{1,3}){0,3}$"
  73 
  74 #define IPADDRESS "^[0-9.]+$"
  75 
  76 #define IPPREFIX "^[0-9.]+/[0-9]+$"
  77 
  78 #define PEERINGSET "^PRNG-"
  79 
  80 #define FILTERSET  "^FLTR-"
  81 
  82 #define RTRSET     "^RTRS-"
  83 
  84 #define NICHANDLE "^[A-Z0-9-]+$"
  85 
  86 /*
  87   XXX This seems to be the same as the Perl code.  But I don't see where a " " is allowed for.
  88   I.e. Perl -> ^[a-zA-Z][\w\-\.\'\|\`]*$
  89   Does \w include [ ;:,?/}{()+*#] ?
  90 #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`-]*$"
  91 */
  92 #define NAME_B "^[a-zA-Z][a-zA-Z_0-9.'|`;:,?/}{()+*#&-]*$"
  93 
  94 #define VALIDIP4PREFIX
  95 
  96 #define EMAIL "^[.a-zA-Z0-9--]*@[a-zA-Z0-9--]*(\\.[a-zA-Z0-9--]+)*$"
  97 
  98 static int perform_regex_test(const char *pattern, char *string) {
     /* [<][>][^][v][top][bottom][index][help] */
  99   int match;
 100 
 101   char *re;
 102 
 103   re = regcmp(pattern, (char*)0);
 104   if (regex(re, string) == NULL) {
 105     match = 0;
 106   }
 107   else {
 108     match = 1;
 109   }
 110 
 111   free(re); /* not a wrapper, because we have not allocated it */
 112 
 113   return match;
 114 } /* perform_regex_test() */
 115 
 116 
 117 static int isdomname(char *string) {
     /* [<][>][^][v][top][bottom][index][help] */
 118     return (    perform_regex_test(DOMAINNAME, string)
 119              && perform_regex_test(DOMAINALPHA, string));
 120 }
 121 
 122 /*
 123  I split the isname up into isname_a & isname_b.  And created isname_ab to join them together.
 124   - So I can test it properly.  -ottrey
 125  */
 126 static int isname_a(char *string) {
     /* [<][>][^][v][top][bottom][index][help] */
 127     return perform_regex_test(AUTONICPREFIXREGULAR, string);
 128 }
 129 
 130 static int isname_b(char *string) {
     /* [<][>][^][v][top][bottom][index][help] */
 131     return perform_regex_test(NAME_B, string);
 132 }
 133 
 134 static int isname_ab(char *string) {
     /* [<][>][^][v][top][bottom][index][help] */
 135     return (isname_a(string) || isname_b(string));
 136 }
 137 
 138 static int wk_is_name(char *key) {
     /* [<][>][^][v][top][bottom][index][help] */
 139     /* Everything matches to name */
 140     return 1;
 141 } /* wk_is_name() */
 142 
 143 static int wk_is_domain(char *key) {
     /* [<][>][^][v][top][bottom][index][help] */
 144     return isdomname(key);
 145 } /* wk_is_domname() */
 146 
 147 static int wk_is_iprange(char *key) {
     /* [<][>][^][v][top][bottom][index][help] */
 148   return perform_regex_test(IPRANGE, key);
 149 } /* wk_is_iprange() */
 150 
 151 static int wk_is_hostname(char *key) {
     /* [<][>][^][v][top][bottom][index][help] */
 152   /* XXX Why is there a hostname & a domainname? */
 153   /* Answer - hostname can be a domainname or an IP */
 154     return (isdomname(key) || wk_is_iprange(key));
 155 } /* wk_is_hostname() */
 156 
 157 /* WK_to_string() */
 158 /*++++++++++++++++++++++++++++++++++++++
 159   Convert the which keytypes bitmap into a string.
 160 
 161   mask_t wk The which keytypes mask to be converted.
 162 
 163   More:
 164   +html+ <PRE>
 165   Authors:
 166         ottrey
 167   +html+ </PRE><DL COMPACT>
 168   +html+ <DT>Online References:
 169   +html+ <DD><UL>
 170   +html+ </UL></DL>
 171 
 172   ++++++++++++++++++++++++++++++++++++++*/
 173 char *WK_to_string(mask_t wk) {
     /* [<][>][^][v][top][bottom][index][help] */
 174 
 175   return MA_to_string(wk, Keytypes);
 176 
 177 } /* WK_to_string() */
 178 
 179 /* WK_new() */
 180 /*++++++++++++++++++++++++++++++++++++++
 181   Create a new which keytypes bitmap.
 182 
 183   char *key The key to be examined.
 184 
 185   More:
 186   +html+ <PRE>
 187   Authors:
 188         ottrey
 189   +html+ </PRE><DL COMPACT>
 190   +html+ <DT>Online References:
 191   +html+ <DD><UL>
 192   +html+ </UL></DL>
 193 
 194   ++++++++++++++++++++++++++++++++++++++*/
 195 mask_t WK_new(char *key) {
     /* [<][>][^][v][top][bottom][index][help] */
 196   mask_t wk; 
 197 
 198   wk = MA_new(MA_END);
 199 
 200   MA_set(&wk, WK_NAME,         wk_is_name(key));
 201   MA_set(&wk, WK_NIC_HDL,      perform_regex_test(NICHANDLE, key));
 202   MA_set(&wk, WK_EMAIL,        perform_regex_test(EMAIL, key));
 203   MA_set(&wk, WK_MNTNER,       perform_regex_test(MAINTAINER, key));
 204   MA_set(&wk, WK_KEY_CERT,     perform_regex_test(KEYCERT, key));
 205   MA_set(&wk, WK_IPADDRESS,    perform_regex_test(IPADDRESS, key));
 206   MA_set(&wk, WK_IPRANGE,      wk_is_iprange(key));
 207   MA_set(&wk, WK_IPPREFIX,     perform_regex_test(IPPREFIX, key));
 208   MA_set(&wk, WK_IP6PREFIX,    perform_regex_test(VALIDIP6PREFIX, key));
 209   MA_set(&wk, WK_NETNAME,      perform_regex_test(NETNAME, key));
 210   MA_set(&wk, WK_NET6NAME,     perform_regex_test(NETNAME, key));
 211   MA_set(&wk, WK_AUTNUM,       perform_regex_test(ASNUM, key));
 212   MA_set(&wk, WK_ASSETNAME,    perform_regex_test(ASSETNAME, key));
 213   MA_set(&wk, WK_ROUTESETNAME, perform_regex_test(ROUTESETNAME, key));
 214   MA_set(&wk, WK_DOMAIN,       wk_is_domain(key));
 215   MA_set(&wk, WK_HOSTNAME,     wk_is_hostname(key));
 216   MA_set(&wk, WK_LIMERICK,     perform_regex_test(LIMERICK, key));
 217   MA_set(&wk, WK_ASRANGE,      perform_regex_test(ASRANGE, key));
 218   MA_set(&wk, WK_PEERINGSET,   perform_regex_test(PEERINGSET, key));
 219   MA_set(&wk, WK_FILTERSET,    perform_regex_test(FILTERSET, key));
 220   MA_set(&wk, WK_RTRSET,       perform_regex_test(RTRSET, key));
 221   
 222   return wk;
 223 
 224 } /* WK_new() */

/* [<][>][^][v][top][bottom][index][help] */