diff options
author | kpfleming <kpfleming@f38db490-d61c-443f-a65b-d21fe96a405b> | 2006-08-21 02:11:39 +0000 |
---|---|---|
committer | kpfleming <kpfleming@f38db490-d61c-443f-a65b-d21fe96a405b> | 2006-08-21 02:11:39 +0000 |
commit | 8b0c007ad990aa27d9868da49215fd1076ac77cc (patch) | |
tree | 270b9c46c1e644483d6d2a35b509f43218ba3252 /main/acl.c | |
parent | a42edc84034f91932a3e12d503e07f76a6eb498a (diff) |
merge new_loader_completion branch, including (at least):
- restructured build tree and makefiles to eliminate recursion problems
- support for embedded modules
- support for static builds
- simpler cross-compilation support
- simpler module/loader interface (no exported symbols)
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@40722 f38db490-d61c-443f-a65b-d21fe96a405b
Diffstat (limited to 'main/acl.c')
-rw-r--r-- | main/acl.c | 425 |
1 files changed, 425 insertions, 0 deletions
diff --git a/main/acl.c b/main/acl.c new file mode 100644 index 000000000..f3fd5097a --- /dev/null +++ b/main/acl.c @@ -0,0 +1,425 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2006, Digium, Inc. + * + * Mark Spencer <markster@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Various sorts of access control + * + * \author Mark Spencer <markster@digium.com> + */ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/time.h> +#include <signal.h> +#include <errno.h> +#include <unistd.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <sys/socket.h> +#include <netdb.h> +#include <net/if.h> +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> +#include <sys/ioctl.h> + +#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) +#include <fcntl.h> +#include <net/route.h> +#endif + +#if defined(SOLARIS) +#include <sys/sockio.h> +#endif + +/* netinet/ip.h may not define the following (See RFCs 791 and 1349) */ +#if !defined(IPTOS_LOWCOST) +#define IPTOS_LOWCOST 0x02 +#endif + +#if !defined(IPTOS_MINCOST) +#define IPTOS_MINCOST IPTOS_LOWCOST +#endif + +#include "asterisk/acl.h" +#include "asterisk/logger.h" +#include "asterisk/channel.h" +#include "asterisk/options.h" +#include "asterisk/utils.h" +#include "asterisk/lock.h" +#include "asterisk/srv.h" + +struct ast_ha { + /* Host access rule */ + struct in_addr netaddr; + struct in_addr netmask; + int sense; + struct ast_ha *next; +}; + +/* Default IP - if not otherwise set, don't breathe garbage */ +static struct in_addr __ourip = { 0x00000000 }; + +struct my_ifreq { + char ifrn_name[IFNAMSIZ]; /* Interface name, e.g. "eth0", "ppp0", etc. */ + struct sockaddr_in ifru_addr; +}; + +/* Free HA structure */ +void ast_free_ha(struct ast_ha *ha) +{ + struct ast_ha *hal; + while (ha) { + hal = ha; + ha = ha->next; + free(hal); + } +} + +/* Copy HA structure */ +static void ast_copy_ha(struct ast_ha *from, struct ast_ha *to) +{ + memcpy(&to->netaddr, &from->netaddr, sizeof(from->netaddr)); + memcpy(&to->netmask, &from->netmask, sizeof(from->netmask)); + to->sense = from->sense; +} + +/* Create duplicate of ha structure */ +static struct ast_ha *ast_duplicate_ha(struct ast_ha *original) +{ + struct ast_ha *new_ha; + + if ((new_ha = ast_malloc(sizeof(*new_ha)))) { + /* Copy from original to new object */ + ast_copy_ha(original, new_ha); + } + + return new_ha; +} + +/* Create duplicate HA link list */ +/* Used in chan_sip2 templates */ +struct ast_ha *ast_duplicate_ha_list(struct ast_ha *original) +{ + struct ast_ha *start = original; + struct ast_ha *ret = NULL; + struct ast_ha *link, *prev = NULL; + + while (start) { + link = ast_duplicate_ha(start); /* Create copy of this object */ + if (prev) + prev->next = link; /* Link previous to this object */ + + if (!ret) + ret = link; /* Save starting point */ + + start = start->next; /* Go to next object */ + prev = link; /* Save pointer to this object */ + } + return ret; /* Return start of list */ +} + +struct ast_ha *ast_append_ha(char *sense, char *stuff, struct ast_ha *path) +{ + struct ast_ha *ha; + char *nm = "255.255.255.255"; + char tmp[256]; + struct ast_ha *prev = NULL; + struct ast_ha *ret; + int x, z; + unsigned int y; + + ret = path; + while (path) { + prev = path; + path = path->next; + } + if ((ha = ast_malloc(sizeof(*ha)))) { + ast_copy_string(tmp, stuff, sizeof(tmp)); + nm = strchr(tmp, '/'); + if (!nm) { + nm = "255.255.255.255"; + } else { + *nm = '\0'; + nm++; + } + if (!strchr(nm, '.')) { + if ((sscanf(nm, "%d", &x) == 1) && (x >= 0) && (x <= 32)) { + y = 0; + for (z = 0; z < x; z++) { + y >>= 1; + y |= 0x80000000; + } + ha->netmask.s_addr = htonl(y); + } + } else if (!inet_aton(nm, &ha->netmask)) { + ast_log(LOG_WARNING, "%s is not a valid netmask\n", nm); + free(ha); + return path; + } + if (!inet_aton(tmp, &ha->netaddr)) { + ast_log(LOG_WARNING, "%s is not a valid IP\n", tmp); + free(ha); + return path; + } + ha->netaddr.s_addr &= ha->netmask.s_addr; + if (!strncasecmp(sense, "p", 1)) { + ha->sense = AST_SENSE_ALLOW; + } else { + ha->sense = AST_SENSE_DENY; + } + ha->next = NULL; + if (prev) { + prev->next = ha; + } else { + ret = ha; + } + } + ast_log(LOG_DEBUG, "%s/%s appended to acl for peer\n", stuff, nm); + return ret; +} + +int ast_apply_ha(struct ast_ha *ha, struct sockaddr_in *sin) +{ + /* Start optimistic */ + int res = AST_SENSE_ALLOW; + while (ha) { + char iabuf[INET_ADDRSTRLEN]; + char iabuf2[INET_ADDRSTRLEN]; + /* DEBUG */ + ast_copy_string(iabuf, ast_inet_ntoa(sin->sin_addr), sizeof(iabuf)); + ast_copy_string(iabuf2, ast_inet_ntoa(ha->netaddr), sizeof(iabuf2)); + ast_log(LOG_DEBUG, "##### Testing %s with %s\n", iabuf, iabuf2); + /* For each rule, if this address and the netmask = the net address + apply the current rule */ + if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == ha->netaddr.s_addr) + res = ha->sense; + ha = ha->next; + } + return res; +} + +int ast_get_ip_or_srv(struct sockaddr_in *sin, const char *value, const char *service) +{ + struct hostent *hp; + struct ast_hostent ahp; + char srv[256]; + char host[256]; + int tportno = ntohs(sin->sin_port); + if (inet_aton(value, &sin->sin_addr)) + return 0; + if (service) { + snprintf(srv, sizeof(srv), "%s.%s", service, value); + if (ast_get_srv(NULL, host, sizeof(host), &tportno, srv) > 0) { + sin->sin_port = htons(tportno); + value = host; + } + } + hp = ast_gethostbyname(value, &ahp); + if (hp) { + memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr)); + } else { + ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value); + return -1; + } + return 0; +} + +struct dscp_codepoint { + char *name; + unsigned int space; +}; + +/* IANA registered DSCP codepoints */ + +static const struct dscp_codepoint dscp_pool1[] = { + { "CS0", 0x00 }, + { "CS1", 0x08 }, + { "CS2", 0x10 }, + { "CS3", 0x18 }, + { "CS4", 0x20 }, + { "CS5", 0x28 }, + { "CS6", 0x30 }, + { "CS7", 0x38 }, + { "AF11", 0x0A }, + { "AF12", 0x0C }, + { "AF13", 0x0E }, + { "AF21", 0x12 }, + { "AF22", 0x14 }, + { "AF23", 0x16 }, + { "AF31", 0x1A }, + { "AF32", 0x1C }, + { "AF33", 0x1E }, + { "AF41", 0x22 }, + { "AF42", 0x24 }, + { "AF43", 0x26 }, + { "EF", 0x2E }, +}; + +int ast_str2tos(const char *value, unsigned int *tos) +{ + int fval; + unsigned int x; + + if (sscanf(value, "%i", &fval) == 1) { + *tos = fval & 0xFF; + return 0; + } + + for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) { + if (!strcasecmp(value, dscp_pool1[x].name)) { + *tos = dscp_pool1[x].space << 2; + return 0; + } + } + + if (!strcasecmp(value, "lowdelay")) + *tos = IPTOS_LOWDELAY; + else if (!strcasecmp(value, "throughput")) + *tos = IPTOS_THROUGHPUT; + else if (!strcasecmp(value, "reliability")) + *tos = IPTOS_RELIABILITY; + else if (!strcasecmp(value, "mincost")) + *tos = IPTOS_MINCOST; + else if (!strcasecmp(value, "none")) + *tos = 0; + else + return -1; + + ast_log(LOG_WARNING, "TOS value %s is deprecated. Please see doc/ip-tos.txt for more information.\n", value); + + return 0; +} + +const char *ast_tos2str(unsigned int tos) +{ + unsigned int x; + + switch (tos) { + case 0: + return "none"; + case IPTOS_LOWDELAY: + return "lowdelay"; + case IPTOS_THROUGHPUT: + return "throughput"; + case IPTOS_RELIABILITY: + return "reliability"; + case IPTOS_MINCOST: + return "mincost"; + default: + for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) { + if (dscp_pool1[x].space == (tos >> 2)) + return dscp_pool1[x].name; + } + } + + return "unknown"; +} + +int ast_get_ip(struct sockaddr_in *sin, const char *value) +{ + return ast_get_ip_or_srv(sin, value, NULL); +} + +/* iface is the interface (e.g. eth0); address is the return value */ +int ast_lookup_iface(char *iface, struct in_addr *address) +{ + int mysock, res = 0; + struct my_ifreq ifreq; + + memset(&ifreq, 0, sizeof(ifreq)); + ast_copy_string(ifreq.ifrn_name, iface, sizeof(ifreq.ifrn_name)); + + mysock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); + res = ioctl(mysock, SIOCGIFADDR, &ifreq); + + close(mysock); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to get IP of %s: %s\n", iface, strerror(errno)); + memcpy((char *)address, (char *)&__ourip, sizeof(__ourip)); + return -1; + } else { + memcpy((char *)address, (char *)&ifreq.ifru_addr.sin_addr, sizeof(ifreq.ifru_addr.sin_addr)); + return 0; + } +} + +int ast_ouraddrfor(struct in_addr *them, struct in_addr *us) +{ + int s; + struct sockaddr_in sin; + socklen_t slen; + + s = socket(PF_INET, SOCK_DGRAM, 0); + if (s < 0) { + ast_log(LOG_WARNING, "Cannot create socket\n"); + return -1; + } + sin.sin_family = AF_INET; + sin.sin_port = 5060; + sin.sin_addr = *them; + if (connect(s, (struct sockaddr *)&sin, sizeof(sin))) { + ast_log(LOG_WARNING, "Cannot connect\n"); + close(s); + return -1; + } + slen = sizeof(sin); + if (getsockname(s, (struct sockaddr *)&sin, &slen)) { + ast_log(LOG_WARNING, "Cannot get socket name\n"); + close(s); + return -1; + } + close(s); + *us = sin.sin_addr; + return 0; +} + +int ast_find_ourip(struct in_addr *ourip, struct sockaddr_in bindaddr) +{ + char ourhost[MAXHOSTNAMELEN] = ""; + struct ast_hostent ahp; + struct hostent *hp; + struct in_addr saddr; + + /* just use the bind address if it is nonzero */ + if (ntohl(bindaddr.sin_addr.s_addr)) { + memcpy(ourip, &bindaddr.sin_addr, sizeof(*ourip)); + return 0; + } + /* try to use our hostname */ + if (gethostname(ourhost, sizeof(ourhost) - 1)) { + ast_log(LOG_WARNING, "Unable to get hostname\n"); + } else { + hp = ast_gethostbyname(ourhost, &ahp); + if (hp) { + memcpy(ourip, hp->h_addr, sizeof(*ourip)); + return 0; + } + } + /* A.ROOT-SERVERS.NET. */ + if (inet_aton("198.41.0.4", &saddr) && !ast_ouraddrfor(&saddr, ourip)) + return 0; + return -1; +} + |