Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/iplink_srv.c

    r417a2ba1 r4802dd7  
    3434 * @brief IP link server stub
    3535 */
    36 
    3736#include <errno.h>
    3837#include <ipc/iplink.h>
    3938#include <stdlib.h>
    4039#include <sys/types.h>
    41 #include <inet/addr.h>
     40
    4241#include <inet/iplink_srv.h>
    4342
    … …  
    4544    ipc_call_t *call)
    4645{
     46        int rc;
    4747        size_t mtu;
    48         int rc = srv->ops->get_mtu(srv, &mtu);
     48
     49        rc = srv->ops->get_mtu(srv, &mtu);
    4950        async_answer_1(callid, rc, mtu);
    5051}
    5152
    52 static void iplink_get_mac48_srv(iplink_srv_t *srv, ipc_callid_t iid,
    53     ipc_call_t *icall)
     53static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t callid,
     54    ipc_call_t *call)
    5455{
    55         addr48_t mac;
    56         int rc = srv->ops->get_mac48(srv, &mac);
     56        int rc;
     57        iplink_srv_addr_t addr;
     58
     59        addr.ipv4 = IPC_GET_ARG1(*call);
     60
     61        rc = srv->ops->addr_add(srv, &addr);
     62        async_answer_0(callid, rc);
     63}
     64
     65static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t callid,
     66    ipc_call_t *call)
     67{
     68        int rc;
     69        iplink_srv_addr_t addr;
     70
     71        addr.ipv4 = IPC_GET_ARG1(*call);
     72
     73        rc = srv->ops->addr_remove(srv, &addr);
     74        async_answer_0(callid, rc);
     75}
     76
     77static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t callid,
     78    ipc_call_t *call)
     79{
     80        iplink_srv_sdu_t sdu;
     81        int rc;
     82
     83        sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
     84        sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
     85
     86        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    5787        if (rc != EOK) {
    58                 async_answer_0(iid, rc);
     88                async_answer_0(callid, rc);
    5989                return;
    6090        }
    61        
    62         ipc_callid_t callid;
    63         size_t size;
    64         if (!async_data_read_receive(&callid, &size)) {
    65                 async_answer_0(callid, EREFUSED);
    66                 async_answer_0(iid, EREFUSED);
    67                 return;
    68         }
    69        
    70         if (size != sizeof(addr48_t)) {
    71                 async_answer_0(callid, EINVAL);
    72                 async_answer_0(iid, EINVAL);
    73                 return;
    74         }
    75        
    76         rc = async_data_read_finalize(callid, &mac, size);
    77         if (rc != EOK)
    78                 async_answer_0(callid, rc);
    79        
    80         async_answer_0(iid, (sysarg_t) rc);
    81 }
    8291
    83 static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t iid,
    84     ipc_call_t *icall)
    85 {
    86         ipc_callid_t callid;
    87         size_t size;
    88         if (!async_data_write_receive(&callid, &size)) {
    89                 async_answer_0(callid, EREFUSED);
    90                 async_answer_0(iid, EREFUSED);
    91                 return;
    92         }
    93        
    94         if (size != sizeof(inet_addr_t)) {
    95                 async_answer_0(callid, EINVAL);
    96                 async_answer_0(iid, EINVAL);
    97                 return;
    98         }
    99        
    100         inet_addr_t addr;
    101         int rc = async_data_write_finalize(callid, &addr, size);
    102         if (rc != EOK) {
    103                 async_answer_0(callid, (sysarg_t) rc);
    104                 async_answer_0(iid, (sysarg_t) rc);
    105         }
    106        
    107         rc = srv->ops->addr_add(srv, &addr);
    108         async_answer_0(iid, (sysarg_t) rc);
    109 }
    110 
    111 static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t iid,
    112     ipc_call_t *icall)
    113 {
    114         ipc_callid_t callid;
    115         size_t size;
    116         if (!async_data_write_receive(&callid, &size)) {
    117                 async_answer_0(callid, EREFUSED);
    118                 async_answer_0(iid, EREFUSED);
    119                 return;
    120         }
    121        
    122         if (size != sizeof(inet_addr_t)) {
    123                 async_answer_0(callid, EINVAL);
    124                 async_answer_0(iid, EINVAL);
    125                 return;
    126         }
    127        
    128         inet_addr_t addr;
    129         int rc = async_data_write_finalize(callid, &addr, size);
    130         if (rc != EOK) {
    131                 async_answer_0(callid, (sysarg_t) rc);
    132                 async_answer_0(iid, (sysarg_t) rc);
    133         }
    134        
    135         rc = srv->ops->addr_remove(srv, &addr);
    136         async_answer_0(iid, (sysarg_t) rc);
    137 }
    138 
    139 static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t iid,
    140     ipc_call_t *icall)
    141 {
    142         iplink_sdu_t sdu;
    143        
    144         sdu.src = IPC_GET_ARG1(*icall);
    145         sdu.dest = IPC_GET_ARG2(*icall);
    146        
    147         int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
    148             &sdu.size);
    149         if (rc != EOK) {
    150                 async_answer_0(iid, rc);
    151                 return;
    152         }
    153        
    15492        rc = srv->ops->send(srv, &sdu);
    15593        free(sdu.data);
    156         async_answer_0(iid, rc);
    157 }
    158 
    159 static void iplink_send6_srv(iplink_srv_t *srv, ipc_callid_t iid,
    160     ipc_call_t *icall)
    161 {
    162         iplink_sdu6_t sdu;
    163        
    164         ipc_callid_t callid;
    165         size_t size;
    166         if (!async_data_write_receive(&callid, &size)) {
    167                 async_answer_0(callid, EREFUSED);
    168                 async_answer_0(iid, EREFUSED);
    169                 return;
    170         }
    171        
    172         if (size != sizeof(addr48_t)) {
    173                 async_answer_0(callid, EINVAL);
    174                 async_answer_0(iid, EINVAL);
    175                 return;
    176         }
    177        
    178         int rc = async_data_write_finalize(callid, &sdu.dest, size);
    179         if (rc != EOK) {
    180                 async_answer_0(callid, (sysarg_t) rc);
    181                 async_answer_0(iid, (sysarg_t) rc);
    182         }
    183        
    184         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
    185             &sdu.size);
    186         if (rc != EOK) {
    187                 async_answer_0(iid, rc);
    188                 return;
    189         }
    190        
    191         rc = srv->ops->send6(srv, &sdu);
    192         free(sdu.data);
    193         async_answer_0(iid, rc);
     94        async_answer_0(callid, rc);
    19495}
    19596
    … …  
    205106int iplink_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    206107{
    207         iplink_srv_t *srv = (iplink_srv_t *) arg;
     108        iplink_srv_t *srv = (iplink_srv_t *)arg;
    208109        int rc;
    209        
     110
    210111        fibril_mutex_lock(&srv->lock);
    211112        if (srv->connected) {
    … …  
    214115                return EBUSY;
    215116        }
    216        
     117
    217118        srv->connected = true;
    218119        fibril_mutex_unlock(&srv->lock);
    219        
     120
    220121        /* Accept the connection */
    221122        async_answer_0(iid, EOK);
    222        
     123
    223124        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    224125        if (sess == NULL)
    225126                return ENOMEM;
    226        
     127
    227128        srv->client_sess = sess;
    228        
     129
    229130        rc = srv->ops->open(srv);
    230131        if (rc != EOK)
    231132                return rc;
    232        
     133
    233134        while (true) {
    234135                ipc_call_t call;
    235136                ipc_callid_t callid = async_get_call(&call);
    236137                sysarg_t method = IPC_GET_IMETHOD(call);
    237                
     138
    238139                if (!method) {
    239140                        /* The other side has hung up */
    240                         fibril_mutex_lock(&srv->lock);
     141                        fibril_mutex_lock(&srv->lock);
    241142                        srv->connected = false;
    242                         fibril_mutex_unlock(&srv->lock);
     143                        fibril_mutex_unlock(&srv->lock);
    243144                        async_answer_0(callid, EOK);
    244145                        break;
    245146                }
    246                
     147
    247148                switch (method) {
    248149                case IPLINK_GET_MTU:
    249150                        iplink_get_mtu_srv(srv, callid, &call);
    250151                        break;
    251                 case IPLINK_GET_MAC48:
    252                         iplink_get_mac48_srv(srv, callid, &call);
    253                         break;
    254152                case IPLINK_SEND:
    255153                        iplink_send_srv(srv, callid, &call);
    256                         break;
    257                 case IPLINK_SEND6:
    258                         iplink_send6_srv(srv, callid, &call);
    259154                        break;
    260155                case IPLINK_ADDR_ADD:
    … …  
    268163                }
    269164        }
    270        
     165
    271166        return srv->ops->close(srv);
    272167}
    273168
    274 /* XXX Version should be part of @a sdu */
    275 int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, ip_ver_t ver)
     169int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
    276170{
    277171        if (srv->client_sess == NULL)
    278172                return EIO;
    279        
     173
    280174        async_exch_t *exch = async_exchange_begin(srv->client_sess);
    281        
     175
    282176        ipc_call_t answer;
    283         aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t)ver,
    284             &answer);
    285        
     177        aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
     178            sdu->ldest.ipv4, &answer);
    286179        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    287180        async_exchange_end(exch);
    288        
     181
    289182        if (rc != EOK) {
    290183                async_forget(req);
    291184                return rc;
    292185        }
    293        
     186
    294187        sysarg_t retval;
    295188        async_wait_for(req, &retval);
    296189        if (retval != EOK)
    297190                return retval;
    298        
     191
    299192        return EOK;
    300193}
Note: See TracChangeset for help on using the changeset viewer.