Documentation / whitespace fix.
[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 struct ast_ha {
75         /* Host access rule */
76         struct in_addr netaddr;
77         struct in_addr netmask;
78         int sense;
79         struct ast_ha *next;
80 };
81
82 /* Default IP - if not otherwise set, don't breathe garbage */
83 static struct in_addr __ourip = { 0x00000000 };
84
85 struct my_ifreq {
86         char ifrn_name[IFNAMSIZ];       /* Interface name, e.g. "eth0", "ppp0", etc.  */
87         struct sockaddr_in ifru_addr;
88 };
89
90 /* Free HA structure */
91 void ast_free_ha(struct ast_ha *ha)
92 {
93         struct ast_ha *hal;
94         while(ha) {
95                 hal = ha;
96                 ha = ha->next;
97                 free(hal);
98         }
99 }
100
101 /* Copy HA structure */
102 static void ast_copy_ha(struct ast_ha *from, struct ast_ha *to)
103 {
104         memcpy(&to->netaddr, &from->netaddr, sizeof(from->netaddr));
105         memcpy(&to->netmask, &from->netmask, sizeof(from->netmask));
106         to->sense = from->sense;
107 }
108
109 /* Create duplicate of ha structure */
110 static struct ast_ha *ast_duplicate_ha(struct ast_ha *original)
111 {
112         struct ast_ha *new_ha;
113
114         if ((new_ha = ast_malloc(sizeof(*new_ha)))) {
115                 /* Copy from original to new object */
116                 ast_copy_ha(original, new_ha);
117         }
118
119         return new_ha;
120 }
121
122 /* Create duplicate HA link list */
123 /*  Used in chan_sip2 templates */
124 struct ast_ha *ast_duplicate_ha_list(struct ast_ha *original)
125 {
126         struct ast_ha *start=original;
127         struct ast_ha *ret = NULL;
128         struct ast_ha *link,*prev=NULL;
129
130         while (start) {
131                 link = ast_duplicate_ha(start);  /* Create copy of this object */
132                 if (prev)
133                         prev->next = link;              /* Link previous to this object */
134
135                 if (!ret)
136                         ret = link;             /* Save starting point */
137
138                 start = start->next;            /* Go to next object */
139                 prev = link;                    /* Save pointer to this object */
140         }
141         return ret;                     /* Return start of list */
142 }
143
144 struct ast_ha *ast_append_ha(char *sense, char *stuff, struct ast_ha *path)
145 {
146         struct ast_ha *ha;
147         char *nm = "255.255.255.255";
148         char tmp[256];
149         struct ast_ha *prev = NULL;
150         struct ast_ha *ret;
151         int x, z;
152         unsigned int y;
153
154         ret = path;
155         while (path) {
156                 prev = path;
157                 path = path->next;
158         }
159         if ((ha = ast_malloc(sizeof(*ha)))) {
160                 ast_copy_string(tmp, stuff, sizeof(tmp));
161                 nm = strchr(tmp, '/');
162                 if (!nm) {
163                         nm = "255.255.255.255";
164                 } else {
165                         *nm = '\0';
166                         nm++;
167                 }
168                 if (!strchr(nm, '.')) {
169                         if ((sscanf(nm, "%d", &x) == 1) && (x >= 0) && (x <= 32)) {
170                                 y = 0;
171                                 for (z=0;z<x;z++) {
172                                         y >>= 1;
173                                         y |= 0x80000000;
174                                 }
175                                 ha->netmask.s_addr = htonl(y);
176                         }
177                 } else if (!inet_aton(nm, &ha->netmask)) {
178                         ast_log(LOG_WARNING, "%s is not a valid netmask\n", nm);
179                         free(ha);
180                         return path;
181                 }
182                 if (!inet_aton(tmp, &ha->netaddr)) {
183                         ast_log(LOG_WARNING, "%s is not a valid IP\n", tmp);
184                         free(ha);
185                         return path;
186                 }
187                 ha->netaddr.s_addr &= ha->netmask.s_addr;
188                 if (!strncasecmp(sense, "p", 1)) {
189                         ha->sense = AST_SENSE_ALLOW;
190                 } else {
191                         ha->sense = AST_SENSE_DENY;
192                 }
193                 ha->next = NULL;
194                 if (prev) {
195                         prev->next = ha;
196                 } else {
197                         ret = ha;
198                 }
199         }
200         ast_log(LOG_DEBUG, "%s/%s appended to acl for peer\n", stuff, nm);
201         return ret;
202 }
203
204 int ast_apply_ha(struct ast_ha *ha, struct sockaddr_in *sin)
205 {
206         /* Start optimistic */
207         int res = AST_SENSE_ALLOW;
208         while (ha) {
209                 char iabuf[INET_ADDRSTRLEN];
210                 char iabuf2[INET_ADDRSTRLEN];
211                 /* DEBUG */
212                 ast_log(LOG_DEBUG,
213                         "##### Testing %s with %s\n",
214                         ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr),
215                         ast_inet_ntoa(iabuf2, sizeof(iabuf2), ha->netaddr));
216                 /* For each rule, if this address and the netmask = the net address
217                    apply the current rule */
218                 if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == ha->netaddr.s_addr)
219                         res = ha->sense;
220                 ha = ha->next;
221         }
222         return res;
223 }
224
225 int ast_get_ip_or_srv(struct sockaddr_in *sin, const char *value, const char *service)
226 {
227         struct hostent *hp;
228         struct ast_hostent ahp;
229         char srv[256];
230         char host[256];
231         int tportno = ntohs(sin->sin_port);
232         if (inet_aton(value, &sin->sin_addr))
233                 return 0;
234         if (service) {
235                 snprintf(srv, sizeof(srv), "%s.%s", service, value);
236                 if (ast_get_srv(NULL, host, sizeof(host), &tportno, srv) > 0) {
237                         sin->sin_port = htons(tportno);
238                         value = host;
239                 }
240         }
241         hp = ast_gethostbyname(value, &ahp);
242         if (hp) {
243                 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
244         } else {
245                 ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value);
246                 return -1;
247         }
248         return 0;
249 }
250
251 struct dscp_codepoint {
252         char *name;
253         unsigned int space;
254 };
255
256 /* IANA registered DSCP codepoints */
257
258 static const struct dscp_codepoint dscp_pool1[] = {
259         { "CS0", 0x00 },
260         { "CS1", 0x08 },
261         { "CS2", 0x10 },
262         { "CS3", 0x18 },
263         { "CS4", 0x20 },
264         { "CS5", 0x28 },
265         { "CS6", 0x30 },
266         { "CS7", 0x38 },
267         { "AF11", 0x0A },
268         { "AF12", 0x0C },
269         { "AF13", 0x0E },
270         { "AF21", 0x12 },
271         { "AF22", 0x14 },
272         { "AF23", 0x16 },
273         { "AF31", 0x1A },
274         { "AF32", 0x1C },
275         { "AF33", 0x1E },
276         { "AF41", 0x22 },
277         { "AF42", 0x24 },
278         { "AF43", 0x26 },
279         { "EF", 0x2E },
280 };
281
282 int ast_str2tos(const char *value, unsigned int *tos)
283 {
284         int fval;
285         unsigned int x;
286
287         if (sscanf(value, "%i", &fval) == 1) {
288                 *tos = fval & 0xFF;
289                 return 0;
290         }
291
292         for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
293                 if (!strcasecmp(value, dscp_pool1[x].name)) {
294                         *tos = dscp_pool1[x].space << 2;
295                         return 0;
296                 }
297         }
298
299         if (!strcasecmp(value, "lowdelay"))
300                 *tos = IPTOS_LOWDELAY;
301         else if (!strcasecmp(value, "throughput"))
302                 *tos = IPTOS_THROUGHPUT;
303         else if (!strcasecmp(value, "reliability"))
304                 *tos = IPTOS_RELIABILITY;
305         else if (!strcasecmp(value, "mincost"))
306                 *tos = IPTOS_MINCOST;
307         else if (!strcasecmp(value, "none"))
308                 *tos = 0;
309         else
310                 return -1;
311
312         ast_log(LOG_WARNING, "TOS value %s is deprecated. Please see doc/ip-tos.txt for more information.\n", value);
313
314         return 0;
315 }
316
317 const char *ast_tos2str(unsigned int tos)
318 {
319         unsigned int x;
320
321         switch (tos) {
322         case 0:
323                 return "none";
324         case IPTOS_LOWDELAY:
325                 return "lowdelay";
326         case IPTOS_THROUGHPUT:
327                 return "throughput";
328         case IPTOS_RELIABILITY:
329                 return "reliability";
330         case IPTOS_MINCOST:
331                 return "mincost";
332         default:
333                 for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
334                         if (dscp_pool1[x].space == (tos >> 2))
335                                 return dscp_pool1[x].name;
336                 }
337         }
338
339         return "unknown";
340 }
341
342 int ast_get_ip(struct sockaddr_in *sin, const char *value)
343 {
344         return ast_get_ip_or_srv(sin, value, NULL);
345 }
346
347 /* iface is the interface (e.g. eth0); address is the return value */
348 int ast_lookup_iface(char *iface, struct in_addr *address)
349 {
350         int mysock, res = 0;
351         struct my_ifreq ifreq;
352
353         memset(&ifreq, 0, sizeof(ifreq));
354         ast_copy_string(ifreq.ifrn_name, iface, sizeof(ifreq.ifrn_name));
355
356         mysock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
357         res = ioctl(mysock, SIOCGIFADDR, &ifreq);
358
359         close(mysock);
360         if (res < 0) {
361                 ast_log(LOG_WARNING, "Unable to get IP of %s: %s\n", iface, strerror(errno));
362                 memcpy((char *)address, (char *)&__ourip, sizeof(__ourip));
363                 return -1;
364         } else {
365                 memcpy((char *)address, (char *)&ifreq.ifru_addr.sin_addr, sizeof(ifreq.ifru_addr.sin_addr));
366                 return 0;
367         }
368 }
369
370 int ast_ouraddrfor(struct in_addr *them, struct in_addr *us)
371 {
372         int s;
373         struct sockaddr_in sin;
374         socklen_t slen;
375
376         s = socket(PF_INET, SOCK_DGRAM, 0);
377         if (s < 0) {
378                 ast_log(LOG_WARNING, "Cannot create socket\n");
379                 return -1;
380         }
381         sin.sin_family = AF_INET;
382         sin.sin_port = 5060;
383         sin.sin_addr = *them;
384         if (connect(s, (struct sockaddr *)&sin, sizeof(sin))) {
385                 ast_log(LOG_WARNING, "Cannot connect\n");
386                 close(s);
387                 return -1;
388         }
389         slen = sizeof(sin);
390         if (getsockname(s, (struct sockaddr *)&sin, &slen)) {
391                 ast_log(LOG_WARNING, "Cannot get socket name\n");
392                 close(s);
393                 return -1;
394         }
395         close(s);
396         *us = sin.sin_addr;
397         return 0;
398 }
399
400 int ast_find_ourip(struct in_addr *ourip, struct sockaddr_in bindaddr)
401 {
402         char ourhost[MAXHOSTNAMELEN] = "";
403         struct ast_hostent ahp;
404         struct hostent *hp;
405         struct in_addr saddr;
406
407         /* just use the bind address if it is nonzero */
408         if (ntohl(bindaddr.sin_addr.s_addr)) {
409                 memcpy(ourip, &bindaddr.sin_addr, sizeof(*ourip));
410                 return 0;
411         }
412         /* try to use our hostname */
413         if (gethostname(ourhost, sizeof(ourhost) - 1)) {
414                 ast_log(LOG_WARNING, "Unable to get hostname\n");
415         } else {
416                 hp = ast_gethostbyname(ourhost, &ahp);
417                 if (hp) {
418                         memcpy(ourip, hp->h_addr, sizeof(*ourip));
419                         return 0;
420                 }
421         }
422         /* A.ROOT-SERVERS.NET. */
423         if (inet_aton("198.41.0.4", &saddr) && !ast_ouraddrfor(&saddr, ourip))
424                 return 0;
425         return -1;
426 }