Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/inetsrv/inetcfg.c

    ra1a101d rbd88bee  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4444#include <str.h>
    4545#include <sys/types.h>
     46#include <types/inetcfg.h>
    4647
    4748#include "addrobj.h"
    … …  
    5657        inet_link_t *ilink;
    5758        inet_addrobj_t *addr;
    58         iplink_addr_t iaddr;
     59        inet_addr_t iaddr;
    5960        int rc;
    6061
    … …  
    8283        }
    8384
    84         iaddr.ipv4 = addr->naddr.ipv4;
     85        inet_naddr_addr(&addr->naddr, &iaddr);
    8586        rc = iplink_addr_add(ilink->iplink, &iaddr);
    8687        if (rc != EOK) {
    … …  
    151152static int inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
    152153{
    153         return ENOTSUP;
     154        return inet_link_get_id_list(addrs, count);
    154155}
    155156
    … …  
    157158{
    158159        return inet_sroute_get_id_list(sroutes, count);
     160}
     161
     162static int inetcfg_link_add(sysarg_t link_id)
     163{
     164        return inet_link_open(link_id);
    159165}
    160166
    … …  
    170176        linfo->name = str_dup(ilink->svc_name);
    171177        linfo->def_mtu = ilink->def_mtu;
     178        if (ilink->mac_valid) {
     179                addr48(ilink->mac, linfo->mac_addr);
     180        } else {
     181                memset(linfo->mac_addr, 0, sizeof(linfo->mac_addr));
     182        }
     183
    172184        return EOK;
     185}
     186
     187static int inetcfg_link_remove(sysarg_t link_id)
     188{
     189        return ENOTSUP;
    173190}
    174191
    … …  
    236253}
    237254
    238 static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
    239     ipc_call_t *call)
    240 {
     255static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
     256    ipc_call_t *icall)
     257{
     258        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
     259       
     260        sysarg_t link_id = IPC_GET_ARG1(*icall);
     261       
     262        ipc_callid_t callid;
     263        size_t size;
     264        if (!async_data_write_receive(&callid, &size)) {
     265                async_answer_0(callid, EINVAL);
     266                async_answer_0(iid, EINVAL);
     267                return;
     268        }
     269       
     270        if (size != sizeof(inet_naddr_t)) {
     271                async_answer_0(callid, EINVAL);
     272                async_answer_0(iid, EINVAL);
     273                return;
     274        }
     275       
     276        inet_naddr_t naddr;
     277        int rc = async_data_write_finalize(callid, &naddr, size);
     278        if (rc != EOK) {
     279                async_answer_0(callid, rc);
     280                async_answer_0(iid, rc);
     281                return;
     282        }
     283       
    241284        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 
    249285        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    250286            0, NULL);
    251287        if (rc != EOK) {
    252                 async_answer_0(callid, rc);
    253                 return;
    254         }
    255 
    256         naddr.ipv4 = IPC_GET_ARG1(*call);
    257         naddr.bits = IPC_GET_ARG2(*call);
    258         link_id    = IPC_GET_ARG3(*call);
    259 
    260         addr_id = 0;
     288                async_answer_0(iid, rc);
     289                return;
     290        }
     291       
     292        sysarg_t addr_id = 0;
    261293        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    262294        free(name);
    263         async_answer_1(callid, rc, addr_id);
     295        async_answer_1(iid, rc, addr_id);
    264296}
    265297
    … …  
    277309}
    278310
    279 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
    280 {
    281         ipc_callid_t rcallid;
    282         size_t max_size;
    283 
    284         sysarg_t addr_id;
     311static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     312{
     313        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
     314       
     315        sysarg_t addr_id = IPC_GET_ARG1(*icall);
     316       
    285317        inet_addr_info_t ainfo;
    286         int rc;
    287 
    288         addr_id = IPC_GET_ARG1(*call);
    289         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    290 
    291         ainfo.naddr.ipv4 = 0;
    292         ainfo.naddr.bits = 0;
     318       
     319        inet_naddr_any(&ainfo.naddr);
    293320        ainfo.ilink = 0;
    294321        ainfo.name = NULL;
    295 
    296         if (!async_data_read_receive(&rcallid, &max_size)) {
    297                 async_answer_0(rcallid, EREFUSED);
    298                 async_answer_0(callid, EREFUSED);
    299                 return;
    300         }
    301 
    302         rc = inetcfg_addr_get(addr_id, &ainfo);
    303         if (rc != EOK) {
    304                 async_answer_0(callid, rc);
    305                 return;
    306         }
    307 
    308         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    309             min(max_size, str_size(ainfo.name)));
     322       
     323        int rc = inetcfg_addr_get(addr_id, &ainfo);
     324        if (rc != EOK) {
     325                async_answer_0(iid, rc);
     326                return;
     327        }
     328       
     329        ipc_callid_t callid;
     330        size_t size;
     331        if (!async_data_read_receive(&callid, &size)) {
     332                async_answer_0(callid, EREFUSED);
     333                async_answer_0(iid, EREFUSED);
     334                return;
     335        }
     336       
     337        if (size != sizeof(inet_naddr_t)) {
     338                async_answer_0(callid, EINVAL);
     339                async_answer_0(iid, EINVAL);
     340                return;
     341        }
     342       
     343        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
     344        if (rc != EOK) {
     345                async_answer_0(callid, rc);
     346                async_answer_0(iid, rc);
     347                return;
     348        }
     349       
     350        if (!async_data_read_receive(&callid, &size)) {
     351                async_answer_0(callid, EREFUSED);
     352                async_answer_0(iid, EREFUSED);
     353                return;
     354        }
     355       
     356        rc = async_data_read_finalize(callid, ainfo.name,
     357            min(size, str_size(ainfo.name)));
    310358        free(ainfo.name);
    311 
    312         async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
    313             ainfo.ilink);
     359       
     360        if (rc != EOK) {
     361                async_answer_0(callid, rc);
     362                async_answer_0(iid, rc);
     363                return;
     364        }
     365       
     366        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
    314367}
    315368
    … …  
    372425}
    373426
    374 
    375427static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    376 {
    377         ipc_callid_t rcallid;
    378         size_t max_size;
    379         size_t act_size;
    380         size_t size;
    381         sysarg_t *id_buf;
    382         int rc;
    383 
    384         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_link_list_srv()");
    385 
    386         if (!async_data_read_receive(&rcallid, &max_size)) {
    387                 async_answer_0(rcallid, EREFUSED);
    388                 async_answer_0(callid, EREFUSED);
    389                 return;
    390         }
    391 
    392         rc = inetcfg_get_link_list(&id_buf, &act_size);
    393         if (rc != EOK) {
    394                 async_answer_0(rcallid, rc);
    395                 async_answer_0(callid, rc);
    396                 return;
    397         }
    398 
    399         size = min(act_size, max_size);
    400 
    401         sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
    402         free(id_buf);
    403 
    404         async_answer_1(callid, retval, act_size);
    405 }
    406 
    407 static void inetcfg_get_sroute_list_srv(ipc_callid_t callid, ipc_call_t *call)
    408428{
    409429        ipc_callid_t rcallid;
    … …  
    415435        int rc;
    416436
    417         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
     437        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    418438
    419439        if (!async_data_read_receive(&rcallid, &max_size)) {
    … …  
    423443        }
    424444
    425         rc = inetcfg_get_sroute_list(&id_buf, &count);
     445        rc = inetcfg_get_link_list(&id_buf, &count);
    426446        if (rc != EOK) {
    427447                async_answer_0(rcallid, rc);
    … …  
    439459}
    440460
     461static void inetcfg_get_sroute_list_srv(ipc_callid_t callid, ipc_call_t *call)
     462{
     463        ipc_callid_t rcallid;
     464        size_t count;
     465        size_t max_size;
     466        size_t act_size;
     467        size_t size;
     468        sysarg_t *id_buf;
     469        int rc;
     470
     471        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
     472
     473        if (!async_data_read_receive(&rcallid, &max_size)) {
     474                async_answer_0(rcallid, EREFUSED);
     475                async_answer_0(callid, EREFUSED);
     476                return;
     477        }
     478
     479        rc = inetcfg_get_sroute_list(&id_buf, &count);
     480        if (rc != EOK) {
     481                async_answer_0(rcallid, rc);
     482                async_answer_0(callid, rc);
     483                return;
     484        }
     485
     486        act_size = count * sizeof(sysarg_t);
     487        size = min(act_size, max_size);
     488
     489        sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
     490        free(id_buf);
     491
     492        async_answer_1(callid, retval, act_size);
     493}
     494
     495static void inetcfg_link_add_srv(ipc_callid_t callid, ipc_call_t *call)
     496{
     497        sysarg_t link_id;
     498        int rc;
     499
     500        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_add_srv()");
     501
     502        link_id = IPC_GET_ARG1(*call);
     503
     504        rc = inetcfg_link_add(link_id);
     505        async_answer_0(callid, rc);
     506}
     507
    441508static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call)
    442509{
    443         ipc_callid_t rcallid;
    444         size_t max_size;
     510        ipc_callid_t name_callid;
     511        ipc_callid_t laddr_callid;
     512        size_t name_max_size;
     513        size_t laddr_max_size;
    445514
    446515        sysarg_t link_id;
    … …  
    453522        linfo.name = NULL;
    454523
    455         if (!async_data_read_receive(&rcallid, &max_size)) {
    456                 async_answer_0(rcallid, EREFUSED);
     524        if (!async_data_read_receive(&name_callid, &name_max_size)) {
     525                async_answer_0(name_callid, EREFUSED);
     526                async_answer_0(callid, EREFUSED);
     527                return;
     528        }
     529
     530        if (!async_data_read_receive(&laddr_callid, &laddr_max_size)) {
     531                async_answer_0(name_callid, EREFUSED);
    457532                async_answer_0(callid, EREFUSED);
    458533                return;
    … …  
    461536        rc = inetcfg_link_get(link_id, &linfo);
    462537        if (rc != EOK) {
    463                 async_answer_0(rcallid, rc);
    464                 async_answer_0(callid, rc);
    465                 return;
    466         }
    467 
    468         sysarg_t retval = async_data_read_finalize(rcallid, linfo.name,
    469             min(max_size, str_size(linfo.name)));
     538                async_answer_0(laddr_callid, rc);
     539                async_answer_0(name_callid, rc);
     540                async_answer_0(callid, rc);
     541                return;
     542        }
     543
     544        sysarg_t retval = async_data_read_finalize(name_callid, linfo.name,
     545            min(name_max_size, str_size(linfo.name)));
     546        if (retval != EOK) {
     547                free(linfo.name);
     548                async_answer_0(laddr_callid, retval);
     549                async_answer_0(callid, retval);
     550                return;
     551        }
     552
     553        retval = async_data_read_finalize(laddr_callid, &linfo.mac_addr,
     554            min(laddr_max_size, sizeof(linfo.mac_addr)));
     555
    470556        free(linfo.name);
    471557
    … …  
    473559}
    474560
    475 static void inetcfg_sroute_create_srv(ipc_callid_t callid,
    476     ipc_call_t *call)
    477 {
     561static void inetcfg_link_remove_srv(ipc_callid_t callid, ipc_call_t *call)
     562{
     563        sysarg_t link_id;
     564        int rc;
     565
     566        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_remove_srv()");
     567
     568        link_id = IPC_GET_ARG1(*call);
     569
     570        rc = inetcfg_link_remove(link_id);
     571        async_answer_0(callid, rc);
     572}
     573
     574static void inetcfg_sroute_create_srv(ipc_callid_t iid,
     575    ipc_call_t *icall)
     576{
     577        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     578
     579        ipc_callid_t callid;
     580        size_t size;
     581        if (!async_data_write_receive(&callid, &size)) {
     582                async_answer_0(callid, EINVAL);
     583                async_answer_0(iid, EINVAL);
     584                return;
     585        }
     586       
     587        if (size != sizeof(inet_naddr_t)) {
     588                async_answer_0(callid, EINVAL);
     589                async_answer_0(iid, EINVAL);
     590                return;
     591        }
     592       
     593        inet_naddr_t dest;
     594        int rc = async_data_write_finalize(callid, &dest, size);
     595        if (rc != EOK) {
     596                async_answer_0(callid, rc);
     597                async_answer_0(iid, rc);
     598                return;
     599        }
     600       
     601        if (!async_data_write_receive(&callid, &size)) {
     602                async_answer_0(callid, EINVAL);
     603                async_answer_0(iid, EINVAL);
     604                return;
     605        }
     606       
     607        if (size != sizeof(inet_addr_t)) {
     608                async_answer_0(callid, EINVAL);
     609                async_answer_0(iid, EINVAL);
     610                return;
     611        }
     612       
     613        inet_addr_t router;
     614        rc = async_data_write_finalize(callid, &router, size);
     615        if (rc != EOK) {
     616                async_answer_0(callid, rc);
     617                async_answer_0(iid, rc);
     618                return;
     619        }
     620       
    478621        char *name;
    479         inet_naddr_t dest;
    480         inet_addr_t router;
    481         sysarg_t sroute_id;
    482         int rc;
    483 
    484         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
    485 
    486622        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    487623            0, NULL);
    488624        if (rc != EOK) {
    489                 async_answer_0(callid, rc);
    490                 return;
    491         }
    492 
    493         dest.ipv4   = IPC_GET_ARG1(*call);
    494         dest.bits   = IPC_GET_ARG2(*call);
    495         router.ipv4 = IPC_GET_ARG3(*call);
    496 
    497         sroute_id = 0;
     625                async_answer_0(iid, rc);
     626                return;
     627        }
     628       
     629        sysarg_t sroute_id = 0;
    498630        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    499631        free(name);
    500         async_answer_1(callid, rc, sroute_id);
     632        async_answer_1(iid, rc, sroute_id);
    501633}
    502634
    … …  
    514646}
    515647
    516 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
    517 {
    518         ipc_callid_t rcallid;
    519         size_t max_size;
    520 
    521         sysarg_t sroute_id;
     648static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     649{
     650        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
     651       
     652        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
     653       
    522654        inet_sroute_info_t srinfo;
    523         int rc;
    524 
    525         sroute_id = IPC_GET_ARG1(*call);
    526         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    527 
    528         srinfo.dest.ipv4 = 0;
    529         srinfo.dest.bits = 0;
    530         srinfo.router.ipv4 = 0;
     655       
     656        inet_naddr_any(&srinfo.dest);
     657        inet_addr_any(&srinfo.router);
    531658        srinfo.name = NULL;
    532 
    533         if (!async_data_read_receive(&rcallid, &max_size)) {
    534                 async_answer_0(rcallid, EREFUSED);
    535                 async_answer_0(callid, EREFUSED);
    536                 return;
    537         }
    538 
    539         rc = inetcfg_sroute_get(sroute_id, &srinfo);
    540         if (rc != EOK) {
    541                 async_answer_0(callid, rc);
    542                 return;
    543         }
    544 
    545         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    546             min(max_size, str_size(srinfo.name)));
     659       
     660        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
     661        if (rc != EOK) {
     662                async_answer_0(iid, rc);
     663                return;
     664        }
     665       
     666        ipc_callid_t callid;
     667        size_t size;
     668        if (!async_data_read_receive(&callid, &size)) {
     669                async_answer_0(callid, EREFUSED);
     670                async_answer_0(iid, EREFUSED);
     671                return;
     672        }
     673       
     674        if (size != sizeof(inet_naddr_t)) {
     675                async_answer_0(callid, EINVAL);
     676                async_answer_0(iid, EINVAL);
     677                return;
     678        }
     679       
     680        rc = async_data_read_finalize(callid, &srinfo.dest, size);
     681        if (rc != EOK) {
     682                async_answer_0(callid, rc);
     683                async_answer_0(iid, rc);
     684                return;
     685        }
     686       
     687        if (!async_data_read_receive(&callid, &size)) {
     688                async_answer_0(callid, EREFUSED);
     689                async_answer_0(iid, EREFUSED);
     690                return;
     691        }
     692       
     693        if (size != sizeof(inet_addr_t)) {
     694                async_answer_0(callid, EINVAL);
     695                async_answer_0(iid, EINVAL);
     696                return;
     697        }
     698       
     699        rc = async_data_read_finalize(callid, &srinfo.router, size);
     700        if (rc != EOK) {
     701                async_answer_0(callid, rc);
     702                async_answer_0(iid, rc);
     703                return;
     704        }
     705       
     706        if (!async_data_read_receive(&callid, &size)) {
     707                async_answer_0(callid, EREFUSED);
     708                async_answer_0(iid, EREFUSED);
     709                return;
     710        }
     711       
     712        rc = async_data_read_finalize(callid, srinfo.name,
     713            min(size, str_size(srinfo.name)));
    547714        free(srinfo.name);
    548 
    549         async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits,
    550             srinfo.router.ipv4);
     715       
     716        async_answer_0(iid, (sysarg_t) rc);
    551717}
    552718
    … …  
    584750                sysarg_t method = IPC_GET_IMETHOD(call);
    585751
     752                log_msg(LOG_DEFAULT, LVL_DEBUG, "method %d", (int)method);
    586753                if (!method) {
    587754                        /* The other side has hung up */
    … …  
    612779                        inetcfg_get_sroute_list_srv(callid, &call);
    613780                        break;
     781                case INETCFG_LINK_ADD:
     782                        inetcfg_link_add_srv(callid, &call);
     783                        break;
    614784                case INETCFG_LINK_GET:
    615785                        inetcfg_link_get_srv(callid, &call);
     786                        break;
     787                case INETCFG_LINK_REMOVE:
     788                        inetcfg_link_remove_srv(callid, &call);
    616789                        break;
    617790                case INETCFG_SROUTE_CREATE:
Note: See TracChangeset for help on using the changeset viewer.