Changeset a35b458 in mainline for uspace/lib/c/generic/inet.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/inet.c

    r3061bc1 ra35b458  
    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.