]> git.stg.codes - stg.git/blob - stglibs/hostallow.lib/hostallow.cpp
Initialise 'user' field in RS_USER's constructor
[stg.git] / 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