Changeset 984a9ba in mainline for uspace/srv/clipboard/clipboard.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 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/srv/clipboard/clipboard.c

    r76f566d r984a9ba  
    4747static service_id_t svc_id;
    4848
    49 static void clip_put_data(cap_call_handle_t req_handle, ipc_call_t *request)
     49static void clip_put_data(ipc_call_t *req)
    5050{
    5151        char *data;
    … …  
    5353        size_t size;
    5454
    55         switch (IPC_GET_ARG1(*request)) {
     55        switch (IPC_GET_ARG1(*req)) {
    5656        case CLIPBOARD_TAG_NONE:
    5757                fibril_mutex_lock(&clip_mtx);
    … …  
    6565
    6666                fibril_mutex_unlock(&clip_mtx);
    67                 async_answer_0(req_handle, EOK);
     67                async_answer_0(req, EOK);
    6868                break;
    6969        case CLIPBOARD_TAG_DATA:
    7070                rc = async_data_write_accept((void **) &data, false, 0, 0, 0, &size);
    7171                if (rc != EOK) {
    72                         async_answer_0(req_handle, rc);
     72                        async_answer_0(req, rc);
    7373                        break;
    7474                }
    … …  
    8484
    8585                fibril_mutex_unlock(&clip_mtx);
    86                 async_answer_0(req_handle, EOK);
     86                async_answer_0(req, EOK);
    8787                break;
    8888        default:
    89                 async_answer_0(req_handle, EINVAL);
    90         }
    91 }
    92 
    93 static void clip_get_data(cap_call_handle_t req_handle, ipc_call_t *request)
     89                async_answer_0(req, EINVAL);
     90        }
     91}
     92
     93static void clip_get_data(ipc_call_t *req)
    9494{
    9595        fibril_mutex_lock(&clip_mtx);
    9696
    97         cap_call_handle_t chandle;
     97        ipc_call_t call;
    9898        size_t size;
    9999
    100100        /* Check for clipboard data tag compatibility */
    101         switch (IPC_GET_ARG1(*request)) {
     101        switch (IPC_GET_ARG1(*req)) {
    102102        case CLIPBOARD_TAG_DATA:
    103                 if (!async_data_read_receive(&chandle, &size)) {
    104                         async_answer_0(chandle, EINVAL);
    105                         async_answer_0(req_handle, EINVAL);
     103                if (!async_data_read_receive(&call, &size)) {
     104                        async_answer_0(&call, EINVAL);
     105                        async_answer_0(req, EINVAL);
    106106                        break;
    107107                }
    … …  
    109109                if (clip_tag != CLIPBOARD_TAG_DATA) {
    110110                        /* So far we only understand binary data */
    111                         async_answer_0(chandle, EOVERFLOW);
    112                         async_answer_0(req_handle, EOVERFLOW);
     111                        async_answer_0(&call, EOVERFLOW);
     112                        async_answer_0(req, EOVERFLOW);
    113113                        break;
    114114                }
    … …  
    116116                if (clip_size != size) {
    117117                        /* The client expects different size of data */
    118                         async_answer_0(chandle, EOVERFLOW);
    119                         async_answer_0(req_handle, EOVERFLOW);
    120                         break;
    121                 }
    122 
    123                 errno_t retval = async_data_read_finalize(chandle, clip_data, size);
     118                        async_answer_0(&call, EOVERFLOW);
     119                        async_answer_0(req, EOVERFLOW);
     120                        break;
     121                }
     122
     123                errno_t retval = async_data_read_finalize(&call, clip_data, size);
    124124                if (retval != EOK) {
    125                         async_answer_0(req_handle, retval);
    126                         break;
    127                 }
    128 
    129                 async_answer_0(req_handle, EOK);
     125                        async_answer_0(req, retval);
     126                        break;
     127                }
     128
     129                async_answer_0(req, EOK);
    130130                break;
    131131        default:
    … …  
    134134                 * data from the clipbard
    135135                 */
    136                 async_answer_0(req_handle, EINVAL);
     136                async_answer_0(req, EINVAL);
    137137                break;
    138138        }
    … …  
    141141}
    142142
    143 static void clip_content(cap_call_handle_t req_handle, ipc_call_t *request)
     143static void clip_content(ipc_call_t *req)
    144144{
    145145        fibril_mutex_lock(&clip_mtx);
    … …  
    149149
    150150        fibril_mutex_unlock(&clip_mtx);
    151         async_answer_2(req_handle, EOK, (sysarg_t) size, (sysarg_t) tag);
    152 }
    153 
    154 static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
    155     void *arg)
     151        async_answer_2(req, EOK, (sysarg_t) size, (sysarg_t) tag);
     152}
     153
     154static void clip_connection(ipc_call_t *icall, void *arg)
    156155{
    157156        /* Accept connection */
    158         async_answer_0(icall_handle, EOK);
     157        async_answer_0(icall, EOK);
    159158
    160159        while (true) {
    161160                ipc_call_t call;
    162                 cap_call_handle_t chandle = async_get_call(&call);
     161                async_get_call(&call);
    163162
    164163                if (!IPC_GET_IMETHOD(call))
    … …  
    167166                switch (IPC_GET_IMETHOD(call)) {
    168167                case CLIPBOARD_PUT_DATA:
    169                         clip_put_data(chandle, &call);
     168                        clip_put_data(&call);
    170169                        break;
    171170                case CLIPBOARD_GET_DATA:
    172                         clip_get_data(chandle, &call);
     171                        clip_get_data(&call);
    173172                        break;
    174173                case CLIPBOARD_CONTENT:
    175                         clip_content(chandle, &call);
     174                        clip_content(&call);
    176175                        break;
    177176                default:
    178                         async_answer_0(chandle, ENOENT);
     177                        async_answer_0(&call, ENOENT);
    179178                }
    180179        }
Note: See TracChangeset for help on using the changeset viewer.