## modules/wk/which_keytypes.c

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

## FUNCTIONS

This source file includes following functions.

1. perform_regex_test
2. isname_a
3. isname_b
4. isname_ab
5. wk_is_name
6. isdomname
7. wk_is_domain
8. wk_is_iprange
9. wk_is_hostname
10. WK_to_string
11. WK_new

       1 /***************************************
       2   $Revision: 1.18 $
       3
       4   which_keytypes:  Determine which keys to look for.
       5
       6   This is based on the existing Perl code.
       7
       8   Authors: ottrey, marek
       9
      10   ******************/ /******************
      11   Copyright (c) 1999                              RIPE NCC
      12
      13   All Rights Reserved
      14
      15   Permission to use, copy, modify, and distribute this software and its
      16   documentation for any purpose and without fee is hereby granted,
      17   provided that the above copyright notice appear in all copies and that
      18   both that copyright notice and this permission notice appear in
      19   supporting documentation, and that the name of the author not be
      20   used in advertising or publicity pertaining to distribution of the
      21   software without specific, written prior permission.
      22
      23   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
      24   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
      25   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
      26   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
      27   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      28   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      29   ***************************************/
      30 #include <stdio.h>
      31 #include <stdlib.h>
      32 #include <strings.h>
      33 #include <libgen.h>
      34 #include <glib.h>
      35
      36 #include "bitmask.h"
      37 #include "memwrap.h"
      38
      39 #define  WK_IMPL
      40 #include "which_keytypes.h"
      41 #include <regex.h>
      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 /*****************************************************************/
      99
     100 static int perform_regex_test(const char *pattern, char *string)
         /* [<][>][^][v][top][bottom][index][help] */
     101 {
     102
     103   int match = 0;
     104
     105   /* These are not used, since REG_NOSUB is specified in regcomp() */
     106   size_t nmatch = 0;
     107   regmatch_t pmatch[1];
     108   regex_t re;
     109   int err;
     110
     111   if( (err = regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB)) != 0)
     112     {
     113       char erbuf[2048];
     114       regerror(err,&re,erbuf,sizeof(erbuf));
     115       die;
     116     }
     117   if (regexec(&re, string, nmatch, pmatch, 0))
     118     match = 0;
     119   else
     120     match = 1;
     121
     122   regfree(&re);
     123
     124   return(match);
     125
     126 }
     127
     128 /*
     129  I split the isname up into isname_a & isname_b.  And created isname_ab to join them together.
     130   - So I can test it properly.  -ottrey
     131  */
     132 #if 0
     133 static int isname_a(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     134     return perform_regex_test(AUTONICPREFIXREGULAR, string);
     135 }
     136
     137 static int isname_b(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     138     return perform_regex_test(NAME_B, string);
     139 }
     140
     141 static int isname_ab(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     142     return (isname_a(string) || isname_b(string));
     143 }
     144 #endif
     145
     146 static int wk_is_name(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     147     /* Everything matches to name */
     148     return 1;
     149 } /* wk_is_name() */
     150
     151 /***************************************************************/
     152
     153 static int isdomname(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     154     return (    perform_regex_test(DOMAINNAME, string)
     155              && perform_regex_test(DOMAINALPHA, string));
     156 }
     157
     158 static int wk_is_domain(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     159     return isdomname(key);
     160 } /* wk_is_domname() */
     161
     162 static int wk_is_iprange(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     163   return perform_regex_test(IPRANGE, key);
     164 } /* wk_is_iprange() */
     165
     166 static int wk_is_hostname(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     167   /* XXX Why is there a hostname & a domainname? */
     168   /* Answer - hostname can be a domainname or an IP */
     169     return (isdomname(key) || wk_is_iprange(key));
     170 } /* wk_is_hostname() */
     171
     172 /* WK_to_string() */
     173 /*++++++++++++++++++++++++++++++++++++++
     174   Convert the which keytypes bitmap into a string.
     175
     176   mask_t wk The which keytypes mask to be converted.
     177
     178   More:
     179   +html+ <PRE>
     180   Authors:
     181         ottrey
     182   +html+ </PRE><DL COMPACT>
     183   +html+ <DT>Online References:
     184   +html+ <DD><UL>
     185   +html+ </UL></DL>
     186
     187   ++++++++++++++++++++++++++++++++++++++*/
     188 char *WK_to_string(mask_t wk) {
         /* [<][>][^][v][top][bottom][index][help] */
     189
     190   return MA_to_string(wk, Keytypes);
     191
     192 } /* WK_to_string() */
     193
     194 /* WK_new() */
     195 /*++++++++++++++++++++++++++++++++++++++
     196   Create a new which keytypes bitmap.
     197
     198   char *key The key to be examined.
     199
     200   More:
     201   +html+ <PRE>
     202   Authors:
     203         ottrey
     204   +html+ </PRE><DL COMPACT>
     205   +html+ <DT>Online References:
     206   +html+ <DD><UL>
     207   +html+ </UL></DL>
     208
     209   ++++++++++++++++++++++++++++++++++++++*/
     210 mask_t WK_new(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     211   mask_t wk;
     212
     213   wk = MA_new(MA_END);
     214
     215   MA_set(&wk, WK_NAME,         wk_is_name(key));
     216   MA_set(&wk, WK_NIC_HDL,      perform_regex_test(NICHANDLE, key));
     217   MA_set(&wk, WK_EMAIL,        perform_regex_test(EMAIL, key));
     218   MA_set(&wk, WK_MNTNER,       perform_regex_test(MAINTAINER, key));
     219   MA_set(&wk, WK_KEY_CERT,     perform_regex_test(KEYCERT, key));
     220   MA_set(&wk, WK_IPADDRESS,    perform_regex_test(IPADDRESS, key));
     221   MA_set(&wk, WK_IPRANGE,      wk_is_iprange(key));
     222   MA_set(&wk, WK_IPPREFIX,     perform_regex_test(IPPREFIX, key));
     223   MA_set(&wk, WK_IP6PREFIX,    perform_regex_test(VALIDIP6PREFIX, key));
     224   MA_set(&wk, WK_NETNAME,      perform_regex_test(NETNAME, key));
     225   MA_set(&wk, WK_NET6NAME,     perform_regex_test(NETNAME, key));
     226   MA_set(&wk, WK_AUTNUM,       perform_regex_test(ASNUM, key));
     227   MA_set(&wk, WK_ASSETNAME,    perform_regex_test(ASSETNAME, key));
     228   MA_set(&wk, WK_ROUTESETNAME, perform_regex_test(ROUTESETNAME, key));
     229   MA_set(&wk, WK_DOMAIN,       wk_is_domain(key));
     230   MA_set(&wk, WK_HOSTNAME,     wk_is_hostname(key));
     231   MA_set(&wk, WK_LIMERICK,     perform_regex_test(LIMERICK, key));
     232   MA_set(&wk, WK_ASRANGE,      perform_regex_test(ASRANGE, key));
     233   MA_set(&wk, WK_PEERINGSET,   perform_regex_test(PEERINGSET, key));
     234   MA_set(&wk, WK_FILTERSET,    perform_regex_test(FILTERSET, key));
     235   MA_set(&wk, WK_RTRSET,       perform_regex_test(RTRSET, key));
     236
     237   return wk;
     238
     239 } /* WK_new() */

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