Changeset a35b458 in mainline for uspace/lib/c/generic/inetcfg.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/inetcfg.c

    r3061bc1 ra35b458  
    119119
    120120        assert(inetcfg_sess == NULL);
    121        
     121
    122122        rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
    123123            IPC_FLAG_BLOCKING);
    124124        if (rc != EOK)
    125125                return ENOENT;
    126        
     126
    127127        inetcfg_sess = loc_service_connect(inet_svc, INTERFACE_INETCFG,
    128128            IPC_FLAG_BLOCKING);
    129129        if (inetcfg_sess == NULL)
    130130                return ENOENT;
    131        
     131
    132132        return EOK;
    133133}
    … …  
    137137{
    138138        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    139        
     139
    140140        ipc_call_t answer;
    141141        aid_t req = async_send_1(exch, INETCFG_ADDR_CREATE_STATIC, link_id,
    142142            &answer);
    143        
     143
    144144        errno_t rc = async_data_write_start(exch, naddr, sizeof(inet_naddr_t));
    145145        if (rc != EOK) {
    … …  
    148148                return rc;
    149149        }
    150        
     150
    151151        rc = async_data_write_start(exch, name, str_size(name));
    152        
    153         async_exchange_end(exch);
    154        
    155         if (rc != EOK) {
    156                 async_forget(req);
    157                 return rc;
    158         }
    159        
    160         errno_t retval;
    161         async_wait_for(req, &retval);
    162        
     152
     153        async_exchange_end(exch);
     154
     155        if (rc != EOK) {
     156                async_forget(req);
     157                return rc;
     158        }
     159
     160        errno_t retval;
     161        async_wait_for(req, &retval);
     162
    163163        *addr_id = IPC_GET_ARG1(answer);
    164        
     164
    165165        return retval;
    166166}
    … …  
    179179{
    180180        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    181        
     181
    182182        ipc_call_t answer;
    183183        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
    184        
     184
    185185        ipc_call_t answer_naddr;
    186186        aid_t req_naddr = async_data_read(exch, &ainfo->naddr,
    187187            sizeof(inet_naddr_t), &answer_naddr);
    188        
     188
    189189        errno_t retval_naddr;
    190190        async_wait_for(req_naddr, &retval_naddr);
    191        
     191
    192192        if (retval_naddr != EOK) {
    193193                async_exchange_end(exch);
    … …  
    195195                return retval_naddr;
    196196        }
    197        
     197
    198198        ipc_call_t answer_name;
    199199        char name_buf[LOC_NAME_MAXLEN + 1];
    200200        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
    201201            &answer_name);
    202        
    203         async_exchange_end(exch);
    204        
     202
     203        async_exchange_end(exch);
     204
    205205        errno_t retval_name;
    206206        async_wait_for(req_name, &retval_name);
    207        
     207
    208208        if (retval_name != EOK) {
    209209                async_forget(req);
    210210                return retval_name;
    211211        }
    212        
    213         errno_t retval;
    214         async_wait_for(req, &retval);
    215        
     212
     213        errno_t retval;
     214        async_wait_for(req, &retval);
     215
    216216        if (retval != EOK)
    217217                return retval;
    218        
     218
    219219        size_t act_size = IPC_GET_ARG2(answer_name);
    220220        assert(act_size <= LOC_NAME_MAXLEN);
    221        
     221
    222222        name_buf[act_size] = '\0';
    223        
     223
    224224        ainfo->ilink = IPC_GET_ARG1(answer);
    225225        ainfo->name = str_dup(name_buf);
    226        
     226
    227227        return EOK;
    228228}
    … …  
    329329{
    330330        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    331        
     331
    332332        ipc_call_t answer;
    333333        aid_t req = async_send_0(exch, INETCFG_SROUTE_CREATE, &answer);
    334        
     334
    335335        errno_t rc = async_data_write_start(exch, dest, sizeof(inet_naddr_t));
    336336        if (rc != EOK) {
    … …  
    339339                return rc;
    340340        }
    341        
     341
    342342        rc = async_data_write_start(exch, router, sizeof(inet_addr_t));
    343343        if (rc != EOK) {
    … …  
    346346                return rc;
    347347        }
    348        
     348
    349349        rc = async_data_write_start(exch, name, str_size(name));
    350        
    351         async_exchange_end(exch);
    352        
    353         if (rc != EOK) {
    354                 async_forget(req);
    355                 return rc;
    356         }
    357        
    358         errno_t retval;
    359         async_wait_for(req, &retval);
    360        
     350
     351        async_exchange_end(exch);
     352
     353        if (rc != EOK) {
     354                async_forget(req);
     355                return rc;
     356        }
     357
     358        errno_t retval;
     359        async_wait_for(req, &retval);
     360
    361361        *sroute_id = IPC_GET_ARG1(answer);
    362        
     362
    363363        return retval;
    364364}
    … …  
    377377{
    378378        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    379        
     379
    380380        ipc_call_t answer;
    381381        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
    382        
     382
    383383        ipc_call_t answer_dest;
    384384        aid_t req_dest = async_data_read(exch, &srinfo->dest,
    385385            sizeof(inet_naddr_t), &answer_dest);
    386        
     386
    387387        errno_t retval_dest;
    388388        async_wait_for(req_dest, &retval_dest);
    389        
     389
    390390        if (retval_dest != EOK) {
    391391                async_exchange_end(exch);
    … …  
    393393                return retval_dest;
    394394        }
    395        
     395
    396396        ipc_call_t answer_router;
    397397        aid_t req_router = async_data_read(exch, &srinfo->router,
    398398            sizeof(inet_addr_t), &answer_router);
    399        
     399
    400400        errno_t retval_router;
    401401        async_wait_for(req_router, &retval_router);
    402        
     402
    403403        if (retval_router != EOK) {
    404404                async_exchange_end(exch);
    … …  
    406406                return retval_router;
    407407        }
    408        
     408
    409409        ipc_call_t answer_name;
    410410        char name_buf[LOC_NAME_MAXLEN + 1];
    411411        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
    412412            &answer_name);
    413        
    414         async_exchange_end(exch);
    415        
     413
     414        async_exchange_end(exch);
     415
    416416        errno_t retval_name;
    417417        async_wait_for(req_name, &retval_name);
    418        
     418
    419419        if (retval_name != EOK) {
    420420                async_forget(req);
    421421                return retval_name;
    422422        }
    423        
    424         errno_t retval;
    425         async_wait_for(req, &retval);
    426        
     423
     424        errno_t retval;
     425        async_wait_for(req, &retval);
     426
    427427        if (retval != EOK)
    428428                return retval;
    429        
     429
    430430        size_t act_size = IPC_GET_ARG2(answer_name);
    431431        assert(act_size <= LOC_NAME_MAXLEN);
    432        
     432
    433433        name_buf[act_size] = '\0';
    434        
     434
    435435        srinfo->name = str_dup(name_buf);
    436        
     436
    437437        return EOK;
    438438}
Note: See TracChangeset for help on using the changeset viewer.