source: mainline/uspace/lib/c/generic/inetcfg.c@ b5cf742a

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b5cf742a was b5cf742a, checked in by Martin Decky <martin@…>, 12 years ago

cstyle (no change in functionality)
  • Property mode set to 100644
File size: 9.3 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#include <async.h>
30#include <assert.h>
31#include <errno.h>
32#include <inet/inetcfg.h>
33#include <ipc/inet.h>
34#include <ipc/services.h>
35#include <loc.h>
36#include <stdlib.h>
37#include <str.h>
38
39static async_sess_t *inetcfg_sess = NULL;
40
41static int inetcfg_get_ids_once(sysarg_t method, sysarg_t arg1,
42 sysarg_t *id_buf, size_t buf_size, size_t *act_size)
43{
44 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
45
46 ipc_call_t answer;
47 aid_t req = async_send_1(exch, method, arg1, &answer);
48 int rc = async_data_read_start(exch, id_buf, buf_size);
49
50 async_exchange_end(exch);
51
52 if (rc != EOK) {
53 async_forget(req);
54 return rc;
55 }
56
57 sysarg_t retval;
58 async_wait_for(req, &retval);
59
60 if (retval != EOK) {
61 return retval;
62 }
63
64 *act_size = IPC_GET_ARG1(answer);
65 return EOK;
66}
67
68/** Get list of IDs.
69 *
70 * Returns an allocated array of service IDs.
71 *
72 * @param method IPC method
73 * @param arg1 IPC argument 1
74 * @param data Place to store pointer to array of IDs
75 * @param count Place to store number of IDs
76 * @return EOK on success or negative error code
77 */
78static int inetcfg_get_ids_internal(sysarg_t method, sysarg_t arg1,
79 sysarg_t **data, size_t *count)
80{
81 *data = NULL;
82 *count = 0;
83
84 size_t act_size = 0;
85 int rc = inetcfg_get_ids_once(method, arg1, NULL, 0,
86 &act_size);
87 if (rc != EOK)
88 return rc;
89
90 size_t alloc_size = act_size;
91 service_id_t *ids = malloc(alloc_size);
92 if (ids == NULL)
93 return ENOMEM;
94
95 while (true) {
96 rc = inetcfg_get_ids_once(method, arg1, ids, alloc_size,
97 &act_size);
98 if (rc != EOK)
99 return rc;
100
101 if (act_size <= alloc_size)
102 break;
103
104 alloc_size = act_size;
105 ids = realloc(ids, alloc_size);
106 if (ids == NULL)
107 return ENOMEM;
108 }
109
110 *count = act_size / sizeof(sysarg_t);
111 *data = ids;
112 return EOK;
113}
114
115int inetcfg_init(void)
116{
117 service_id_t inet_svc;
118 int rc;
119
120 assert(inetcfg_sess == NULL);
121
122 rc = loc_service_get_id(SERVICE_NAME_INETCFG, &inet_svc,
123 IPC_FLAG_BLOCKING);
124 if (rc != EOK)
125 return ENOENT;
126
127 inetcfg_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
128 IPC_FLAG_BLOCKING);
129 if (inetcfg_sess == NULL)
130 return ENOENT;
131
132 return EOK;
133}
134
135int inetcfg_addr_create_static(const char *name, inet_naddr_t *naddr,
136 sysarg_t link_id, sysarg_t *addr_id)
137{
138 uint32_t naddr_addr;
139 uint8_t naddr_bits;
140 int rc = inet_naddr_pack(naddr, &naddr_addr, &naddr_bits);
141 if (rc != EOK)
142 return rc;
143
144 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
145
146 ipc_call_t answer;
147 aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC,
148 (sysarg_t) naddr_addr, (sysarg_t) naddr_bits, link_id, &answer);
149 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
150
151 async_exchange_end(exch);
152
153 if (retval != EOK) {
154 async_forget(req);
155 return retval;
156 }
157
158 async_wait_for(req, &retval);
159 *addr_id = IPC_GET_ARG1(answer);
160
161 return (int) retval;
162}
163
164int inetcfg_addr_delete(sysarg_t addr_id)
165{
166 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
167
168 int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
169 async_exchange_end(exch);
170
171 return rc;
172}
173
174int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
175{
176 ipc_call_t dreply;
177 sysarg_t dretval;
178 size_t act_size;
179 char name_buf[LOC_NAME_MAXLEN + 1];
180
181 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
182
183 ipc_call_t answer;
184 aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
185 aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
186 async_wait_for(dreq, &dretval);
187
188 async_exchange_end(exch);
189
190 if (dretval != EOK) {
191 async_forget(req);
192 return dretval;
193 }
194
195 sysarg_t retval;
196 async_wait_for(req, &retval);
197
198 if (retval != EOK)
199 return (int) retval;
200
201 act_size = IPC_GET_ARG2(dreply);
202 assert(act_size <= LOC_NAME_MAXLEN);
203
204 name_buf[act_size] = '\0';
205
206 inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
207 &ainfo->naddr);
208 ainfo->ilink = IPC_GET_ARG3(answer);
209 ainfo->name = str_dup(name_buf);
210
211 return EOK;
212}
213
214int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
215{
216 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
217
218 ipc_call_t answer;
219 aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
220 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
221
222 async_exchange_end(exch);
223
224 if (retval != EOK) {
225 async_forget(req);
226 return retval;
227 }
228
229 async_wait_for(req, &retval);
230 *addr_id = IPC_GET_ARG1(answer);
231
232 return retval;
233}
234
235int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
236{
237 return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
238 0, addrs, count);
239}
240
241int inetcfg_get_link_list(sysarg_t **links, size_t *count)
242{
243 return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
244 0, links, count);
245}
246
247int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
248{
249 return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
250 0, sroutes, count);
251}
252
253int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
254{
255 ipc_call_t dreply;
256 sysarg_t dretval;
257 size_t act_size;
258 char name_buf[LOC_NAME_MAXLEN + 1];
259
260 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
261
262 ipc_call_t answer;
263 aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
264 aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
265 async_wait_for(dreq, &dretval);
266
267 async_exchange_end(exch);
268
269 if (dretval != EOK) {
270 async_forget(req);
271 return dretval;
272 }
273
274 sysarg_t retval;
275 async_wait_for(req, &retval);
276
277 if (retval != EOK)
278 return retval;
279
280 act_size = IPC_GET_ARG2(dreply);
281 assert(act_size <= LOC_NAME_MAXLEN);
282 name_buf[act_size] = '\0';
283
284 linfo->name = str_dup(name_buf);
285 linfo->def_mtu = IPC_GET_ARG1(answer);
286
287 return EOK;
288}
289
290int inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
291 inet_addr_t *router, sysarg_t *sroute_id)
292{
293 uint32_t dest_addr;
294 uint8_t dest_bits;
295 int rc = inet_naddr_pack(dest, &dest_addr, &dest_bits);
296 if (rc != EOK)
297 return rc;
298
299 uint32_t router_addr;
300 rc = inet_addr_pack(router, &router_addr);
301 if (rc != EOK)
302 return rc;
303
304 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
305
306 ipc_call_t answer;
307 aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
308 (sysarg_t) dest_addr, (sysarg_t) dest_bits, (sysarg_t) router_addr,
309 &answer);
310 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
311
312 async_exchange_end(exch);
313
314 if (retval != EOK) {
315 async_forget(req);
316 return retval;
317 }
318
319 async_wait_for(req, &retval);
320 *sroute_id = IPC_GET_ARG1(answer);
321
322 return retval;
323}
324
325int inetcfg_sroute_delete(sysarg_t sroute_id)
326{
327 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
328
329 int rc = async_req_1_0(exch, INETCFG_SROUTE_DELETE, sroute_id);
330 async_exchange_end(exch);
331
332 return rc;
333}
334
335int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
336{
337 ipc_call_t dreply;
338 sysarg_t dretval;
339 size_t act_size;
340 char name_buf[LOC_NAME_MAXLEN + 1];
341
342 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
343
344 ipc_call_t answer;
345 aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
346 aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
347 async_wait_for(dreq, &dretval);
348
349 async_exchange_end(exch);
350
351 if (dretval != EOK) {
352 async_forget(req);
353 return dretval;
354 }
355
356 sysarg_t retval;
357 async_wait_for(req, &retval);
358
359 if (retval != EOK)
360 return (int) retval;
361
362 act_size = IPC_GET_ARG2(dreply);
363 assert(act_size <= LOC_NAME_MAXLEN);
364 name_buf[act_size] = '\0';
365
366 inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
367 &srinfo->dest);
368 inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
369 srinfo->name = str_dup(name_buf);
370
371 return EOK;
372}
373
374int inetcfg_sroute_get_id(const char *name, sysarg_t *sroute_id)
375{
376 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
377
378 ipc_call_t answer;
379 aid_t req = async_send_0(exch, INETCFG_SROUTE_GET_ID, &answer);
380 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
381
382 async_exchange_end(exch);
383
384 if (retval != EOK) {
385 async_forget(req);
386 return retval;
387 }
388
389 async_wait_for(req, &retval);
390 *sroute_id = IPC_GET_ARG1(answer);
391
392 return retval;
393}
394
395/** @}
396 */
Note: See TracBrowser for help on using the repository browser.