Ignore:
File:
1 edited

Legend:

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

    r77ad86c r695b6ff  
    3030#include <assert.h>
    3131#include <errno.h>
     32#include <net/socket_codes.h>
    3233#include <inet/inet.h>
    3334#include <ipc/inet.h>
     
    108109{
    109110        async_exch_t *exch = async_exchange_begin(inet_sess);
    110 
     111       
    111112        ipc_call_t answer;
    112         aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
    113             dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
    114         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    115         async_exchange_end(exch);
    116 
    117         if (rc != EOK) {
    118                 async_forget(req);
    119                 return rc;
    120         }
    121 
     113        aid_t req = async_send_4(exch, INET_SEND, dgram->iplink, dgram->tos,
     114            ttl, df, &answer);
     115       
     116        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     117        if (rc != EOK) {
     118                async_exchange_end(exch);
     119                async_forget(req);
     120                return rc;
     121        }
     122       
     123        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
     124        if (rc != EOK) {
     125                async_exchange_end(exch);
     126                async_forget(req);
     127                return rc;
     128        }
     129       
     130        rc = async_data_write_start(exch, dgram->data, dgram->size);
     131       
     132        async_exchange_end(exch);
     133       
     134        if (rc != EOK) {
     135                async_forget(req);
     136                return rc;
     137        }
     138       
    122139        sysarg_t retval;
    123140        async_wait_for(req, &retval);
    124         if (retval != EOK)
    125                 return retval;
    126 
    127         return EOK;
     141       
     142        return (int) retval;
    128143}
    129144
    130145int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    131146{
    132         sysarg_t local_addr;
    133         async_exch_t *exch = async_exchange_begin(inet_sess);
    134 
    135         int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
    136             tos, &local_addr);
    137         async_exchange_end(exch);
    138 
    139         if (rc != EOK)
    140                 return rc;
    141 
    142         local->ipv4 = local_addr;
    143         return EOK;
    144 }
    145 
    146 static void inet_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    147 {
    148         int rc;
     147        async_exch_t *exch = async_exchange_begin(inet_sess);
     148       
     149        ipc_call_t answer;
     150        aid_t req = async_send_1(exch, INET_GET_SRCADDR, tos, &answer);
     151       
     152        int rc = async_data_write_start(exch, remote, sizeof(inet_addr_t));
     153        if (rc != EOK) {
     154                async_exchange_end(exch);
     155                async_forget(req);
     156                return rc;
     157        }
     158       
     159        rc = async_data_read_start(exch, local, sizeof(inet_addr_t));
     160       
     161        async_exchange_end(exch);
     162       
     163        if (rc != EOK) {
     164                async_forget(req);
     165                return rc;
     166        }
     167       
     168        sysarg_t retval;
     169        async_wait_for(req, &retval);
     170       
     171        return (int) retval;
     172}
     173
     174static void inet_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
     175{
    149176        inet_dgram_t dgram;
    150 
    151         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    152         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
    153         dgram.tos = IPC_GET_ARG3(*call);
    154 
     177       
     178        dgram.tos = IPC_GET_ARG1(*icall);
     179       
     180        ipc_callid_t callid;
     181        size_t size;
     182        if (!async_data_write_receive(&callid, &size)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187       
     188        if (size != sizeof(inet_addr_t)) {
     189                async_answer_0(callid, EINVAL);
     190                async_answer_0(iid, EINVAL);
     191                return;
     192        }
     193       
     194        int rc = async_data_write_finalize(callid, &dgram.src, size);
     195        if (rc != EOK) {
     196                async_answer_0(callid, rc);
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200       
     201        if (!async_data_write_receive(&callid, &size)) {
     202                async_answer_0(callid, EINVAL);
     203                async_answer_0(iid, EINVAL);
     204                return;
     205        }
     206       
     207        if (size != sizeof(inet_addr_t)) {
     208                async_answer_0(callid, EINVAL);
     209                async_answer_0(iid, EINVAL);
     210                return;
     211        }
     212       
     213        rc = async_data_write_finalize(callid, &dgram.dest, size);
     214        if (rc != EOK) {
     215                async_answer_0(callid, rc);
     216                async_answer_0(iid, rc);
     217                return;
     218        }
     219       
    155220        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    156221        if (rc != EOK) {
    157                 async_answer_0(callid, rc);
    158                 return;
    159         }
    160 
     222                async_answer_0(iid, rc);
     223                return;
     224        }
     225       
    161226        rc = inet_ev_ops->recv(&dgram);
    162         async_answer_0(callid, rc);
     227        async_answer_0(iid, rc);
    163228}
    164229
     
    168233                ipc_call_t call;
    169234                ipc_callid_t callid = async_get_call(&call);
    170 
     235               
    171236                if (!IPC_GET_IMETHOD(call)) {
    172237                        /* TODO: Handle hangup */
    173238                        return;
    174239                }
    175 
     240               
    176241                switch (IPC_GET_IMETHOD(call)) {
    177242                case INET_EV_RECV:
Note: See TracChangeset for help on using the changeset viewer.