Index: uspace/app/inetcfg/inetcfg.c =================================================================== --- uspace/app/inetcfg/inetcfg.c (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/app/inetcfg/inetcfg.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -51,4 +51,6 @@ printf("\t" NAME " create / \n"); printf("\t" NAME " delete \n"); + printf("\t" NAME " add-sr / \n"); + printf("\t" NAME " del-sr \n"); } @@ -82,8 +84,35 @@ } - if (bits < 1 || bits > 31) + if (bits > 31) return EINVAL; naddr->bits = bits; + return EOK; +} + +static int addr_parse(const char *text, inet_addr_t *addr) +{ + unsigned long a[4]; + char *cp = (char *)text; + int i; + + for (i = 0; i < 3; i++) { + a[i] = strtoul(cp, &cp, 10); + if (*cp != '.') + return EINVAL; + ++cp; + } + + a[3] = strtoul(cp, &cp, 10); + if (*cp != '\0') + return EINVAL; + + addr->ipv4 = 0; + for (i = 0; i < 4; i++) { + if (a[i] > 255) + return EINVAL; + addr->ipv4 = (addr->ipv4 << 8) | a[i]; + } + return EOK; } @@ -103,4 +132,18 @@ } +static int addr_format(inet_addr_t *addr, char **bufp) +{ + int rc; + + rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24, + (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff, + addr->ipv4 & 0xff); + + if (rc < 0) + return ENOMEM; + + return EOK; +} + static int addr_create_static(int argc, char *argv[]) { @@ -138,5 +181,6 @@ rc = naddr_parse(addr_spec, &naddr); if (rc != EOK) { - printf(NAME ": Invalid address format '%s'.\n", addr_spec); + printf(NAME ": Invalid network address format '%s'.\n", + addr_spec); return EINVAL; } @@ -197,4 +241,91 @@ } +static int sroute_create(int argc, char *argv[]) +{ + char *dest_str; + char *router_str; + char *route_name; + + inet_naddr_t dest; + inet_addr_t router; + sysarg_t sroute_id; + int rc; + + if (argc < 3) { + printf(NAME ": Missing arguments.\n"); + print_syntax(); + return EINVAL; + } + + if (argc > 3) { + printf(NAME ": Too many arguments.\n"); + print_syntax(); + return EINVAL; + } + + dest_str = argv[0]; + router_str = argv[1]; + route_name = argv[2]; + + rc = naddr_parse(dest_str, &dest); + if (rc != EOK) { + printf(NAME ": Invalid network address format '%s'.\n", + dest_str); + return EINVAL; + } + + rc = addr_parse(router_str, &router); + if (rc != EOK) { + printf(NAME ": Invalid address format '%s'.\n", router_str); + return EINVAL; + } + + rc = inetcfg_sroute_create(route_name, &dest, &router, &sroute_id); + if (rc != EOK) { + printf(NAME ": Failed creating static route '%s' (%d)\n", + route_name, rc); + return EIO; + } + + return EOK; +} + +static int sroute_delete(int argc, char *argv[]) +{ + char *route_name; + sysarg_t sroute_id; + int rc; + + if (argc < 1) { + printf(NAME ": Missing arguments.\n"); + print_syntax(); + return EINVAL; + } + + if (argc > 1) { + printf(NAME ": Too many arguments.\n"); + print_syntax(); + return EINVAL; + } + + route_name = argv[0]; + + rc = inetcfg_sroute_get_id(route_name, &sroute_id); + if (rc != EOK) { + printf(NAME ": Static route '%s' not found (%d).\n", + route_name, rc); + return ENOENT; + } + + rc = inetcfg_sroute_delete(sroute_id); + if (rc != EOK) { + printf(NAME ": Failed deleting static route '%s' (%d)\n", + route_name, rc); + return EIO; + } + + return EOK; +} + static int addr_list(void) { @@ -213,4 +344,8 @@ return rc; } + + printf("Configured addresses:\n"); + + ainfo.name = linfo.name = astr = NULL; for (i = 0; i < count; i++) { @@ -219,4 +354,5 @@ printf("Failed getting properties of address %zu.\n", (size_t)addr_list[i]); + ainfo.name = NULL; continue; } @@ -226,4 +362,5 @@ printf("Failed getting properties of link %zu.\n", (size_t)ainfo.ilink); + linfo.name = NULL; continue; } @@ -232,16 +369,97 @@ if (rc != EOK) { printf("Memory allocation failed.\n"); + astr = NULL; goto out; } - printf("%s %s %s\n", astr, linfo.name, + printf(" %s %s %s\n", astr, linfo.name, ainfo.name); - free(astr); free(ainfo.name); free(linfo.name); - } + free(astr); + + ainfo.name = linfo.name = astr = NULL; + } + + if (count == 0) + printf(" None\n"); out: + if (ainfo.name != NULL) + free(ainfo.name); + if (linfo.name != NULL) + free(linfo.name); + if (astr != NULL) + free(astr); + free(addr_list); + + return EOK; +} + +static int sroute_list(void) +{ + sysarg_t *sroute_list; + inet_sroute_info_t srinfo; + + size_t count; + size_t i; + int rc; + char *dest_str; + char *router_str; + + rc = inetcfg_get_sroute_list(&sroute_list, &count); + if (rc != EOK) { + printf(NAME ": Failed getting address list.\n"); + return rc; + } + + printf("Static routes:\n"); + + srinfo.name = dest_str = router_str = NULL; + + for (i = 0; i < count; i++) { + rc = inetcfg_sroute_get(sroute_list[i], &srinfo); + if (rc != EOK) { + printf("Failed getting properties of static route %zu.\n", + (size_t)sroute_list[i]); + srinfo.name = NULL; + continue; + } + + rc = naddr_format(&srinfo.dest, &dest_str); + if (rc != EOK) { + printf("Memory allocation failed.\n"); + dest_str = NULL; + goto out; + } + + rc = addr_format(&srinfo.router, &router_str); + if (rc != EOK) { + printf("Memory allocation failed.\n"); + router_str = NULL; + goto out; + } + + printf(" %s %s %s\n", dest_str, router_str, srinfo.name); + + free(srinfo.name); + free(dest_str); + free(router_str); + + router_str = srinfo.name = dest_str = NULL; + } + + if (count == 0) + printf(" None\n"); +out: + if (srinfo.name != NULL) + free(srinfo.name); + if (dest_str != NULL) + free(dest_str); + if (router_str != NULL) + free(router_str); + + free(sroute_list); return EOK; @@ -261,4 +479,7 @@ if (argc < 2) { rc = addr_list(); + if (rc != EOK) + return 1; + rc = sroute_list(); if (rc != EOK) return 1; @@ -274,4 +495,12 @@ if (rc != EOK) return 1; + } else if (str_cmp(argv[1], "add-sr") == 0) { + rc = sroute_create(argc - 2, argv + 2); + if (rc != EOK) + return 1; + } else if (str_cmp(argv[1], "del-sr") == 0) { + rc = sroute_delete(argc - 2, argv + 2); + if (rc != EOK) + return 1; } else { printf(NAME ": Unknown command '%s'.\n", argv[1]); Index: uspace/lib/c/generic/inetcfg.c =================================================================== --- uspace/lib/c/generic/inetcfg.c (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/lib/c/generic/inetcfg.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -238,4 +238,10 @@ } +int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count) +{ + return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST, + 0, sroutes, count); +} + int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo) { @@ -274,4 +280,97 @@ } +int inetcfg_sroute_create(const char *name, inet_naddr_t *dest, + inet_addr_t *router, sysarg_t *sroute_id) +{ + async_exch_t *exch = async_exchange_begin(inetcfg_sess); + + ipc_call_t answer; + aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE, + dest->ipv4, dest->bits, router->ipv4, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + async_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + *sroute_id = IPC_GET_ARG1(answer); + + return retval; +} + +int inetcfg_sroute_delete(sysarg_t sroute_id) +{ + async_exch_t *exch = async_exchange_begin(inetcfg_sess); + + int rc = async_req_1_0(exch, INETCFG_SROUTE_DELETE, sroute_id); + async_exchange_end(exch); + + return rc; +} + +int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo) +{ + ipc_call_t dreply; + sysarg_t dretval; + size_t act_size; + char name_buf[LOC_NAME_MAXLEN + 1]; + + async_exch_t *exch = async_exchange_begin(inetcfg_sess); + + ipc_call_t answer; + aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer); + aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply); + async_wait_for(dreq, &dretval); + + async_exchange_end(exch); + + if (dretval != EOK) { + async_wait_for(req, NULL); + return dretval; + } + + sysarg_t retval; + async_wait_for(req, &retval); + + if (retval != EOK) + return retval; + + act_size = IPC_GET_ARG2(dreply); + assert(act_size <= LOC_NAME_MAXLEN); + name_buf[act_size] = '\0'; + + srinfo->dest.ipv4 = IPC_GET_ARG1(answer); + srinfo->dest.bits = IPC_GET_ARG2(answer); + srinfo->router.ipv4 = IPC_GET_ARG3(answer); + srinfo->name = str_dup(name_buf); + + return EOK; +} + +int inetcfg_sroute_get_id(const char *name, sysarg_t *sroute_id) +{ + async_exch_t *exch = async_exchange_begin(inetcfg_sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, INETCFG_SROUTE_GET_ID, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + async_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + *sroute_id = IPC_GET_ARG1(answer); + + return retval; +} + /** @} */ Index: uspace/lib/c/include/inet/inetcfg.h =================================================================== --- uspace/lib/c/include/inet/inetcfg.h (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/lib/c/include/inet/inetcfg.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -63,4 +63,14 @@ } inet_link_info_t; +/** Static route info */ +typedef struct { + /** Destination network address */ + inet_naddr_t dest; + /** Router address */ + inet_addr_t router; + /** Static route name */ + char *name; +} inet_sroute_info_t; + extern int inetcfg_init(void); extern int inetcfg_addr_create_static(const char *, inet_naddr_t *, sysarg_t, sysarg_t *); @@ -70,5 +80,11 @@ extern int inetcfg_get_addr_list(sysarg_t **, size_t *); extern int inetcfg_get_link_list(sysarg_t **, size_t *); +extern int inetcfg_get_sroute_list(sysarg_t **, size_t *); extern int inetcfg_link_get(sysarg_t, inet_link_info_t *); +extern int inetcfg_sroute_get(sysarg_t, inet_sroute_info_t *); +extern int inetcfg_sroute_get_id(const char *, sysarg_t *); +extern int inetcfg_sroute_create(const char *, inet_naddr_t *, inet_addr_t *, + sysarg_t *); +extern int inetcfg_sroute_delete(sysarg_t); #endif Index: uspace/lib/c/include/ipc/inet.h =================================================================== --- uspace/lib/c/include/ipc/inet.h (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/lib/c/include/ipc/inet.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -69,5 +69,10 @@ INETCFG_GET_ADDR_LIST, INETCFG_GET_LINK_LIST, + INETCFG_GET_SROUTE_LIST, INETCFG_LINK_GET, + INETCFG_SROUTE_CREATE, + INETCFG_SROUTE_DELETE, + INETCFG_SROUTE_GET, + INETCFG_SROUTE_GET_ID } inetcfg_request_t; Index: uspace/srv/inet/Makefile =================================================================== --- uspace/srv/inet/Makefile (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/Makefile (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -35,7 +35,9 @@ inet.c \ inet_link.c \ + inet_util.c \ inetcfg.c \ inetping.c \ - pdu.c + pdu.c \ + sroute.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/inet/addrobj.c =================================================================== --- uspace/srv/inet/addrobj.c (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/addrobj.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -46,16 +46,9 @@ #include "inet.h" #include "inet_link.h" +#include "inet_util.h" static FIBRIL_MUTEX_INITIALIZE(addr_list_lock); static LIST_INITIALIZE(addr_list); static sysarg_t addr_id = 0; - -static uint32_t inet_netmask(int bits) -{ - assert(bits >= 1); - assert(bits < 32); - - return BIT_RANGE(uint32_t, 31, 31 - (bits - 1)); -} inet_addrobj_t *inet_addrobj_new(void) @@ -162,5 +155,5 @@ } -/** Find address object matching address @a addr. +/** Find address object with the given ID. * * @param id Address object ID @@ -188,7 +181,7 @@ } -/** Send datagram to directly reachable destination */ -int inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_dgram_t *dgram, - uint8_t proto, uint8_t ttl, int df) +/** Send datagram from address object */ +int inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_addr_t *ldest, + inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df) { inet_addr_t lsrc_addr; Index: uspace/srv/inet/addrobj.h =================================================================== --- uspace/srv/inet/addrobj.h (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/addrobj.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -55,6 +55,6 @@ extern inet_addrobj_t *inet_addrobj_find_by_name(const char *, inet_link_t *); extern inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t); -extern int inet_addrobj_send_dgram(inet_addrobj_t *, inet_dgram_t *, - uint8_t, uint8_t, int); +extern int inet_addrobj_send_dgram(inet_addrobj_t *, inet_addr_t *, + inet_dgram_t *, uint8_t, uint8_t, int); extern int inet_addrobj_get_id_list(sysarg_t **, size_t *); Index: uspace/srv/inet/inet.c =================================================================== --- uspace/srv/inet/inet.c (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/inet.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -54,4 +54,5 @@ #include "inetping.h" #include "inet_link.h" +#include "sroute.h" #define NAME "inet" @@ -120,18 +121,46 @@ } +static int inet_find_dir(inet_addr_t *src, inet_addr_t *dest, uint8_t tos, + inet_dir_t *dir) +{ + inet_sroute_t *sr; + + /* XXX Handle case where source address is specified */ + (void) src; + + dir->aobj = inet_addrobj_find(dest, iaf_net); + if (dir->aobj != NULL) { + dir->ldest = *dest; + dir->dtype = dt_direct; + } else { + /* No direct path, try using a static route */ + sr = inet_sroute_find(dest); + if (sr != NULL) { + dir->aobj = inet_addrobj_find(&sr->router, iaf_net); + dir->ldest = sr->router; + dir->dtype = dt_router; + } + } + + if (dir->aobj == NULL) { + log_msg(LVL_DEBUG, "inet_send: No route to destination."); + return ENOENT; + } + + return EOK; +} + int inet_route_packet(inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df) { - inet_addrobj_t *addr; - - addr = inet_addrobj_find(&dgram->dest, iaf_net); - if (addr != NULL) { - /* Destination is directly accessible */ - return inet_addrobj_send_dgram(addr, dgram, proto, ttl, df); - } - - /* TODO: Gateways */ - log_msg(LVL_DEBUG, "inet_send: No route to destination."); - return ENOENT; + inet_dir_t dir; + int rc; + + rc = inet_find_dir(&dgram->src, &dgram->dest, dgram->tos, &dir); + if (rc != EOK) + return rc; + + return inet_addrobj_send_dgram(dir.aobj, &dir.ldest, dgram, + proto, ttl, df); } @@ -144,14 +173,16 @@ int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local) { - inet_addrobj_t *addr; - - addr = inet_addrobj_find(remote, iaf_net); - if (addr != NULL) { - /* Destination is directly accessible */ - local->ipv4 = addr->naddr.ipv4; - return EOK; - } - - return ENOENT; + inet_dir_t dir; + int rc; + + rc = inet_find_dir(NULL, remote, tos, &dir); + if (rc != EOK) + return rc; + + /* XXX dt_local? */ + + /* Take source address from the address object */ + local->ipv4 = dir.aobj->naddr.ipv4; + return EOK; } Index: uspace/srv/inet/inet.h =================================================================== --- uspace/srv/inet/inet.h (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/inet.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -90,4 +90,14 @@ } inet_link_info_t; +/** Static route info */ +typedef struct { + /** Destination network address */ + inet_naddr_t dest; + /** Router address */ + inet_addr_t router; + /** Static route name */ + char *name; +} inet_sroute_info_t; + typedef struct { inet_addr_t src; @@ -125,4 +135,34 @@ } inet_addrobj_t; +/** Static route configuration */ +typedef struct { + link_t sroute_list; + sysarg_t id; + /** Destination network */ + inet_naddr_t dest; + /** Router via which to route packets */ + inet_addr_t router; + char *name; +} inet_sroute_t; + +typedef enum { + /** Destination is on this network node */ + dt_local, + /** Destination is directly reachable */ + dt_direct, + /** Destination is behind a router */ + dt_router +} inet_dir_type_t; + +/** Direction (next hop) to a destination */ +typedef struct { + /** Route type */ + inet_dir_type_t dtype; + /** Address object (direction) */ + inet_addrobj_t *aobj; + /** Local destination address */ + inet_addr_t ldest; +} inet_dir_t; + typedef struct { inet_addr_t src; Index: uspace/srv/inet/inet_util.c =================================================================== --- uspace/srv/inet/inet_util.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) +++ uspace/srv/inet/inet_util.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2012 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup inet + * @{ + */ +/** + * @file + * @brief + */ + +#include +#include +#include +#include "inet_util.h" + +uint32_t inet_netmask(int bits) +{ + assert(bits >= 0); + assert(bits < 32); + + if (bits == 0) + return 0; + else + return BIT_RANGE(uint32_t, 31, 31 - (bits - 1)); +} + +/** @} + */ Index: uspace/srv/inet/inet_util.h =================================================================== --- uspace/srv/inet/inet_util.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) +++ uspace/srv/inet/inet_util.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup inet + * @{ + */ +/** + * @file + * @brief + */ + +#ifndef INET_UTIL_H_ +#define INET_UTIL_H_ + +#include + +uint32_t inet_netmask(int bits); + +#endif + +/** @} + */ Index: uspace/srv/inet/inetcfg.c =================================================================== --- uspace/srv/inet/inetcfg.c (revision 3b3c689ff125151df11825f53e0b224b082b7157) +++ uspace/srv/inet/inetcfg.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -49,4 +49,5 @@ #include "inet_link.h" #include "inetcfg.h" +#include "sroute.h" static int inetcfg_addr_create_static(char *name, inet_naddr_t *naddr, @@ -66,4 +67,9 @@ addr = inet_addrobj_new(); + if (addr == NULL) { + *addr_id = 0; + return ENOMEM; + } + addr->naddr = *naddr; addr->ilink = ilink; @@ -143,4 +149,9 @@ } +static int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count) +{ + return inet_sroute_get_id_list(sroutes, count); +} + static int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo) { @@ -153,4 +164,67 @@ linfo->name = str_dup(ilink->svc_name); + return EOK; +} + +static int inetcfg_sroute_create(char *name, inet_naddr_t *dest, + inet_addr_t *router, sysarg_t *sroute_id) +{ + inet_sroute_t *sroute; + + sroute = inet_sroute_new(); + if (sroute == NULL) { + *sroute_id = 0; + return ENOMEM; + } + + sroute->dest = *dest; + sroute->router = *router; + sroute->name = str_dup(name); + inet_sroute_add(sroute); + + *sroute_id = sroute->id; + return EOK; +} + +static int inetcfg_sroute_delete(sysarg_t sroute_id) +{ + inet_sroute_t *sroute; + + sroute = inet_sroute_get_by_id(sroute_id); + if (sroute == NULL) + return ENOENT; + + inet_sroute_remove(sroute); + inet_sroute_delete(sroute); + + return EOK; +} + +static int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo) +{ + inet_sroute_t *sroute; + + sroute = inet_sroute_get_by_id(sroute_id); + if (sroute == NULL) + return ENOENT; + + srinfo->dest = sroute->dest; + srinfo->router = sroute->router; + srinfo->name = str_dup(sroute->name); + + return EOK; +} + +static int inetcfg_sroute_get_id(char *name, sysarg_t *sroute_id) +{ + inet_sroute_t *sroute; + + sroute = inet_sroute_find_by_name(name); + if (sroute == NULL) { + log_msg(LVL_DEBUG, "Static route '%s' not found.", name); + return ENOENT; + } + + *sroute_id = sroute->id; return EOK; } @@ -257,5 +331,4 @@ async_answer_1(callid, rc, addr_id); } - static void inetcfg_get_addr_list_srv(ipc_callid_t callid, ipc_call_t *call) @@ -293,37 +366,4 @@ } -static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call) -{ - ipc_callid_t rcallid; - size_t max_size; - - sysarg_t link_id; - inet_link_info_t linfo; - int rc; - - link_id = IPC_GET_ARG1(*call); - log_msg(LVL_DEBUG, "inetcfg_link_get_srv()"); - - linfo.name = NULL; - - if (!async_data_read_receive(&rcallid, &max_size)) { - async_answer_0(rcallid, EREFUSED); - async_answer_0(callid, EREFUSED); - return; - } - - rc = inetcfg_link_get(link_id, &linfo); - if (rc != EOK) { - async_answer_0(rcallid, rc); - async_answer_0(callid, rc); - return; - } - - sysarg_t retval = async_data_read_finalize(rcallid, linfo.name, - min(max_size, str_size(linfo.name))); - free(linfo.name); - - async_answer_0(callid, retval); -} static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call) @@ -359,4 +399,171 @@ } +static void inetcfg_get_sroute_list_srv(ipc_callid_t callid, ipc_call_t *call) +{ + ipc_callid_t rcallid; + size_t count; + size_t max_size; + size_t act_size; + size_t size; + sysarg_t *id_buf; + int rc; + + log_msg(LVL_DEBUG, "inetcfg_get_sroute_list_srv()"); + + if (!async_data_read_receive(&rcallid, &max_size)) { + async_answer_0(rcallid, EREFUSED); + async_answer_0(callid, EREFUSED); + return; + } + + rc = inetcfg_get_sroute_list(&id_buf, &count); + if (rc != EOK) { + async_answer_0(rcallid, rc); + async_answer_0(callid, rc); + return; + } + + act_size = count * sizeof(sysarg_t); + size = min(act_size, max_size); + + sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size); + free(id_buf); + + async_answer_1(callid, retval, act_size); +} + +static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call) +{ + ipc_callid_t rcallid; + size_t max_size; + + sysarg_t link_id; + inet_link_info_t linfo; + int rc; + + link_id = IPC_GET_ARG1(*call); + log_msg(LVL_DEBUG, "inetcfg_link_get_srv()"); + + linfo.name = NULL; + + if (!async_data_read_receive(&rcallid, &max_size)) { + async_answer_0(rcallid, EREFUSED); + async_answer_0(callid, EREFUSED); + return; + } + + rc = inetcfg_link_get(link_id, &linfo); + if (rc != EOK) { + async_answer_0(rcallid, rc); + async_answer_0(callid, rc); + return; + } + + sysarg_t retval = async_data_read_finalize(rcallid, linfo.name, + min(max_size, str_size(linfo.name))); + free(linfo.name); + + async_answer_0(callid, retval); +} + +static void inetcfg_sroute_create_srv(ipc_callid_t callid, + ipc_call_t *call) +{ + char *name; + inet_naddr_t dest; + inet_addr_t router; + sysarg_t sroute_id; + int rc; + + log_msg(LVL_DEBUG, "inetcfg_sroute_create_srv()"); + + rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN, + 0, NULL); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + dest.ipv4 = IPC_GET_ARG1(*call); + dest.bits = IPC_GET_ARG2(*call); + router.ipv4 = IPC_GET_ARG3(*call); + + sroute_id = 0; + rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id); + free(name); + async_answer_1(callid, rc, sroute_id); +} + +static void inetcfg_sroute_delete_srv(ipc_callid_t callid, ipc_call_t *call) +{ + sysarg_t sroute_id; + int rc; + + log_msg(LVL_DEBUG, "inetcfg_sroute_delete_srv()"); + + sroute_id = IPC_GET_ARG1(*call); + + rc = inetcfg_sroute_delete(sroute_id); + async_answer_0(callid, rc); +} + +static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call) +{ + ipc_callid_t rcallid; + size_t max_size; + + sysarg_t sroute_id; + inet_sroute_info_t srinfo; + int rc; + + sroute_id = IPC_GET_ARG1(*call); + log_msg(LVL_DEBUG, "inetcfg_sroute_get_srv()"); + + srinfo.dest.ipv4 = 0; + srinfo.dest.bits = 0; + srinfo.router.ipv4 = 0; + srinfo.name = NULL; + + if (!async_data_read_receive(&rcallid, &max_size)) { + async_answer_0(rcallid, EREFUSED); + async_answer_0(callid, EREFUSED); + return; + } + + rc = inetcfg_sroute_get(sroute_id, &srinfo); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name, + min(max_size, str_size(srinfo.name))); + free(srinfo.name); + + async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits, + srinfo.router.ipv4); +} + +static void inetcfg_sroute_get_id_srv(ipc_callid_t callid, ipc_call_t *call) +{ + char *name; + sysarg_t sroute_id; + int rc; + + log_msg(LVL_DEBUG, "inetcfg_sroute_get_id_srv()"); + + rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN, + 0, NULL); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + sroute_id = 0; + rc = inetcfg_sroute_get_id(name, &sroute_id); + free(name); + async_answer_1(callid, rc, sroute_id); +} + void inet_cfg_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg) { @@ -396,6 +603,21 @@ inetcfg_get_link_list_srv(callid, &call); break; + case INETCFG_GET_SROUTE_LIST: + inetcfg_get_sroute_list_srv(callid, &call); + break; case INETCFG_LINK_GET: inetcfg_link_get_srv(callid, &call); + break; + case INETCFG_SROUTE_CREATE: + inetcfg_sroute_create_srv(callid, &call); + break; + case INETCFG_SROUTE_DELETE: + inetcfg_sroute_delete_srv(callid, &call); + break; + case INETCFG_SROUTE_GET: + inetcfg_sroute_get_srv(callid, &call); + break; + case INETCFG_SROUTE_GET_ID: + inetcfg_sroute_get_id_srv(callid, &call); break; default: Index: uspace/srv/inet/sroute.c =================================================================== --- uspace/srv/inet/sroute.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) +++ uspace/srv/inet/sroute.c (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -0,0 +1,219 @@ +/* + * Copyright (c) 2012 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup inet + * @{ + */ +/** + * @file + * @brief + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "sroute.h" +#include "inet.h" +#include "inet_link.h" +#include "inet_util.h" + +static FIBRIL_MUTEX_INITIALIZE(sroute_list_lock); +static LIST_INITIALIZE(sroute_list); +static sysarg_t sroute_id = 0; + +inet_sroute_t *inet_sroute_new(void) +{ + inet_sroute_t *sroute = calloc(1, sizeof(inet_sroute_t)); + + if (sroute == NULL) { + log_msg(LVL_ERROR, "Failed allocating static route object. " + "Out of memory."); + return NULL; + } + + link_initialize(&sroute->sroute_list); + fibril_mutex_lock(&sroute_list_lock); + sroute->id = ++sroute_id; + fibril_mutex_unlock(&sroute_list_lock); + + return sroute; +} + +void inet_sroute_delete(inet_sroute_t *sroute) +{ + if (sroute->name != NULL) + free(sroute->name); + free(sroute); +} + +void inet_sroute_add(inet_sroute_t *sroute) +{ + fibril_mutex_lock(&sroute_list_lock); + list_append(&sroute->sroute_list, &sroute_list); + fibril_mutex_unlock(&sroute_list_lock); +} + +void inet_sroute_remove(inet_sroute_t *sroute) +{ + fibril_mutex_lock(&sroute_list_lock); + list_remove(&sroute->sroute_list); + fibril_mutex_unlock(&sroute_list_lock); +} + +/** Find address object matching address @a addr. + * + * @param addr Address + */ +inet_sroute_t *inet_sroute_find(inet_addr_t *addr) +{ + uint32_t mask; + inet_sroute_t *best; + + log_msg(LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4); + + fibril_mutex_lock(&sroute_list_lock); + + best = NULL; + + list_foreach(sroute_list, link) { + inet_sroute_t *sroute = list_get_instance(link, + inet_sroute_t, sroute_list); + + /* Look for the most specific route */ + if (best != NULL && best->dest.bits >= sroute->dest.bits) + continue; + + mask = inet_netmask(sroute->dest.bits); + if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) { + fibril_mutex_unlock(&sroute_list_lock); + log_msg(LVL_DEBUG, "inet_sroute_find: found %p", + sroute); + return sroute; + } + } + + log_msg(LVL_DEBUG, "inet_sroute_find: Not found"); + fibril_mutex_unlock(&sroute_list_lock); + + return NULL; +} + +/** Find static route with a specific name. + * + * @param name Address object name + * @return Address object + */ +inet_sroute_t *inet_sroute_find_by_name(const char *name) +{ + log_msg(LVL_DEBUG, "inet_sroute_find_by_name('%s')", + name); + + fibril_mutex_lock(&sroute_list_lock); + + list_foreach(sroute_list, link) { + inet_sroute_t *sroute = list_get_instance(link, + inet_sroute_t, sroute_list); + + if (str_cmp(sroute->name, name) == 0) { + fibril_mutex_unlock(&sroute_list_lock); + log_msg(LVL_DEBUG, "inet_sroute_find_by_name: found %p", + sroute); + return sroute; + } + } + + log_msg(LVL_DEBUG, "inet_sroute_find_by_name: Not found"); + fibril_mutex_unlock(&sroute_list_lock); + + return NULL; +} + +/** Find static route with the given ID. + * + * @param id Address object ID + * @return Address object + */ +inet_sroute_t *inet_sroute_get_by_id(sysarg_t id) +{ + log_msg(LVL_DEBUG, "inet_sroute_get_by_id(%zu)", (size_t)id); + + fibril_mutex_lock(&sroute_list_lock); + + list_foreach(sroute_list, link) { + inet_sroute_t *sroute = list_get_instance(link, + inet_sroute_t, sroute_list); + + if (sroute->id == id) { + fibril_mutex_unlock(&sroute_list_lock); + return sroute; + } + } + + fibril_mutex_unlock(&sroute_list_lock); + + return NULL; +} + +/** Get IDs of all static routes. */ +int inet_sroute_get_id_list(sysarg_t **rid_list, size_t *rcount) +{ + sysarg_t *id_list; + size_t count, i; + + fibril_mutex_lock(&sroute_list_lock); + count = list_count(&sroute_list); + + id_list = calloc(count, sizeof(sysarg_t)); + if (id_list == NULL) { + fibril_mutex_unlock(&sroute_list_lock); + return ENOMEM; + } + + i = 0; + list_foreach(sroute_list, link) { + inet_sroute_t *sroute = list_get_instance(link, + inet_sroute_t, sroute_list); + + id_list[i++] = sroute->id; + } + + fibril_mutex_unlock(&sroute_list_lock); + + *rid_list = id_list; + *rcount = count; + + return EOK; +} + +/** @} + */ Index: uspace/srv/inet/sroute.h =================================================================== --- uspace/srv/inet/sroute.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) +++ uspace/srv/inet/sroute.h (revision 8bf672df361c98c8f5273d51034e67574914aaf3) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2012 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup inet + * @{ + */ +/** + * @file + * @brief + */ + +#ifndef INET_SROUTE_H_ +#define INET_SROUTE_H_ + +#include +#include "inet.h" + +extern inet_sroute_t *inet_sroute_new(void); +extern void inet_sroute_delete(inet_sroute_t *); +extern void inet_sroute_add(inet_sroute_t *); +extern void inet_sroute_remove(inet_sroute_t *); +extern inet_sroute_t *inet_sroute_find(inet_addr_t *); +extern inet_sroute_t *inet_sroute_find_by_name(const char *); +extern inet_sroute_t *inet_sroute_get_by_id(sysarg_t); +extern int inet_sroute_send_dgram(inet_sroute_t *, inet_addr_t *, + inet_dgram_t *, uint8_t, uint8_t, int); +extern int inet_sroute_get_id_list(sysarg_t **, size_t *); + + +#endif + +/** @} + */