Changeset 257feec in mainline


Ignore:
Timestamp:
2013-06-27T12:48:32Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9f391e9
Parents:
679ee84
Message:

cstyle (no change in functionality)

Location:
uspace
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/inet/inet.c

    r679ee84 r257feec  
    4444#include <sys/types.h>
    4545
    46 #define NAME "inet"
     46#define NAME  "inet"
    4747
    4848static void print_syntax(void)
    … …  
    257257        if (count > 0)
    258258                printf("    [Addr/Width] [Link-Name] [Addr-Name] [Def-MTU]\n");
    259         ainfo.name = linfo.name = astr = NULL;
     259        ainfo.name = NULL;
     260        linfo.name = NULL;
     261        astr = NULL;
    260262
    261263        for (i = 0; i < count; i++) {
    … …  
    290292                free(astr);
    291293
    292                 ainfo.name = linfo.name = astr = NULL;
     294                ainfo.name = NULL;
     295                linfo.name = NULL;
     296                astr = NULL;
    293297        }
    294298
    … …  
    329333                printf("    [Dest/Width] [Router-Addr] [Route-Name]\n");
    330334
    331         srinfo.name = dest_str = router_str = NULL;
     335        srinfo.name = NULL;
     336        dest_str = NULL;
     337        router_str = NULL;
    332338
    333339        for (i = 0; i < count; i++) {
    … …  
    360366                free(router_str);
    361367
    362                 router_str = srinfo.name = dest_str = NULL;
     368                router_str = NULL;
     369                srinfo.name = NULL;
     370                dest_str = NULL;
    363371        }
    364372

  • uspace/lib/c/include/net/in.h

    r679ee84 r257feec  
    4545#define INET_ADDRSTRLEN  (4 * 3 + 3 + 1)
    4646
    47 #define INADDR_ANY 0
     47#define INADDR_ANY  0
    4848
    4949/** INET address. */

  • uspace/lib/c/include/net/in6.h

    r679ee84 r257feec  
    4343
    4444/** INET6 string address maximum length. */
    45 #define INET6_ADDRSTRLEN        (8 * 4 + 7 + 1)
    46 
    47 /** Type definition of the INET6 address.
    48  * @see in6_addr
    49  */
    50 typedef struct in6_addr in6_addr_t;
    51 
    52 /** Type definition of the INET6 socket address.
    53  * @see sockaddr_in6
    54  */
    55 typedef struct sockaddr_in6     sockaddr_in6_t;
     45#define INET6_ADDRSTRLEN  (8 * 4 + 7 + 1)
    5646
    5747/** INET6 address. */
    58 struct in6_addr {
     48typedef struct in6_addr {
    5949        /** 16 byte IPv6 address. */
    60         unsigned char s6_addr[16];
    61 };
     50        uint8_t s6_addr[16];
     51} in6_addr_t;
    6252
    6353/** INET6 socket address.
    6454 * @see sockaddr
    6555 */
    66 struct sockaddr_in6 {
     56typedef struct sockaddr_in6 {
    6757        /** Address family. Should be AF_INET6. */
    6858        uint16_t sin6_family;
    … …  
    7565        /** Scope identifier. */
    7666        uint32_t sin6_scope_id;
    77 };
     67} sockaddr_in6_t;
    7868
    7969#endif

  • uspace/lib/c/include/net/inet.h

    r679ee84 r257feec  
    4141#include <byteorder.h>
    4242
    43 /** Type definition of the socket address.
    44  * @see sockaddr
    45  */
    46 typedef struct sockaddr         sockaddr_t;
    47 
    4843/** Type definition of the address information.
    4944 * @see addrinfo
    5045 */
    51 typedef struct addrinfo         addrinfo_t;
     46typedef struct addrinfo addrinfo_t;
    5247
    5348/** Socket address. */
    54 struct sockaddr {
     49typedef struct sockaddr {
    5550        /** Address family. @see socket.h */
    5651        uint16_t sa_family;
    5752        /** 14 byte protocol address. */
    5853        uint8_t sa_data[14];
    59 };
     54} sockaddr_t;
    6055
    6156extern int inet_ntop(uint16_t, const uint8_t *, char *, size_t);

  • uspace/lib/c/include/net/socket_codes.h

    r679ee84 r257feec  
    4646enum {
    4747        AF_NONE = 0,
    48         AF_INET,        /* IPv4 address */
    49         AF_INET6        /* IPv6 address */
     48        AF_INET,  /* IPv4 address */
     49        AF_INET6  /* IPv6 address */
    5050};
    5151
    … …  
    5353
    5454/** @name Protocol families definitions
    55  *  Same as address families.
     55 * Same as address families.
    5656 */
    5757/*@{*/
    5858
    59 #define PF_INET         AF_INET
    60 #define PF_INET6        AF_INET6
     59#define PF_INET   AF_INET
     60#define PF_INET6  AF_INET6
    6161
    6262/*@}*/

  • uspace/srv/net/dnsrsrv/transport.c

    r679ee84 r257feec  
    208208                if (rc != EOK)
    209209                        goto error;
    210 
     210               
    211211                treq = treq_create(req);
    212212                if (treq == NULL) {
    … …  
    214214                        goto error;
    215215                }
    216 
    217 
     216               
    218217                fibril_mutex_lock(&treq->done_lock);
    219218                while (treq->done != true) {
    … …  
    225224                        }
    226225                }
    227 
     226               
    228227                fibril_mutex_unlock(&treq->done_lock);
    229 
     228               
    230229                if (rc != ETIMEOUT)
    231230                        break;
    232231        }
    233 
     232       
    234233        if (ntry >= REQ_RETRY_MAX) {
    235234                rc = EIO;
    236235                goto error;
    237236        }
    238 
     237       
    239238        if (treq->status != EOK) {
    240239                rc = treq->status;
    241240                goto error;
    242241        }
    243 
     242       
    244243        *rresp = treq->resp;
    245244        treq_destroy(treq);
    246245        free(req_data);
    247246        return EOK;
     247       
    248248error:
    249249        if (treq != NULL)
    250250                treq_destroy(treq);
     251       
    251252        free(req_data);
    252253        return rc;

  • uspace/srv/net/ethip/arp.c

    r679ee84 r257feec  
    106106        if (rc != EOK)
    107107                return rc;
    108 
     108       
    109109        (void) atrans_wait_timeout(ARP_REQUEST_TIMEOUT);
    110 
     110       
    111111        return atrans_lookup(ip_addr, mac_addr);
    112112}

  • uspace/srv/net/ethip/atrans.c

    r679ee84 r257feec  
    124124int atrans_wait_timeout(suseconds_t timeout)
    125125{
    126         int rc;
    127 
    128126        fibril_mutex_lock(&atrans_list_lock);
    129         rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
     127        int rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
    130128            timeout);
    131129        fibril_mutex_unlock(&atrans_list_lock);
    132 
     130       
    133131        return rc;
    134132}

  • uspace/srv/net/ethip/ethip.c

    r679ee84 r257feec  
    191191        if (rc != EOK)
    192192                return rc;
    193 
     193       
    194194        rc = ethip_nic_send(nic, data, size);
    195195        free(data);
    196 
     196       
    197197        return rc;
    198198}
    … …  
    232232                    frame.etype_len);
    233233        }
    234 
     234       
    235235        free(frame.data);
    236236        return rc;

  • uspace/srv/net/ethip/ethip_nic.c

    r679ee84 r257feec  
    364364{
    365365        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
    366 
     366       
    367367        list_foreach(nic->addr_list, link) {
    368368                ethip_link_addr_t *laddr = list_get_instance(link,
    369369                    ethip_link_addr_t, addr_list);
    370 
     370               
    371371                if (addr == laddr->addr)
    372372                        return laddr;
    373373        }
    374 
     374       
    375375        return NULL;
    376376}

  • uspace/srv/net/ethip/pdu.h

    r679ee84 r257feec  
    4747extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
    4848
    49 
    5049#endif
    5150

  • uspace/srv/net/ethip/std.h

    r679ee84 r257feec  
    4040#include <sys/types.h>
    4141
    42 #define ETH_ADDR_SIZE 6
    43 #define IPV4_ADDR_SIZE 4
    44 #define ETH_FRAME_MIN_SIZE 60
     42#define ETH_ADDR_SIZE       6
     43#define IPV4_ADDR_SIZE      4
     44#define ETH_FRAME_MIN_SIZE  60
    4545
    4646/** Ethernet frame header */
    … …  
    9191};
    9292
    93 
    9493#endif
    9594

  • uspace/srv/net/inetsrv/addrobj.c

    r679ee84 r257feec  
    137137                }
    138138        }
    139 
     139       
    140140        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
    141141        fibril_mutex_unlock(&addr_list_lock);
    142 
     142       
    143143        return NULL;
    144144}

  • uspace/srv/net/inetsrv/addrobj.h

    r679ee84 r257feec  
    5959extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
    6060
    61 
    6261#endif
    6362

  • uspace/srv/net/inetsrv/icmp_std.h

    r679ee84 r257feec  
    4343
    4444/** Type of service used for ICMP */
    45 #define ICMP_TOS        0
     45#define ICMP_TOS  0
    4646
    4747/** ICMP message type */

  • uspace/srv/net/inetsrv/inet_link.c

    r679ee84 r257feec  
    7070                return rc;
    7171        }
    72 
     72       
    7373        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()");
    7474        rc = inet_recv_packet(&packet);
    7575        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc);
    7676        free(packet.data);
    77 
     77       
    7878        return rc;
    7979}
    … …  
    232232        if (ilink->iplink != NULL)
    233233                iplink_close(ilink->iplink);
     234       
    234235        inet_link_delete(ilink);
    235236        return rc;
    … …  
    263264         * inet_pdu_encode().
    264265         */
     266       
    265267        inet_packet_t packet;
    266268       

  • uspace/srv/net/inetsrv/inetcfg.c

    r679ee84 r257feec  
    377377}
    378378
    379 
    380379static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    381380{

  • uspace/srv/net/inetsrv/inetping.c

    r679ee84 r257feec  
    9494        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    9595        async_exchange_end(exch);
    96 
     96       
    9797        if (rc != EOK) {
    9898                async_forget(req);
    9999                return rc;
    100100        }
    101 
     101       
    102102        sysarg_t retval;
    103103        async_wait_for(req, &retval);
    104         if (retval != EOK) {
    105                 return retval;
    106         }
    107 
    108         return EOK;
     104       
     105        return (int) retval;
    109106}
    110107
    … …  
    151148        if (sess == NULL)
    152149                return ENOMEM;
    153 
     150       
    154151        client->sess = sess;
    155152        link_initialize(&client->client_list);
    156 
     153       
    157154        fibril_mutex_lock(&client_list_lock);
    158155        client->ident = ++inetping_ident;
    159156        list_append(&client->client_list, &client_list);
    160157        fibril_mutex_unlock(&client_list_lock);
    161 
     158       
    162159        return EOK;
    163160}
    … …  
    167164        async_hangup(client->sess);
    168165        client->sess = NULL;
    169 
     166       
    170167        fibril_mutex_lock(&client_list_lock);
    171168        list_remove(&client->client_list);
    … …  
    204201        if (rc != EOK)
    205202                return;
    206 
     203       
    207204        while (true) {
    208205                ipc_call_t call;
    209206                ipc_callid_t callid = async_get_call(&call);
    210207                sysarg_t method = IPC_GET_IMETHOD(call);
    211 
     208               
    212209                if (!method) {
    213210                        /* The other side has hung up */
    … …  
    215212                        break;
    216213                }
    217 
     214               
    218215                switch (method) {
    219216                case INETPING_SEND:
    … …  
    227224                }
    228225        }
    229 
     226       
    230227        inetping_client_fini(&client);
    231228}

  • uspace/srv/net/inetsrv/pdu.c

    r679ee84 r257feec  
    203203
    204204        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
    205 
     205       
    206206        if (size < sizeof(ip_header_t)) {
    207207                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
    … …  
    223223                return EINVAL;
    224224        }
    225 
     225       
    226226        if (tot_len > size) {
    227227                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
    … …  
    242242        packet->ttl = hdr->ttl;
    243243        packet->ident = ident;
    244 
     244       
    245245        packet->df = (flags_foff & BIT_V(uint16_t, FF_FLAG_DF)) != 0;
    246246        packet->mf = (flags_foff & BIT_V(uint16_t, FF_FLAG_MF)) != 0;
    247247        packet->offs = foff * FRAG_OFFS_UNIT;
    248 
     248       
    249249        /* XXX IP options */
    250250        data_offs = sizeof(uint32_t) * BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h,
    … …  
    257257                return ENOMEM;
    258258        }
    259 
    260         memcpy(packet->data, (uint8_t *)data + data_offs, packet->size);
    261 
     259       
     260        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
     261       
    262262        return EOK;
    263263}

  • uspace/srv/net/loopip/loopip.c

    r679ee84 r257feec  
    4444#include <stdlib.h>
    4545
    46 #define NAME "loopip"
     46#define NAME  "loopip"
    4747
    4848static int loopip_open(iplink_srv_t *srv);
    … …  
    8181                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu);
    8282        }
    83 
     83       
    8484        return 0;
    8585}
    … …  
    9999                return rc;
    100100        }
    101 
     101       
    102102        iplink_srv_init(&loopip_iplink);
    103103        loopip_iplink.ops = &loopip_iplink_ops;
    104104        loopip_iplink.arg = NULL;
    105 
     105       
    106106        prodcons_initialize(&loopip_rcv_queue);
    107107
    … …  
    117117                return rc;
    118118        }
    119 
     119       
    120120        rc = loc_service_add_to_cat(sid, iplink_cat);
    121121        if (rc != EOK) {
    … …  
    123123                return rc;
    124124        }
    125 
     125       
    126126        fid_t fid = fibril_create(loopip_recv_fibril, NULL);
    127127        if (fid == 0)
    128128                return ENOMEM;
    129 
     129       
    130130        fibril_add_ready(fid);
    131 
     131       
    132132        return EOK;
    133133}
    … …  
    160160        if (rqe == NULL)
    161161                return ENOMEM;
     162       
    162163        /*
    163164         * Clone SDU
    … …  
    170171                return ENOMEM;
    171172        }
    172 
     173       
    173174        memcpy(rqe->sdu.data, sdu->data, sdu->size);
    174175        rqe->sdu.size = sdu->size;
    175 
     176       
    176177        /*
    177178         * Insert to receive queue
    178179         */
    179180        prodcons_produce(&loopip_rcv_queue, &rqe->link);
    180 
     181       
    181182        return EOK;
    182183}
    … …  
    211212                return 1;
    212213        }
    213 
     214       
    214215        rc = loopip_init();
    215216        if (rc != EOK)
    … …  
    219220        task_retval(0);
    220221        async_manager();
    221 
     222       
    222223        /* Not reached */
    223224        return 0;

  • uspace/srv/net/tcp/ncsim.c

    r679ee84 r257feec  
    128128        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()");
    129129
    130 
    131130        while (true) {
    132131                fibril_mutex_lock(&sim_queue_lock);

  • uspace/srv/net/tcp/sock.c

    r679ee84 r257feec  
    429429
    430430        fibril_mutex_unlock(&socket->lock);
    431 
     431       
    432432        switch (trc) {
    433433        case TCP_EOK:
    … …  
    440440                assert(false);
    441441        }
    442 
     442       
    443443        if (rc == EOK)
    444444                fibril_add_ready(socket->recv_fibril);
    445 
     445       
    446446        async_answer_0(callid, rc);
    447447}
    … …  
    687687        socket = (tcp_sockdata_t *)sock_core->specific_data;
    688688        fibril_mutex_lock(&socket->lock);
    689 
     689       
    690690        if (socket->conn == NULL) {
    691691                fibril_mutex_unlock(&socket->lock);
    … …  
    703703                    &socket->recv_buffer_lock);
    704704        }
    705 
     705       
    706706        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    707707
    … …  
    723723                assert(false);
    724724        }
    725 
     725       
    726726        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
     727       
    727728        if (rc != EOK) {
    728729                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    769770                }
    770771        }
    771 
     772       
    772773        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
    773774        if (!async_data_read_receive(&rcallid, &length)) {
    … …  
    777778                return;
    778779        }
    779 
     780       
    780781        if (length > data_len)
    781782                length = data_len;
    782 
     783       
    783784        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    784785        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    785 
     786       
    786787        socket->recv_buffer_used -= length;
    787788        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
    … …  
    792793                tcp_sock_notify_data(socket->sock_core);
    793794        }
    794 
     795       
    795796        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    796797
    … …  
    800801        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    801802        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
    802 
     803       
    803804        fibril_mutex_unlock(&socket->recv_buffer_lock);
    804805        fibril_mutex_unlock(&socket->lock);

  • uspace/srv/net/udp/sock.c

    r679ee84 r257feec  
    222222                assert(false);
    223223        }
    224 
     224       
    225225        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    226226        async_answer_0(callid, rc);
    … …  
    428428        socket = (udp_sockdata_t *)sock_core->specific_data;
    429429        fibril_mutex_lock(&socket->lock);
    430 
     430       
    431431        if (socket->assoc == NULL) {
    432432                fibril_mutex_unlock(&socket->lock);
    … …  
    444444                    &socket->recv_buffer_lock);
    445445        }
    446 
     446       
    447447        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    448448
    … …  
    467467                assert(false);
    468468        }
    469 
     469       
    470470        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     471       
    471472        if (rc != EOK) {
    472473                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    519520                return;
    520521        }
    521 
     522       
    522523        if (length > data_len)
    523524                length = data_len;
    524 
     525       
    525526        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    526527        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    … …  
    528529        if (length < data_len && rc == EOK)
    529530                rc = EOVERFLOW;
    530 
     531       
    531532        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
    532533        IPC_SET_ARG2(answer, 0);
    … …  
    535536        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    536537            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    537 
     538       
    538539        socket->recv_buffer_used = 0;
    539 
     540       
    540541        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    541542        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    612613        while (true) {
    613614                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    614                 while (sock->recv_buffer_used != 0 && sock->sock_core != NULL) {
     615                while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
    615616                        fibril_condvar_wait(&sock->recv_buffer_cv,
    616617                            &sock->recv_buffer_lock);

  • uspace/srv/net/udp/std.h

    r679ee84 r257feec  
    4040#include <sys/types.h>
    4141
    42 #define IP_PROTO_UDP 17
     42#define IP_PROTO_UDP  17
    4343
    4444/** UDP Header */
    … …  
    6464        /** Protocol */
    6565        uint8_t protocol;
    66         /** TCP length */
     66        /** UDP length */
    6767        uint16_t udp_length;
    6868} udp_phdr_t;
Note: See TracChangeset for help on using the changeset viewer.