Changeset b5cf742a in mainline


Ignore:
Timestamp:
2013-06-28T16:22:42Z (11 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
edf0d27
Parents:
e52b4b5
Message:

cstyle (no change in functionality)

Location:
uspace
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest1/nettest1.c

    re52b4b5 rb5cf742a  
    5454
    5555/** Echo module name. */
    56 #define NAME    "Nettest1"
     56#define NAME  "nettest1"
    5757
    5858/** Packet data pattern. */
    59 #define NETTEST1_TEXT   "Networking test 1 - sockets"
     59#define NETTEST1_TEXT  "Networking test 1 - sockets"
    6060
    6161static int family = PF_INET;
    … …  
    114114        int value;
    115115        int rc;
    116 
     116       
    117117        switch (argv[*index][1]) {
    118118        /*
    … …  
    120120         */
    121121        case 'f':
    122                 rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
    123                 if (rc != EOK)
    124                         return rc;
     122                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     123                    socket_parse_protocol_family);
     124                if (rc != EOK)
     125                        return rc;
     126               
     127                family = (uint16_t) value;
    125128                break;
    126129        case 'h':
    … …  
    131134                if (rc != EOK)
    132135                        return rc;
     136               
    133137                break;
    134138        case 'n':
    … …  
    136140                if (rc != EOK)
    137141                        return rc;
     142               
    138143                break;
    139144        case 'p':
    … …  
    141146                if (rc != EOK)
    142147                        return rc;
     148               
    143149                port = (uint16_t) value;
    144150                break;
    … …  
    147153                if (rc != EOK)
    148154                        return rc;
     155               
    149156                size = (value >= 0) ? (size_t) value : 0;
    150157                break;
    151158        case 't':
    152                 rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
    153                 if (rc != EOK)
    154                         return rc;
     159                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     160                    socket_parse_socket_type);
     161                if (rc != EOK)
     162                        return rc;
     163               
    155164                type = (sock_type_t) value;
    156165                break;
    … …  
    158167                verbose = 1;
    159168                break;
     169       
    160170        /*
    161171         * Long options with double dash ('-')
    … …  
    163173        case '-':
    164174                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    165                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     175                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    166176                            socket_parse_protocol_family);
    167177                        if (rc != EOK)
    168178                                return rc;
     179                       
     180                        family = (uint16_t) value;
    169181                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    170182                        nettest1_print_help();
    … …  
    182194                        if (rc != EOK)
    183195                                return rc;
     196                       
    184197                        port = (uint16_t) value;
    185198                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    188201                        if (rc != EOK)
    189202                                return rc;
     203                       
    190204                        type = (sock_type_t) value;
    191205                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    200214                return EINVAL;
    201215        }
    202 
     216       
    203217        return EOK;
    204218}
    … …  
    211225static void nettest1_fill_buffer(char *buffer, size_t size)
    212226{
    213         size_t length;
    214 
    215         length = 0;
     227        size_t length = 0;
    216228        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    217229                memcpy(buffer + length, NETTEST1_TEXT,
    … …  
    219231                length += sizeof(NETTEST1_TEXT) - 1;
    220232        }
    221 
     233       
    222234        memcpy(buffer + length, NETTEST1_TEXT, size - length);
    223235        buffer[size] = '\0';
    … …  
    226238static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    227239{
    228         int rc;
    229 
    230240        if (verbose)
    231241                printf("%d sockets, %d messages\n", nsockets, nmessages);
    232 
    233         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    234         if (rc != EOK)
    235                 return rc;
    236 
     242       
     243        int rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     244        if (rc != EOK)
     245                return rc;
     246       
    237247        if (type == SOCK_STREAM) {
    238248                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    241251                        return rc;
    242252        }
    243 
     253       
    244254        rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    245255            &addrlen, data, size, nmessages);
    246256        if (rc != EOK)
    247257                return rc;
    248 
     258       
    249259        rc = sockets_close(verbose, socket_ids, nsockets);
    250260        if (rc != EOK)
    251261                return rc;
    252 
     262       
    253263        if (verbose)
    254264                printf("\tOK\n");
    255 
     265       
    256266        /****/
    257 
     267       
    258268        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    259269        if (rc != EOK)
    260270                return rc;
    261 
     271       
    262272        if (type == SOCK_STREAM) {
    263273                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    266276                        return rc;
    267277        }
    268 
     278       
    269279        rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    270280            data, size, nmessages);
    271281        if (rc != EOK)
    272282                return rc;
    273 
     283       
    274284        rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    275285            data, size, nmessages);
    276286        if (rc != EOK)
    277287                return rc;
    278 
     288       
    279289        rc = sockets_close(verbose, socket_ids, nsockets);
    280290        if (rc != EOK)
    281291                return rc;
    282 
     292       
    283293        if (verbose)
    284294                printf("\tOK\n");
    285 
     295       
    286296        return EOK;
    287297}
    … …  
    320330                }
    321331        }
    322 
     332       
    323333        /* If not before the last argument containing the host */
    324334        if (index >= argc) {
    … …  
    366376                }
    367377        }
    368 
     378       
    369379        /* Check data buffer size */
    370380        if (size <= 0) {
    … …  
    373383                size = 1024;
    374384        }
    375 
     385       
    376386        /*
    377387         * Prepare data buffer. Allocate size bytes plus one for the
    … …  
    384394        }
    385395        nettest1_fill_buffer(data, size);
    386 
     396       
    387397        /* Check socket count */
    388398        if (sockets <= 0) {
    … …  
    391401                sockets = 2;
    392402        }
    393 
     403       
    394404        /*
    395405         * Prepare socket buffer. Allocate count fields plus the terminating
    … …  
    401411                return ENOMEM;
    402412        }
     413       
    403414        socket_ids[sockets] = 0;
    404 
     415       
    405416        if (verbose)
    406417                printf("Starting tests\n");
    407 
     418       
    408419        rc = gettimeofday(&time_before, NULL);
    409420        if (rc != EOK) {
    … …  
    411422                return rc;
    412423        }
    413 
     424       
    414425        nettest1_test(socket_ids,       1,        1);
    415426        nettest1_test(socket_ids,       1, messages);
    416427        nettest1_test(socket_ids, sockets,        1);
    417428        nettest1_test(socket_ids, sockets, messages);
    418 
     429       
    419430        rc = gettimeofday(&time_after, NULL);
    420431        if (rc != EOK) {
    … …  
    422433                return rc;
    423434        }
    424 
     435       
    425436        printf("Tested in %ld microseconds\n", tv_sub(&time_after,
    426437            &time_before));
    427 
     438       
    428439        if (verbose)
    429440                printf("Exiting\n");
    430 
     441       
    431442        return EOK;
    432443}
    433444
    434 
    435445/** @}
    436446 */

  • uspace/app/nettest2/nettest2.c

    re52b4b5 rb5cf742a  
    5555
    5656/** Echo module name. */
    57 #define NAME    "Nettest2"
     57#define NAME  "nettest2"
    5858
    5959/** Packet data pattern. */
    60 #define NETTEST2_TEXT   "Networking test 2 - transfer"
     60#define NETTEST2_TEXT  "Networking test 2 - transfer"
    6161
    6262static size_t size;
    … …  
    107107static void nettest2_fill_buffer(char *buffer, size_t size)
    108108{
    109         size_t length;
    110 
    111         length = 0;
     109        size_t length = 0;
    112110        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    113111                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    115113                length += sizeof(NETTEST2_TEXT) - 1;
    116114        }
    117 
     115       
    118116        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    119117        buffer[size] = '\0';
    … …  
    130128        int value;
    131129        int rc;
    132 
     130       
    133131        switch (argv[*index][1]) {
    134132        /*
    … …  
    136134         */
    137135        case 'f':
    138                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    139137                    socket_parse_protocol_family);
    140138                if (rc != EOK)
    141139                        return rc;
     140               
     141                family = (uint16_t) value;
    142142                break;
    143143        case 'h':
    144144                nettest2_print_help();
    145145                return EOK;
    146                 break;
    147146        case 'm':
    148147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    149148                if (rc != EOK)
    150149                        return rc;
     150               
    151151                break;
    152152        case 'n':
    … …  
    154154                if (rc != EOK)
    155155                        return rc;
     156               
    156157                break;
    157158        case 'p':
    … …  
    159160                if (rc != EOK)
    160161                        return rc;
     162               
    161163                port = (uint16_t) value;
    162164                break;
    … …  
    165167                if (rc != EOK)
    166168                        return rc;
     169               
    167170                size = (value >= 0) ? (size_t) value : 0;
    168171                break;
    … …  
    172175                if (rc != EOK)
    173176                        return rc;
     177               
    174178                type = (sock_type_t) value;
    175179                break;
    … …  
    177181                verbose = true;
    178182                break;
     183       
    179184        /*
    180185         * Long options with double dash ('-')
    … …  
    182187        case '-':
    183188                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    184                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     189                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    185190                            socket_parse_protocol_family);
    186191                        if (rc != EOK)
    187192                                return rc;
     193                       
     194                        family = (uint16_t) value;
    188195                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    189196                        nettest2_print_help();
    … …  
    201208                        if (rc != EOK)
    202209                                return rc;
     210                       
    203211                        port = (uint16_t) value;
    204212                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    207215                        if (rc != EOK)
    208216                                return rc;
     217                       
    209218                        type = (sock_type_t) value;
    210219                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    219228                return EINVAL;
    220229        }
    221 
     230       
    222231        return EOK;
    223232}
    … …  
    266275                }
    267276        }
    268 
     277       
    269278        /* If not before the last argument containing the host */
    270279        if (index >= argc) {
    … …  
    312321                }
    313322        }
    314 
     323       
    315324        /* Check data buffer size. */
    316325        if (size <= 0) {
    … …  
    319328                size = 1024;
    320329        }
    321 
     330       
    322331        /*
    323332         * Prepare the buffer. Allocate size bytes plus one for terminating
    … …  
    329338                return ENOMEM;
    330339        }
    331 
     340       
    332341        /* Fill buffer with a pattern. */
    333342        nettest2_fill_buffer(data, size);
    334 
     343       
    335344        /* Check socket count. */
    336345        if (sockets <= 0) {
    … …  
    339348                sockets = 2;
    340349        }
    341 
     350       
    342351        /*
    343352         * Prepare the socket buffer.
    … …  
    350359        }
    351360        socket_ids[sockets] = 0;
    352 
     361       
    353362        if (verbose)
    354363                printf("Starting tests\n");
    355 
     364       
    356365        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    357366        if (rc != EOK)
    358367                return rc;
    359 
     368       
    360369        if (type == SOCK_STREAM) {
    361370                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    364373                        return rc;
    365374        }
    366 
     375       
    367376        if (verbose)
    368377                printf("\n");
    369 
     378       
    370379        rc = gettimeofday(&time_before, NULL);
    371380        if (rc != EOK) {
    … …  
    373382                return rc;
    374383        }
    375 
     384       
    376385        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    377386            &addrlen, data, size, messages);
    378387        if (rc != EOK)
    379388                return rc;
    380 
     389       
    381390        rc = gettimeofday(&time_after, NULL);
    382391        if (rc != EOK) {
    … …  
    384393                return rc;
    385394        }
    386 
     395       
    387396        if (verbose)
    388397                printf("\tOK\n");
    389 
     398       
    390399        printf("sendto + recvfrom tested in %ld microseconds\n",
    391400            tv_sub(&time_after, &time_before));
    392 
     401       
    393402        rc = gettimeofday(&time_before, NULL);
    394403        if (rc != EOK) {
    … …  
    396405                return rc;
    397406        }
    398 
     407       
    399408        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    400409            data, size, messages);
    401410        if (rc != EOK)
    402411                return rc;
    403 
     412       
    404413        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    405414            data, size, messages);
    406415        if (rc != EOK)
    407416                return rc;
    408 
     417       
    409418        rc = gettimeofday(&time_after, NULL);
    410419        if (rc != EOK) {
    … …  
    412421                return rc;
    413422        }
    414 
     423       
    415424        if (verbose)
    416425                printf("\tOK\n");
    417 
     426       
    418427        printf("sendto, recvfrom tested in %ld microseconds\n",
    419428            tv_sub(&time_after, &time_before));
    420 
     429       
    421430        rc = sockets_close(verbose, socket_ids, sockets);
    422431        if (rc != EOK)
    423432                return rc;
    424 
     433       
    425434        if (verbose)
    426435                printf("\nExiting\n");
    427 
     436       
    428437        return EOK;
    429438}

  • uspace/app/nterm/conn.c

    re52b4b5 rb5cf742a  
    103103                goto error;
    104104        }
    105 
     105       
    106106        conn_fd = socket(PF_INET, SOCK_STREAM, 0);
    107107        if (conn_fd < 0)
    108108                goto error;
    109 
     109       
    110110        printf("Connecting to host %s port %u\n", addr_s, ntohs(addr.sin_port));
    111 
     111       
    112112        rc = connect(conn_fd, (struct sockaddr *)&addr, sizeof(addr));
    113113        if (rc != EOK)
    114114                goto error;
    115 
     115       
    116116        rcv_fid = fibril_create(rcv_fibril, NULL);
    117117        if (rcv_fid == 0)
    118118                goto error;
    119 
     119       
    120120        fibril_add_ready(rcv_fid);
    121 
     121       
    122122        return EOK;
    123 
     123       
    124124error:
    125125        if (conn_fd >= 0) {
    … …  
    127127                conn_fd = -1;
    128128        }
    129 
     129       
    130130        return EIO;
    131131}
    … …  
    133133int conn_send(void *data, size_t size)
    134134{
    135         int rc;
    136 
    137         rc = send(conn_fd, data, size, 0);
     135        int rc = send(conn_fd, data, size, 0);
    138136        if (rc != EOK)
    139137                return EIO;
    140 
     138       
    141139        return EOK;
    142140}

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

    re52b4b5 rb5cf742a  
    169169        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    170170        dgram.tos = IPC_GET_ARG3(*call);
    171 
     171       
    172172        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    173173        if (rc != EOK) {
    … …  
    175175                return;
    176176        }
    177 
     177       
    178178        rc = inet_ev_ops->recv(&dgram);
    179179        async_answer_0(callid, rc);
    … …  
    185185                ipc_call_t call;
    186186                ipc_callid_t callid = async_get_call(&call);
    187 
     187               
    188188                if (!IPC_GET_IMETHOD(call)) {
    189189                        /* TODO: Handle hangup */
    190190                        return;
    191191                }
    192 
     192               
    193193                switch (IPC_GET_IMETHOD(call)) {
    194194                case INET_EV_RECV:

  • uspace/lib/c/generic/inetcfg.c

    re52b4b5 rb5cf742a  
    159159        *addr_id = IPC_GET_ARG1(answer);
    160160       
    161         return retval;
     161        return (int) retval;
    162162}
    163163
    … …  
    178178        size_t act_size;
    179179        char name_buf[LOC_NAME_MAXLEN + 1];
    180 
    181         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    182 
     180       
     181        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     182       
    183183        ipc_call_t answer;
    184184        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
    185185        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    186186        async_wait_for(dreq, &dretval);
    187 
    188         async_exchange_end(exch);
    189 
     187       
     188        async_exchange_end(exch);
     189       
    190190        if (dretval != EOK) {
    191191                async_forget(req);
    192192                return dretval;
    193193        }
    194 
     194       
    195195        sysarg_t retval;
    196196        async_wait_for(req, &retval);
    197 
     197       
    198198        if (retval != EOK)
    199                 return retval;
    200 
     199                return (int) retval;
     200       
    201201        act_size = IPC_GET_ARG2(dreply);
    202202        assert(act_size <= LOC_NAME_MAXLEN);
     203       
    203204        name_buf[act_size] = '\0';
    204205       
    … …  
    207208        ainfo->ilink = IPC_GET_ARG3(answer);
    208209        ainfo->name = str_dup(name_buf);
    209 
     210       
    210211        return EOK;
    211212}
    … …  
    340341
    341342        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    342 
     343       
    343344        ipc_call_t answer;
    344345        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
    345346        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    346347        async_wait_for(dreq, &dretval);
    347 
    348         async_exchange_end(exch);
    349 
     348       
     349        async_exchange_end(exch);
     350       
    350351        if (dretval != EOK) {
    351352                async_forget(req);
    352353                return dretval;
    353354        }
    354 
     355       
    355356        sysarg_t retval;
    356357        async_wait_for(req, &retval);
    357 
     358       
    358359        if (retval != EOK)
    359                 return retval;
    360 
     360                return (int) retval;
     361       
    361362        act_size = IPC_GET_ARG2(dreply);
    362363        assert(act_size <= LOC_NAME_MAXLEN);
    … …  
    367368        inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
    368369        srinfo->name = str_dup(name_buf);
    369 
     370       
    370371        return EOK;
    371372}

  • uspace/lib/c/generic/iplink.c

    re52b4b5 rb5cf742a  
    9999        sysarg_t retval;
    100100        async_wait_for(req, &retval);
    101         if (retval != EOK)
    102                 return retval;
    103101       
    104         return EOK;
     102        return (int) retval;
    105103}
    106104
    … …  
    169167static void iplink_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    170168{
    171         iplink_t *iplink = (iplink_t *)arg;
    172 
     169        iplink_t *iplink = (iplink_t *) arg;
     170       
    173171        while (true) {
    174172                ipc_call_t call;
    175173                ipc_callid_t callid = async_get_call(&call);
    176 
     174               
    177175                if (!IPC_GET_IMETHOD(call)) {
    178176                        /* TODO: Handle hangup */
    179177                        return;
    180178                }
    181 
     179               
    182180                switch (IPC_GET_IMETHOD(call)) {
    183181                case IPLINK_EV_RECV:

  • uspace/lib/c/generic/iplink_srv.c

    re52b4b5 rb5cf742a  
    4444    ipc_call_t *call)
    4545{
    46         int rc;
    4746        size_t mtu;
    48 
    49         rc = srv->ops->get_mtu(srv, &mtu);
     47        int rc = srv->ops->get_mtu(srv, &mtu);
    5048        async_answer_1(callid, rc, mtu);
    5149}
    … …  
    7068        iplink_srv_sdu_t sdu;
    7169        int rc;
    72 
     70       
    7371        sdu.lsrc = IPC_GET_ARG1(*call);
    7472        sdu.ldest = IPC_GET_ARG2(*call);
    75 
     73       
    7674        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    7775        if (rc != EOK) {
    … …  
    7977                return;
    8078        }
    81 
     79       
    8280        rc = srv->ops->send(srv, &sdu);
    8381        free(sdu.data);
    … …  
    9896        iplink_srv_t *srv = (iplink_srv_t *)arg;
    9997        int rc;
    100 
     98       
    10199        fibril_mutex_lock(&srv->lock);
    102100        if (srv->connected) {
    … …  
    105103                return EBUSY;
    106104        }
    107 
     105       
    108106        srv->connected = true;
    109107        fibril_mutex_unlock(&srv->lock);
    110 
     108       
    111109        /* Accept the connection */
    112110        async_answer_0(iid, EOK);
    113 
     111       
    114112        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    115113        if (sess == NULL)
    116114                return ENOMEM;
    117 
     115       
    118116        srv->client_sess = sess;
    119 
     117       
    120118        rc = srv->ops->open(srv);
    121119        if (rc != EOK)
    122120                return rc;
    123 
     121       
    124122        while (true) {
    125123                ipc_call_t call;
    126124                ipc_callid_t callid = async_get_call(&call);
    127125                sysarg_t method = IPC_GET_IMETHOD(call);
    128 
     126               
    129127                if (!method) {
    130128                        /* The other side has hung up */
    … …  
    135133                        break;
    136134                }
    137 
     135               
    138136                switch (method) {
    139137                case IPLINK_GET_MTU:
    … …  
    153151                }
    154152        }
    155 
     153       
    156154        return srv->ops->close(srv);
    157155}
    … …  
    161159        if (srv->client_sess == NULL)
    162160                return EIO;
    163 
     161       
    164162        async_exch_t *exch = async_exchange_begin(srv->client_sess);
    165 
     163       
    166164        ipc_call_t answer;
    167165        aid_t req = async_send_2(exch, IPLINK_EV_RECV, (sysarg_t) sdu->lsrc,
    … …  
    169167        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    170168        async_exchange_end(exch);
    171 
     169       
    172170        if (rc != EOK) {
    173171                async_forget(req);
    174172                return rc;
    175173        }
    176 
     174       
    177175        sysarg_t retval;
    178176        async_wait_for(req, &retval);
    179177        if (retval != EOK)
    180178                return retval;
    181 
     179       
    182180        return EOK;
    183181}
Note: See TracChangeset for help on using the changeset viewer.