Changeset 02a09ed in mainline for uspace/srv/net/inetsrv/inetcfg.c


Ignore:
Timestamp:
2013-06-28T20:20:03Z (12 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/srv/net/inetsrv/inetcfg.c

    redf0d27 r02a09ed  
    236236}
    237237
    238 static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
    239     ipc_call_t *call)
    240 {
     238static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
     239    ipc_call_t *icall)
     240{
     241        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
     242       
     243        sysarg_t link_id = IPC_GET_ARG1(*icall);
     244       
     245        ipc_callid_t callid;
     246        size_t size;
     247        if (!async_data_write_receive(&callid, &size)) {
     248                async_answer_0(callid, EINVAL);
     249                async_answer_0(iid, EINVAL);
     250                return;
     251        }
     252       
     253        if (size != sizeof(inet_naddr_t)) {
     254                async_answer_0(callid, EINVAL);
     255                async_answer_0(iid, EINVAL);
     256                return;
     257        }
     258       
     259        inet_naddr_t naddr;
     260        int rc = async_data_write_finalize(callid, &naddr, size);
     261        if (rc != EOK) {
     262                async_answer_0(callid, rc);
     263                async_answer_0(iid, rc);
     264                return;
     265        }
     266       
    241267        char *name;
    242         inet_naddr_t naddr;
    243         sysarg_t link_id;
    244         sysarg_t addr_id;
    245         int rc;
    246 
    247         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    248 
    249268        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    250269            0, NULL);
    251270        if (rc != EOK) {
    252                 async_answer_0(callid, rc);
    253                 return;
    254         }
    255 
    256         inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &naddr);
    257         link_id = IPC_GET_ARG3(*call);
    258 
    259         addr_id = 0;
     271                async_answer_0(iid, rc);
     272                return;
     273        }
     274       
     275        sysarg_t addr_id = 0;
    260276        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    261277        free(name);
    262         async_answer_1(callid, rc, addr_id);
     278        async_answer_1(iid, rc, addr_id);
    263279}
    264280
    … …  
    276292}
    277293
    278 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
     294static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
    279295{
    280296        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    281297       
    282         sysarg_t addr_id = IPC_GET_ARG1(*call);
     298        sysarg_t addr_id = IPC_GET_ARG1(*icall);
    283299       
    284300        inet_addr_info_t ainfo;
    … …  
    288304        ainfo.name = NULL;
    289305       
    290         ipc_callid_t rcallid;
    291         size_t max_size;
    292        
    293         if (!async_data_read_receive(&rcallid, &max_size)) {
    294                 async_answer_0(rcallid, EREFUSED);
    295                 async_answer_0(callid, EREFUSED);
    296                 return;
    297         }
    298        
    299306        int rc = inetcfg_addr_get(addr_id, &ainfo);
    300307        if (rc != EOK) {
    301                 async_answer_0(callid, rc);
    302                 return;
    303         }
    304        
    305         uint32_t naddr_addr;
    306         uint8_t naddr_bits;
    307         rc = inet_naddr_pack(&ainfo.naddr, &naddr_addr, &naddr_bits);
    308         if (rc != EOK) {
    309                 async_answer_0(callid, rc);
    310                 return;
    311         }
    312        
    313         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    314             min(max_size, str_size(ainfo.name)));
     308                async_answer_0(iid, rc);
     309                return;
     310        }
     311       
     312        ipc_callid_t callid;
     313        size_t size;
     314        if (!async_data_read_receive(&callid, &size)) {
     315                async_answer_0(callid, EREFUSED);
     316                async_answer_0(iid, EREFUSED);
     317                return;
     318        }
     319       
     320        if (size != sizeof(inet_naddr_t)) {
     321                async_answer_0(callid, EINVAL);
     322                async_answer_0(iid, EINVAL);
     323                return;
     324        }
     325       
     326        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
     327        if (rc != EOK) {
     328                async_answer_0(callid, rc);
     329                async_answer_0(iid, rc);
     330                return;
     331        }
     332       
     333        if (!async_data_read_receive(&callid, &size)) {
     334                async_answer_0(callid, EREFUSED);
     335                async_answer_0(iid, EREFUSED);
     336                return;
     337        }
     338       
     339        rc = async_data_read_finalize(callid, ainfo.name,
     340            min(size, str_size(ainfo.name)));
    315341        free(ainfo.name);
    316342       
    317         async_answer_3(callid, retval, (sysarg_t) naddr_addr,
    318             (sysarg_t) naddr_bits, ainfo.ilink);
     343        if (rc != EOK) {
     344                async_answer_0(callid, rc);
     345                async_answer_0(iid, rc);
     346                return;
     347        }
     348       
     349        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
    319350}
    320351
    … …  
    477508}
    478509
    479 static void inetcfg_sroute_create_srv(ipc_callid_t callid,
    480     ipc_call_t *call)
     510static void inetcfg_sroute_create_srv(ipc_callid_t iid,
     511    ipc_call_t *icall)
    481512{
    482513        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     514
     515        ipc_callid_t callid;
     516        size_t size;
     517        if (!async_data_write_receive(&callid, &size)) {
     518                async_answer_0(callid, EINVAL);
     519                async_answer_0(iid, EINVAL);
     520                return;
     521        }
     522       
     523        if (size != sizeof(inet_naddr_t)) {
     524                async_answer_0(callid, EINVAL);
     525                async_answer_0(iid, EINVAL);
     526                return;
     527        }
     528       
     529        inet_naddr_t dest;
     530        int rc = async_data_write_finalize(callid, &dest, size);
     531        if (rc != EOK) {
     532                async_answer_0(callid, rc);
     533                async_answer_0(iid, rc);
     534                return;
     535        }
     536       
     537        if (!async_data_write_receive(&callid, &size)) {
     538                async_answer_0(callid, EINVAL);
     539                async_answer_0(iid, EINVAL);
     540                return;
     541        }
     542       
     543        if (size != sizeof(inet_addr_t)) {
     544                async_answer_0(callid, EINVAL);
     545                async_answer_0(iid, EINVAL);
     546                return;
     547        }
     548       
     549        inet_addr_t router;
     550        rc = async_data_write_finalize(callid, &router, size);
     551        if (rc != EOK) {
     552                async_answer_0(callid, rc);
     553                async_answer_0(iid, rc);
     554                return;
     555        }
    483556       
    484557        char *name;
    485         int rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
     558        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    486559            0, NULL);
    487560        if (rc != EOK) {
    488                 async_answer_0(callid, rc);
    489                 return;
    490         }
    491        
    492         inet_naddr_t dest;
    493         inet_addr_t router;
    494        
    495         inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &dest);
    496         inet_addr_unpack(IPC_GET_ARG3(*call), &router);
     561                async_answer_0(iid, rc);
     562                return;
     563        }
    497564       
    498565        sysarg_t sroute_id = 0;
    499566        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    500567        free(name);
    501         async_answer_1(callid, rc, sroute_id);
     568        async_answer_1(iid, rc, sroute_id);
    502569}
    503570
    … …  
    515582}
    516583
    517 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
     584static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
    518585{
    519586        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    520587       
    521         sysarg_t sroute_id = IPC_GET_ARG1(*call);
     588        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
    522589       
    523590        inet_sroute_info_t srinfo;
    … …  
    527594        srinfo.name = NULL;
    528595       
    529         ipc_callid_t rcallid;
    530         size_t max_size;
    531         if (!async_data_read_receive(&rcallid, &max_size)) {
    532                 async_answer_0(rcallid, EREFUSED);
    533                 async_answer_0(callid, EREFUSED);
    534                 return;
    535         }
    536        
    537596        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
    538597        if (rc != EOK) {
    539                 async_answer_0(callid, rc);
    540                 return;
    541         }
    542        
    543         uint32_t dest_addr;
    544         uint8_t dest_bits;
    545         rc = inet_naddr_pack(&srinfo.dest, &dest_addr, &dest_bits);
    546         if (rc != EOK) {
    547                 async_answer_0(callid, rc);
    548                 return;
    549         }
    550        
    551         uint32_t router_addr;
    552         rc = inet_addr_pack(&srinfo.router, &router_addr);
    553         if (rc != EOK) {
    554                 async_answer_0(callid, rc);
    555                 return;
    556         }
    557        
    558         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    559             min(max_size, str_size(srinfo.name)));
     598                async_answer_0(iid, rc);
     599                return;
     600        }
     601       
     602        ipc_callid_t callid;
     603        size_t size;
     604        if (!async_data_read_receive(&callid, &size)) {
     605                async_answer_0(callid, EREFUSED);
     606                async_answer_0(iid, EREFUSED);
     607                return;
     608        }
     609       
     610        if (size != sizeof(inet_naddr_t)) {
     611                async_answer_0(callid, EINVAL);
     612                async_answer_0(iid, EINVAL);
     613                return;
     614        }
     615       
     616        rc = async_data_read_finalize(callid, &srinfo.dest, size);
     617        if (rc != EOK) {
     618                async_answer_0(callid, rc);
     619                async_answer_0(iid, rc);
     620                return;
     621        }
     622       
     623        if (!async_data_read_receive(&callid, &size)) {
     624                async_answer_0(callid, EREFUSED);
     625                async_answer_0(iid, EREFUSED);
     626                return;
     627        }
     628       
     629        if (size != sizeof(inet_addr_t)) {
     630                async_answer_0(callid, EINVAL);
     631                async_answer_0(iid, EINVAL);
     632                return;
     633        }
     634       
     635        rc = async_data_read_finalize(callid, &srinfo.router, size);
     636        if (rc != EOK) {
     637                async_answer_0(callid, rc);
     638                async_answer_0(iid, rc);
     639                return;
     640        }
     641       
     642        if (!async_data_read_receive(&callid, &size)) {
     643                async_answer_0(callid, EREFUSED);
     644                async_answer_0(iid, EREFUSED);
     645                return;
     646        }
     647       
     648        rc = async_data_read_finalize(callid, srinfo.name,
     649            min(size, str_size(srinfo.name)));
    560650        free(srinfo.name);
    561651       
    562         async_answer_3(callid, retval, (sysarg_t) dest_addr,
    563             (sysarg_t) dest_bits, (sysarg_t) router_addr);
     652        async_answer_0(iid, (sysarg_t) rc);
    564653}
    565654
Note: See TracChangeset for help on using the changeset viewer.