Changeset 98abd40 in mainline for uspace/lib/c/generic/iplink_srv.c


Ignore:
Timestamp:
2013-07-06T21:57:22Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c8bb1633, cdc8a391
Parents:
b8e72fd1 (diff), 507c6f3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb8e72fd1 r98abd40  
    3434 * @brief IP link server stub
    3535 */
     36
    3637#include <errno.h>
    3738#include <ipc/iplink.h>
    3839#include <stdlib.h>
    3940#include <sys/types.h>
    40 
     41#include <inet/addr.h>
    4142#include <inet/iplink_srv.h>
    4243
    … …  
    4445    ipc_call_t *call)
    4546{
    46         int rc;
    4747        size_t mtu;
    48 
    49         rc = srv->ops->get_mtu(srv, &mtu);
     48        int rc = srv->ops->get_mtu(srv, &mtu);
    5049        async_answer_1(callid, rc, mtu);
    5150}
    5251
    53 static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t callid,
    54     ipc_call_t *call)
    55 {
    56         int rc;
    57         iplink_srv_addr_t addr;
    58 
    59         addr.ipv4 = IPC_GET_ARG1(*call);
    60 
     52static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t iid,
     53    ipc_call_t *icall)
     54{
     55        ipc_callid_t callid;
     56        size_t size;
     57        if (!async_data_write_receive(&callid, &size)) {
     58                async_answer_0(callid, EREFUSED);
     59                async_answer_0(iid, EREFUSED);
     60                return;
     61        }
     62       
     63        if (size != sizeof(inet_addr_t)) {
     64                async_answer_0(callid, EINVAL);
     65                async_answer_0(iid, EINVAL);
     66                return;
     67        }
     68       
     69        inet_addr_t addr;
     70        int rc = async_data_write_finalize(callid, &addr, size);
     71        if (rc != EOK) {
     72                async_answer_0(callid, (sysarg_t) rc);
     73                async_answer_0(iid, (sysarg_t) rc);
     74        }
     75       
    6176        rc = srv->ops->addr_add(srv, &addr);
    62         async_answer_0(callid, rc);
    63 }
    64 
    65 static 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 
     77        async_answer_0(iid, (sysarg_t) rc);
     78}
     79
     80static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t iid,
     81    ipc_call_t *icall)
     82{
     83        ipc_callid_t callid;
     84        size_t size;
     85        if (!async_data_write_receive(&callid, &size)) {
     86                async_answer_0(callid, EREFUSED);
     87                async_answer_0(iid, EREFUSED);
     88                return;
     89        }
     90       
     91        if (size != sizeof(inet_addr_t)) {
     92                async_answer_0(callid, EINVAL);
     93                async_answer_0(iid, EINVAL);
     94                return;
     95        }
     96       
     97        inet_addr_t addr;
     98        int rc = async_data_write_finalize(callid, &addr, size);
     99        if (rc != EOK) {
     100                async_answer_0(callid, (sysarg_t) rc);
     101                async_answer_0(iid, (sysarg_t) rc);
     102        }
     103       
    73104        rc = srv->ops->addr_remove(srv, &addr);
    74         async_answer_0(callid, rc);
    75 }
    76 
    77 static 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);
    87         if (rc != EOK) {
    88                 async_answer_0(callid, rc);
    89                 return;
    90         }
    91 
     105        async_answer_0(iid, (sysarg_t) rc);
     106}
     107
     108static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t iid,
     109    ipc_call_t *icall)
     110{
     111        iplink_sdu_t sdu;
     112       
     113        ipc_callid_t callid;
     114        size_t size;
     115        if (!async_data_write_receive(&callid, &size)) {
     116                async_answer_0(callid, EREFUSED);
     117                async_answer_0(iid, EREFUSED);
     118                return;
     119        }
     120       
     121        if (size != sizeof(inet_addr_t)) {
     122                async_answer_0(callid, EINVAL);
     123                async_answer_0(iid, EINVAL);
     124                return;
     125        }
     126       
     127        int rc = async_data_write_finalize(callid, &sdu.src, size);
     128        if (rc != EOK) {
     129                async_answer_0(callid, (sysarg_t) rc);
     130                async_answer_0(iid, (sysarg_t) rc);
     131        }
     132       
     133        if (!async_data_write_receive(&callid, &size)) {
     134                async_answer_0(callid, EREFUSED);
     135                async_answer_0(iid, EREFUSED);
     136                return;
     137        }
     138       
     139        if (size != sizeof(inet_addr_t)) {
     140                async_answer_0(callid, EINVAL);
     141                async_answer_0(iid, EINVAL);
     142                return;
     143        }
     144       
     145        rc = async_data_write_finalize(callid, &sdu.dest, size);
     146        if (rc != EOK) {
     147                async_answer_0(callid, (sysarg_t) rc);
     148                async_answer_0(iid, (sysarg_t) rc);
     149        }
     150       
     151        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
     152            &sdu.size);
     153        if (rc != EOK)
     154                return;
     155       
    92156        rc = srv->ops->send(srv, &sdu);
    93157        free(sdu.data);
    94         async_answer_0(callid, rc);
     158        async_answer_0(iid, rc);
    95159}
    96160
    … …  
    108172        iplink_srv_t *srv = (iplink_srv_t *)arg;
    109173        int rc;
    110 
     174       
    111175        fibril_mutex_lock(&srv->lock);
    112176        if (srv->connected) {
    … …  
    115179                return EBUSY;
    116180        }
    117 
     181       
    118182        srv->connected = true;
    119183        fibril_mutex_unlock(&srv->lock);
    120 
     184       
    121185        /* Accept the connection */
    122186        async_answer_0(iid, EOK);
    123 
     187       
    124188        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    125189        if (sess == NULL)
    126190                return ENOMEM;
    127 
     191       
    128192        srv->client_sess = sess;
    129 
     193       
    130194        rc = srv->ops->open(srv);
    131195        if (rc != EOK)
    132196                return rc;
    133 
     197       
    134198        while (true) {
    135199                ipc_call_t call;
    136200                ipc_callid_t callid = async_get_call(&call);
    137201                sysarg_t method = IPC_GET_IMETHOD(call);
    138 
     202               
    139203                if (!method) {
    140204                        /* The other side has hung up */
    141                         fibril_mutex_lock(&srv->lock);
     205                        fibril_mutex_lock(&srv->lock);
    142206                        srv->connected = false;
    143                         fibril_mutex_unlock(&srv->lock);
     207                        fibril_mutex_unlock(&srv->lock);
    144208                        async_answer_0(callid, EOK);
    145209                        break;
    146210                }
    147 
     211               
    148212                switch (method) {
    149213                case IPLINK_GET_MTU:
    … …  
    163227                }
    164228        }
    165 
     229       
    166230        return srv->ops->close(srv);
    167231}
    168232
    169 int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
     233int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
    170234{
    171235        if (srv->client_sess == NULL)
    172236                return EIO;
    173 
     237       
    174238        async_exch_t *exch = async_exchange_begin(srv->client_sess);
    175 
     239       
    176240        ipc_call_t answer;
    177         aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
    178             sdu->ldest.ipv4, &answer);
     241        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
     242            &answer);
     243       
    179244        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    180245        async_exchange_end(exch);
    181 
     246       
    182247        if (rc != EOK) {
    183248                async_forget(req);
    184249                return rc;
    185250        }
    186 
     251       
    187252        sysarg_t retval;
    188253        async_wait_for(req, &retval);
    189254        if (retval != EOK)
    190255                return retval;
    191 
     256       
    192257        return EOK;
    193258}
Note: See TracChangeset for help on using the changeset viewer.