Changeset b5cf742a in mainline for uspace/lib/c


Ignore:
Timestamp:
2013-06-28T16:22:42Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
edf0d27
Parents:
e52b4b5
Message:

cstyle (no change in functionality)

Location:
uspace/lib/c/generic
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/inet.c

    re52b4b5 rb5cf742a  
    169169        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    170170        dgram.tos = IPC_GET_ARG3(*call);
    171 
     171       
    172172        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    173173        if (rc != EOK) {
     
    175175                return;
    176176        }
    177 
     177       
    178178        rc = inet_ev_ops->recv(&dgram);
    179179        async_answer_0(callid, rc);
     
    185185                ipc_call_t call;
    186186                ipc_callid_t callid = async_get_call(&call);
    187 
     187               
    188188                if (!IPC_GET_IMETHOD(call)) {
    189189                        /* TODO: Handle hangup */
    190190                        return;
    191191                }
    192 
     192               
    193193                switch (IPC_GET_IMETHOD(call)) {
    194194                case INET_EV_RECV:
  • uspace/lib/c/generic/inetcfg.c

    re52b4b5 rb5cf742a  
    159159        *addr_id = IPC_GET_ARG1(answer);
    160160       
    161         return retval;
     161        return (int) retval;
    162162}
    163163
     
    178178        size_t act_size;
    179179        char name_buf[LOC_NAME_MAXLEN + 1];
    180 
    181         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    182 
     180       
     181        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     182       
    183183        ipc_call_t answer;
    184184        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
    185185        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    186186        async_wait_for(dreq, &dretval);
    187 
    188         async_exchange_end(exch);
    189 
     187       
     188        async_exchange_end(exch);
     189       
    190190        if (dretval != EOK) {
    191191                async_forget(req);
    192192                return dretval;
    193193        }
    194 
     194       
    195195        sysarg_t retval;
    196196        async_wait_for(req, &retval);
    197 
     197       
    198198        if (retval != EOK)
    199                 return retval;
    200 
     199                return (int) retval;
     200       
    201201        act_size = IPC_GET_ARG2(dreply);
    202202        assert(act_size <= LOC_NAME_MAXLEN);
     203       
    203204        name_buf[act_size] = '\0';
    204205       
     
    207208        ainfo->ilink = IPC_GET_ARG3(answer);
    208209        ainfo->name = str_dup(name_buf);
    209 
     210       
    210211        return EOK;
    211212}
     
    340341
    341342        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    342 
     343       
    343344        ipc_call_t answer;
    344345        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
    345346        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    346347        async_wait_for(dreq, &dretval);
    347 
    348         async_exchange_end(exch);
    349 
     348       
     349        async_exchange_end(exch);
     350       
    350351        if (dretval != EOK) {
    351352                async_forget(req);
    352353                return dretval;
    353354        }
    354 
     355       
    355356        sysarg_t retval;
    356357        async_wait_for(req, &retval);
    357 
     358       
    358359        if (retval != EOK)
    359                 return retval;
    360 
     360                return (int) retval;
     361       
    361362        act_size = IPC_GET_ARG2(dreply);
    362363        assert(act_size <= LOC_NAME_MAXLEN);
     
    367368        inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
    368369        srinfo->name = str_dup(name_buf);
    369 
     370       
    370371        return EOK;
    371372}
  • uspace/lib/c/generic/iplink.c

    re52b4b5 rb5cf742a  
    9999        sysarg_t retval;
    100100        async_wait_for(req, &retval);
    101         if (retval != EOK)
    102                 return retval;
    103101       
    104         return EOK;
     102        return (int) retval;
    105103}
    106104
     
    169167static void iplink_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    170168{
    171         iplink_t *iplink = (iplink_t *)arg;
    172 
     169        iplink_t *iplink = (iplink_t *) arg;
     170       
    173171        while (true) {
    174172                ipc_call_t call;
    175173                ipc_callid_t callid = async_get_call(&call);
    176 
     174               
    177175                if (!IPC_GET_IMETHOD(call)) {
    178176                        /* TODO: Handle hangup */
    179177                        return;
    180178                }
    181 
     179               
    182180                switch (IPC_GET_IMETHOD(call)) {
    183181                case IPLINK_EV_RECV:
  • uspace/lib/c/generic/iplink_srv.c

    re52b4b5 rb5cf742a  
    4444    ipc_call_t *call)
    4545{
    46         int rc;
    4746        size_t mtu;
    48 
    49         rc = srv->ops->get_mtu(srv, &mtu);
     47        int rc = srv->ops->get_mtu(srv, &mtu);
    5048        async_answer_1(callid, rc, mtu);
    5149}
     
    7068        iplink_srv_sdu_t sdu;
    7169        int rc;
    72 
     70       
    7371        sdu.lsrc = IPC_GET_ARG1(*call);
    7472        sdu.ldest = IPC_GET_ARG2(*call);
    75 
     73       
    7674        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    7775        if (rc != EOK) {
     
    7977                return;
    8078        }
    81 
     79       
    8280        rc = srv->ops->send(srv, &sdu);
    8381        free(sdu.data);
     
    9896        iplink_srv_t *srv = (iplink_srv_t *)arg;
    9997        int rc;
    100 
     98       
    10199        fibril_mutex_lock(&srv->lock);
    102100        if (srv->connected) {
     
    105103                return EBUSY;
    106104        }
    107 
     105       
    108106        srv->connected = true;
    109107        fibril_mutex_unlock(&srv->lock);
    110 
     108       
    111109        /* Accept the connection */
    112110        async_answer_0(iid, EOK);
    113 
     111       
    114112        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    115113        if (sess == NULL)
    116114                return ENOMEM;
    117 
     115       
    118116        srv->client_sess = sess;
    119 
     117       
    120118        rc = srv->ops->open(srv);
    121119        if (rc != EOK)
    122120                return rc;
    123 
     121       
    124122        while (true) {
    125123                ipc_call_t call;
    126124                ipc_callid_t callid = async_get_call(&call);
    127125                sysarg_t method = IPC_GET_IMETHOD(call);
    128 
     126               
    129127                if (!method) {
    130128                        /* The other side has hung up */
     
    135133                        break;
    136134                }
    137 
     135               
    138136                switch (method) {
    139137                case IPLINK_GET_MTU:
     
    153151                }
    154152        }
    155 
     153       
    156154        return srv->ops->close(srv);
    157155}
     
    161159        if (srv->client_sess == NULL)
    162160                return EIO;
    163 
     161       
    164162        async_exch_t *exch = async_exchange_begin(srv->client_sess);
    165 
     163       
    166164        ipc_call_t answer;
    167165        aid_t req = async_send_2(exch, IPLINK_EV_RECV, (sysarg_t) sdu->lsrc,
     
    169167        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    170168        async_exchange_end(exch);
    171 
     169       
    172170        if (rc != EOK) {
    173171                async_forget(req);
    174172                return rc;
    175173        }
    176 
     174       
    177175        sysarg_t retval;
    178176        async_wait_for(req, &retval);
    179177        if (retval != EOK)
    180178                return retval;
    181 
     179       
    182180        return EOK;
    183181}
Note: See TracChangeset for help on using the changeset viewer.