Changeset 02a09ed in mainline for uspace/lib/c/generic/inetcfg.c


Ignore:
Timestamp:
2013-06-28T20:20:03Z (11 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1d24ad3
Parents:
edf0d27
Message:

add basic infrastructure for IPv6 (inactive)
make inet_addr_t a universal address type

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    redf0d27 r02a09ed  
    136136    sysarg_t link_id, sysarg_t *addr_id)
    137137{
    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);
     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        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       
     163        *addr_id = IPC_GET_ARG1(answer);
     164       
     165        return (int) retval;
     166}
     167
     168int inetcfg_addr_delete(sysarg_t addr_id)
     169{
     170        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     171
     172        int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
     173        async_exchange_end(exch);
     174
     175        return rc;
     176}
     177
     178int 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
     230int 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);
    149236        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    150        
    151         async_exchange_end(exch);
    152        
     237
     238        async_exchange_end(exch);
     239
    153240        if (retval != EOK) {
    154241                async_forget(req);
    155242                return retval;
    156243        }
    157        
     244
    158245        async_wait_for(req, &retval);
    159246        *addr_id = IPC_GET_ARG1(answer);
    160        
    161         return (int) retval;
    162 }
    163 
    164 int 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 
    174 int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
     247
     248        return retval;
     249}
     250
     251int 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
     257int 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
     263int 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
     269int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    175270{
    176271        ipc_call_t dreply;
    … …  
    178273        size_t act_size;
    179274        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 
    214 int 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 
    235 int 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 
    241 int 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 
    247 int 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 
    253 int 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];
    259275
    260276        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    … …  
    291307    inet_addr_t *router, sysarg_t *sroute_id)
    292308{
    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);
     309        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     310       
     311        ipc_call_t answer;
     312        aid_t req = async_send_0(exch, INETCFG_SROUTE_CREATE, &answer);
     313       
     314        int rc = async_data_write_start(exch, dest, sizeof(inet_naddr_t));
     315        if (rc != EOK) {
     316                async_exchange_end(exch);
     317                async_forget(req);
     318                return rc;
     319        }
     320       
     321        rc = async_data_write_start(exch, router, sizeof(inet_addr_t));
     322        if (rc != EOK) {
     323                async_exchange_end(exch);
     324                async_forget(req);
     325                return rc;
     326        }
     327       
     328        rc = async_data_write_start(exch, name, str_size(name));
     329       
     330        async_exchange_end(exch);
     331       
     332        if (rc != EOK) {
     333                async_forget(req);
     334                return rc;
     335        }
     336       
     337        sysarg_t retval;
     338        async_wait_for(req, &retval);
     339       
    320340        *sroute_id = IPC_GET_ARG1(answer);
    321341       
    322         return retval;
     342        return (int) retval;
    323343}
    324344
    … …  
    335355int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
    336356{
    337         ipc_call_t dreply;
    338         sysarg_t dretval;
    339         size_t act_size;
     357        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     358       
     359        ipc_call_t answer;
     360        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
     361       
     362        ipc_call_t answer_dest;
     363        aid_t req_dest = async_data_read(exch, &srinfo->dest,
     364            sizeof(inet_naddr_t), &answer_dest);
     365       
     366        sysarg_t retval_dest;
     367        async_wait_for(req_dest, &retval_dest);
     368       
     369        if (retval_dest != EOK) {
     370                async_exchange_end(exch);
     371                async_forget(req);
     372                return (int) retval_dest;
     373        }
     374       
     375        ipc_call_t answer_router;
     376        aid_t req_router = async_data_read(exch, &srinfo->router,
     377            sizeof(inet_addr_t), &answer_router);
     378       
     379        sysarg_t retval_router;
     380        async_wait_for(req_router, &retval_router);
     381       
     382        if (retval_router != EOK) {
     383                async_exchange_end(exch);
     384                async_forget(req);
     385                return (int) retval_router;
     386        }
     387       
     388        ipc_call_t answer_name;
    340389        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;
     390        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
     391            &answer_name);
     392       
     393        async_exchange_end(exch);
     394       
     395        sysarg_t retval_name;
     396        async_wait_for(req_name, &retval_name);
     397       
     398        if (retval_name != EOK) {
     399                async_forget(req);
     400                return (int) retval_name;
    354401        }
    355402       
    … …  
    360407                return (int) retval;
    361408       
    362         act_size = IPC_GET_ARG2(dreply);
     409        size_t act_size = IPC_GET_ARG2(answer_name);
    363410        assert(act_size <= LOC_NAME_MAXLEN);
     411       
    364412        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);
     413       
    369414        srinfo->name = str_dup(name_buf);
    370415       
Note: See TracChangeset for help on using the changeset viewer.