Fix build of asterisk again (ahem, committers!)
[asterisk/asterisk.git] / acl.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Various sorts of access control
22  *
23  * \author Mark Spencer <markster@digium.com>
24  */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/time.h>
30 #include <signal.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
35 #include <sys/socket.h>
36 #include <netdb.h>
37 #include <net/if.h>
38 #include <netinet/in.h>
39 #include <netinet/in_systm.h>
40 #include <netinet/ip.h>
41 #include <sys/ioctl.h>
42
43 #if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)
44 #include <fcntl.h>
45 #include <net/route.h>
46 #endif
47
48 #if defined(SOLARIS)
49 #include <sys/sockio.h>
50 #endif
51
52 /* netinet/ip.h may not define the following (See RFCs 791 and 1349) */
53 #if !defined(IPTOS_LOWCOST)
54 #define       IPTOS_LOWCOST           0x02
55 #endif
56
57 #if !defined(IPTOS_MINCOST)
58 #define       IPTOS_MINCOST           IPTOS_LOWCOST
59 #endif
60
61 #include "asterisk.h"
62
63 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
64
65 #include "asterisk/acl.h"
66 #include "asterisk/logger.h"
67 #include "asterisk/channel.h"
68 #include "asterisk/options.h"
69 #include "asterisk/utils.h"
70 #include "asterisk/lock.h"
71 #include "asterisk/srv.h"
72 #include "asterisk/compat.h"
73
74 #if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)
75 AST_MUTEX_DEFINE_STATIC(routeseq_lock);
76 #endif
77
78 struct ast_ha {
79         /* Host access rule */
80         struct in_addr netaddr;
81         struct in_addr netmask;
82         int sense;
83         struct ast_ha *next;
84 };
85
86 /* Default IP - if not otherwise set, don't breathe garbage */
87 static struct in_addr __ourip = { 0x00000000 };
88
89 struct my_ifreq {
90         char ifrn_name[IFNAMSIZ];       /* Interface name, e.g. "eth0", "ppp0", etc.  */
91         struct sockaddr_in ifru_addr;
92 };
93
94 /* Free HA structure */
95 void ast_free_ha(struct ast_ha *ha)
96 {
97         struct ast_ha *hal;
98         while(ha) {
99                 hal = ha;
100                 ha = ha->next;
101                 free(hal);
102         }
103 }
104
105 /* Copy HA structure */
106 static void ast_copy_ha(struct ast_ha *from, struct ast_ha *to)
107 {
108         memcpy(&to->netaddr, &from->netaddr, sizeof(from->netaddr));
109         memcpy(&to->netmask, &from->netmask, sizeof(from->netmask));
110         to->sense = from->sense;
111 }
112
113 /* Create duplicate of ha structure */
114 static struct ast_ha *ast_duplicate_ha(struct ast_ha *original)
115 {
116         struct ast_ha *new_ha;
117
118         if ((new_ha = ast_malloc(sizeof(*new_ha)))) {
119                 /* Copy from original to new object */
120                 ast_copy_ha(original, new_ha);
121         }
122
123         return new_ha;
124 }
125
126 /* Create duplicate HA link list */
127 /*  Used in chan_sip2 templates */
128 struct ast_ha *ast_duplicate_ha_list(struct ast_ha *original)
129 {
130         struct ast_ha *start=original;
131         struct ast_ha *ret = NULL;
132         struct ast_ha *link,*prev=NULL;
133
134         while (start) {
135                 link = ast_duplicate_ha(start);  /* Create copy of this object */
136                 if (prev)
137                         prev->next = link;              /* Link previous to this object */
138
139                 if (!ret)
140                         ret = link;             /* Save starting point */
141
142                 start = start->next;            /* Go to next object */
143                 prev = link;                    /* Save pointer to this object */
144         }
145         return ret;                     /* Return start of list */
146 }
147
148 struct ast_ha *ast_append_ha(char *sense, char *stuff, struct ast_ha *path)
149 {
150         struct ast_ha *ha;
151         char *nm = "255.255.255.255";
152         char tmp[256];
153         struct ast_ha *prev = NULL;
154         struct ast_ha *ret;
155         int x, z;
156         unsigned int y;
157
158         ret = path;
159         while (path) {
160                 prev = path;
161                 path = path->next;
162         }
163         if ((ha = ast_malloc(sizeof(*ha)))) {
164                 ast_copy_string(tmp, stuff, sizeof(tmp));
165                 nm = strchr(tmp, '/');
166                 if (!nm) {
167                         nm = "255.255.255.255";
168                 } else {
169                         *nm = '\0';
170                         nm++;
171                 }
172                 if (!strchr(nm, '.')) {
173                         if ((sscanf(nm, "%d", &x) == 1) && (x >= 0) && (x <= 32)) {
174                                 y = 0;
175                                 for (z=0;z<x;z++) {
176                                         y >>= 1;
177                                         y |= 0x80000000;
178                                 }
179                                 ha->netmask.s_addr = htonl(y);
180                         }
181                 } else if (!inet_aton(nm, &ha->netmask)) {
182                         ast_log(LOG_WARNING, "%s is not a valid netmask\n", nm);
183                         free(ha);
184                         return path;
185                 }
186                 if (!inet_aton(tmp, &ha->netaddr)) {
187                         ast_log(LOG_WARNING, "%s is not a valid IP\n", tmp);
188                         free(ha);
189                         return path;
190                 }
191                 ha->netaddr.s_addr &= ha->netmask.s_addr;
192                 if (!strncasecmp(sense, "p", 1)) {
193                         ha->sense = AST_SENSE_ALLOW;
194                 } else {
195                         ha->sense = AST_SENSE_DENY;
196                 }
197                 ha->next = NULL;
198                 if (prev) {
199                         prev->next = ha;
200                 } else {
201                         ret = ha;
202                 }
203         }
204         ast_log(LOG_DEBUG, "%s/%s appended to acl for peer\n", stuff, nm);
205         return ret;
206 }
207
208 int ast_apply_ha(struct ast_ha *ha, struct sockaddr_in *sin)
209 {
210         /* Start optimistic */
211         int res = AST_SENSE_ALLOW;
212         while (ha) {
213                 char iabuf[INET_ADDRSTRLEN];
214                 char iabuf2[INET_ADDRSTRLEN];
215                 /* DEBUG */
216                 ast_log(LOG_DEBUG,
217                         "##### Testing %s with %s\n",
218                         ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr),
219                         ast_inet_ntoa(iabuf2, sizeof(iabuf2), ha->netaddr));
220                 /* For each rule, if this address and the netmask = the net address
221                    apply the current rule */
222                 if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == ha->netaddr.s_addr)
223                         res = ha->sense;
224                 ha = ha->next;
225         }
226         return res;
227 }
228
229 int ast_get_ip_or_srv(struct sockaddr_in *sin, const char *value, const char *service)
230 {
231         struct hostent *hp;
232         struct ast_hostent ahp;
233         char srv[256];
234         char host[256];
235         int tportno = ntohs(sin->sin_port);
236         if (inet_aton(value, &sin->sin_addr))
237                 return 0;
238         if (service) {
239                 snprintf(srv, sizeof(srv), "%s.%s", service, value);
240                 if (ast_get_srv(NULL, host, sizeof(host), &tportno, srv) > 0) {
241                         sin->sin_port = htons(tportno);
242                         value = host;
243                 }
244         }
245         hp = ast_gethostbyname(value, &ahp);
246         if (hp) {
247                 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
248         } else {
249                 ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value);
250                 return -1;
251         }
252         return 0;
253 }
254
255 struct dscp_codepoint {
256         char *name;
257         unsigned int space;
258 };
259
260 /* IANA registered DSCP codepoints */
261
262 static const struct dscp_codepoint dscp_pool1[] = {
263         { "CS0", 0x00 },
264         { "CS1", 0x08 },
265         { "CS2", 0x10 },
266         { "CS3", 0x18 },
267         { "CS4", 0x20 },
268         { "CS5", 0x28 },
269         { "CS6", 0x30 },
270         { "CS7", 0x38 },
271         { "AF11", 0x0A },
272         { "AF12", 0x0C },
273         { "AF13", 0x0E },
274         { "AF21", 0x12 },
275         { "AF22", 0x14 },
276         { "AF23", 0x16 },
277         { "AF31", 0x1A },
278         { "AF32", 0x1C },
279         { "AF33", 0x1E },
280         { "AF41", 0x22 },
281         { "AF42", 0x24 },
282         { "AF43", 0x26 },
283         { "EF", 0x2E },
284 };
285
286 int ast_str2tos(const char *value, unsigned int *tos)
287 {
288         int fval;
289         unsigned int x;
290
291         if (sscanf(value, "%i", &fval) == 1) {
292                 *tos = fval & 0xFF;
293                 return 0;
294         }
295
296         for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
297                 if (!strcasecmp(value, dscp_pool1[x].name)) {
298                         *tos = dscp_pool1[x].space << 2;
299                         return 0;
300                 }
301         }
302
303         if (!strcasecmp(value, "lowdelay"))
304                 *tos = IPTOS_LOWDELAY;
305         else if (!strcasecmp(value, "throughput"))
306                 *tos = IPTOS_THROUGHPUT;
307         else if (!strcasecmp(value, "reliability"))
308                 *tos = IPTOS_RELIABILITY;
309         else if (!strcasecmp(value, "mincost"))
310                 *tos = IPTOS_MINCOST;
311         else if (!strcasecmp(value, "none"))
312                 *tos = 0;
313         else
314                 return -1;
315
316         ast_log(LOG_WARNING, "TOS value %s is deprecated. Please see doc/ip-tos.txt for more information.\n", value);
317
318         return 0;
319 }
320
321 const char *ast_tos2str(unsigned int tos)
322 {
323         unsigned int x;
324
325         switch (tos) {
326         case 0:
327                 return "none";
328         case IPTOS_LOWDELAY:
329                 return "lowdelay";
330         case IPTOS_THROUGHPUT:
331                 return "throughput";
332         case IPTOS_RELIABILITY:
333                 return "reliability";
334         case IPTOS_MINCOST:
335                 return "mincost";
336         default:
337                 for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
338                         if (dscp_pool1[x].space == (tos >> 2))
339                                 return dscp_pool1[x].name;
340                 }
341         }
342
343         return "unknown";
344 }
345
346 int ast_get_ip(struct sockaddr_in *sin, const char *value)
347 {
348         return ast_get_ip_or_srv(sin, value, NULL);
349 }
350
351 /* iface is the interface (e.g. eth0); address is the return value */
352 int ast_lookup_iface(char *iface, struct in_addr *address)
353 {
354         int mysock, res = 0;
355         struct my_ifreq ifreq;
356
357         memset(&ifreq, 0, sizeof(ifreq));
358         ast_copy_string(ifreq.ifrn_name, iface, sizeof(ifreq.ifrn_name));
359
360         mysock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
361         res = ioctl(mysock, SIOCGIFADDR, &ifreq);
362
363         close(mysock);
364         if (res < 0) {
365                 ast_log(LOG_WARNING, "Unable to get IP of %s: %s\n", iface, strerror(errno));
366                 memcpy((char *)address, (char *)&__ourip, sizeof(__ourip));
367                 return -1;
368         } else {
369                 memcpy((char *)address, (char *)&ifreq.ifru_addr.sin_addr, sizeof(ifreq.ifru_addr.sin_addr));
370                 return 0;
371         }
372 }
373
374 int ast_ouraddrfor(struct in_addr *them, struct in_addr *us)
375 {
376         int s;
377         struct sockaddr_in sin;
378         socklen_t slen;
379
380         s = socket(PF_INET, SOCK_DGRAM, 0);
381         if (s < 0) {
382                 ast_log(LOG_WARNING, "Cannot create socket\n");
383                 return -1;
384         }
385         sin.sin_family = AF_INET;
386         sin.sin_port = 5060;
387         sin.sin_addr = *them;
388         if (connect(s, (struct sockaddr *)&sin, sizeof(sin))) {
389                 ast_log(LOG_WARNING, "Cannot connect\n");
390                 close(s);
391                 return -1;
392         }
393         slen = sizeof(sin);
394         if (getsockname(s, (struct sockaddr *)&sin, &slen)) {
395                 ast_log(LOG_WARNING, "Cannot get socket name\n");
396                 close(s);
397                 return -1;
398         }
399         close(s);
400         *us = sin.sin_addr;
401         return 0;
402 }
403
404 int ast_find_ourip(struct in_addr *ourip, struct sockaddr_in bindaddr)
405 {
406         char ourhost[MAXHOSTNAMELEN] = "";
407         struct ast_hostent ahp;
408         struct hostent *hp;
409         struct in_addr saddr;
410
411         /* just use the bind address if it is nonzero */
412         if (ntohl(bindaddr.sin_addr.s_addr)) {
413                 memcpy(ourip, &bindaddr.sin_addr, sizeof(*ourip));
414                 return 0;
415         }
416         /* try to use our hostname */
417         if (gethostname(ourhost, sizeof(ourhost) - 1)) {
418                 ast_log(LOG_WARNING, "Unable to get hostname\n");
419         } else {
420                 hp = ast_gethostbyname(ourhost, &ahp);
421                 if (hp) {
422                         memcpy(ourip, hp->h_addr, sizeof(*ourip));
423                         return 0;
424                 }
425         }
426         /* A.ROOT-SERVERS.NET. */
427         if (inet_aton("198.41.0.4", &saddr) && !ast_ouraddrfor(&saddr, ourip))
428                 return 0;
429         return -1;
430 }