1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2008 InspIRCd Development Team
* See: http://www.inspircd.org/wiki/index.php/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
/* $Core: libIRCDcidr */
#include "inspircd.h"
#include "wildcard.h"
/* Used when comparing CIDR masks for the modulus bits left over.
* A lot of ircd's seem to do this:
* ((-1) << (8 - (mask % 8)))
* But imho, it sucks in comparison to a nice neat lookup table.
*/
const unsigned char inverted_bits[8] = { 0x00, /* 00000000 - 0 bits - never actually used */
0x80, /* 10000000 - 1 bits */
0xC0, /* 11000000 - 2 bits */
0xE0, /* 11100000 - 3 bits */
0xF0, /* 11110000 - 4 bits */
0xF8, /* 11111000 - 5 bits */
0xFC, /* 11111100 - 6 bits */
0xFE /* 11111110 - 7 bits */
};
/* Match raw bytes using CIDR bit matching, used by higher level MatchCIDR() */
bool irc::sockets::MatchCIDRBits(unsigned char* address, unsigned char* mask, unsigned int mask_bits)
{
unsigned int divisor = mask_bits / 8; /* Number of whole bytes in the mask */
unsigned int modulus = mask_bits % 8; /* Remaining bits in the mask after whole bytes are dealt with */
/* First (this is faster) compare the odd bits with logic ops */
if (modulus)
if ((address[divisor] & inverted_bits[modulus]) != (mask[divisor] & inverted_bits[modulus]))
/* If they dont match, return false */
return false;
/* Secondly (this is slower) compare the whole bytes */
if (memcmp(address, mask, divisor))
return false;
/* The address matches the mask, to mask_bits bits of mask */
return true;
}
/* Match CIDR, but dont attempt to match() against leading *!*@ sections */
bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask)
{
return MatchCIDR(address, cidr_mask, false);
}
/* Match CIDR strings, e.g. 127.0.0.1 to 127.0.0.0/8 or 3ffe:1:5:6::8 to 3ffe:1::0/32
* If you have a lot of hosts to match, youre probably better off building your mask once
* and then using the lower level MatchCIDRBits directly.
*
* This will also attempt to match any leading usernames or nicknames on the mask, using
* match(), when match_with_username is true.
*/
bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool match_with_username)
{
unsigned char addr_raw[16];
unsigned char mask_raw[16];
unsigned int bits = 0;
char* mask = NULL;
/* The caller is trying to match ident@<mask>/bits.
* Chop off the ident@ portion, use match() on it
* seperately.
*/
if (match_with_username)
{
/* Duplicate the strings, and try to find the position
* of the @ symbol in each
*/
char* address_dupe = strdup(address);
char* cidr_dupe = strdup(cidr_mask);
/* Use strchr not strrchr, because its going to be nearer to the left */
char* username_mask_pos = strrchr(cidr_dupe, '@');
char* username_addr_pos = strrchr(address_dupe, '@');
/* Both strings have an @ symbol in them */
if (username_mask_pos && username_addr_pos)
{
/* Zero out the location of the @ symbol */
*username_mask_pos = *username_addr_pos = 0;
/* Try and match() the strings before the @
* symbols, and recursively call MatchCIDR without
* username matching enabled to match the host part.
*/
bool result = (match(address_dupe, cidr_dupe) && MatchCIDR(username_addr_pos + 1, username_mask_pos + 1, false));
/* Free the stuff we created */
free(address_dupe);
free(cidr_dupe);
/* Return a result */
return result;
}
else
{
/* One or both didnt have an @ in,
* just match as CIDR
*/
free(address_dupe);
free(cidr_dupe);
mask = strdup(cidr_mask);
}
}
else
{
/* Make a copy of the cidr mask string,
* we're going to change it
*/
mask = strdup(cidr_mask);
}
in_addr address_in4;
in_addr mask_in4;
/* Use strrchr for this, its nearer to the right */
char* bits_chars = strrchr(mask,'/');
if (bits_chars)
{
bits = atoi(bits_chars + 1);
*bits_chars = 0;
}
else
{
/* No 'number of bits' field! */
free(mask);
return false;
}
#ifdef SUPPORT_IP6LINKS
in6_addr address_in6;
in6_addr mask_in6;
if (inet_pton(AF_INET6, address, &address_in6) > 0)
{
if (inet_pton(AF_INET6, mask, &mask_in6) > 0)
{
memcpy(&addr_raw, &address_in6.s6_addr, 16);
memcpy(&mask_raw, &mask_in6.s6_addr, 16);
if (bits > 128)
bits = 128;
}
else
{
/* The address was valid ipv6, but the mask
* that goes with it wasnt.
*/
free(mask);
return false;
}
}
else
#endif
if (inet_pton(AF_INET, address, &address_in4) > 0)
{
if (inet_pton(AF_INET, mask, &mask_in4) > 0)
{
memcpy(&addr_raw, &address_in4.s_addr, 4);
memcpy(&mask_raw, &mask_in4.s_addr, 4);
if (bits > 32)
bits = 32;
}
else
{
/* The address was valid ipv4,
* but the mask that went with it wasnt.
*/
free(mask);
return false;
}
}
else
{
/* The address was neither ipv4 or ipv6 */
free(mask);
return false;
}
/* Low-level-match the bits in the raw data */
free(mask);
return MatchCIDRBits(addr_raw, mask_raw, bits);
}
|
