Changeset 984a9ba in mainline for uspace/lib/c/generic/iplink_srv.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r76f566d r984a9ba  
    4242#include <inet/iplink_srv.h>
    4343
    44 static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t chandle,
    45     ipc_call_t *call)
     44static void iplink_get_mtu_srv(iplink_srv_t *srv, ipc_call_t *call)
    4645{
    4746        size_t mtu;
    4847        errno_t rc = srv->ops->get_mtu(srv, &mtu);
    49         async_answer_1(chandle, rc, mtu);
    50 }
    51 
    52 static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    53     ipc_call_t *icall)
     48        async_answer_1(call, rc, mtu);
     49}
     50
     51static void iplink_get_mac48_srv(iplink_srv_t *srv, ipc_call_t *icall)
    5452{
    5553        addr48_t mac;
    5654        errno_t rc = srv->ops->get_mac48(srv, &mac);
    5755        if (rc != EOK) {
    58                 async_answer_0(icall_handle, rc);
    59                 return;
    60         }
    61 
    62         cap_call_handle_t chandle;
    63         size_t size;
    64         if (!async_data_read_receive(&chandle, &size)) {
    65                 async_answer_0(chandle, EREFUSED);
    66                 async_answer_0(icall_handle, EREFUSED);
     56                async_answer_0(icall, rc);
     57                return;
     58        }
     59
     60        ipc_call_t call;
     61        size_t size;
     62        if (!async_data_read_receive(&call, &size)) {
     63                async_answer_0(&call, EREFUSED);
     64                async_answer_0(icall, EREFUSED);
    6765                return;
    6866        }
    6967
    7068        if (size != sizeof(addr48_t)) {
    71                 async_answer_0(chandle, EINVAL);
    72                 async_answer_0(icall_handle, EINVAL);
    73                 return;
    74         }
    75 
    76         rc = async_data_read_finalize(chandle, &mac, size);
     69                async_answer_0(&call, EINVAL);
     70                async_answer_0(icall, EINVAL);
     71                return;
     72        }
     73
     74        rc = async_data_read_finalize(&call, &mac, size);
    7775        if (rc != EOK)
    78                 async_answer_0(chandle, rc);
    79 
    80         async_answer_0(icall_handle, rc);
    81 }
    82 
    83 static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    84     ipc_call_t *icall)
     76                async_answer_0(&call, rc);
     77
     78        async_answer_0(icall, rc);
     79}
     80
     81static void iplink_set_mac48_srv(iplink_srv_t *srv, ipc_call_t *icall)
    8582{
    8683        errno_t rc;
    8784        size_t size;
    8885        addr48_t mac;
    89         cap_call_handle_t chandle;
    90 
    91         if (!async_data_write_receive(&chandle, &size)) {
    92                 async_answer_0(chandle, EREFUSED);
    93                 async_answer_0(icall_handle, EREFUSED);
     86
     87        ipc_call_t call;
     88        if (!async_data_write_receive(&call, &size)) {
     89                async_answer_0(&call, EREFUSED);
     90                async_answer_0(icall, EREFUSED);
    9491        }
    9592
    9693        rc = srv->ops->set_mac48(srv, &mac);
    9794        if (rc != EOK) {
    98                 async_answer_0(icall_handle, rc);
    99                 return;
    100         }
    101 
    102         rc = async_data_read_finalize(chandle, &mac, sizeof(addr48_t));
     95                async_answer_0(icall, rc);
     96                return;
     97        }
     98
     99        rc = async_data_read_finalize(&call, &mac, sizeof(addr48_t));
    103100        if (rc != EOK)
    104                 async_answer_0(chandle, rc);
    105 
    106         async_answer_0(icall_handle, rc);
    107 }
    108 
    109 static void iplink_addr_add_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    110     ipc_call_t *icall)
    111 {
    112         cap_call_handle_t chandle;
    113         size_t size;
    114         if (!async_data_write_receive(&chandle, &size)) {
    115                 async_answer_0(chandle, EREFUSED);
    116                 async_answer_0(icall_handle, EREFUSED);
     101                async_answer_0(&call, rc);
     102
     103        async_answer_0(icall, rc);
     104}
     105
     106static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_call_t *icall)
     107{
     108        ipc_call_t call;
     109        size_t size;
     110        if (!async_data_write_receive(&call, &size)) {
     111                async_answer_0(&call, EREFUSED);
     112                async_answer_0(icall, EREFUSED);
    117113                return;
    118114        }
    119115
    120116        if (size != sizeof(inet_addr_t)) {
    121                 async_answer_0(chandle, EINVAL);
    122                 async_answer_0(icall_handle, EINVAL);
     117                async_answer_0(&call, EINVAL);
     118                async_answer_0(icall, EINVAL);
    123119                return;
    124120        }
    125121
    126122        inet_addr_t addr;
    127         errno_t rc = async_data_write_finalize(chandle, &addr, size);
    128         if (rc != EOK) {
    129                 async_answer_0(chandle, rc);
    130                 async_answer_0(icall_handle, rc);
     123        errno_t rc = async_data_write_finalize(&call, &addr, size);
     124        if (rc != EOK) {
     125                async_answer_0(&call, rc);
     126                async_answer_0(icall, rc);
    131127        }
    132128
    133129        rc = srv->ops->addr_add(srv, &addr);
    134         async_answer_0(icall_handle, rc);
    135 }
    136 
    137 static void iplink_addr_remove_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    138     ipc_call_t *icall)
    139 {
    140         cap_call_handle_t chandle;
    141         size_t size;
    142         if (!async_data_write_receive(&chandle, &size)) {
    143                 async_answer_0(chandle, EREFUSED);
    144                 async_answer_0(icall_handle, EREFUSED);
     130        async_answer_0(icall, rc);
     131}
     132
     133static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_call_t *icall)
     134{
     135        ipc_call_t call;
     136        size_t size;
     137        if (!async_data_write_receive(&call, &size)) {
     138                async_answer_0(&call, EREFUSED);
     139                async_answer_0(icall, EREFUSED);
    145140                return;
    146141        }
    147142
    148143        if (size != sizeof(inet_addr_t)) {
    149                 async_answer_0(chandle, EINVAL);
    150                 async_answer_0(icall_handle, EINVAL);
     144                async_answer_0(&call, EINVAL);
     145                async_answer_0(icall, EINVAL);
    151146                return;
    152147        }
    153148
    154149        inet_addr_t addr;
    155         errno_t rc = async_data_write_finalize(chandle, &addr, size);
    156         if (rc != EOK) {
    157                 async_answer_0(chandle, rc);
    158                 async_answer_0(icall_handle, rc);
     150        errno_t rc = async_data_write_finalize(&call, &addr, size);
     151        if (rc != EOK) {
     152                async_answer_0(&call, rc);
     153                async_answer_0(icall, rc);
    159154        }
    160155
    161156        rc = srv->ops->addr_remove(srv, &addr);
    162         async_answer_0(icall_handle, rc);
    163 }
    164 
    165 static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    166     ipc_call_t *icall)
     157        async_answer_0(icall, rc);
     158}
     159
     160static void iplink_send_srv(iplink_srv_t *srv, ipc_call_t *icall)
    167161{
    168162        iplink_sdu_t sdu;
    … …  
    174168            &sdu.size);
    175169        if (rc != EOK) {
    176                 async_answer_0(icall_handle, rc);
     170                async_answer_0(icall, rc);
    177171                return;
    178172        }
    … …  
    180174        rc = srv->ops->send(srv, &sdu);
    181175        free(sdu.data);
    182         async_answer_0(icall_handle, rc);
    183 }
    184 
    185 static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    186     ipc_call_t *icall)
     176        async_answer_0(icall, rc);
     177}
     178
     179static void iplink_send6_srv(iplink_srv_t *srv, ipc_call_t *icall)
    187180{
    188181        iplink_sdu6_t sdu;
    189182
    190         cap_call_handle_t chandle;
    191         size_t size;
    192         if (!async_data_write_receive(&chandle, &size)) {
    193                 async_answer_0(chandle, EREFUSED);
    194                 async_answer_0(icall_handle, EREFUSED);
     183        ipc_call_t call;
     184        size_t size;
     185        if (!async_data_write_receive(&call, &size)) {
     186                async_answer_0(&call, EREFUSED);
     187                async_answer_0(icall, EREFUSED);
    195188                return;
    196189        }
    197190
    198191        if (size != sizeof(addr48_t)) {
    199                 async_answer_0(chandle, EINVAL);
    200                 async_answer_0(icall_handle, EINVAL);
    201                 return;
    202         }
    203 
    204         errno_t rc = async_data_write_finalize(chandle, &sdu.dest, size);
    205         if (rc != EOK) {
    206                 async_answer_0(chandle, rc);
    207                 async_answer_0(icall_handle, rc);
     192                async_answer_0(&call, EINVAL);
     193                async_answer_0(icall, EINVAL);
     194                return;
     195        }
     196
     197        errno_t rc = async_data_write_finalize(&call, &sdu.dest, size);
     198        if (rc != EOK) {
     199                async_answer_0(&call, rc);
     200                async_answer_0(icall, rc);
    208201        }
    209202
    … …  
    211204            &sdu.size);
    212205        if (rc != EOK) {
    213                 async_answer_0(icall_handle, rc);
     206                async_answer_0(icall, rc);
    214207                return;
    215208        }
    … …  
    217210        rc = srv->ops->send6(srv, &sdu);
    218211        free(sdu.data);
    219         async_answer_0(icall_handle, rc);
     212        async_answer_0(icall, rc);
    220213}
    221214
    … …  
    229222}
    230223
    231 errno_t iplink_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     224errno_t iplink_conn(ipc_call_t *icall, void *arg)
    232225{
    233226        iplink_srv_t *srv = (iplink_srv_t *) arg;
    … …  
    237230        if (srv->connected) {
    238231                fibril_mutex_unlock(&srv->lock);
    239                 async_answer_0(icall_handle, EBUSY);
     232                async_answer_0(icall, EBUSY);
    240233                return EBUSY;
    241234        }
    … …  
    245238
    246239        /* Accept the connection */
    247         async_answer_0(icall_handle, EOK);
     240        async_answer_0(icall, EOK);
    248241
    249242        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    259252        while (true) {
    260253                ipc_call_t call;
    261                 cap_call_handle_t chandle = async_get_call(&call);
     254                async_get_call(&call);
    262255                sysarg_t method = IPC_GET_IMETHOD(call);
    263256
    … …  
    267260                        srv->connected = false;
    268261                        fibril_mutex_unlock(&srv->lock);
    269                         async_answer_0(chandle, EOK);
     262                        async_answer_0(&call, EOK);
    270263                        break;
    271264                }
    … …  
    273266                switch (method) {
    274267                case IPLINK_GET_MTU:
    275                         iplink_get_mtu_srv(srv, chandle, &call);
     268                        iplink_get_mtu_srv(srv, &call);
    276269                        break;
    277270                case IPLINK_GET_MAC48:
    278                         iplink_get_mac48_srv(srv, chandle, &call);
     271                        iplink_get_mac48_srv(srv, &call);
    279272                        break;
    280273                case IPLINK_SET_MAC48:
    281                         iplink_set_mac48_srv(srv, chandle, &call);
     274                        iplink_set_mac48_srv(srv, &call);
    282275                        break;
    283276                case IPLINK_SEND:
    284                         iplink_send_srv(srv, chandle, &call);
     277                        iplink_send_srv(srv, &call);
    285278                        break;
    286279                case IPLINK_SEND6:
    287                         iplink_send6_srv(srv, chandle, &call);
     280                        iplink_send6_srv(srv, &call);
    288281                        break;
    289282                case IPLINK_ADDR_ADD:
    290                         iplink_addr_add_srv(srv, chandle, &call);
     283                        iplink_addr_add_srv(srv, &call);
    291284                        break;
    292285                case IPLINK_ADDR_REMOVE:
    293                         iplink_addr_remove_srv(srv, chandle, &call);
     286                        iplink_addr_remove_srv(srv, &call);
    294287                        break;
    295288                default:
    296                         async_answer_0(chandle, EINVAL);
     289                        async_answer_0(&call, EINVAL);
    297290                }
    298291        }
Note: See TracChangeset for help on using the changeset viewer.