## 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.20 $
       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
     101 /*++++++++++++++++++++++++++++++++++++++
     102
     103   compile a regular expression and run on the text given.
     104
     105   unsigned perform_regex_test   returns 1 for match, 0 for no match
     106
     107   const char *pattern           regular expression pattern
     108
     109   char *string                  text to be checked
     110
     111   ++++++++++++++++++++++++++++++++++++++*/
     112 static unsigned perform_regex_test(const char *pattern, char *string)
         /* [<][>][^][v][top][bottom][index][help] */
     113 {
     114
     115   int match = 0;
     116
     117   /* These are not used, since REG_NOSUB is specified in regcomp() */
     118   size_t nmatch = 0;
     119   regmatch_t pmatch[1];
     120   regex_t re;
     121   int err;
     122
     123   if( (err = regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB)) != 0)
     124     {
     125       char erbuf[2048];
     126       regerror(err,&re,erbuf,sizeof(erbuf));
     127       die;
     128     }
     129   if (regexec(&re, string, nmatch, pmatch, 0))
     130     match = 0;
     131   else
     132     match = 1;
     133
     134   regfree(&re);
     135
     136   return(match);
     137
     138 }
     139
     140 /*
     141  I split the isname up into isname_a & isname_b.  And created isname_ab to join them together.
     142   - So I can test it properly.  -ottrey
     143  */
     144 #if 0
     145 static unsigned int isname_a(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     146     return perform_regex_test(AUTONICPREFIXREGULAR, string);
     147 }
     148
     149 static unsigned int isname_b(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     150     return perform_regex_test(NAME_B, string);
     151 }
     152
     153 static unsigned int isname_ab(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     154     return (isname_a(string) || isname_b(string));
     155 }
     156 #endif
     157
     158 static unsigned int wk_is_name(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     159     /* Everything apart from addresses matches to name */
     160     if( perform_regex_test(IPADDRESS, key)
     161         || perform_regex_test(IPPREFIX, key)
     162         || perform_regex_test(VALIDIP6PREFIX, key) ) {
     163       return 0;
     164     }
     165     else {
     166       return 1;
     167     }
     168 } /* wk_is_name() */
     169
     170 /***************************************************************/
     171
     172 static unsigned int isdomname(char *string) {
         /* [<][>][^][v][top][bottom][index][help] */
     173     return (    perform_regex_test(DOMAINNAME, string)
     174              && perform_regex_test(DOMAINALPHA, string));
     175 }
     176
     177 static unsigned int wk_is_domain(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     178     return isdomname(key);
     179 } /* wk_is_domname() */
     180
     181 static unsigned int wk_is_iprange(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     182   return perform_regex_test(IPRANGE, key);
     183 } /* wk_is_iprange() */
     184
     185 static unsigned int wk_is_hostname(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     186   /* XXX Why is there a hostname & a domainname? */
     187   /* Answer - hostname can be a domainname or an IP */
     188     return (isdomname(key) || wk_is_iprange(key));
     189 } /* wk_is_hostname() */
     190
     191 /* WK_to_string() */
     192 /*++++++++++++++++++++++++++++++++++++++
     193   Convert the which keytypes bitmap into a string.
     194
     195   mask_t wk The which keytypes mask to be converted.
     196
     197   More:
     198   +html+ <PRE>
     199   Authors:
     200         ottrey
     201   +html+ </PRE><DL COMPACT>
     202   +html+ <DT>Online References:
     203   +html+ <DD><UL>
     204   +html+ </UL></DL>
     205
     206   ++++++++++++++++++++++++++++++++++++++*/
     207 char *WK_to_string(mask_t wk) {
         /* [<][>][^][v][top][bottom][index][help] */
     208
     209   return MA_to_string(wk, Keytypes);
     210
     211 } /* WK_to_string() */
     212
     213 /* WK_new() */
     214 /*++++++++++++++++++++++++++++++++++++++
     215   Create a new which keytypes bitmap.
     216
     217   char *key The key to be examined.
     218
     219   More:
     220   +html+ <PRE>
     221   Authors:
     222         ottrey
     223   +html+ </PRE><DL COMPACT>
     224   +html+ <DT>Online References:
     225   +html+ <DD><UL>
     226   +html+ </UL></DL>
     227
     228   ++++++++++++++++++++++++++++++++++++++*/
     229 mask_t WK_new(char *key) {
         /* [<][>][^][v][top][bottom][index][help] */
     230   mask_t wk;
     231
     232   wk = MA_new(MA_END);
     233
     234   MA_set(&wk, WK_NAME,         wk_is_name(key));
     235   MA_set(&wk, WK_NIC_HDL,      perform_regex_test(NICHANDLE, key));
     236   MA_set(&wk, WK_EMAIL,        perform_regex_test(EMAIL, key));
     237   MA_set(&wk, WK_MNTNER,       perform_regex_test(MAINTAINER, key));
     238   MA_set(&wk, WK_KEY_CERT,     perform_regex_test(KEYCERT, key));
     239   MA_set(&wk, WK_IPADDRESS,    perform_regex_test(IPADDRESS, key));
     240   MA_set(&wk, WK_IPRANGE,      wk_is_iprange(key));
     241   MA_set(&wk, WK_IPPREFIX,     perform_regex_test(IPPREFIX, key));
     242   MA_set(&wk, WK_IP6PREFIX,    perform_regex_test(VALIDIP6PREFIX, key));
     243   MA_set(&wk, WK_NETNAME,      perform_regex_test(NETNAME, key));
     244   MA_set(&wk, WK_NET6NAME,     perform_regex_test(NETNAME, key));
     245   MA_set(&wk, WK_AUTNUM,       perform_regex_test(ASNUM, key));
     246   MA_set(&wk, WK_ASSETNAME,    perform_regex_test(ASSETNAME, key));
     247   MA_set(&wk, WK_ROUTESETNAME, perform_regex_test(ROUTESETNAME, key));
     248   MA_set(&wk, WK_DOMAIN,       wk_is_domain(key));
     249   MA_set(&wk, WK_HOSTNAME,     wk_is_hostname(key));
     250   MA_set(&wk, WK_LIMERICK,     perform_regex_test(LIMERICK, key));
     251   MA_set(&wk, WK_ASRANGE,      perform_regex_test(ASRANGE, key));
     252   MA_set(&wk, WK_PEERINGSET,   perform_regex_test(PEERINGSET, key));
     253   MA_set(&wk, WK_FILTERSET,    perform_regex_test(FILTERSET, key));
     254   MA_set(&wk, WK_RTRSET,       perform_regex_test(RTRSET, key));
     255
     256   return wk;
     257
     258 } /* WK_new() */

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