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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a35b458 was a35b458, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.
  • Property mode set to 100644
File size: 10.5 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 errno_t 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 errno_t 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 errno_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 an error code
77 */
78static errno_t 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 errno_t 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
115errno_t inetcfg_init(void)
116{
117 service_id_t inet_svc;
118 errno_t rc;
119
120 assert(inetcfg_sess == NULL);
121
122 rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
123 IPC_FLAG_BLOCKING);
124 if (rc != EOK)
125 return ENOENT;
126
127 inetcfg_sess = loc_service_connect(inet_svc, INTERFACE_INETCFG,
128 IPC_FLAG_BLOCKING);
129 if (inetcfg_sess == NULL)
130 return ENOENT;
131
132 return EOK;
133}
134
135errno_t inetcfg_addr_create_static(const char *name, inet_naddr_t *naddr,
136 sysarg_t link_id, sysarg_t *addr_id)
137{
138 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
139
140 ipc_call_t answer;
141 aid_t req = async_send_1(exch, INETCFG_ADDR_CREATE_STATIC, link_id,
142 &answer);
143
144 errno_t rc = async_data_write_start(exch, naddr, sizeof(inet_naddr_t));
145 if (rc != EOK) {
146 async_exchange_end(exch);
147 async_forget(req);
148 return rc;
149 }
150
151 rc = async_data_write_start(exch, name, str_size(name));
152
153 async_exchange_end(exch);
154
155 if (rc != EOK) {
156 async_forget(req);
157 return rc;
158 }
159
160 errno_t retval;
161 async_wait_for(req, &retval);
162
163 *addr_id = IPC_GET_ARG1(answer);
164
165 return retval;
166}
167
168errno_t inetcfg_addr_delete(sysarg_t addr_id)
169{
170 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
171
172 errno_t rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
173 async_exchange_end(exch);
174
175 return rc;
176}
177
178errno_t inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
179{
180 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
181
182 ipc_call_t answer;
183 aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
184
185 ipc_call_t answer_naddr;
186 aid_t req_naddr = async_data_read(exch, &ainfo->naddr,
187 sizeof(inet_naddr_t), &answer_naddr);
188
189 errno_t retval_naddr;
190 async_wait_for(req_naddr, &retval_naddr);
191
192 if (retval_naddr != EOK) {
193 async_exchange_end(exch);
194 async_forget(req);
195 return retval_naddr;
196 }
197
198 ipc_call_t answer_name;
199 char name_buf[LOC_NAME_MAXLEN + 1];
200 aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
201 &answer_name);
202
203 async_exchange_end(exch);
204
205 errno_t retval_name;
206 async_wait_for(req_name, &retval_name);
207
208 if (retval_name != EOK) {
209 async_forget(req);
210 return retval_name;
211 }
212
213 errno_t retval;
214 async_wait_for(req, &retval);
215
216 if (retval != EOK)
217 return retval;
218
219 size_t act_size = IPC_GET_ARG2(answer_name);
220 assert(act_size <= LOC_NAME_MAXLEN);
221
222 name_buf[act_size] = '\0';
223
224 ainfo->ilink = IPC_GET_ARG1(answer);
225 ainfo->name = str_dup(name_buf);
226
227 return EOK;
228}
229
230errno_t inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
231{
232 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
233
234 ipc_call_t answer;
235 aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
236 errno_t retval = async_data_write_start(exch, name, str_size(name));
237
238 async_exchange_end(exch);
239
240 if (retval != EOK) {
241 async_forget(req);
242 return retval;
243 }
244
245 async_wait_for(req, &retval);
246 *addr_id = IPC_GET_ARG1(answer);
247
248 return retval;
249}
250
251errno_t inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
252{
253 return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
254 0, addrs, count);
255}
256
257errno_t inetcfg_get_link_list(sysarg_t **links, size_t *count)
258{
259 return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
260 0, links, count);
261}
262
263errno_t inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
264{
265 return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
266 0, sroutes, count);
267}
268
269errno_t inetcfg_link_add(sysarg_t link_id)
270{
271 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
272
273 errno_t rc = async_req_1_0(exch, INETCFG_LINK_ADD, link_id);
274 async_exchange_end(exch);
275
276 return rc;
277}
278
279errno_t inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
280{
281 ipc_call_t dreply;
282 errno_t dretval;
283 size_t act_size;
284 char name_buf[LOC_NAME_MAXLEN + 1];
285
286 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
287
288 ipc_call_t answer;
289 aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
290 aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
291 errno_t rc = async_data_read_start(exch, &linfo->mac_addr, sizeof(addr48_t));
292 async_wait_for(dreq, &dretval);
293
294 async_exchange_end(exch);
295
296 if (dretval != EOK || rc != EOK) {
297 async_forget(req);
298 return dretval;
299 }
300
301 errno_t retval;
302 async_wait_for(req, &retval);
303
304 if (retval != EOK)
305 return retval;
306
307 act_size = IPC_GET_ARG2(dreply);
308 assert(act_size <= LOC_NAME_MAXLEN);
309 name_buf[act_size] = '\0';
310
311 linfo->name = str_dup(name_buf);
312 linfo->def_mtu = IPC_GET_ARG1(answer);
313
314 return EOK;
315}
316
317errno_t inetcfg_link_remove(sysarg_t link_id)
318{
319 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
320
321 errno_t rc = async_req_1_0(exch, INETCFG_LINK_REMOVE, link_id);
322 async_exchange_end(exch);
323
324 return rc;
325}
326
327errno_t inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
328 inet_addr_t *router, sysarg_t *sroute_id)
329{
330 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
331
332 ipc_call_t answer;
333 aid_t req = async_send_0(exch, INETCFG_SROUTE_CREATE, &answer);
334
335 errno_t rc = async_data_write_start(exch, dest, sizeof(inet_naddr_t));
336 if (rc != EOK) {
337 async_exchange_end(exch);
338 async_forget(req);
339 return rc;
340 }
341
342 rc = async_data_write_start(exch, router, sizeof(inet_addr_t));
343 if (rc != EOK) {
344 async_exchange_end(exch);
345 async_forget(req);
346 return rc;
347 }
348
349 rc = async_data_write_start(exch, name, str_size(name));
350
351 async_exchange_end(exch);
352
353 if (rc != EOK) {
354 async_forget(req);
355 return rc;
356 }
357
358 errno_t retval;
359 async_wait_for(req, &retval);
360
361 *sroute_id = IPC_GET_ARG1(answer);
362
363 return retval;
364}
365
366errno_t inetcfg_sroute_delete(sysarg_t sroute_id)
367{
368 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
369
370 errno_t rc = async_req_1_0(exch, INETCFG_SROUTE_DELETE, sroute_id);
371 async_exchange_end(exch);
372
373 return rc;
374}
375
376errno_t inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
377{
378 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
379
380 ipc_call_t answer;
381 aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
382
383 ipc_call_t answer_dest;
384 aid_t req_dest = async_data_read(exch, &srinfo->dest,
385 sizeof(inet_naddr_t), &answer_dest);
386
387 errno_t retval_dest;
388 async_wait_for(req_dest, &retval_dest);
389
390 if (retval_dest != EOK) {
391 async_exchange_end(exch);
392 async_forget(req);
393 return retval_dest;
394 }
395
396 ipc_call_t answer_router;
397 aid_t req_router = async_data_read(exch, &srinfo->router,
398 sizeof(inet_addr_t), &answer_router);
399
400 errno_t retval_router;
401 async_wait_for(req_router, &retval_router);
402
403 if (retval_router != EOK) {
404 async_exchange_end(exch);
405 async_forget(req);
406 return retval_router;
407 }
408
409 ipc_call_t answer_name;
410 char name_buf[LOC_NAME_MAXLEN + 1];
411 aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
412 &answer_name);
413
414 async_exchange_end(exch);
415
416 errno_t retval_name;
417 async_wait_for(req_name, &retval_name);
418
419 if (retval_name != EOK) {
420 async_forget(req);
421 return retval_name;
422 }
423
424 errno_t retval;
425 async_wait_for(req, &retval);
426
427 if (retval != EOK)
428 return retval;
429
430 size_t act_size = IPC_GET_ARG2(answer_name);
431 assert(act_size <= LOC_NAME_MAXLEN);
432
433 name_buf[act_size] = '\0';
434
435 srinfo->name = str_dup(name_buf);
436
437 return EOK;
438}
439
440errno_t inetcfg_sroute_get_id(const char *name, sysarg_t *sroute_id)
441{
442 async_exch_t *exch = async_exchange_begin(inetcfg_sess);
443
444 ipc_call_t answer;
445 aid_t req = async_send_0(exch, INETCFG_SROUTE_GET_ID, &answer);
446 errno_t retval = async_data_write_start(exch, name, str_size(name));
447
448 async_exchange_end(exch);
449
450 if (retval != EOK) {
451 async_forget(req);
452 return retval;
453 }
454
455 async_wait_for(req, &retval);
456 *sroute_id = IPC_GET_ARG1(answer);
457
458 return retval;
459}
460
461/** @}
462 */
Note: See TracBrowser for help on using the repository browser.