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/drv/generic/remote_usbdiag.c

    r76f566d r984a9ba  
    126126}
    127127
    128 static void remote_usbdiag_test_in(ddf_fun_t *, void *,
    129     cap_call_handle_t, ipc_call_t *);
    130 static void remote_usbdiag_test_out(ddf_fun_t *, void *,
    131     cap_call_handle_t, ipc_call_t *);
     128static void remote_usbdiag_test_in(ddf_fun_t *, void *, ipc_call_t *);
     129static void remote_usbdiag_test_out(ddf_fun_t *, void *, ipc_call_t *);
    132130
    133131/** Remote USB diagnostic interface operations. */
    … …  
    143141};
    144142
    145 void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface,
    146     cap_call_handle_t chandle, ipc_call_t *call)
     143void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    147144{
    148145        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    149146
     147        ipc_call_t data;
    150148        size_t size;
    151         cap_call_handle_t data_chandle;
    152         if (!async_data_write_receive(&data_chandle, &size)) {
    153                 async_answer_0(data_chandle, EINVAL);
    154                 async_answer_0(chandle, EINVAL);
     149        if (!async_data_write_receive(&data, &size)) {
     150                async_answer_0(&data, EINVAL);
     151                async_answer_0(call, EINVAL);
    155152                return;
    156153        }
    157154
    158155        if (size != sizeof(usbdiag_test_params_t)) {
    159                 async_answer_0(data_chandle, EINVAL);
    160                 async_answer_0(chandle, EINVAL);
     156                async_answer_0(&data, EINVAL);
     157                async_answer_0(call, EINVAL);
    161158                return;
    162159        }
    163160
    164161        usbdiag_test_params_t params;
    165         if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
    166                 async_answer_0(chandle, EINVAL);
     162        if (async_data_write_finalize(&data, &params, size) != EOK) {
     163                async_answer_0(call, EINVAL);
    167164                return;
    168165        }
    … …  
    173170
    174171        if (ret != EOK) {
    175                 async_answer_0(chandle, ret);
    176                 return;
    177         }
    178 
    179         if (!async_data_read_receive(&data_chandle, &size)) {
    180                 async_answer_0(data_chandle, EINVAL);
    181                 async_answer_0(chandle, EINVAL);
     172                async_answer_0(call, ret);
     173                return;
     174        }
     175
     176        if (!async_data_read_receive(&data, &size)) {
     177                async_answer_0(&data, EINVAL);
     178                async_answer_0(call, EINVAL);
    182179                return;
    183180        }
    184181
    185182        if (size != sizeof(usbdiag_test_results_t)) {
    186                 async_answer_0(data_chandle, EINVAL);
    187                 async_answer_0(chandle, EINVAL);
    188                 return;
    189         }
    190 
    191         if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
    192                 async_answer_0(chandle, EINVAL);
    193                 return;
    194         }
    195 
    196         async_answer_0(chandle, ret);
    197 }
    198 
    199 void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface,
    200     cap_call_handle_t chandle, ipc_call_t *call)
     183                async_answer_0(&data, EINVAL);
     184                async_answer_0(call, EINVAL);
     185                return;
     186        }
     187
     188        if (async_data_read_finalize(&data, &results, size) != EOK) {
     189                async_answer_0(call, EINVAL);
     190                return;
     191        }
     192
     193        async_answer_0(call, ret);
     194}
     195
     196void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    201197{
    202198        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    203199
     200        ipc_call_t data;
    204201        size_t size;
    205         cap_call_handle_t data_chandle;
    206         if (!async_data_write_receive(&data_chandle, &size)) {
    207                 async_answer_0(data_chandle, EINVAL);
    208                 async_answer_0(chandle, EINVAL);
     202        if (!async_data_write_receive(&data, &size)) {
     203                async_answer_0(&data, EINVAL);
     204                async_answer_0(call, EINVAL);
    209205                return;
    210206        }
    211207
    212208        if (size != sizeof(usbdiag_test_params_t)) {
    213                 async_answer_0(data_chandle, EINVAL);
    214                 async_answer_0(chandle, EINVAL);
     209                async_answer_0(&data, EINVAL);
     210                async_answer_0(call, EINVAL);
    215211                return;
    216212        }
    217213
    218214        usbdiag_test_params_t params;
    219         if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
    220                 async_answer_0(chandle, EINVAL);
     215        if (async_data_write_finalize(&data, &params, size) != EOK) {
     216                async_answer_0(call, EINVAL);
    221217                return;
    222218        }
    … …  
    227223
    228224        if (ret != EOK) {
    229                 async_answer_0(chandle, ret);
    230                 return;
    231         }
    232 
    233         if (!async_data_read_receive(&data_chandle, &size)) {
    234                 async_answer_0(data_chandle, EINVAL);
    235                 async_answer_0(chandle, EINVAL);
     225                async_answer_0(call, ret);
     226                return;
     227        }
     228
     229        if (!async_data_read_receive(&data, &size)) {
     230                async_answer_0(&data, EINVAL);
     231                async_answer_0(call, EINVAL);
    236232                return;
    237233        }
    238234
    239235        if (size != sizeof(usbdiag_test_results_t)) {
    240                 async_answer_0(data_chandle, EINVAL);
    241                 async_answer_0(chandle, EINVAL);
    242                 return;
    243         }
    244 
    245         if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
    246                 async_answer_0(chandle, EINVAL);
    247                 return;
    248         }
    249 
    250         async_answer_0(chandle, ret);
     236                async_answer_0(&data, EINVAL);
     237                async_answer_0(call, EINVAL);
     238                return;
     239        }
     240
     241        if (async_data_read_finalize(&data, &results, size) != EOK) {
     242                async_answer_0(call, EINVAL);
     243                return;
     244        }
     245
     246        async_answer_0(call, ret);
    251247}
    252248
Note: See TracChangeset for help on using the changeset viewer.