uspace/srv/net/inetsrv/addrobj.c

   1 /*
   2  * Copyright (c) 2012 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup inet
  30  * @{
  31  */
  32 /**
  33  * @file
  34  * @brief
  35  */
  36
  37 #include <bitops.h>
  38 #include <errno.h>
  39 #include <fibril_synch.h>
  40 #include <io/log.h>
  41 #include <ipc/loc.h>
  42 #include <stdlib.h>
  43 #include <str.h>
  44
  45 #include "addrobj.h"
  46 #include "inetsrv.h"
  47 #include "inet_link.h"
  48 #include "inet_util.h"
  49
  50 static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
  51
  52 static FIBRIL_MUTEX_INITIALIZE(addr_list_lock);
  53 static LIST_INITIALIZE(addr_list);
  54 static sysarg_t addr_id = 0;
  55
  56 inet_addrobj_t *inet_addrobj_new(void)
  57 {
  58         inet_addrobj_t *addr = calloc(1, sizeof(inet_addrobj_t));
  59
  60         if (addr == NULL) {
  61                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating address object. "
  62                     "Out of memory.");
  63                 return NULL;
  64         }
  65
  66         link_initialize(&addr->addr_list);
  67         fibril_mutex_lock(&addr_list_lock);
  68         addr->id = ++addr_id;
  69         fibril_mutex_unlock(&addr_list_lock);
  70
  71         return addr;
  72 }
  73
  74 void inet_addrobj_delete(inet_addrobj_t *addr)
  75 {
  76         if (addr->name != NULL)
  77                 free(addr->name);
  78         free(addr);
  79 }
  80
  81 int inet_addrobj_add(inet_addrobj_t *addr)
  82 {
  83         inet_addrobj_t *aobj;
  84
  85         fibril_mutex_lock(&addr_list_lock);
  86         aobj = inet_addrobj_find_by_name_locked(addr->name, addr->ilink);
  87         if (aobj != NULL) {
  88                 /* Duplicate address name */
  89                 fibril_mutex_unlock(&addr_list_lock);
  90                 return EEXISTS;
  91         }
  92
  93         list_append(&addr->addr_list, &addr_list);
  94         fibril_mutex_unlock(&addr_list_lock);
  95
  96         return EOK;
  97 }
  98
  99 void inet_addrobj_remove(inet_addrobj_t *addr)
 100 {
 101         fibril_mutex_lock(&addr_list_lock);
 102         list_remove(&addr->addr_list);
 103         fibril_mutex_unlock(&addr_list_lock);
 104 }
 105
 106 /** Find address object matching address @a addr.
 107  *
 108  * @param addr  Address
 109  * @oaram find  iaf_net to find network (using mask),
 110  *              iaf_addr to find local address (exact match)
 111  */
 112 inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
 113 {
 114         uint32_t addr_addr;
 115         int rc = inet_addr_pack(addr, &addr_addr);
 116         if (rc != EOK)
 117                 return NULL;
 118
 119         fibril_mutex_lock(&addr_list_lock);
 120
 121         list_foreach(addr_list, link) {
 122                 inet_addrobj_t *naddr = list_get_instance(link,
 123                     inet_addrobj_t, addr_list);
 124
 125                 uint32_t naddr_addr;
 126                 uint8_t naddr_bits;
 127                 rc = inet_naddr_pack(&naddr->naddr, &naddr_addr, &naddr_bits);
 128                 if (rc != EOK)
 129                         continue;
 130
 131                 uint32_t mask = inet_netmask(naddr_bits);
 132                 if ((naddr_addr & mask) == (addr_addr & mask)) {
 133                         fibril_mutex_unlock(&addr_list_lock);
 134                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
 135                             naddr);
 136                         return naddr;
 137                 }
 138         }
 139
 140         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
 141         fibril_mutex_unlock(&addr_list_lock);
 142
 143         return NULL;
 144 }
 145
 146 /** Find address object on a link, with a specific name.
 147  *
 148  * @param name  Address object name
 149  * @param ilink Inet link
 150  * @return      Address object
 151  */
 152 static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *name, inet_link_t *ilink)
 153 {
 154         assert(fibril_mutex_is_locked(&addr_list_lock));
 155
 156         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked('%s', '%s')",
 157             name, ilink->svc_name);
 158
 159         list_foreach(addr_list, link) {
 160                 inet_addrobj_t *naddr = list_get_instance(link,
 161                     inet_addrobj_t, addr_list);
 162
 163                 if (naddr->ilink == ilink && str_cmp(naddr->name, name) == 0) {
 164                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: found %p",
 165                             naddr);
 166                         return naddr;
 167                 }
 168         }
 169
 170         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: Not found");
 171
 172         return NULL;
 173 }
 174
 175
 176 /** Find address object on a link, with a specific name.
 177  *
 178  * @param name  Address object name
 179  * @param ilink Inet link
 180  * @return      Address object
 181  */
 182 inet_addrobj_t *inet_addrobj_find_by_name(const char *name, inet_link_t *ilink)
 183 {
 184         inet_addrobj_t *aobj;
 185
 186         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')",
 187             name, ilink->svc_name);
 188
 189         fibril_mutex_lock(&addr_list_lock);
 190         aobj = inet_addrobj_find_by_name_locked(name, ilink);
 191         fibril_mutex_unlock(&addr_list_lock);
 192
 193         return aobj;
 194 }
 195
 196 /** Find address object with the given ID.
 197  *
 198  * @param id    Address object ID
 199  * @return      Address object
 200  */
 201 inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t id)
 202 {
 203         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id);
 204
 205         fibril_mutex_lock(&addr_list_lock);
 206
 207         list_foreach(addr_list, link) {
 208                 inet_addrobj_t *naddr = list_get_instance(link,
 209                     inet_addrobj_t, addr_list);
 210
 211                 if (naddr->id == id) {
 212                         fibril_mutex_unlock(&addr_list_lock);
 213                         return naddr;
 214                 }
 215         }
 216
 217         fibril_mutex_unlock(&addr_list_lock);
 218
 219         return NULL;
 220 }
 221
 222 /** Send datagram from address object */
 223 int inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_addr_t *ldest,
 224     inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
 225 {
 226         inet_addr_t lsrc_addr;
 227         inet_naddr_addr(&addr->naddr, &lsrc_addr);
 228
 229         inet_addr_t *ldest_addr = ldest;
 230
 231         return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
 232             proto, ttl, df);
 233 }
 234
 235 /** Get IDs of all address objects. */
 236 int inet_addrobj_get_id_list(sysarg_t **rid_list, size_t *rcount)
 237 {
 238         sysarg_t *id_list;
 239         size_t count, i;
 240
 241         fibril_mutex_lock(&addr_list_lock);
 242         count = list_count(&addr_list);
 243
 244         id_list = calloc(count, sizeof(sysarg_t));
 245         if (id_list == NULL) {
 246                 fibril_mutex_unlock(&addr_list_lock);
 247                 return ENOMEM;
 248         }
 249
 250         i = 0;
 251         list_foreach(addr_list, link) {
 252                 inet_addrobj_t *addr = list_get_instance(link,
 253                     inet_addrobj_t, addr_list);
 254
 255                 id_list[i++] = addr->id;
 256         }
 257
 258         fibril_mutex_unlock(&addr_list_lock);
 259
 260         *rid_list = id_list;
 261         *rcount = count;
 262
 263         return EOK;
 264 }
 265
 266 /** @}
 267  */