Changeset 8565a42 in mainline for uspace/lib/c/generic/inet.c


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

File:
1 edited

Legend:

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

    r3061bc1 r8565a42  
    4545{
    4646        async_exch_t *exch = async_exchange_begin(inet_sess);
    47        
     47
    4848        ipc_call_t answer;
    4949        aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer);
    50        
     50
    5151        port_id_t port;
    5252        errno_t rc = async_create_callback_port(exch, INTERFACE_INET_CB, 0, 0,
    5353            inet_cb_conn, NULL, &port);
    54        
    55         async_exchange_end(exch);
    56        
     54
     55        async_exchange_end(exch);
     56
    5757        if (rc != EOK)
    5858                return rc;
    59        
     59
    6060        errno_t retval;
    6161        async_wait_for(req, &retval);
    62        
     62
    6363        return retval;
    6464}
     
    6969        errno_t rc = async_req_1_0(exch, INET_SET_PROTO, protocol);
    7070        async_exchange_end(exch);
    71        
     71
    7272        return rc;
    7373}
     
    8181        assert(inet_ev_ops == NULL);
    8282        assert(inet_protocol == 0);
    83        
     83
    8484        rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
    8585            IPC_FLAG_BLOCKING);
    8686        if (rc != EOK)
    8787                return ENOENT;
    88        
     88
    8989        inet_sess = loc_service_connect(inet_svc, INTERFACE_INET,
    9090            IPC_FLAG_BLOCKING);
    9191        if (inet_sess == NULL)
    9292                return ENOENT;
    93        
     93
    9494        if (inet_set_proto(protocol) != EOK) {
    9595                async_hangup(inet_sess);
     
    9797                return EIO;
    9898        }
    99        
     99
    100100        if (inet_callback_create() != EOK) {
    101101                async_hangup(inet_sess);
     
    103103                return EIO;
    104104        }
    105        
     105
    106106        inet_protocol = protocol;
    107107        inet_ev_ops = ev_ops;
     
    113113{
    114114        async_exch_t *exch = async_exchange_begin(inet_sess);
    115        
     115
    116116        ipc_call_t answer;
    117117        aid_t req = async_send_4(exch, INET_SEND, dgram->iplink, dgram->tos,
    118118            ttl, df, &answer);
    119        
     119
    120120        errno_t rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
    121121        if (rc != EOK) {
     
    124124                return rc;
    125125        }
    126        
     126
    127127        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
    128128        if (rc != EOK) {
     
    131131                return rc;
    132132        }
    133        
     133
    134134        rc = async_data_write_start(exch, dgram->data, dgram->size);
    135        
    136         async_exchange_end(exch);
    137        
    138         if (rc != EOK) {
    139                 async_forget(req);
    140                 return rc;
    141         }
    142        
     135
     136        async_exchange_end(exch);
     137
     138        if (rc != EOK) {
     139                async_forget(req);
     140                return rc;
     141        }
     142
    143143        errno_t retval;
    144144        async_wait_for(req, &retval);
    145        
     145
    146146        return retval;
    147147}
     
    150150{
    151151        async_exch_t *exch = async_exchange_begin(inet_sess);
    152        
     152
    153153        ipc_call_t answer;
    154154        aid_t req = async_send_1(exch, INET_GET_SRCADDR, tos, &answer);
    155        
     155
    156156        errno_t rc = async_data_write_start(exch, remote, sizeof(inet_addr_t));
    157157        if (rc != EOK) {
     
    160160                return rc;
    161161        }
    162        
     162
    163163        rc = async_data_read_start(exch, local, sizeof(inet_addr_t));
    164        
    165         async_exchange_end(exch);
    166        
    167         if (rc != EOK) {
    168                 async_forget(req);
    169                 return rc;
    170         }
    171        
     164
     165        async_exchange_end(exch);
     166
     167        if (rc != EOK) {
     168                async_forget(req);
     169                return rc;
     170        }
     171
    172172        errno_t retval;
    173173        async_wait_for(req, &retval);
    174        
     174
    175175        return retval;
    176176}
     
    179179{
    180180        inet_dgram_t dgram;
    181        
     181
    182182        dgram.tos = IPC_GET_ARG1(*icall);
    183183        dgram.iplink = IPC_GET_ARG2(*icall);
    184        
     184
    185185        ipc_callid_t callid;
    186186        size_t size;
     
    190190                return;
    191191        }
    192        
     192
    193193        if (size != sizeof(inet_addr_t)) {
    194194                async_answer_0(callid, EINVAL);
     
    196196                return;
    197197        }
    198        
     198
    199199        errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
    200200        if (rc != EOK) {
     
    203203                return;
    204204        }
    205        
     205
    206206        if (!async_data_write_receive(&callid, &size)) {
    207207                async_answer_0(callid, EINVAL);
     
    209209                return;
    210210        }
    211        
     211
    212212        if (size != sizeof(inet_addr_t)) {
    213213                async_answer_0(callid, EINVAL);
     
    215215                return;
    216216        }
    217        
     217
    218218        rc = async_data_write_finalize(callid, &dgram.dest, size);
    219219        if (rc != EOK) {
     
    222222                return;
    223223        }
    224        
     224
    225225        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    226226        if (rc != EOK) {
     
    228228                return;
    229229        }
    230        
     230
    231231        rc = inet_ev_ops->recv(&dgram);
    232232        free(dgram.data);
     
    239239                ipc_call_t call;
    240240                ipc_callid_t callid = async_get_call(&call);
    241                
     241
    242242                if (!IPC_GET_IMETHOD(call)) {
    243243                        /* TODO: Handle hangup */
    244244                        return;
    245245                }
    246                
     246
    247247                switch (IPC_GET_IMETHOD(call)) {
    248248                case INET_EV_RECV:
Note: See TracChangeset for help on using the changeset viewer.