stglibs/hostallow.lib/hostallow.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Date: 27.10.2002
  19  */
  20
  21 /*
  22  *    Author : Boris Mikhailenko <stg34@ua.fm>
  23  */
  24
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <sys/types.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <arpa/inet.h>
  32 #include <algorithm>
  33 #include <functional>
  34
  35 #include "hostallow.h"
  36 //-----------------------------------------------------------------------------
  37 HOSTALLOW::HOSTALLOW()
  38 {
  39
  40 }
  41 //-----------------------------------------------------------------------------
  42 int HOSTALLOW::ParseHosts(const char * str, int hostsType)
  43 {
  44 /*
  45 ðÒÏÉÚ×ÏÄÉÍ ÒÁÚÂÏÒ ÓÔÒÏËÉ ×ÉÄÁ host host host ...
  46 ÇÄÅ host ÍÏÖÅÔ ÉÍÅÔØ ×ÉÄ a.b.c.d ÉÌÉ a.b.c.d/e
  47 ÉÌÉ all.
  48 ÐÒÉÞÅÍ × ÓÌÕÞÁÅ ÓÅÔÉ ÍÁÓËÁ É ÁÄÒÅÓ ÄÏÌÖÎÙ ÂÙÔØ
  49 ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÉÍÉ ÄÒÕÇ ÄÒÕÇÕ.
  50
  51 òÅÚÕÌØÔÁÔÙ ÚÁÎÏÓÉÍ × ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÉÊ ÓÐÉÓÏË
  52  * */
  53
  54 int len;
  55 char *s;
  56 char * tok;
  57 uint32_t ip;
  58 uint32_t mask;
  59 //INETADDR inetAddr;
  60
  61 if (strcasecmp(str, "all") == 0)
  62     {
  63     if (hostsType == hostsAllow)
  64         hostAllowList.push_back(INETADDR());
  65     else
  66         hostDenyList.push_back(INETADDR());
  67     return 0;
  68     }
  69 else
  70     {
  71     len = strlen(str);
  72
  73     s = new char[len + 1];
  74
  75     strcpy(s, str);
  76
  77     tok = strtok(s, " ");
  78
  79     while (tok)
  80         {
  81         if (ParseIPMask(tok, &ip, &mask) != 0)
  82             {
  83             return -1;
  84             delete[] s;
  85             }
  86         //printfd(__FILE__, "ParseHosts tok %s\n", tok);
  87         tok = strtok(NULL, " ");
  88         if (hostsType == hostsAllow)
  89             {
  90             //printfd(__FILE__, "ParseHosts APPEND allow %X %X\n", ip, mask);
  91             hostAllowList.push_back(INETADDR(ip, mask));
  92             }
  93         else
  94             {
  95             //printfd(__FILE__, "ParseHosts APPEND deny  %X %X\n", ip, mask);
  96             hostDenyList.push_back(INETADDR(ip, mask));
  97             }
  98         }
  99     }
 100
 101 delete[] s;
 102 return 0;
 103 }
 104 //-----------------------------------------------------------------------------
 105 int HOSTALLOW::ParseIPMask(const char * s, uint32_t * ip, uint32_t * mask)
 106 {
 107 /*
 108 òÁÚÂÏÒ ÓÔÒÏËÉ ×ÉÄÁ a.b.c.d/e ÉÌÉ a.b.c.d
 109
 110 123.123.123.123/30
 111  * */
 112 int len;
 113 char * host;
 114
 115 int i = 0, msk;
 116
 117 len = strlen(s);
 118 host = new char[len + 1];
 119
 120 while (s[i] != 0 && s[i] != '/')
 121     {
 122     host[i] = s[i];
 123     i++;
 124     }
 125
 126 host[i] = 0;
 127
 128 if (inet_addr(host) == INADDR_NONE)
 129     {
 130     delete[] host;
 131     sprintf(errMsg, "Icorrect IP address %s", host);
 132     return -1;
 133     }
 134
 135 *ip = inet_addr(host);
 136
 137 char *res;
 138
 139 if (s[i] == '/')
 140     {
 141     msk = strtol(&s[i+1], &res, 10);
 142     if (*res != 0)
 143         {
 144         sprintf(errMsg, "Icorrect mask %s", &s[i+1]);
 145         delete[] host;
 146         return -1;
 147         }
 148
 149     if (msk < 0 || msk > 32)
 150         {
 151         sprintf(errMsg, "Icorrect mask %s", &s[i+1]);
 152         delete[] host;
 153         *mask = 0;
 154         return 0;
 155         }
 156
 157     uint32_t m = 0;
 158     m = htonl(0xFFffFFff<<(32 - msk));
 159
 160     *mask = m;
 161     }
 162 else
 163     {
 164     *mask = 0xFFffFFff;
 165     }
 166
 167 if ((*ip & *mask) != *ip)
 168     {
 169     sprintf(errMsg, "Address does'n match mask.\n");
 170     delete[] host;
 171     return -1;
 172     }
 173
 174 delete[] host;
 175 return 0;
 176 }
 177 //-----------------------------------------------------------------------------
 178 int HOSTALLOW::ParseOrder(const char * str)
 179 {
 180 /*
 181 ÐÒÏÉÚ×ÏÄÉÍ ÒÁÚÂÏÒ ÓÔÒÏËÉ ×ÉÄÁ allow deny ÉÌÉ deny allow
 182  */
 183
 184 if (strcasecmp(str, "allow,deny") == 0)
 185     {
 186     order = orderAllow;
 187     return 0;
 188     }
 189
 190 if (strcasecmp(str, "deny,allow") == 0)
 191     {
 192     order = orderDeny;
 193     return 0;
 194     }
 195
 196 sprintf(errMsg, "Parameter \'order\' must be \'allow,deny\' or \'deny,allow\'");
 197 return -1;
 198 }
 199 //-----------------------------------------------------------------------------
 200 int HOSTALLOW::GetError()
 201 {
 202 /*
 203 ÷ÏÚ×ÒÁÝÁÅÍ ËÏÄ ÏÛÉÂËÉ É ÓÂÒÁÓÙ×ÁÅÍ ÅÅ.
 204  * */
 205 return 0;
 206 }
 207 //-----------------------------------------------------------------------------
 208 bool HOSTALLOW::HostAllowed(uint32_t ip)
 209 {
 210 /*
 211 ðÒÏ×ÅÒÑÅÍ Ñ×ÌÑÅÔÓÑ ÌÉ éð ÒÁÚÒÅÛÅÎÎÙÍ ÉÌÉ ÎÅÔ
 212  * */
 213
 214 if (order == orderDeny)
 215     {
 216     if (IsHostInDeniedList(ip))
 217         {
 218         return false;
 219         }
 220
 221     if (IsHostInAllowedList(ip))
 222         {
 223         return true;
 224         }
 225     }
 226 else
 227     {
 228     if (IsHostInAllowedList(ip))
 229         {
 230         return true;
 231         }
 232
 233     if (IsHostInDeniedList(ip))
 234         {
 235         return false;
 236         }
 237     }
 238
 239 return false;
 240 }
 241 //-----------------------------------------------------------------------------
 242 int HOSTALLOW::IsIPInSubnet(uint32_t checkedIP, INETADDR &ia)
 243 {
 244 //uint32_t checkedIP;
 245 if ((ia.mask & checkedIP) == (ia.ip))
 246     return true;
 247 return false;
 248 }
 249 //-----------------------------------------------------------------------------
 250 bool HOSTALLOW::IsHostInAllowedList(uint32_t ip)
 251 {
 252 /*
 253 îÁÈÏÄÉÔÓÑ ÌÉ éð × ÓÐÉÓËÅ ÒÁÚÒÅÛÅÎÎÙÈ
 254  * */
 255 list<INETADDR>::iterator li;
 256
 257 li = hostAllowList.begin();
 258
 259 while(li != hostAllowList.end())
 260     {
 261     if (IsIPInSubnet(ip, *li))
 262         return true;
 263     }
 264
 265 return false;
 266 }
 267 //-----------------------------------------------------------------------------
 268 bool HOSTALLOW::IsHostInDeniedList(uint32_t ip)
 269 {
 270 /*
 271 îÁÈÏÄÉÔÓÑ ÌÉ éð × ÓÐÉÓËÅ ÚÁÐÒÅÝÅÎÎÙÈ
 272  * */
 273 list<INETADDR>::iterator li;
 274
 275 li = hostDenyList.begin();
 276
 277 while(li != hostDenyList.end())
 278     {
 279     if (IsIPInSubnet(ip, *li))
 280         return true;
 281     }
 282
 283 return false;
 284 }
 285 //-----------------------------------------------------------------------------
 286 const char * HOSTALLOW::GetStrError()
 287 {
 288 /*
 289 ÷ÏÚ×ÒÁÝÁÅÍ ÔÅËÓÔÏ×ÏÅ ÏÐÉÓÁÎÉÅ ÏÛÉÂËÉ.
 290  * */
 291 return errMsg;
 292 }
 293 //-----------------------------------------------------------------------------
 294