]> git.meshlink.io Git - meshlink/blob - src/subnet_parse.c
Add an invitation protocol.
[meshlink] / src / subnet_parse.c
1 /*
2     subnet_parse.c -- handle subnet parsing
3     Copyright (C) 2000-2012 Guus Sliepen <guus@tinc-vpn.org>,
4                   2000-2005 Ivo Timmermans
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License along
17     with this program; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "system.h"
22
23 #include "logger.h"
24 #include "net.h"
25 #include "netutl.h"
26 #include "subnet.h"
27 #include "utils.h"
28 #include "xalloc.h"
29
30 /* Subnet mask handling */
31
32 int maskcmp(const void *va, const void *vb, int masklen) {
33         int i, m, result;
34         const char *a = va;
35         const char *b = vb;
36
37         for(m = masklen, i = 0; m >= 8; m -= 8, i++) {
38                 result = a[i] - b[i];
39                 if(result)
40                         return result;
41         }
42
43         if(m)
44                 return (a[i] & (0x100 - (1 << (8 - m)))) -
45                         (b[i] & (0x100 - (1 << (8 - m))));
46
47         return 0;
48 }
49
50 void mask(void *va, int masklen, int len) {
51         int i;
52         char *a = va;
53
54         i = masklen / 8;
55         masklen %= 8;
56
57         if(masklen)
58                 a[i++] &= (0x100 - (1 << (8 - masklen)));
59
60         for(; i < len; i++)
61                 a[i] = 0;
62 }
63
64 void maskcpy(void *va, const void *vb, int masklen, int len) {
65         int i, m;
66         char *a = va;
67         const char *b = vb;
68
69         for(m = masklen, i = 0; m >= 8; m -= 8, i++)
70                 a[i] = b[i];
71
72         if(m) {
73                 a[i] = b[i] & (0x100 - (1 << (8 - m)));
74                 i++;
75         }
76
77         for(; i < len; i++)
78                 a[i] = 0;
79 }
80
81 bool maskcheck(const void *va, int masklen, int len) {
82         int i;
83         const char *a = va;
84
85         i = masklen / 8;
86         masklen %= 8;
87
88         if(masklen && a[i++] & (0xff >> masklen))
89                 return false;
90
91         for(; i < len; i++)
92                 if(a[i] != 0)
93                         return false;
94
95         return true;
96 }
97
98 /* Subnet comparison */
99
100 static int subnet_compare_mac(const subnet_t *a, const subnet_t *b) {
101         int result;
102
103         result = memcmp(&a->net.mac.address, &b->net.mac.address, sizeof a->net.mac.address);
104
105         if(result)
106                 return result;
107
108         result = a->weight - b->weight;
109
110         if(result || !a->owner || !b->owner)
111                 return result;
112
113         return strcmp(a->owner->name, b->owner->name);
114 }
115
116 static int subnet_compare_ipv4(const subnet_t *a, const subnet_t *b) {
117         int result;
118
119         result = b->net.ipv4.prefixlength - a->net.ipv4.prefixlength;
120
121         if(result)
122                 return result;
123
124         result = memcmp(&a->net.ipv4.address, &b->net.ipv4.address, sizeof(ipv4_t));
125
126         if(result)
127                 return result;
128
129         result = a->weight - b->weight;
130
131         if(result || !a->owner || !b->owner)
132                 return result;
133
134         return strcmp(a->owner->name, b->owner->name);
135 }
136
137 static int subnet_compare_ipv6(const subnet_t *a, const subnet_t *b) {
138         int result;
139
140         result = b->net.ipv6.prefixlength - a->net.ipv6.prefixlength;
141
142         if(result)
143                 return result;
144
145         result = memcmp(&a->net.ipv6.address, &b->net.ipv6.address, sizeof(ipv6_t));
146
147         if(result)
148                 return result;
149
150         result = a->weight - b->weight;
151
152         if(result || !a->owner || !b->owner)
153                 return result;
154
155         return strcmp(a->owner->name, b->owner->name);
156 }
157
158 int subnet_compare(const subnet_t *a, const subnet_t *b) {
159         int result;
160
161         result = a->type - b->type;
162
163         if(result)
164                 return result;
165
166         switch (a->type) {
167         case SUBNET_MAC:
168                 return subnet_compare_mac(a, b);
169         case SUBNET_IPV4:
170                 return subnet_compare_ipv4(a, b);
171         case SUBNET_IPV6:
172                 return subnet_compare_ipv6(a, b);
173         default:
174                 logger(DEBUG_ALWAYS, LOG_ERR, "subnet_compare() was called with unknown subnet type %d, exitting!", a->type);
175                 exit(1);
176         }
177
178         return 0;
179 }
180
181 /* Ascii representation of subnets */
182
183 bool str2net(subnet_t *subnet, const char *subnetstr) {
184         int i, l;
185         uint16_t x[8];
186         int weight = 10;
187
188         if(sscanf(subnetstr, "%hu.%hu.%hu.%hu/%d#%d",
189                           &x[0], &x[1], &x[2], &x[3], &l, &weight) >= 5) {
190                 if(l < 0 || l > 32)
191                         return false;
192
193                 subnet->type = SUBNET_IPV4;
194                 subnet->net.ipv4.prefixlength = l;
195                 subnet->weight = weight;
196
197                 for(int i = 0; i < 4; i++) {
198                         if(x[i] > 255)
199                                 return false;
200                         subnet->net.ipv4.address.x[i] = x[i];
201                 }
202
203                 return true;
204         }
205
206         if(sscanf(subnetstr, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx/%d#%d",
207                           &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
208                           &l, &weight) >= 9) {
209                 if(l < 0 || l > 128)
210                         return false;
211
212                 subnet->type = SUBNET_IPV6;
213                 subnet->net.ipv6.prefixlength = l;
214                 subnet->weight = weight;
215
216                 for(i = 0; i < 8; i++)
217                         subnet->net.ipv6.address.x[i] = htons(x[i]);
218
219                 return true;
220         }
221
222         if(sscanf(subnetstr, "%hu.%hu.%hu.%hu#%d", &x[0], &x[1], &x[2], &x[3], &weight) >= 4) {
223                 subnet->type = SUBNET_IPV4;
224                 subnet->net.ipv4.prefixlength = 32;
225                 subnet->weight = weight;
226
227                 for(i = 0; i < 4; i++) {
228                         if(x[i] > 255)
229                                 return false;
230                         subnet->net.ipv4.address.x[i] = x[i];
231                 }
232
233                 return true;
234         }
235
236         if(sscanf(subnetstr, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx#%d",
237                           &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], &weight) >= 8) {
238                 subnet->type = SUBNET_IPV6;
239                 subnet->net.ipv6.prefixlength = 128;
240                 subnet->weight = weight;
241
242                 for(i = 0; i < 8; i++)
243                         subnet->net.ipv6.address.x[i] = htons(x[i]);
244
245                 return true;
246         }
247
248         if(sscanf(subnetstr, "%hx:%hx:%hx:%hx:%hx:%hx#%d",
249                           &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &weight) >= 6) {
250                 subnet->type = SUBNET_MAC;
251                 subnet->weight = weight;
252
253                 for(i = 0; i < 6; i++)
254                         subnet->net.mac.address.x[i] = x[i];
255
256                 return true;
257         }
258
259         // IPv6 short form
260         if(strstr(subnetstr, "::")) {
261                 const char *p;
262                 char *q;
263                 int colons = 0;
264
265                 // Count number of colons
266                 for(p = subnetstr; *p; p++)
267                         if(*p == ':')
268                                 colons++;
269
270                 if(colons > 7)
271                         return false;
272
273                 // Scan numbers before the double colon
274                 p = subnetstr;
275                 for(i = 0; i < colons; i++) {
276                         if(*p == ':')
277                                 break;
278                         x[i] = strtoul(p, &q, 0x10);
279                         if(!q || p == q || *q != ':')
280                                 return false;
281                         p = ++q;
282                 }
283
284                 p++;
285                 colons -= i;
286                 if(!i) {
287                         p++;
288                         colons--;
289                 }
290
291                 if(!*p || *p == '/' || *p == '#')
292                         colons--;
293
294                 // Fill in the blanks
295                 for(; i < 8 - colons; i++)
296                         x[i] = 0;
297
298                 // Scan the remaining numbers
299                 for(; i < 8; i++) {
300                         x[i] = strtoul(p, &q, 0x10);
301                         if(!q || p == q)
302                                 return false;
303                         if(i == 7) {
304                                 p = q;
305                                 break;
306                         }
307                         if(*q != ':')
308                                 return false;
309                         p = ++q;
310                 }
311
312                 l = 128;
313                 if(*p == '/')
314                         sscanf(p, "/%d#%d", &l, &weight);
315                 else if(*p == '#')
316                         sscanf(p, "#%d", &weight);
317
318                 if(l < 0 || l > 128)
319                         return false;
320
321                 subnet->type = SUBNET_IPV6;
322                 subnet->net.ipv6.prefixlength = l;
323                 subnet->weight = weight;
324
325                 for(i = 0; i < 8; i++)
326                         subnet->net.ipv6.address.x[i] = htons(x[i]);
327
328                 return true;
329         }
330
331         return false;
332 }
333
334 bool net2str(char *netstr, int len, const subnet_t *subnet) {
335         if(!netstr || !subnet) {
336                 logger(DEBUG_ALWAYS, LOG_ERR, "net2str() was called with netstr=%p, subnet=%p!", netstr, subnet);
337                 return false;
338         }
339
340         switch (subnet->type) {
341                 case SUBNET_MAC:
342                         snprintf(netstr, len, "%hx:%hx:%hx:%hx:%hx:%hx#%d",
343                                          subnet->net.mac.address.x[0],
344                                          subnet->net.mac.address.x[1],
345                                          subnet->net.mac.address.x[2],
346                                          subnet->net.mac.address.x[3],
347                                          subnet->net.mac.address.x[4],
348                                          subnet->net.mac.address.x[5],
349                                          subnet->weight);
350                         break;
351
352                 case SUBNET_IPV4:
353                         snprintf(netstr, len, "%hu.%hu.%hu.%hu/%d#%d",
354                                          subnet->net.ipv4.address.x[0],
355                                          subnet->net.ipv4.address.x[1],
356                                          subnet->net.ipv4.address.x[2],
357                                          subnet->net.ipv4.address.x[3],
358                                          subnet->net.ipv4.prefixlength,
359                                          subnet->weight);
360                         break;
361
362                 case SUBNET_IPV6:
363                         snprintf(netstr, len, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx/%d#%d",
364                                          ntohs(subnet->net.ipv6.address.x[0]),
365                                          ntohs(subnet->net.ipv6.address.x[1]),
366                                          ntohs(subnet->net.ipv6.address.x[2]),
367                                          ntohs(subnet->net.ipv6.address.x[3]),
368                                          ntohs(subnet->net.ipv6.address.x[4]),
369                                          ntohs(subnet->net.ipv6.address.x[5]),
370                                          ntohs(subnet->net.ipv6.address.x[6]),
371                                          ntohs(subnet->net.ipv6.address.x[7]),
372                                          subnet->net.ipv6.prefixlength,
373                                          subnet->weight);
374                         break;
375
376                 default:
377                         logger(DEBUG_ALWAYS, LOG_ERR, "net2str() was called with unknown subnet type %d, exiting!", subnet->type);
378                         exit(1);
379         }
380
381         return true;
382 }