source: mainline/uspace/srv/net/inetsrv/addrobj.c@ eec201d

Last change on this file since eec201d was 09ab0a9a, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix vertical spacing with new Ccheck revision.
  • Property mode set to 100644
File size: 7.1 KB
Line 
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#include "addrobj.h"
45#include "inetsrv.h"
46#include "inet_link.h"
47#include "ndp.h"
48
49static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
50
51static FIBRIL_MUTEX_INITIALIZE(addr_list_lock);
52static LIST_INITIALIZE(addr_list);
53static sysarg_t addr_id = 0;
54
55inet_addrobj_t *inet_addrobj_new(void)
56{
57 inet_addrobj_t *addr = calloc(1, sizeof(inet_addrobj_t));
58
59 if (addr == NULL) {
60 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating address object. "
61 "Out of memory.");
62 return NULL;
63 }
64
65 link_initialize(&addr->addr_list);
66 fibril_mutex_lock(&addr_list_lock);
67 addr->id = ++addr_id;
68 fibril_mutex_unlock(&addr_list_lock);
69
70 return addr;
71}
72
73void inet_addrobj_delete(inet_addrobj_t *addr)
74{
75 if (addr->name != NULL)
76 free(addr->name);
77 free(addr);
78}
79
80errno_t inet_addrobj_add(inet_addrobj_t *addr)
81{
82 inet_addrobj_t *aobj;
83
84 fibril_mutex_lock(&addr_list_lock);
85 aobj = inet_addrobj_find_by_name_locked(addr->name, addr->ilink);
86 if (aobj != NULL) {
87 /* Duplicate address name */
88 fibril_mutex_unlock(&addr_list_lock);
89 return EEXIST;
90 }
91
92 list_append(&addr->addr_list, &addr_list);
93 fibril_mutex_unlock(&addr_list_lock);
94
95 return EOK;
96}
97
98void inet_addrobj_remove(inet_addrobj_t *addr)
99{
100 fibril_mutex_lock(&addr_list_lock);
101 list_remove(&addr->addr_list);
102 fibril_mutex_unlock(&addr_list_lock);
103}
104
105/** Find address object matching address @a addr.
106 *
107 * @param addr Address
108 * @oaram find iaf_net to find network (using mask),
109 * iaf_addr to find local address (exact match)
110 *
111 */
112inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
113{
114 fibril_mutex_lock(&addr_list_lock);
115
116 list_foreach(addr_list, addr_list, inet_addrobj_t, naddr) {
117 switch (find) {
118 case iaf_net:
119 if (inet_naddr_compare_mask(&naddr->naddr, addr)) {
120 fibril_mutex_unlock(&addr_list_lock);
121 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
122 naddr);
123 return naddr;
124 }
125 break;
126 case iaf_addr:
127 if (inet_naddr_compare(&naddr->naddr, addr)) {
128 fibril_mutex_unlock(&addr_list_lock);
129 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
130 naddr);
131 return naddr;
132 }
133 break;
134 }
135 }
136
137 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
138 fibril_mutex_unlock(&addr_list_lock);
139
140 return NULL;
141}
142
143/** Find address object on a link, with a specific name.
144 *
145 * @param name Address object name
146 * @param ilink Inet link
147 * @return Address object
148 */
149static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *name, inet_link_t *ilink)
150{
151 assert(fibril_mutex_is_locked(&addr_list_lock));
152
153 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked('%s', '%s')",
154 name, ilink->svc_name);
155
156 list_foreach(addr_list, addr_list, inet_addrobj_t, naddr) {
157 if (naddr->ilink == ilink && str_cmp(naddr->name, name) == 0) {
158 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: found %p",
159 naddr);
160 return naddr;
161 }
162 }
163
164 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: Not found");
165
166 return NULL;
167}
168
169/** Find address object on a link, with a specific name.
170 *
171 * @param name Address object name
172 * @param ilink Inet link
173 * @return Address object
174 */
175inet_addrobj_t *inet_addrobj_find_by_name(const char *name, inet_link_t *ilink)
176{
177 inet_addrobj_t *aobj;
178
179 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')",
180 name, ilink->svc_name);
181
182 fibril_mutex_lock(&addr_list_lock);
183 aobj = inet_addrobj_find_by_name_locked(name, ilink);
184 fibril_mutex_unlock(&addr_list_lock);
185
186 return aobj;
187}
188
189/** Find address object with the given ID.
190 *
191 * @param id Address object ID
192 * @return Address object
193 */
194inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t id)
195{
196 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id);
197
198 fibril_mutex_lock(&addr_list_lock);
199
200 list_foreach(addr_list, addr_list, inet_addrobj_t, naddr) {
201 if (naddr->id == id) {
202 fibril_mutex_unlock(&addr_list_lock);
203 return naddr;
204 }
205 }
206
207 fibril_mutex_unlock(&addr_list_lock);
208
209 return NULL;
210}
211
212/** Send datagram from address object */
213errno_t inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_addr_t *ldest,
214 inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
215{
216 inet_addr_t lsrc_addr;
217 inet_naddr_addr(&addr->naddr, &lsrc_addr);
218
219 addr32_t lsrc_v4;
220 addr128_t lsrc_v6;
221 ip_ver_t lsrc_ver = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
222
223 addr32_t ldest_v4;
224 addr128_t ldest_v6;
225 ip_ver_t ldest_ver = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
226
227 if (lsrc_ver != ldest_ver)
228 return EINVAL;
229
230 errno_t rc;
231 addr48_t ldest_mac;
232
233 switch (ldest_ver) {
234 case ip_v4:
235 return inet_link_send_dgram(addr->ilink, lsrc_v4, ldest_v4,
236 dgram, proto, ttl, df);
237 case ip_v6:
238 /*
239 * Translate local destination IPv6 address.
240 */
241 rc = ndp_translate(lsrc_v6, ldest_v6, ldest_mac, addr->ilink);
242 if (rc != EOK)
243 return rc;
244
245 return inet_link_send_dgram6(addr->ilink, ldest_mac, dgram,
246 proto, ttl, df);
247 default:
248 assert(false);
249 break;
250 }
251
252 return ENOTSUP;
253}
254
255/** Get IDs of all address objects. */
256errno_t inet_addrobj_get_id_list(sysarg_t **rid_list, size_t *rcount)
257{
258 sysarg_t *id_list;
259 size_t count, i;
260
261 fibril_mutex_lock(&addr_list_lock);
262 count = list_count(&addr_list);
263
264 id_list = calloc(count, sizeof(sysarg_t));
265 if (id_list == NULL) {
266 fibril_mutex_unlock(&addr_list_lock);
267 return ENOMEM;
268 }
269
270 i = 0;
271 list_foreach(addr_list, addr_list, inet_addrobj_t, addr) {
272 id_list[i++] = addr->id;
273 }
274
275 fibril_mutex_unlock(&addr_list_lock);
276
277 *rid_list = id_list;
278 *rcount = count;
279
280 return EOK;
281}
282
283/** @}
284 */
Note: See TracBrowser for help on using the repository browser.