Changeset 8565a42 in mainline for uspace/srv/net


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 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.

Location:
uspace/srv/net
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/dhcp/dhcp.c

    r3061bc1 r8565a42  
    430430
    431431        dlink->retries_left = dhcp_discover_retries;
    432        
     432
    433433        if ((dlink->timeout->state == fts_not_set) ||
    434434            (dlink->timeout->state == fts_fired))
    435435                fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
    436436                    dhcpsrv_discover_timeout, dlink);
    437        
     437
    438438        return rc;
    439439}
    … …  
    507507{
    508508        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
    509        
     509
    510510        dhcp_link_t *dlink = dhcpsrv_link_find(link_id);
    511        
     511
    512512        if (dlink == NULL) {
    513513                log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu doesn't exist",
    … …  
    515515                return EINVAL;
    516516        }
    517        
     517
    518518        return dhcp_discover_proc(dlink);
    519519}

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

    r3061bc1 r8565a42  
    298298{
    299299        assert(buf_size >= 4);
    300        
     300
    301301        uint32_t w = ((uint32_t) buf[0] << 24) +
    302302            ((uint32_t) buf[1] << 16) +
    303303            ((uint32_t) buf[2] << 8) +
    304304            buf[3];
    305        
     305
    306306        return w;
    307307}
    … …  
    311311{
    312312        assert(buf_size >= 16);
    313        
     313
    314314        addr128_t_be2host(buf, addr);
    315315}

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

    r3061bc1 r8565a42  
    9090{
    9191        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    92        
     92
    9393        ip_ver_t ver = IPC_GET_ARG1(*icall);
    94        
     94
    9595        char *name;
    9696        errno_t rc = async_data_write_accept((void **) &name, true, 0,
    … …  
    100100                return;
    101101        }
    102        
     102
    103103        dns_host_info_t *hinfo;
    104104        rc = dns_name2host(name, &hinfo, ver);
    … …  
    107107                return;
    108108        }
    109        
     109
    110110        ipc_callid_t callid;
    111111        size_t size;
    … …  
    115115                return;
    116116        }
    117        
     117
    118118        if (size != sizeof(inet_addr_t)) {
    119119                async_answer_0(callid, EINVAL);
    … …  
    121121                return;
    122122        }
    123        
     123
    124124        rc = async_data_read_finalize(callid, &hinfo->addr, size);
    125125        if (rc != EOK) {
    … …  
    128128                return;
    129129        }
    130        
     130
    131131        if (!async_data_read_receive(&callid, &size)) {
    132132                async_answer_0(callid, EREFUSED);
    … …  
    134134                return;
    135135        }
    136        
     136
    137137        size_t act_size = str_size(hinfo->cname);
    138138        if (act_size > size) {
    … …  
    141141                return;
    142142        }
    143        
     143
    144144        rc = async_data_read_finalize(callid, hinfo->cname, act_size);
    145145        if (rc != EOK)
    146146                async_answer_0(callid, rc);
    147        
     147
    148148        async_answer_0(iid, rc);
    149        
     149
    150150        dns_hostinfo_destroy(hinfo);
    151151}
    … …  
    155155{
    156156        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    157        
     157
    158158        ipc_callid_t callid;
    159159        size_t size;
    … …  
    163163                return;
    164164        }
    165        
     165
    166166        if (size != sizeof(inet_addr_t)) {
    167167                async_answer_0(callid, EINVAL);
    … …  
    169169                return;
    170170        }
    171        
     171
    172172        // FIXME locking
    173        
     173
    174174        errno_t rc = async_data_read_finalize(callid, &dns_server_addr, size);
    175175        if (rc != EOK)
    176176                async_answer_0(callid, rc);
    177        
     177
    178178        async_answer_0(iid, rc);
    179179}
    … …  
    183183{
    184184        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    185        
     185
    186186        ipc_callid_t callid;
    187187        size_t size;
    … …  
    191191                return;
    192192        }
    193        
     193
    194194        if (size != sizeof(inet_addr_t)) {
    195195                async_answer_0(callid, EINVAL);
    … …  
    197197                return;
    198198        }
    199        
     199
    200200        // FIXME locking
    201        
     201
    202202        errno_t rc = async_data_write_finalize(callid, &dns_server_addr, size);
    203203        if (rc != EOK) {
    … …  
    205205                async_answer_0(iid, rc);
    206206        }
    207        
     207
    208208        async_answer_0(iid, rc);
    209209}

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

    r3061bc1 r8565a42  
    5454        if (sname == NULL)
    5555                return ENOMEM;
    56        
     56
    5757        char *qname = str_dup(name);
    5858        if (qname == NULL) {
    … …  
    6060                return ENOMEM;
    6161        }
    62        
     62
    6363        dns_question_t *question = calloc(1, sizeof(dns_question_t));
    6464        if (question == NULL) {
    … …  
    6767                return ENOMEM;
    6868        }
    69        
     69
    7070        question->qname = qname;
    7171        question->qtype = qtype;
    7272        question->qclass = DC_IN;
    73        
     73
    7474        dns_message_t *msg = dns_message_new();
    7575        if (msg == NULL) {
    … …  
    7979                return ENOMEM;
    8080        }
    81        
     81
    8282        msg->id = msg_id++;
    8383        msg->qr = QR_QUERY;
    … …  
    8787        msg->rd = true;
    8888        msg->ra = false;
    89        
     89
    9090        list_append(&question->msg, &msg->question);
    91        
     91
    9292        log_msg(LOG_DEFAULT, LVL_DEBUG, "dns_name_query: send DNS request");
    9393        dns_message_t *amsg;
    … …  
    9898                return rc;
    9999        }
    100        
     100
    101101        list_foreach(amsg->answer, msg, dns_rr_t, rr) {
    102102                log_msg(LOG_DEFAULT, LVL_DEBUG, " - '%s' %u/%u, dsize %zu",
    103103                    rr->name, rr->rtype, rr->rclass, rr->rdata_size);
    104                
     104
    105105                if ((rr->rtype == DTYPE_CNAME) && (rr->rclass == DC_IN) &&
    106106                    (str_cmp(rr->name, sname) == 0)) {
    107                        
     107
    108108                        log_msg(LOG_DEFAULT, LVL_DEBUG, "decode cname (%p, %zu, %zu)",
    109109                            amsg->pdu.data, amsg->pdu.size, rr->roff);
    110                        
     110
    111111                        char *cname;
    112112                        size_t eoff;
    … …  
    114114                        if (rc != EOK) {
    115115                                assert((rc == EINVAL) || (rc == ENOMEM));
    116                                
     116
    117117                                log_msg(LOG_DEFAULT, LVL_DEBUG, "error decoding cname");
    118                                
     118
    119119                                dns_message_destroy(msg);
    120120                                dns_message_destroy(amsg);
    121121                                free(sname);
    122                                
     122
    123123                                return rc;
    124124                        }
    125                        
     125
    126126                        log_msg(LOG_DEFAULT, LVL_DEBUG, "name = '%s' "
    127127                            "cname = '%s'", sname, cname);
    128                        
     128
    129129                        /* Continue looking for the more canonical name */
    130130                        free(sname);
    131131                        sname = cname;
    132132                }
    133                
     133
    134134                if ((qtype == DTYPE_A) && (rr->rtype == DTYPE_A) &&
    135135                    (rr->rclass == DC_IN) && (rr->rdata_size == sizeof(addr32_t)) &&
    136136                    (str_cmp(rr->name, sname) == 0)) {
    137                        
     137
    138138                        info->cname = str_dup(rr->name);
    139139                        if (info->cname == NULL) {
    … …  
    141141                                dns_message_destroy(amsg);
    142142                                free(sname);
    143                                
     143
    144144                                return ENOMEM;
    145145                        }
    146                        
     146
    147147                        inet_addr_set(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
    148148                            &info->addr);
    149                        
     149
    150150                        dns_message_destroy(msg);
    151151                        dns_message_destroy(amsg);
    152152                        free(sname);
    153                        
     153
    154154                        return EOK;
    155155                }
    156                
     156
    157157                if ((qtype == DTYPE_AAAA) && (rr->rtype == DTYPE_AAAA) &&
    158158                    (rr->rclass == DC_IN) && (rr->rdata_size == sizeof(addr128_t)) &&
    159159                    (str_cmp(rr->name, sname) == 0)) {
    160                
     160
    161161                        info->cname = str_dup(rr->name);
    162162                        if (info->cname == NULL) {
    … …  
    164164                                dns_message_destroy(amsg);
    165165                                free(sname);
    166                                
     166
    167167                                return ENOMEM;
    168168                        }
    169                        
     169
    170170                        addr128_t addr;
    171171                        dns_addr128_t_decode(rr->rdata, rr->rdata_size, addr);
    172                        
     172
    173173                        inet_addr_set6(addr, &info->addr);
    174                        
     174
    175175                        dns_message_destroy(msg);
    176176                        dns_message_destroy(amsg);
    177177                        free(sname);
    178                        
     178
    179179                        return EOK;
    180180                }
    181181        }
    182        
     182
    183183        log_msg(LOG_DEFAULT, LVL_DEBUG, "'%s' not resolved, fail", sname);
    184        
     184
    185185        dns_message_destroy(msg);
    186186        dns_message_destroy(amsg);
    187187        free(sname);
    188        
     188
    189189        return EIO;
    190190}
    … …  
    195195        if (info == NULL)
    196196                return ENOMEM;
    197        
     197
    198198        errno_t rc;
    199        
     199
    200200        switch (ver) {
    201201        case ip_any:
    202202                rc = dns_name_query(name, DTYPE_AAAA, info);
    203                
     203
    204204                if (rc != EOK)
    205205                        rc = dns_name_query(name, DTYPE_A, info);
    206                
     206
    207207                break;
    208208        case ip_v4:
    … …  
    215215                rc = EINVAL;
    216216        }
    217        
     217
    218218        if (rc == EOK)
    219219                *rinfo = info;
    220220        else
    221221                free(info);
    222        
     222
    223223        return rc;
    224224}

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

    r3061bc1 r8565a42  
    5555{
    5656        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
    57        
     57
    5858        arp_eth_packet_t packet;
    5959        errno_t rc = arp_pdu_decode(frame->data, frame->size, &packet);
    6060        if (rc != EOK)
    6161                return;
    62        
     62
    6363        log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
    6464            packet.opcode, packet.target_proto_addr);
    65        
     65
    6666        inet_addr_t addr;
    6767        inet_addr_set(packet.target_proto_addr, &addr);
    68        
     68
    6969        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, &addr);
    7070        if (laddr == NULL)
    7171                return;
    72        
     72
    7373        addr32_t laddr_v4;
    7474        ip_ver_t laddr_ver = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
    7575        if (laddr_ver != ip_v4)
    7676                return;
    77        
     77
    7878        log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
    79        
     79
    8080        (void) atrans_add(packet.sender_proto_addr,
    8181            packet.sender_hw_addr);
    82        
     82
    8383        if (packet.opcode == aop_request) {
    8484                arp_eth_packet_t reply;
    85                
     85
    8686                reply.opcode = aop_reply;
    8787                addr48(nic->mac_addr, reply.sender_hw_addr);
    … …  
    8989                addr48(packet.sender_hw_addr, reply.target_hw_addr);
    9090                reply.target_proto_addr = packet.sender_proto_addr;
    91                
     91
    9292                arp_send_packet(nic, &reply);
    9393        }
    … …  
    106106        if (rc == EOK)
    107107                return EOK;
    108        
     108
    109109        arp_eth_packet_t packet;
    110        
     110
    111111        packet.opcode = aop_request;
    112112        addr48(nic->mac_addr, packet.sender_hw_addr);
    … …  
    114114        addr48(addr48_broadcast, packet.target_hw_addr);
    115115        packet.target_proto_addr = ip_addr;
    116        
     116
    117117        rc = arp_send_packet(nic, &packet);
    118118        if (rc != EOK)
    119119                return rc;
    120        
     120
    121121        return atrans_lookup_timeout(ip_addr, ARP_REQUEST_TIMEOUT, mac_addr);
    122122}

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

    r3061bc1 r8565a42  
    8080{
    8181        async_set_fallback_port_handler(ethip_client_conn, NULL);
    82        
     82
    8383        errno_t rc = loc_server_register(NAME);
    8484        if (rc != EOK) {
    … …  
    8686                return rc;
    8787        }
    88        
     88
    8989        rc = ethip_nic_discovery_start();
    9090        if (rc != EOK)
    9191                return rc;
    92        
     92
    9393        return EOK;
    9494}
    … …  
    173173{
    174174        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
    175        
     175
    176176        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    177177        eth_frame_t frame;
    178        
     178
    179179        errno_t rc = arp_translate(nic, sdu->src, sdu->dest, frame.dest);
    180180        if (rc != EOK) {
    … …  
    183183                return rc;
    184184        }
    185        
     185
    186186        addr48(nic->mac_addr, frame.src);
    187187        frame.etype_len = ETYPE_IP;
    188188        frame.data = sdu->data;
    189189        frame.size = sdu->size;
    190        
     190
    191191        void *data;
    192192        size_t size;
    … …  
    194194        if (rc != EOK)
    195195                return rc;
    196        
     196
    197197        rc = ethip_nic_send(nic, data, size);
    198198        free(data);
    199        
     199
    200200        return rc;
    201201}
    … …  
    204204{
    205205        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send6()");
    206        
     206
    207207        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    208208        eth_frame_t frame;
    209        
     209
    210210        addr48(sdu->dest, frame.dest);
    211211        addr48(nic->mac_addr, frame.src);
    … …  
    213213        frame.data = sdu->data;
    214214        frame.size = sdu->size;
    215        
     215
    216216        void *data;
    217217        size_t size;
    … …  
    219219        if (rc != EOK)
    220220                return rc;
    221        
     221
    222222        rc = ethip_nic_send(nic, data, size);
    223223        free(data);
    224        
     224
    225225        return rc;
    226226}
    … …  
    230230        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv);
    231231        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    232        
     232
    233233        log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
    234        
     234
    235235        eth_frame_t frame;
    236236        errno_t rc = eth_pdu_decode(data, size, &frame);
    … …  
    239239                return rc;
    240240        }
    241        
     241
    242242        iplink_recv_sdu_t sdu;
    243        
     243
    244244        switch (frame.etype_len) {
    245245        case ETYPE_ARP:
    … …  
    264264                    frame.etype_len);
    265265        }
    266        
     266
    267267        free(frame.data);
    268268        return rc;
    … …  
    279279{
    280280        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mac48()");
    281        
     281
    282282        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    283283        addr48(nic->mac_addr, *mac);
    284        
     284
    285285        return EOK;
    286286}
    … …  
    289289{
    290290        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_set_mac48()");
    291        
     291
    292292        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    293293        addr48(*mac, nic->mac_addr);
    294        
     294
    295295        return EOK;
    296296}
    … …  
    299299{
    300300        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    301        
     301
    302302        return ethip_nic_addr_add(nic, addr);
    303303}
    … …  
    306306{
    307307        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    308        
     308
    309309        return ethip_nic_addr_remove(nic, addr);
    310310}

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

    r3061bc1 r8565a42  
    6262        /** MAC address */
    6363        addr48_t mac_addr;
    64        
     64
    6565        /**
    6666         * List of IP addresses configured on this link

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

    r3061bc1 r8565a42  
    112112                return NULL;
    113113        }
    114        
     114
    115115        link_initialize(&nic->link);
    116116        list_initialize(&nic->addr_list);
    117        
     117
    118118        return nic;
    119119}
    … …  
    127127                return NULL;
    128128        }
    129        
     129
    130130        link_initialize(&laddr->link);
    131131        laddr->addr = *addr;
    132        
     132
    133133        return laddr;
    134134}
    … …  
    138138        if (nic->svc_name != NULL)
    139139                free(nic->svc_name);
    140        
     140
    141141        free(nic);
    142142}
    … …  
    151151        bool in_list = false;
    152152        nic_address_t nic_address;
    153        
     153
    154154        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_open()");
    155155        ethip_nic_t *nic = ethip_nic_new();
    156156        if (nic == NULL)
    157157                return ENOMEM;
    158        
     158
    159159        errno_t rc = loc_service_get_name(sid, &nic->svc_name);
    160160        if (rc != EOK) {
    … …  
    162162                goto error;
    163163        }
    164        
     164
    165165        nic->sess = loc_service_connect(sid, INTERFACE_DDF, 0);
    166166        if (nic->sess == NULL) {
    … …  
    168168                goto error;
    169169        }
    170        
     170
    171171        nic->svc_id = sid;
    172        
     172
    173173        rc = nic_callback_create(nic->sess, ethip_nic_cb_conn, nic);
    174174        if (rc != EOK) {
    … …  
    192192                goto error;
    193193        }
    194        
     194
    195195        addr48(nic_address.address, nic->mac_addr);
    196196
    … …  
    216216        if (in_list)
    217217                list_remove(&nic->link);
    218        
     218
    219219        if (nic->sess != NULL)
    220220                async_hangup(nic->sess);
    221        
     221
    222222        ethip_nic_delete(nic);
    223223        return rc;
    … …  
    332332                return rc;
    333333        }
    334        
     334
    335335        return ethip_nic_check_new();
    336336}
    … …  
    371371{
    372372        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_setup_multicast()");
    373        
     373
    374374        /* Count the number of multicast addresses */
    375        
     375
    376376        size_t count = 0;
    377        
     377
    378378        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    379379                ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, NULL);
    … …  
    381381                        count++;
    382382        }
    383        
     383
    384384        if (count == 0)
    385385                return nic_multicast_set_mode(nic->sess, NIC_MULTICAST_BLOCKED,
    386386                    NULL, 0);
    387        
     387
    388388        nic_address_t *mac_list = calloc(count, sizeof(nic_address_t));
    389389        if (mac_list == NULL)
    390390                return ENOMEM;
    391        
     391
    392392        /* Create the multicast MAC list */
    393        
     393
    394394        size_t i = 0;
    395        
     395
    396396        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    397397                addr128_t v6;
    … …  
    399399                if (ver != ip_v6)
    400400                        continue;
    401                
     401
    402402                assert(i < count);
    403                
     403
    404404                addr48_t mac;
    405405                addr48_solicited_node(v6, mac);
    406                
     406
    407407                /* Avoid duplicate addresses in the list */
    408                
     408
    409409                bool found = false;
    410                
     410
    411411                for (size_t j = 0; j < i; j++) {
    412412                        if (addr48_compare(mac_list[j].address, mac)) {
    … …  
    415415                        }
    416416                }
    417                
     417
    418418                if (!found) {
    419419                        addr48(mac, mac_list[i].address);
    … …  
    422422                        count--;
    423423        }
    424        
     424
    425425        /* Setup the multicast MAC list */
    426        
     426
    427427        errno_t rc = nic_multicast_set_mode(nic->sess, NIC_MULTICAST_LIST,
    428428            mac_list, count);
    429        
     429
    430430        free(mac_list);
    431431        return rc;
    … …  
    435435{
    436436        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
    437        
     437
    438438        ethip_link_addr_t *laddr = ethip_nic_addr_new(addr);
    439439        if (laddr == NULL)
    440440                return ENOMEM;
    441        
     441
    442442        list_append(&laddr->link, &nic->addr_list);
    443        
     443
    444444        return ethip_nic_setup_multicast(nic);
    445445}
    … …  
    448448{
    449449        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
    450        
     450
    451451        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, addr);
    452452        if (laddr == NULL)
    453453                return ENOENT;
    454        
     454
    455455        list_remove(&laddr->link);
    456456        ethip_link_addr_delete(laddr);
    457        
     457
    458458        return ethip_nic_setup_multicast(nic);
    459459}
    … …  
    463463{
    464464        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
    465        
     465
    466466        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    467467                if (inet_addr_compare(addr, &laddr->addr))
    468468                        return laddr;
    469469        }
    470        
     470
    471471        return NULL;
    472472}

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

    r3061bc1 r8565a42  
    113113{
    114114        fibril_mutex_lock(&addr_list_lock);
    115        
     115
    116116        list_foreach(addr_list, addr_list, inet_addrobj_t, naddr) {
    117117                switch (find) {
    … …  
    134134                }
    135135        }
    136        
     136
    137137        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
    138138        fibril_mutex_unlock(&addr_list_lock);
    139        
     139
    140140        return NULL;
    141141}

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

    r3061bc1 r8565a42  
    5050{
    5151        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv_echo_request()");
    52        
     52
    5353        if (dgram->size < sizeof(icmpv6_message_t))
    5454                return EINVAL;
    55        
     55
    5656        icmpv6_message_t *request = (icmpv6_message_t *) dgram->data;
    5757        size_t size = dgram->size;
    58        
     58
    5959        addr128_t src_v6;
    6060        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
    61        
     61
    6262        addr128_t dest_v6;
    6363        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    64        
     64
    6565        if ((src_ver != dest_ver) || (src_ver != ip_v6))
    6666                return EINVAL;
    67        
     67
    6868        icmpv6_message_t *reply = calloc(1, size);
    6969        if (reply == NULL)
    7070                return ENOMEM;
    71        
     71
    7272        memcpy(reply, request, size);
    73        
     73
    7474        reply->type = ICMPV6_ECHO_REPLY;
    7575        reply->code = 0;
    7676        reply->checksum = 0;
    77        
     77
    7878        inet_dgram_t rdgram;
    79        
     79
    8080        inet_get_srcaddr(&dgram->src, 0, &rdgram.src);
    8181        rdgram.dest = dgram->src;
    … …  
    8484        rdgram.data = reply;
    8585        rdgram.size = size;
    86        
     86
    8787        icmpv6_phdr_t phdr;
    88        
     88
    8989        host2addr128_t_be(dest_v6, phdr.src_addr);
    9090        host2addr128_t_be(src_v6, phdr.dest_addr);
    … …  
    9292        memset(phdr.zeroes, 0, 3);
    9393        phdr.next = IP_PROTO_ICMPV6;
    94        
     94
    9595        uint16_t cs_phdr =
    9696            inet_checksum_calc(INET_CHECKSUM_INIT, &phdr,
    9797            sizeof(icmpv6_phdr_t));
    98        
     98
    9999        uint16_t cs_all = inet_checksum_calc(cs_phdr, reply, size);
    100        
     100
    101101        reply->checksum = host2uint16_t_be(cs_all);
    102        
     102
    103103        errno_t rc = inet_route_packet(&rdgram, IP_PROTO_ICMPV6,
    104104            INET6_HOP_LIMIT_MAX, 0);
    105        
     105
    106106        free(reply);
    107        
     107
    108108        return rc;
    109109}
    … …  
    112112{
    113113        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv_echo_reply()");
    114        
     114
    115115        if (dgram->size < sizeof(icmpv6_message_t))
    116116                return EINVAL;
    117        
     117
    118118        inetping_sdu_t sdu;
    119        
     119
    120120        sdu.src = dgram->src;
    121121        sdu.dest = dgram->dest;
    122        
     122
    123123        icmpv6_message_t *reply = (icmpv6_message_t *) dgram->data;
    124        
     124
    125125        sdu.seq_no = uint16_t_be2host(reply->un.echo.seq_no);
    126126        sdu.data = reply + sizeof(icmpv6_message_t);
    127127        sdu.size = dgram->size - sizeof(icmpv6_message_t);
    128        
     128
    129129        uint16_t ident = uint16_t_be2host(reply->un.echo.ident);
    130        
     130
    131131        return inetping_recv(ident, &sdu);
    132132}
    … …  
    135135{
    136136        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv()");
    137        
     137
    138138        if (dgram->size < 1)
    139139                return EINVAL;
    140        
     140
    141141        uint8_t type = *(uint8_t *) dgram->data;
    142        
     142
    143143        switch (type) {
    144144        case ICMPV6_ECHO_REQUEST:
    … …  
    153153                break;
    154154        }
    155        
     155
    156156        return EINVAL;
    157157}
    … …  
    163163        if (rdata == NULL)
    164164                return ENOMEM;
    165        
     165
    166166        icmpv6_message_t *request = (icmpv6_message_t *) rdata;
    167        
     167
    168168        request->type = ICMPV6_ECHO_REQUEST;
    169169        request->code = 0;
    … …  
    171171        request->un.echo.ident = host2uint16_t_be(ident);
    172172        request->un.echo.seq_no = host2uint16_t_be(sdu->seq_no);
    173        
     173
    174174        memcpy(rdata + sizeof(icmpv6_message_t), sdu->data, sdu->size);
    175        
     175
    176176        inet_dgram_t dgram;
    177        
     177
    178178        dgram.src = sdu->src;
    179179        dgram.dest = sdu->dest;
    … …  
    182182        dgram.data = rdata;
    183183        dgram.size = rsize;
    184        
     184
    185185        icmpv6_phdr_t phdr;
    186        
     186
    187187        assert(sdu->src.version == ip_v6);
    188188        assert(sdu->dest.version == ip_v6);
    189        
     189
    190190        host2addr128_t_be(sdu->src.addr6, phdr.src_addr);
    191191        host2addr128_t_be(sdu->dest.addr6, phdr.dest_addr);
    … …  
    193193        memset(phdr.zeroes, 0, 3);
    194194        phdr.next = IP_PROTO_ICMPV6;
    195        
     195
    196196        uint16_t cs_phdr =
    197197            inet_checksum_calc(INET_CHECKSUM_INIT, &phdr,
    198198            sizeof(icmpv6_phdr_t));
    199        
     199
    200200        uint16_t cs_all = inet_checksum_calc(cs_phdr, rdata, rsize);
    201        
     201
    202202        request->checksum = host2uint16_t_be(cs_all);
    203        
     203
    204204        errno_t rc = inet_route_packet(&dgram, IP_PROTO_ICMPV6,
    205205            INET6_HOP_LIMIT_MAX, 0);
    206        
     206
    207207        free(rdata);
    208        
     208
    209209        return rc;
    210210}

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

    r3061bc1 r8565a42  
    154154        if (ilink->svc_name != NULL)
    155155                free(ilink->svc_name);
    156        
     156
    157157        free(ilink);
    158158}
    … …  
    197197                goto error;
    198198        }
    199        
     199
    200200        /*
    201201         * Get the MAC address of the link. If the link has a MAC
    … …  
    221221
    222222        inet_addrobj_t *addr = NULL;
    223        
     223
    224224        /* XXX FIXME Cannot rely on loopback being the first IP link service!! */
    225225        if (first_link) {
    226226                addr = inet_addrobj_new();
    227                
     227
    228228                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
    229229                first_link = false;
    230230        }
    231        
     231
    232232        if (addr != NULL) {
    233233                addr->ilink = ilink;
    234234                addr->name = str_dup("v4a");
    235                
     235
    236236                rc = inet_addrobj_add(addr);
    237237                if (rc == EOK) {
    … …  
    249249                }
    250250        }
    251        
     251
    252252        inet_addrobj_t *addr6 = NULL;
    253        
     253
    254254        if (first_link6) {
    255255                addr6 = inet_addrobj_new();
    256                
     256
    257257                inet_naddr6(&addr6->naddr, 0, 0, 0, 0, 0, 0, 0, 1, 128);
    258258                first_link6 = false;
    259259        } else if (ilink->mac_valid) {
    260260                addr6 = inet_addrobj_new();
    261                
     261
    262262                addr128_t link_local;
    263263                inet_link_local_node_ip(ilink->mac, link_local);
    264                
     264
    265265                inet_naddr_set6(link_local, 64, &addr6->naddr);
    266266        }
    267        
     267
    268268        if (addr6 != NULL) {
    269269                addr6->ilink = ilink;
    270270                addr6->name = str_dup("v6a");
    271                
     271
    272272                rc = inet_addrobj_add(addr6);
    273273                if (rc == EOK) {
    … …  
    285285                }
    286286        }
    287        
     287
    288288        log_msg(LOG_DEFAULT, LVL_DEBUG, "Configured link '%s'.", ilink->svc_name);
    289289        return EOK;
    290        
     290
    291291error:
    292292        if (ilink->iplink != NULL)
    293293                iplink_close(ilink->iplink);
    294        
     294
    295295        inet_link_delete(ilink);
    296296        return rc;
    … …  
    319319        if (src_ver != ip_v4)
    320320                return EINVAL;
    321        
     321
    322322        addr32_t dest_v4;
    323323        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, &dest_v4, NULL);
    324324        if (dest_ver != ip_v4)
    325325                return EINVAL;
    326        
     326
    327327        /*
    328328         * Fill packet structure. Fragmentation is performed by
    329329         * inet_pdu_encode().
    330330         */
    331        
     331
    332332        iplink_sdu_t sdu;
    333        
     333
    334334        sdu.src = lsrc;
    335335        sdu.dest = ldest;
    336        
     336
    337337        inet_packet_t packet;
    338        
     338
    339339        packet.src = dgram->src;
    340340        packet.dest = dgram->dest;
    … …  
    342342        packet.proto = proto;
    343343        packet.ttl = ttl;
    344        
     344
    345345        /* Allocate identifier */
    346346        fibril_mutex_lock(&ip_ident_lock);
    347347        packet.ident = ++ip_ident;
    348348        fibril_mutex_unlock(&ip_ident_lock);
    349        
     349
    350350        packet.df = df;
    351351        packet.data = dgram->data;
    352352        packet.size = dgram->size;
    353        
     353
    354354        errno_t rc;
    355355        size_t offs = 0;
    356        
     356
    357357        do {
    358358                /* Encode one fragment */
    359                
     359
    360360                size_t roffs;
    361361                rc = inet_pdu_encode(&packet, src_v4, dest_v4, offs, ilink->def_mtu,
    … …  
    363363                if (rc != EOK)
    364364                        return rc;
    365                
     365
    366366                /* Send the PDU */
    367367                rc = iplink_send(ilink->iplink, &sdu);
    368                
     368
    369369                free(sdu.data);
    370370                offs = roffs;
    371371        } while (offs < packet.size);
    372        
     372
    373373        return rc;
    374374}
    … …  
    394394        if (src_ver != ip_v6)
    395395                return EINVAL;
    396        
     396
    397397        addr128_t dest_v6;
    398398        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    399399        if (dest_ver != ip_v6)
    400400                return EINVAL;
    401        
     401
    402402        iplink_sdu6_t sdu6;
    403403        addr48(ldest, sdu6.dest);
    404        
     404
    405405        /*
    406406         * Fill packet structure. Fragmentation is performed by
    407407         * inet_pdu_encode6().
    408408         */
    409        
     409
    410410        inet_packet_t packet;
    411        
     411
    412412        packet.src = dgram->src;
    413413        packet.dest = dgram->dest;
    … …  
    415415        packet.proto = proto;
    416416        packet.ttl = ttl;
    417        
     417
    418418        /* Allocate identifier */
    419419        fibril_mutex_lock(&ip_ident_lock);
    420420        packet.ident = ++ip_ident;
    421421        fibril_mutex_unlock(&ip_ident_lock);
    422        
     422
    423423        packet.df = df;
    424424        packet.data = dgram->data;
    425425        packet.size = dgram->size;
    426        
     426
    427427        errno_t rc;
    428428        size_t offs = 0;
    429        
     429
    430430        do {
    431431                /* Encode one fragment */
    432                
     432
    433433                size_t roffs;
    434434                rc = inet_pdu_encode6(&packet, src_v6, dest_v6, offs, ilink->def_mtu,
    … …  
    436436                if (rc != EOK)
    437437                        return rc;
    438                
     438
    439439                /* Send the PDU */
    440440                rc = iplink_send6(ilink->iplink, &sdu6);
    441                
     441
    442442                free(sdu6.data);
    443443                offs = roffs;
    444444        } while (offs < packet.size);
    445        
     445
    446446        return rc;
    447447}

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

    r3061bc1 r8565a42  
    257257{
    258258        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    259        
     259
    260260        sysarg_t link_id = IPC_GET_ARG1(*icall);
    261        
     261
    262262        ipc_callid_t callid;
    263263        size_t size;
    … …  
    267267                return;
    268268        }
    269        
     269
    270270        if (size != sizeof(inet_naddr_t)) {
    271271                async_answer_0(callid, EINVAL);
    … …  
    273273                return;
    274274        }
    275        
     275
    276276        inet_naddr_t naddr;
    277277        errno_t rc = async_data_write_finalize(callid, &naddr, size);
    … …  
    281281                return;
    282282        }
    283        
     283
    284284        char *name;
    285285        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    … …  
    289289                return;
    290290        }
    291        
     291
    292292        sysarg_t addr_id = 0;
    293293        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    … …  
    312312{
    313313        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    314        
     314
    315315        sysarg_t addr_id = IPC_GET_ARG1(*icall);
    316        
     316
    317317        inet_addr_info_t ainfo;
    318        
     318
    319319        inet_naddr_any(&ainfo.naddr);
    320320        ainfo.ilink = 0;
    321321        ainfo.name = NULL;
    322        
     322
    323323        errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
    324324        if (rc != EOK) {
    … …  
    326326                return;
    327327        }
    328        
     328
    329329        ipc_callid_t callid;
    330330        size_t size;
    … …  
    334334                return;
    335335        }
    336        
     336
    337337        if (size != sizeof(inet_naddr_t)) {
    338338                async_answer_0(callid, EINVAL);
    … …  
    340340                return;
    341341        }
    342        
     342
    343343        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
    344344        if (rc != EOK) {
    … …  
    347347                return;
    348348        }
    349        
     349
    350350        if (!async_data_read_receive(&callid, &size)) {
    351351                async_answer_0(callid, EREFUSED);
    … …  
    353353                return;
    354354        }
    355        
     355
    356356        rc = async_data_read_finalize(callid, ainfo.name,
    357357            min(size, str_size(ainfo.name)));
    358358        free(ainfo.name);
    359        
    360         if (rc != EOK) {
    361                 async_answer_0(callid, rc);
    362                 async_answer_0(iid, rc);
    363                 return;
    364         }
    365        
     359
     360        if (rc != EOK) {
     361                async_answer_0(callid, rc);
     362                async_answer_0(iid, rc);
     363                return;
     364        }
     365
    366366        async_answer_1(iid, rc, ainfo.ilink);
    367367}
    … …  
    584584                return;
    585585        }
    586        
     586
    587587        if (size != sizeof(inet_naddr_t)) {
    588588                async_answer_0(callid, EINVAL);
    … …  
    590590                return;
    591591        }
    592        
     592
    593593        inet_naddr_t dest;
    594594        errno_t rc = async_data_write_finalize(callid, &dest, size);
    … …  
    598598                return;
    599599        }
    600        
     600
    601601        if (!async_data_write_receive(&callid, &size)) {
    602602                async_answer_0(callid, EINVAL);
    … …  
    604604                return;
    605605        }
    606        
     606
    607607        if (size != sizeof(inet_addr_t)) {
    608608                async_answer_0(callid, EINVAL);
    … …  
    610610                return;
    611611        }
    612        
     612
    613613        inet_addr_t router;
    614614        rc = async_data_write_finalize(callid, &router, size);
    … …  
    618618                return;
    619619        }
    620        
     620
    621621        char *name;
    622622        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    … …  
    626626                return;
    627627        }
    628        
     628
    629629        sysarg_t sroute_id = 0;
    630630        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    … …  
    649649{
    650650        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    651        
     651
    652652        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
    653        
     653
    654654        inet_sroute_info_t srinfo;
    655        
     655
    656656        inet_naddr_any(&srinfo.dest);
    657657        inet_addr_any(&srinfo.router);
    658658        srinfo.name = NULL;
    659        
     659
    660660        errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
    661661        if (rc != EOK) {
    … …  
    663663                return;
    664664        }
    665        
     665
    666666        ipc_callid_t callid;
    667667        size_t size;
    … …  
    671671                return;
    672672        }
    673        
     673
    674674        if (size != sizeof(inet_naddr_t)) {
    675675                async_answer_0(callid, EINVAL);
    … …  
    677677                return;
    678678        }
    679        
     679
    680680        rc = async_data_read_finalize(callid, &srinfo.dest, size);
    681681        if (rc != EOK) {
    … …  
    684684                return;
    685685        }
    686        
     686
    687687        if (!async_data_read_receive(&callid, &size)) {
    688688                async_answer_0(callid, EREFUSED);
    … …  
    690690                return;
    691691        }
    692        
     692
    693693        if (size != sizeof(inet_addr_t)) {
    694694                async_answer_0(callid, EINVAL);
    … …  
    696696                return;
    697697        }
    698        
     698
    699699        rc = async_data_read_finalize(callid, &srinfo.router, size);
    700700        if (rc != EOK) {
    … …  
    703703                return;
    704704        }
    705        
     705
    706706        if (!async_data_read_receive(&callid, &size)) {
    707707                async_answer_0(callid, EREFUSED);
    … …  
    709709                return;
    710710        }
    711        
     711
    712712        rc = async_data_read_finalize(callid, srinfo.name,
    713713            min(size, str_size(srinfo.name)));
    714714        free(srinfo.name);
    715        
     715
    716716        async_answer_0(iid, rc);
    717717}

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

    r3061bc1 r8565a42  
    8787{
    8888        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()");
    89        
     89
    9090        port_id_t port;
    9191        errno_t rc = async_create_port(INTERFACE_INET,
    … …  
    9393        if (rc != EOK)
    9494                return rc;
    95        
     95
    9696        rc = async_create_port(INTERFACE_INETCFG,
    9797            inet_cfg_conn, NULL, &port);
    9898        if (rc != EOK)
    9999                return rc;
    100        
     100
    101101        rc = async_create_port(INTERFACE_INETPING,
    102102            inetping_conn, NULL, &port);
    103103        if (rc != EOK)
    104104                return rc;
    105        
     105
    106106        rc = loc_server_register(NAME);
    107107        if (rc != EOK) {
    … …  
    109109                return EEXIST;
    110110        }
    111        
     111
    112112        service_id_t sid;
    113113        rc = loc_service_register(SERVICE_NAME_INET, &sid);
    … …  
    116116                return EEXIST;
    117117        }
    118        
     118
    119119        return EOK;
    120120}
    … …  
    234234{
    235235        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
    236        
     236
    237237        uint8_t tos = IPC_GET_ARG1(*icall);
    238        
     238
    239239        ipc_callid_t callid;
    240240        size_t size;
    … …  
    244244                return;
    245245        }
    246        
     246
    247247        if (size != sizeof(inet_addr_t)) {
    248248                async_answer_0(callid, EINVAL);
    … …  
    250250                return;
    251251        }
    252        
     252
    253253        inet_addr_t remote;
    254254        errno_t rc = async_data_write_finalize(callid, &remote, size);
    … …  
    257257                async_answer_0(iid, rc);
    258258        }
    259        
     259
    260260        inet_addr_t local;
    261261        rc = inet_get_srcaddr(&remote, tos, &local);
    … …  
    264264                return;
    265265        }
    266        
     266
    267267        if (!async_data_read_receive(&callid, &size)) {
    268268                async_answer_0(callid, EREFUSED);
    … …  
    270270                return;
    271271        }
    272        
     272
    273273        if (size != sizeof(inet_addr_t)) {
    274274                async_answer_0(callid, EINVAL);
    … …  
    276276                return;
    277277        }
    278        
     278
    279279        rc = async_data_read_finalize(callid, &local, size);
    280280        if (rc != EOK) {
    … …  
    283283                return;
    284284        }
    285        
     285
    286286        async_answer_0(iid, rc);
    287287}
    … …  
    291291{
    292292        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
    293        
     293
    294294        inet_dgram_t dgram;
    295        
     295
    296296        dgram.iplink = IPC_GET_ARG1(*icall);
    297297        dgram.tos = IPC_GET_ARG2(*icall);
    298        
     298
    299299        uint8_t ttl = IPC_GET_ARG3(*icall);
    300300        int df = IPC_GET_ARG4(*icall);
    301        
     301
    302302        ipc_callid_t callid;
    303303        size_t size;
    … …  
    307307                return;
    308308        }
    309        
     309
    310310        if (size != sizeof(inet_addr_t)) {
    311311                async_answer_0(callid, EINVAL);
    … …  
    313313                return;
    314314        }
    315        
     315
    316316        errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
    317317        if (rc != EOK) {
    … …  
    319319                async_answer_0(iid, rc);
    320320        }
    321        
     321
    322322        if (!async_data_write_receive(&callid, &size)) {
    323323                async_answer_0(callid, EREFUSED);
    … …  
    325325                return;
    326326        }
    327        
     327
    328328        if (size != sizeof(inet_addr_t)) {
    329329                async_answer_0(callid, EINVAL);
    … …  
    331331                return;
    332332        }
    333        
     333
    334334        rc = async_data_write_finalize(callid, &dgram.dest, size);
    335335        if (rc != EOK) {
    … …  
    337337                async_answer_0(iid, rc);
    338338        }
    339        
     339
    340340        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0,
    341341            &dgram.size);
    … …  
    344344                return;
    345345        }
    346        
     346
    347347        rc = inet_send(client, &dgram, client->protocol, ttl, df);
    348        
     348
    349349        free(dgram.data);
    350350        async_answer_0(iid, rc);

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

    r3061bc1 r8565a42  
    6868        inet_dgram_t dgram;
    6969        ndp_pdu_encode(packet, &dgram);
    70        
     70
    7171        inet_link_send_dgram6(link, packet->target_hw_addr, &dgram,
    7272            IP_PROTO_ICMPV6, INET6_HOP_LIMIT_MAX, 0);
    73        
     73
    7474        free(dgram.data);
    75        
     75
    7676        return EOK;
    7777}
    … …  
    8686{
    8787        log_msg(LOG_DEFAULT, LVL_DEBUG, "ndp_received()");
    88        
     88
    8989        ndp_packet_t packet;
    9090        errno_t rc = ndp_pdu_decode(dgram, &packet);
    9191        if (rc != EOK)
    9292                return rc;
    93        
     93
    9494        inet_addr_t sender;
    9595        inet_addr_set6(packet.sender_proto_addr, &sender);
    96        
     96
    9797        inet_addr_t target;
    9898        inet_addr_set6(packet.target_proto_addr, &target);
    99        
     99
    100100        inet_addrobj_t *laddr;
    101        
     101
    102102        log_msg(LOG_DEFAULT, LVL_DEBUG, "NDP PDU decoded; opcode: %d",
    103103            packet.opcode);
    104        
     104
    105105        switch (packet.opcode) {
    106106        case ICMPV6_NEIGHBOUR_SOLICITATION:
    … …  
    111111                        if (rc != EOK)
    112112                                return rc;
    113                        
     113
    114114                        ndp_packet_t reply;
    115                        
     115
    116116                        reply.opcode = ICMPV6_NEIGHBOUR_ADVERTISEMENT;
    117117                        addr48(laddr->ilink->mac, reply.sender_hw_addr);
    … …  
    119119                        addr48(packet.sender_hw_addr, reply.target_hw_addr);
    120120                        addr128(packet.sender_proto_addr, reply.target_proto_addr);
    121                        
     121
    122122                        ndp_send_packet(laddr->ilink, &reply);
    123123                }
    124                
     124
    125125                break;
    126126        case ICMPV6_NEIGHBOUR_ADVERTISEMENT:
    … …  
    129129                        return ntrans_add(packet.sender_proto_addr,
    130130                            packet.sender_hw_addr);
    131                
     131
    132132                break;
    133133        case ICMPV6_ROUTER_ADVERTISEMENT:
    … …  
    136136                return ENOTSUP;
    137137        }
    138        
     138
    139139        return EOK;
    140140}
    … …  
    159159                return EOK;
    160160        }
    161        
     161
    162162        errno_t rc = ntrans_lookup(ip_addr, mac_addr);
    163163        if (rc == EOK)
    164164                return EOK;
    165        
     165
    166166        ndp_packet_t packet;
    167        
     167
    168168        packet.opcode = ICMPV6_NEIGHBOUR_SOLICITATION;
    169169        addr48(ilink->mac, packet.sender_hw_addr);
    … …  
    172172        addr48_solicited_node(ip_addr, packet.target_hw_addr);
    173173        ndp_solicited_node_ip(ip_addr, packet.target_proto_addr);
    174        
     174
    175175        rc = ndp_send_packet(ilink, &packet);
    176176        if (rc != EOK)
    177177                return rc;
    178        
     178
    179179        (void) ntrans_wait_timeout(NDP_REQUEST_TIMEOUT);
    180        
     180
    181181        return ntrans_lookup(ip_addr, mac_addr);
    182182}

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

    r3061bc1 r8565a42  
    142142                return ENOENT;
    143143        }
    144        
     144
    145145        fibril_mutex_unlock(&ntrans_list_lock);
    146146        addr48(ntrans->mac_addr, mac_addr);
    … …  
    162162            timeout);
    163163        fibril_mutex_unlock(&ntrans_list_lock);
    164        
     164
    165165        return rc;
    166166}

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

    r3061bc1 r8565a42  
    107107        /* Upper bound for fragment offset field */
    108108        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l + 1);
    109        
     109
    110110        /* Verify that total size of datagram is within reasonable bounds */
    111111        if (packet->size > FRAG_OFFS_UNIT * fragoff_limit)
    112112                return ELIMIT;
    113        
     113
    114114        size_t hdr_size = sizeof(ip_header_t);
    115115        if (hdr_size >= mtu)
    116116                return EINVAL;
    117        
     117
    118118        assert(hdr_size % 4 == 0);
    119119        assert(offs % FRAG_OFFS_UNIT == 0);
    120120        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
    121        
     121
    122122        /* Value for the fragment offset field */
    123123        uint16_t foff = offs / FRAG_OFFS_UNIT;
    124        
     124
    125125        /* Amount of space in the PDU available for payload */
    126126        size_t spc_avail = mtu - hdr_size;
    127127        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
    128        
     128
    129129        /* Amount of data (payload) to transfer */
    130130        size_t xfer_size = min(packet->size - offs, spc_avail);
    131        
     131
    132132        /* Total PDU size */
    133133        size_t size = hdr_size + xfer_size;
    134        
     134
    135135        /* Offset of remaining payload */
    136136        size_t rem_offs = offs + xfer_size;
    137        
     137
    138138        /* Flags */
    139139        uint16_t flags_foff =
    … …  
    141141            (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
    142142            (foff << FF_FRAGOFF_l);
    143        
     143
    144144        void *data = calloc(size, 1);
    145145        if (data == NULL)
    146146                return ENOMEM;
    147        
     147
    148148        /* Encode header fields */
    149149        ip_header_t *hdr = (ip_header_t *) data;
    150        
     150
    151151        hdr->ver_ihl =
    152152            (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    … …  
    160160        hdr->src_addr = host2uint32_t_be(src);
    161161        hdr->dest_addr = host2uint32_t_be(dest);
    162        
     162
    163163        /* Compute checksum */
    164164        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
    165165            (void *) hdr, hdr_size);
    166166        hdr->chksum = host2uint16_t_be(chksum);
    167        
     167
    168168        /* Copy payload */
    169169        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
    170        
     170
    171171        *rdata = data;
    172172        *rsize = size;
    173173        *roffs = rem_offs;
    174        
     174
    175175        return EOK;
    176176}
    … …  
    200200        if (mtu < 1280)
    201201                return ELIMIT;
    202        
     202
    203203        /* Upper bound for fragment offset field */
    204204        size_t fragoff_limit = 1 << (OF_FRAGOFF_h - OF_FRAGOFF_l);
    205        
     205
    206206        /* Verify that total size of datagram is within reasonable bounds */
    207207        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
    208208                return ELIMIT;
    209        
     209
    210210        /* Determine whether we need the Fragment extension header */
    211211        bool fragment;
    … …  
    214214        else
    215215                fragment = true;
    216        
     216
    217217        size_t hdr_size;
    218218        if (fragment)
    … …  
    220220        else
    221221                hdr_size = sizeof(ip6_header_t);
    222        
     222
    223223        if (hdr_size >= mtu)
    224224                return EINVAL;
    225        
     225
    226226        static_assert(sizeof(ip6_header_t) % 8 == 0);
    227227        assert(hdr_size % 8 == 0);
    228228        assert(offs % FRAG_OFFS_UNIT == 0);
    229229        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
    230        
     230
    231231        /* Value for the fragment offset field */
    232232        uint16_t foff = offs / FRAG_OFFS_UNIT;
    233        
     233
    234234        /* Amount of space in the PDU available for payload */
    235235        size_t spc_avail = mtu - hdr_size;
    236236        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
    237        
     237
    238238        /* Amount of data (payload) to transfer */
    239239        size_t xfer_size = min(packet->size - offs, spc_avail);
    240        
     240
    241241        /* Total PDU size */
    242242        size_t size = hdr_size + xfer_size;
    243        
     243
    244244        /* Offset of remaining payload */
    245245        size_t rem_offs = offs + xfer_size;
    246        
     246
    247247        /* Flags */
    248248        uint16_t offsmf =
    249249            (rem_offs < packet->size ? BIT_V(uint16_t, OF_FLAG_M) : 0) +
    250250            (foff << OF_FRAGOFF_l);
    251        
     251
    252252        void *data = calloc(size, 1);
    253253        if (data == NULL)
    254254                return ENOMEM;
    255        
     255
    256256        /* Encode header fields */
    257257        ip6_header_t *hdr6 = (ip6_header_t *) data;
    258        
     258
    259259        hdr6->ver_tc = (6 << (VI_VERSION_l));
    260260        memset(hdr6->tc_fl, 0, 3);
    261261        hdr6->hop_limit = packet->ttl;
    262        
     262
    263263        host2addr128_t_be(src, hdr6->src_addr);
    264264        host2addr128_t_be(dest, hdr6->dest_addr);
    265        
     265
    266266        /* Optionally encode Fragment extension header fields */
    267267        if (fragment) {
    268268                assert(offsmf != 0);
    269                
     269
    270270                hdr6->payload_len = host2uint16_t_be(packet->size +
    271271                    sizeof(ip6_header_fragment_t));
    272272                hdr6->next = IP6_NEXT_FRAGMENT;
    273                
     273
    274274                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
    275275                    (hdr6 + 1);
    276                
     276
    277277                hdr6f->next = packet->proto;
    278278                hdr6f->reserved = 0;
    … …  
    281281        } else {
    282282                assert(offsmf == 0);
    283                
     283
    284284                hdr6->payload_len = host2uint16_t_be(packet->size);
    285285                hdr6->next = packet->proto;
    286286        }
    287        
     287
    288288        /* Copy payload */
    289289        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
    290        
     290
    291291        *rdata = data;
    292292        *rsize = size;
    293293        *roffs = rem_offs;
    294        
     294
    295295        return EOK;
    296296}
    … …  
    312312{
    313313        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
    314        
     314
    315315        if (size < sizeof(ip_header_t)) {
    316316                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
    317317                return EINVAL;
    318318        }
    319        
     319
    320320        ip_header_t *hdr = (ip_header_t *) data;
    321        
     321
    322322        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
    323323            VI_VERSION_l, hdr->ver_ihl);
    … …  
    326326                return EINVAL;
    327327        }
    328        
     328
    329329        size_t tot_len = uint16_t_be2host(hdr->tot_len);
    330330        if (tot_len < sizeof(ip_header_t)) {
    … …  
    332332                return EINVAL;
    333333        }
    334        
     334
    335335        if (tot_len > size) {
    336336                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
    … …  
    338338                return EINVAL;
    339339        }
    340        
     340
    341341        uint16_t ident = uint16_t_be2host(hdr->id);
    342342        uint16_t flags_foff = uint16_t_be2host(hdr->flags_foff);
    … …  
    344344            flags_foff);
    345345        /* XXX Checksum */
    346        
     346
    347347        inet_addr_set(uint32_t_be2host(hdr->src_addr), &packet->src);
    348348        inet_addr_set(uint32_t_be2host(hdr->dest_addr), &packet->dest);
    … …  
    351351        packet->ttl = hdr->ttl;
    352352        packet->ident = ident;
    353        
     353
    354354        packet->df = (flags_foff & BIT_V(uint16_t, FF_FLAG_DF)) != 0;
    355355        packet->mf = (flags_foff & BIT_V(uint16_t, FF_FLAG_MF)) != 0;
    356356        packet->offs = foff * FRAG_OFFS_UNIT;
    357        
     357
    358358        /* XXX IP options */
    359359        size_t data_offs = sizeof(uint32_t) *
    360360            BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h, VI_IHL_l, hdr->ver_ihl);
    361        
     361
    362362        packet->size = tot_len - data_offs;
    363363        packet->data = calloc(packet->size, 1);
    … …  
    366366                return ENOMEM;
    367367        }
    368        
     368
    369369        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
    370370        packet->link_id = link_id;
    371        
     371
    372372        return EOK;
    373373}
    … …  
    389389{
    390390        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode6()");
    391        
     391
    392392        if (size < sizeof(ip6_header_t)) {
    393393                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
    394394                return EINVAL;
    395395        }
    396        
     396
    397397        ip6_header_t *hdr6 = (ip6_header_t *) data;
    398        
     398
    399399        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
    400400            VI_VERSION_l, hdr6->ver_tc);
    … …  
    403403                return EINVAL;
    404404        }
    405        
     405
    406406        size_t payload_len = uint16_t_be2host(hdr6->payload_len);
    407407        if (payload_len + sizeof(ip6_header_t) > size) {
    … …  
    410410                return EINVAL;
    411411        }
    412        
     412
    413413        uint32_t ident;
    414414        uint16_t offsmf;
    … …  
    416416        uint16_t next;
    417417        size_t data_offs = sizeof(ip6_header_t);
    418        
     418
    419419        /* Fragment extension header */
    420420        if (hdr6->next == IP6_NEXT_FRAGMENT) {
    421421                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
    422422                    (hdr6 + 1);
    423                
     423
    424424                ident = uint32_t_be2host(hdr6f->id);
    425425                offsmf = uint16_t_be2host(hdr6f->offsmf);
    … …  
    435435                next = hdr6->next;
    436436        }
    437        
     437
    438438        addr128_t src;
    439439        addr128_t dest;
    440        
     440
    441441        addr128_t_be2host(hdr6->src_addr, src);
    442442        inet_addr_set6(src, &packet->src);
    443        
     443
    444444        addr128_t_be2host(hdr6->dest_addr, dest);
    445445        inet_addr_set6(dest, &packet->dest);
    446        
     446
    447447        packet->tos = 0;
    448448        packet->proto = next;
    449449        packet->ttl = hdr6->hop_limit;
    450450        packet->ident = ident;
    451        
     451
    452452        packet->df = 1;
    453453        packet->mf = (offsmf & BIT_V(uint16_t, OF_FLAG_M)) != 0;
    454454        packet->offs = foff * FRAG_OFFS_UNIT;
    455        
     455
    456456        packet->size = payload_len;
    457457        packet->data = calloc(packet->size, 1);
    … …  
    460460                return ENOMEM;
    461461        }
    462        
     462
    463463        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
    464464        packet->link_id = link_id;
    … …  
    480480        dgram->tos = 0;
    481481        dgram->size = sizeof(icmpv6_message_t) + sizeof(ndp_message_t);
    482        
     482
    483483        dgram->data = calloc(1, dgram->size);
    484484        if (dgram->data == NULL)
    485485                return ENOMEM;
    486        
     486
    487487        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
    488        
     488
    489489        icmpv6->type = ndp->opcode;
    490490        icmpv6->code = 0;
    491491        memset(icmpv6->un.ndp.reserved, 0, 3);
    492        
     492
    493493        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
    494        
     494
    495495        if (ndp->opcode == ICMPV6_NEIGHBOUR_SOLICITATION) {
    496496                host2addr128_t_be(ndp->solicited_ip, message->target_address);
    … …  
    502502                icmpv6->un.ndp.flags = NDP_FLAG_OVERRIDE | NDP_FLAG_SOLICITED;
    503503        }
    504        
     504
    505505        message->length = 1;
    506506        addr48(ndp->sender_hw_addr, message->mac);
    507        
     507
    508508        icmpv6_phdr_t phdr;
    509        
     509
    510510        host2addr128_t_be(ndp->sender_proto_addr, phdr.src_addr);
    511511        host2addr128_t_be(ndp->target_proto_addr, phdr.dest_addr);
    … …  
    513513        memset(phdr.zeroes, 0, 3);
    514514        phdr.next = IP_PROTO_ICMPV6;
    515        
     515
    516516        uint16_t cs_phdr =
    517517            inet_checksum_calc(INET_CHECKSUM_INIT, &phdr,
    518518            sizeof(icmpv6_phdr_t));
    519        
     519
    520520        uint16_t cs_all = inet_checksum_calc(cs_phdr, dgram->data,
    521521            dgram->size);
    522        
     522
    523523        icmpv6->checksum = host2uint16_t_be(cs_all);
    524        
     524
    525525        return EOK;
    526526}
    … …  
    541541        if (src_ver != ip_v6)
    542542                return EINVAL;
    543        
     543
    544544        if (dgram->size < sizeof(icmpv6_message_t) + sizeof(ndp_message_t))
    545545                return EINVAL;
    546        
     546
    547547        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
    548        
     548
    549549        ndp->opcode = icmpv6->type;
    550        
     550
    551551        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
    552        
     552
    553553        addr128_t_be2host(message->target_address, ndp->target_proto_addr);
    554554        addr48(message->mac, ndp->sender_hw_addr);
    555        
     555
    556556        return EOK;
    557557}

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

    r3061bc1 r8565a42  
    9696{
    9797        ip_ver_t addr_ver = inet_addr_get(addr, NULL, NULL);
    98        
     98
    9999        inet_sroute_t *best = NULL;
    100100        uint8_t best_bits = 0;
    101        
    102         fibril_mutex_lock(&sroute_list_lock);
    103        
     101
     102        fibril_mutex_lock(&sroute_list_lock);
     103
    104104        list_foreach(sroute_list, sroute_list, inet_sroute_t, sroute) {
    105105                uint8_t dest_bits;
    106106                ip_ver_t dest_ver = inet_naddr_get(&sroute->dest, NULL, NULL,
    107107                    &dest_bits);
    108                
     108
    109109                /* Skip comparison with different address family */
    110110                if (addr_ver != dest_ver)
    111111                        continue;
    112                
     112
    113113                /* Look for the most specific route */
    114114                if ((best != NULL) && (best_bits >= dest_bits))
    115115                        continue;
    116                
     116
    117117                if (inet_naddr_compare_mask(&sroute->dest, addr)) {
    118118                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
    119119                            sroute);
    120                        
     120
    121121                        best = sroute;
    122122                        best_bits = dest_bits;
    123123                }
    124124        }
    125        
     125
    126126        if (best == NULL)
    127127                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
    128        
    129         fibril_mutex_unlock(&sroute_list_lock);
    130        
     128
     129        fibril_mutex_unlock(&sroute_list_lock);
     130
    131131        return best;
    132132}

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

    r3061bc1 r8565a42  
    7777typedef struct {
    7878        link_t link;
    79        
     79
    8080        /* XXX Version should be part of SDU */
    8181        ip_ver_t ver;
    … …  
    9090                rqueue_entry_t *rqe =
    9191                    list_get_instance(link, rqueue_entry_t, link);
    92                
     92
    9393                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu, rqe->ver);
    94                
     94
    9595                free(rqe->sdu.data);
    9696                free(rqe);
    9797        }
    98        
     98
    9999        return 0;
    100100}
    … …  
    103103{
    104104        async_set_fallback_port_handler(loopip_client_conn, NULL);
    105        
     105
    106106        errno_t rc = loc_server_register(NAME);
    107107        if (rc != EOK) {
    … …  
    109109                return rc;
    110110        }
    111        
     111
    112112        iplink_srv_init(&loopip_iplink);
    113113        loopip_iplink.ops = &loopip_iplink_ops;
    114114        loopip_iplink.arg = NULL;
    115        
     115
    116116        prodcons_initialize(&loopip_rcv_queue);
    117        
     117
    118118        const char *svc_name = "net/loopback";
    119119        service_id_t sid;
    … …  
    124124                return rc;
    125125        }
    126        
     126
    127127        category_id_t iplink_cat;
    128128        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    … …  
    131131                return rc;
    132132        }
    133        
     133
    134134        rc = loc_service_add_to_cat(sid, iplink_cat);
    135135        if (rc != EOK) {
    … …  
    138138                return rc;
    139139        }
    140        
     140
    141141        fid_t fid = fibril_create(loopip_recv_fibril, NULL);
    142142        if (fid == 0)
    143143                return ENOMEM;
    144        
     144
    145145        fibril_add_ready(fid);
    146        
     146
    147147        return EOK;
    148148}
    … …  
    169169{
    170170        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_send()");
    171        
     171
    172172        rqueue_entry_t *rqe = calloc(1, sizeof(rqueue_entry_t));
    173173        if (rqe == NULL)
    174174                return ENOMEM;
    175        
     175
    176176        /*
    177177         * Clone SDU
    … …  
    183183                return ENOMEM;
    184184        }
    185        
     185
    186186        memcpy(rqe->sdu.data, sdu->data, sdu->size);
    187187        rqe->sdu.size = sdu->size;
    188        
     188
    189189        /*
    190190         * Insert to receive queue
    191191         */
    192192        prodcons_produce(&loopip_rcv_queue, &rqe->link);
    193        
     193
    194194        return EOK;
    195195}
    … …  
    198198{
    199199        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip6_send()");
    200        
     200
    201201        rqueue_entry_t *rqe = calloc(1, sizeof(rqueue_entry_t));
    202202        if (rqe == NULL)
    203203                return ENOMEM;
    204        
     204
    205205        /*
    206206         * Clone SDU
    … …  
    212212                return ENOMEM;
    213213        }
    214        
     214
    215215        memcpy(rqe->sdu.data, sdu->data, sdu->size);
    216216        rqe->sdu.size = sdu->size;
    217        
     217
    218218        /*
    219219         * Insert to receive queue
    220220         */
    221221        prodcons_produce(&loopip_rcv_queue, &rqe->link);
    222        
     222
    223223        return EOK;
    224224}
    … …  
    250250{
    251251        printf("%s: HelenOS loopback IP link provider\n", NAME);
    252        
     252
    253253        errno_t rc = log_init(NAME);
    254254        if (rc != EOK) {
    … …  
    256256                return rc;
    257257        }
    258        
     258
    259259        rc = loopip_init();
    260260        if (rc != EOK) {
    … …  
    262262                return rc;
    263263        }
    264        
     264
    265265        printf("%s: Accepting connections.\n", NAME);
    266266        task_retval(0);
    267267        async_manager();
    268        
     268
    269269        /* Not reached */
    270270        return 0;

  • uspace/srv/net/slip/slip.c

    r3061bc1 r8565a42  
    129129{
    130130        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send()");
    131        
     131
    132132        chardev_t *chardev = (chardev_t *) srv->arg;
    133133        uint8_t *data = sdu->data;
    134        
     134
    135135        /*
    136136         * Strictly speaking, this is not prescribed by the RFC, but the RFC
    … …  
    139139         */
    140140        write_buffered(chardev, SLIP_END);
    141        
     141
    142142        for (size_t i = 0; i < sdu->size; i++) {
    143143                switch (data[i]) {
    … …  
    155155                }
    156156        }
    157        
     157
    158158        write_buffered(chardev, SLIP_END);
    159159        write_flush(chardev);
    160        
     160
    161161        return EOK;
    162162}
    … …  
    165165{
    166166        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send6()");
    167        
     167
    168168        return ENOTSUP;
    169169}
    … …  
    272272                                break;
    273273                        }
    274                        
     274
    275275                }
    276276
Note: See TracChangeset for help on using the changeset viewer.