Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/inetcfg.c

    r7af0cc5 r77ad86c  
    137137{
    138138        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         int 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         sysarg_t retval;
    161         async_wait_for(req, &retval);
    162        
     139
     140        ipc_call_t answer;
     141        aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
     142            naddr->bits, link_id, &answer);
     143        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     144
     145        async_exchange_end(exch);
     146
     147        if (retval != EOK) {
     148                async_forget(req);
     149                return retval;
     150        }
     151
     152        async_wait_for(req, &retval);
    163153        *addr_id = IPC_GET_ARG1(answer);
    164        
    165         return (int) retval;
     154
     155        return retval;
    166156}
    167157
    … …  
    177167
    178168int 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         sysarg_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 (int) 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         sysarg_t retval_name;
    206         async_wait_for(req_name, &retval_name);
    207        
    208         if (retval_name != EOK) {
    209                 async_forget(req);
    210                 return (int) retval_name;
    211         }
    212        
    213         sysarg_t retval;
    214         async_wait_for(req, &retval);
    215        
    216         if (retval != EOK)
    217                 return (int) 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 
    230 int 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         sysarg_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 
    251 int 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 
    257 int 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 
    263 int 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 
    269 int inetcfg_link_add(sysarg_t link_id)
    270 {
    271         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    272 
    273         int rc = async_req_1_0(exch, INETCFG_LINK_ADD, link_id);
    274         async_exchange_end(exch);
    275 
    276         return rc;
    277 }
    278 
    279 int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    280169{
    281170        ipc_call_t dreply;
    … …  
    287176
    288177        ipc_call_t answer;
    289         aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
     178        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
    290179        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    291         int rc = async_data_read_start(exch, &linfo->mac_addr, sizeof(addr48_t));
    292180        async_wait_for(dreq, &dretval);
    293181
    294182        async_exchange_end(exch);
    295183
    296         if (dretval != EOK || rc != EOK) {
     184        if (dretval != EOK) {
    297185                async_forget(req);
    298186                return dretval;
    … …  
    309197        name_buf[act_size] = '\0';
    310198
     199        ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
     200        ainfo->naddr.bits = IPC_GET_ARG2(answer);
     201        ainfo->ilink = IPC_GET_ARG3(answer);
     202        ainfo->name = str_dup(name_buf);
     203
     204        return EOK;
     205}
     206
     207int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
     208{
     209        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     210
     211        ipc_call_t answer;
     212        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
     213        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     214
     215        async_exchange_end(exch);
     216
     217        if (retval != EOK) {
     218                async_forget(req);
     219                return retval;
     220        }
     221
     222        async_wait_for(req, &retval);
     223        *addr_id = IPC_GET_ARG1(answer);
     224
     225        return retval;
     226}
     227
     228int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
     229{
     230        return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
     231            0, addrs, count);
     232}
     233
     234int inetcfg_get_link_list(sysarg_t **links, size_t *count)
     235{
     236        return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
     237            0, links, count);
     238}
     239
     240int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
     241{
     242        return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
     243            0, sroutes, count);
     244}
     245
     246int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
     247{
     248        ipc_call_t dreply;
     249        sysarg_t dretval;
     250        size_t act_size;
     251        char name_buf[LOC_NAME_MAXLEN + 1];
     252
     253        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     254
     255        ipc_call_t answer;
     256        aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
     257        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
     258        async_wait_for(dreq, &dretval);
     259
     260        async_exchange_end(exch);
     261
     262        if (dretval != EOK) {
     263                async_forget(req);
     264                return dretval;
     265        }
     266
     267        sysarg_t retval;
     268        async_wait_for(req, &retval);
     269
     270        if (retval != EOK)
     271                return retval;
     272
     273        act_size = IPC_GET_ARG2(dreply);
     274        assert(act_size <= LOC_NAME_MAXLEN);
     275        name_buf[act_size] = '\0';
     276
    311277        linfo->name = str_dup(name_buf);
    312278        linfo->def_mtu = IPC_GET_ARG1(answer);
    … …  
    315281}
    316282
    317 int inetcfg_link_remove(sysarg_t link_id)
    318 {
    319         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    320 
    321         int rc = async_req_1_0(exch, INETCFG_LINK_REMOVE, link_id);
    322         async_exchange_end(exch);
    323 
    324         return rc;
    325 }
    326 
    327283int inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
    328284    inet_addr_t *router, sysarg_t *sroute_id)
    329285{
    330286        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         int 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        
     287
     288        ipc_call_t answer;
     289        aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
     290            dest->ipv4, dest->bits, router->ipv4, &answer);
     291        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     292
     293        async_exchange_end(exch);
     294
     295        if (retval != EOK) {
     296                async_forget(req);
     297                return retval;
     298        }
     299
     300        async_wait_for(req, &retval);
     301        *sroute_id = IPC_GET_ARG1(answer);
     302
     303        return retval;
     304}
     305
     306int inetcfg_sroute_delete(sysarg_t sroute_id)
     307{
     308        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     309
     310        int rc = async_req_1_0(exch, INETCFG_SROUTE_DELETE, sroute_id);
     311        async_exchange_end(exch);
     312
     313        return rc;
     314}
     315
     316int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
     317{
     318        ipc_call_t dreply;
     319        sysarg_t dretval;
     320        size_t act_size;
     321        char name_buf[LOC_NAME_MAXLEN + 1];
     322
     323        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     324
     325        ipc_call_t answer;
     326        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
     327        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
     328        async_wait_for(dreq, &dretval);
     329
     330        async_exchange_end(exch);
     331
     332        if (dretval != EOK) {
     333                async_forget(req);
     334                return dretval;
     335        }
     336
    358337        sysarg_t retval;
    359338        async_wait_for(req, &retval);
    360        
    361         *sroute_id = IPC_GET_ARG1(answer);
    362        
    363         return (int) retval;
    364 }
    365 
    366 int inetcfg_sroute_delete(sysarg_t sroute_id)
    367 {
    368         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    369 
    370         int rc = async_req_1_0(exch, INETCFG_SROUTE_DELETE, sroute_id);
    371         async_exchange_end(exch);
    372 
    373         return rc;
    374 }
    375 
    376 int 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         sysarg_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 (int) 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         sysarg_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 (int) 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         sysarg_t retval_name;
    417         async_wait_for(req_name, &retval_name);
    418        
    419         if (retval_name != EOK) {
    420                 async_forget(req);
    421                 return (int) retval_name;
    422         }
    423        
    424         sysarg_t retval;
    425         async_wait_for(req, &retval);
    426        
     339
    427340        if (retval != EOK)
    428                 return (int) retval;
    429        
    430         size_t act_size = IPC_GET_ARG2(answer_name);
     341                return retval;
     342
     343        act_size = IPC_GET_ARG2(dreply);
    431344        assert(act_size <= LOC_NAME_MAXLEN);
    432        
    433345        name_buf[act_size] = '\0';
    434        
     346
     347        srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
     348        srinfo->dest.bits = IPC_GET_ARG2(answer);
     349        srinfo->router.ipv4 = IPC_GET_ARG3(answer);
    435350        srinfo->name = str_dup(name_buf);
    436        
     351
    437352        return EOK;
    438353}
Note: See TracChangeset for help on using the changeset viewer.