Changeset 984a9ba in mainline for uspace/srv/net/dnsrsrv/dnsrsrv.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/net/dnsrsrv/dnsrsrv.c

    r76f566d r984a9ba  
    5353#define NAME  "dnsres"
    5454
    55 static void dnsr_client_conn(cap_call_handle_t, ipc_call_t *, void *);
     55static void dnsr_client_conn(ipc_call_t *, void *);
    5656
    5757static errno_t dnsr_init(void)
    … …  
    8686}
    8787
    88 static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    89     ipc_call_t *icall)
     88static void dnsr_name2host_srv(dnsr_client_t *client, ipc_call_t *icall)
    9089{
    9190        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    … …  
    9796            DNS_NAME_MAX_SIZE, 0, NULL);
    9897        if (rc != EOK) {
    99                 async_answer_0(icall_handle, rc);
     98                async_answer_0(icall, rc);
    10099                return;
    101100        }
    … …  
    104103        rc = dns_name2host(name, &hinfo, ver);
    105104        if (rc != EOK) {
    106                 async_answer_0(icall_handle, rc);
    107                 return;
    108         }
    109 
    110         cap_call_handle_t chandle;
     105                async_answer_0(icall, rc);
     106                return;
     107        }
     108
     109        ipc_call_t call;
    111110        size_t size;
    112         if (!async_data_read_receive(&chandle, &size)) {
    113                 async_answer_0(chandle, EREFUSED);
    114                 async_answer_0(icall_handle, EREFUSED);
     111        if (!async_data_read_receive(&call, &size)) {
     112                async_answer_0(&call, EREFUSED);
     113                async_answer_0(icall, EREFUSED);
    115114                return;
    116115        }
    117116
    118117        if (size != sizeof(inet_addr_t)) {
    119                 async_answer_0(chandle, EINVAL);
    120                 async_answer_0(icall_handle, EINVAL);
    121                 return;
    122         }
    123 
    124         rc = async_data_read_finalize(chandle, &hinfo->addr, size);
    125         if (rc != EOK) {
    126                 async_answer_0(chandle, rc);
    127                 async_answer_0(icall_handle, rc);
    128                 return;
    129         }
    130 
    131         if (!async_data_read_receive(&chandle, &size)) {
    132                 async_answer_0(chandle, EREFUSED);
    133                 async_answer_0(icall_handle, EREFUSED);
     118                async_answer_0(&call, EINVAL);
     119                async_answer_0(icall, EINVAL);
     120                return;
     121        }
     122
     123        rc = async_data_read_finalize(&call, &hinfo->addr, size);
     124        if (rc != EOK) {
     125                async_answer_0(&call, rc);
     126                async_answer_0(icall, rc);
     127                return;
     128        }
     129
     130        if (!async_data_read_receive(&call, &size)) {
     131                async_answer_0(&call, EREFUSED);
     132                async_answer_0(icall, EREFUSED);
    134133                return;
    135134        }
    … …  
    137136        size_t act_size = str_size(hinfo->cname);
    138137        if (act_size > size) {
    139                 async_answer_0(chandle, EINVAL);
    140                 async_answer_0(icall_handle, EINVAL);
    141                 return;
    142         }
    143 
    144         rc = async_data_read_finalize(chandle, hinfo->cname, act_size);
     138                async_answer_0(&call, EINVAL);
     139                async_answer_0(icall, EINVAL);
     140                return;
     141        }
     142
     143        rc = async_data_read_finalize(&call, hinfo->cname, act_size);
    145144        if (rc != EOK)
    146                 async_answer_0(chandle, rc);
    147 
    148         async_answer_0(icall_handle, rc);
     145                async_answer_0(&call, rc);
     146
     147        async_answer_0(icall, rc);
    149148
    150149        dns_hostinfo_destroy(hinfo);
    151150}
    152151
    153 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    154     ipc_call_t *icall)
     152static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_call_t *icall)
    155153{
    156154        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    157155
    158         cap_call_handle_t chandle;
     156        ipc_call_t call;
    159157        size_t size;
    160         if (!async_data_read_receive(&chandle, &size)) {
    161                 async_answer_0(chandle, EREFUSED);
    162                 async_answer_0(icall_handle, EREFUSED);
     158        if (!async_data_read_receive(&call, &size)) {
     159                async_answer_0(&call, EREFUSED);
     160                async_answer_0(icall, EREFUSED);
    163161                return;
    164162        }
    165163
    166164        if (size != sizeof(inet_addr_t)) {
    167                 async_answer_0(chandle, EINVAL);
    168                 async_answer_0(icall_handle, EINVAL);
     165                async_answer_0(&call, EINVAL);
     166                async_answer_0(icall, EINVAL);
    169167                return;
    170168        }
    … …  
    172170        // FIXME locking
    173171
    174         errno_t rc = async_data_read_finalize(chandle, &dns_server_addr, size);
     172        errno_t rc = async_data_read_finalize(&call, &dns_server_addr, size);
    175173        if (rc != EOK)
    176                 async_answer_0(chandle, rc);
    177 
    178         async_answer_0(icall_handle, rc);
    179 }
    180 
    181 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    182     ipc_call_t *icall)
     174                async_answer_0(&call, rc);
     175
     176        async_answer_0(icall, rc);
     177}
     178
     179static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_call_t *icall)
    183180{
    184181        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    185182
    186         cap_call_handle_t chandle;
     183        ipc_call_t call;
    187184        size_t size;
    188         if (!async_data_write_receive(&chandle, &size)) {
    189                 async_answer_0(chandle, EREFUSED);
    190                 async_answer_0(icall_handle, EREFUSED);
     185        if (!async_data_write_receive(&call, &size)) {
     186                async_answer_0(&call, EREFUSED);
     187                async_answer_0(icall, EREFUSED);
    191188                return;
    192189        }
    193190
    194191        if (size != sizeof(inet_addr_t)) {
    195                 async_answer_0(chandle, EINVAL);
    196                 async_answer_0(icall_handle, EINVAL);
     192                async_answer_0(&call, EINVAL);
     193                async_answer_0(icall, EINVAL);
    197194                return;
    198195        }
    … …  
    200197        // FIXME locking
    201198
    202         errno_t rc = async_data_write_finalize(chandle, &dns_server_addr, size);
    203         if (rc != EOK) {
    204                 async_answer_0(chandle, rc);
    205                 async_answer_0(icall_handle, rc);
    206         }
    207 
    208         async_answer_0(icall_handle, rc);
    209 }
    210 
    211 static void dnsr_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     199        errno_t rc = async_data_write_finalize(&call, &dns_server_addr, size);
     200        if (rc != EOK) {
     201                async_answer_0(&call, rc);
     202                async_answer_0(icall, rc);
     203        }
     204
     205        async_answer_0(icall, rc);
     206}
     207
     208static void dnsr_client_conn(ipc_call_t *icall, void *arg)
    212209{
    213210        dnsr_client_t client;
    … …  
    216213
    217214        /* Accept the connection */
    218         async_answer_0(icall_handle, EOK);
     215        async_answer_0(icall, EOK);
    219216
    220217        while (true) {
    221218                ipc_call_t call;
    222                 cap_call_handle_t chandle = async_get_call(&call);
     219                async_get_call(&call);
    223220                sysarg_t method = IPC_GET_IMETHOD(call);
    224221
    225222                if (!method) {
    226223                        /* The other side has hung up */
    227                         async_answer_0(chandle, EOK);
     224                        async_answer_0(&call, EOK);
    228225                        return;
    229226                }
    … …  
    231228                switch (method) {
    232229                case DNSR_NAME2HOST:
    233                         dnsr_name2host_srv(&client, chandle, &call);
     230                        dnsr_name2host_srv(&client, &call);
    234231                        break;
    235232                case DNSR_GET_SRVADDR:
    236                         dnsr_get_srvaddr_srv(&client, chandle, &call);
     233                        dnsr_get_srvaddr_srv(&client, &call);
    237234                        break;
    238235                case DNSR_SET_SRVADDR:
    239                         dnsr_set_srvaddr_srv(&client, chandle, &call);
     236                        dnsr_set_srvaddr_srv(&client, &call);
    240237                        break;
    241238                default:
    242                         async_answer_0(chandle, EINVAL);
     239                        async_answer_0(&call, EINVAL);
    243240                }
    244241        }
Note: See TracChangeset for help on using the changeset viewer.