more memory allocation wrapper conversion (issue #6365)
[asterisk/asterisk.git] / acl.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, 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 int ast_str2tos(const char *value, int *tos)
256 {
257         int fval;
258         if (sscanf(value, "%i", &fval) == 1)
259                 *tos = fval & 0xff;
260         else if (!strcasecmp(value, "lowdelay"))
261                 *tos = IPTOS_LOWDELAY;
262         else if (!strcasecmp(value, "throughput"))
263                 *tos = IPTOS_THROUGHPUT;
264         else if (!strcasecmp(value, "reliability"))
265                 *tos = IPTOS_RELIABILITY;
266         else if (!strcasecmp(value, "mincost"))
267                 *tos = IPTOS_MINCOST;
268         else if (!strcasecmp(value, "none"))
269                 *tos = 0;
270         else
271                 return -1;
272         return 0;
273 }
274
275 int ast_get_ip(struct sockaddr_in *sin, const char *value)
276 {
277         return ast_get_ip_or_srv(sin, value, NULL);
278 }
279
280 /* iface is the interface (e.g. eth0); address is the return value */
281 int ast_lookup_iface(char *iface, struct in_addr *address) 
282 {
283         int mysock, res = 0;
284         struct my_ifreq ifreq;
285
286         memset(&ifreq, 0, sizeof(ifreq));
287         ast_copy_string(ifreq.ifrn_name, iface, sizeof(ifreq.ifrn_name));
288
289         mysock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
290         res = ioctl(mysock, SIOCGIFADDR, &ifreq);
291
292         close(mysock);
293         if (res < 0) {
294                 ast_log(LOG_WARNING, "Unable to get IP of %s: %s\n", iface, strerror(errno));
295                 memcpy((char *)address, (char *)&__ourip, sizeof(__ourip));
296                 return -1;
297         } else {
298                 memcpy((char *)address, (char *)&ifreq.ifru_addr.sin_addr, sizeof(ifreq.ifru_addr.sin_addr));
299                 return 0;
300         }
301 }
302
303 int ast_ouraddrfor(struct in_addr *them, struct in_addr *us)
304 {
305         int s;
306         struct sockaddr_in sin;
307         socklen_t slen;
308
309         s = socket(PF_INET, SOCK_DGRAM, 0);
310         if (s < 0) {
311                 ast_log(LOG_WARNING, "Cannot create socket\n");
312                 return -1;
313         }
314         sin.sin_family = AF_INET;
315         sin.sin_port = 5060;
316         sin.sin_addr = *them;
317         if (connect(s, (struct sockaddr *)&sin, sizeof(sin))) {
318                 ast_log(LOG_WARNING, "Cannot connect\n");
319                 close(s);
320                 return -1;
321         }
322         slen = sizeof(sin);
323         if (getsockname(s, (struct sockaddr *)&sin, &slen)) {
324                 ast_log(LOG_WARNING, "Cannot get socket name\n");
325                 close(s);
326                 return -1;
327         }
328         close(s);
329         *us = sin.sin_addr;
330         return 0;
331 }
332
333 int ast_find_ourip(struct in_addr *ourip, struct sockaddr_in bindaddr)
334 {
335         char ourhost[MAXHOSTNAMELEN] = "";
336         struct ast_hostent ahp;
337         struct hostent *hp;
338         struct in_addr saddr;
339
340         /* just use the bind address if it is nonzero */
341         if (ntohl(bindaddr.sin_addr.s_addr)) {
342                 memcpy(ourip, &bindaddr.sin_addr, sizeof(*ourip));
343                 return 0;
344         }
345         /* try to use our hostname */
346         if (gethostname(ourhost, sizeof(ourhost) - 1)) {
347                 ast_log(LOG_WARNING, "Unable to get hostname\n");
348         } else {
349                 hp = ast_gethostbyname(ourhost, &ahp);
350                 if (hp) {
351                         memcpy(ourip, hp->h_addr, sizeof(*ourip));
352                         return 0;
353                 }
354         }
355         /* A.ROOT-SERVERS.NET. */
356         if (inet_aton("198.41.0.4", &saddr) && !ast_ouraddrfor(&saddr, ourip))
357                 return 0;
358         return -1;
359 }
360