Changeset 4c53333 in mainline for uspace/srv/net


Ignore:
Timestamp:
2013-07-11T08:21:10Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
64e63ce1
Parents:
80445cf (diff), c8bb1633 (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.
Message:

merge mainline changes

Location:
uspace/srv/net
Files:
18 added
38 edited
24 moved

Legend:

Unmodified
Added
Removed

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

    r80445cf r4c53333  
    3838#include <io/log.h>
    3939#include <inet/iplink_srv.h>
     40#include <inet/addr.h>
    4041#include <stdlib.h>
    41 
     42#include <net/socket_codes.h>
    4243#include "arp.h"
    4344#include "atrans.h"
    … …  
    5455void arp_received(ethip_nic_t *nic, eth_frame_t *frame)
    5556{
    56         int rc;
     57        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
     58       
    5759        arp_eth_packet_t packet;
    58         arp_eth_packet_t reply;
    59         ethip_link_addr_t *laddr;
    60 
    61         log_msg(LVL_DEBUG, "arp_received()");
    62 
    63         rc = arp_pdu_decode(frame->data, frame->size, &packet);
     60        int rc = arp_pdu_decode(frame->data, frame->size, &packet);
    6461        if (rc != EOK)
    6562                return;
    66 
    67         log_msg(LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
    68             packet.opcode, packet.target_proto_addr.ipv4);
    69 
    70         laddr = ethip_nic_addr_find(nic, &packet.target_proto_addr);
    71         if (laddr != NULL) {
    72                 log_msg(LVL_DEBUG, "Request/reply to my address");
    73 
    74                 (void) atrans_add(&packet.sender_proto_addr,
    75                     &packet.sender_hw_addr);
    76 
    77                 if (packet.opcode == aop_request) {
    78                         reply.opcode = aop_reply;
    79                         reply.sender_hw_addr = nic->mac_addr;
    80                         reply.sender_proto_addr = laddr->addr;
    81                         reply.target_hw_addr = packet.sender_hw_addr;
    82                         reply.target_proto_addr = packet.sender_proto_addr;
    83 
    84                         arp_send_packet(nic, &reply);
    85                 }
     63       
     64        log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
     65            packet.opcode, packet.target_proto_addr);
     66       
     67        inet_addr_t addr;
     68        inet_addr_set(packet.target_proto_addr, &addr);
     69       
     70        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, &addr);
     71        if (laddr == NULL)
     72                return;
     73       
     74        addr32_t laddr_v4;
     75        uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
     76        if (laddr_af != AF_INET)
     77                return;
     78       
     79        log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
     80       
     81        (void) atrans_add(packet.sender_proto_addr,
     82            packet.sender_hw_addr);
     83       
     84        if (packet.opcode == aop_request) {
     85                arp_eth_packet_t reply;
     86               
     87                reply.opcode = aop_reply;
     88                addr48(nic->mac_addr, reply.sender_hw_addr);
     89                reply.sender_proto_addr = laddr_v4;
     90                addr48(packet.sender_hw_addr, reply.target_hw_addr);
     91                reply.target_proto_addr = packet.sender_proto_addr;
     92               
     93                arp_send_packet(nic, &reply);
    8694        }
    8795}
    8896
    89 int arp_translate(ethip_nic_t *nic, iplink_srv_addr_t *src_addr,
    90     iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     97int arp_translate(ethip_nic_t *nic, addr32_t src_addr, addr32_t ip_addr,
     98    addr48_t mac_addr)
    9199{
    92         int rc;
    93         arp_eth_packet_t packet;
    94 
    95         rc = atrans_lookup(ip_addr, mac_addr);
     100        int rc = atrans_lookup(ip_addr, mac_addr);
    96101        if (rc == EOK)
    97102                return EOK;
    98 
     103       
     104        arp_eth_packet_t packet;
     105       
    99106        packet.opcode = aop_request;
    100         packet.sender_hw_addr = nic->mac_addr;
    101         packet.sender_proto_addr = *src_addr;
    102         packet.target_hw_addr.addr = MAC48_BROADCAST;
    103         packet.target_proto_addr = *ip_addr;
    104 
     107        addr48(nic->mac_addr, packet.sender_hw_addr);
     108        packet.sender_proto_addr = src_addr;
     109        addr48(addr48_broadcast, packet.target_hw_addr);
     110        packet.target_proto_addr = ip_addr;
     111       
    105112        rc = arp_send_packet(nic, &packet);
    106113        if (rc != EOK)
    107114                return rc;
    108 
     115       
    109116        (void) atrans_wait_timeout(ARP_REQUEST_TIMEOUT);
    110 
     117       
    111118        return atrans_lookup(ip_addr, mac_addr);
    112119}
    … …  
    122129        size_t fsize;
    123130
    124         log_msg(LVL_DEBUG, "arp_send_packet()");
     131        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_send_packet()");
    125132
    126133        rc = arp_pdu_encode(packet, &pdata, &psize);
    … …  
    128135                return rc;
    129136
    130         frame.dest.addr = packet->target_hw_addr.addr;
    131         frame.src.addr =  packet->sender_hw_addr.addr;
     137        addr48(packet->target_hw_addr, frame.dest);
     138        addr48(packet->sender_hw_addr, frame.src);
    132139        frame.etype_len = ETYPE_ARP;
    133140        frame.data = pdata;

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

    r80445cf r4c53333  
    3939
    4040#include <inet/iplink_srv.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    4344extern void arp_received(ethip_nic_t *, eth_frame_t *);
    44 extern int arp_translate(ethip_nic_t *, iplink_srv_addr_t *,
    45     iplink_srv_addr_t *, mac48_addr_t *);
     45extern int arp_translate(ethip_nic_t *, addr32_t, addr32_t, addr48_t);
    4646
    4747#endif

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

    r80445cf r4c53333  
    4949static FIBRIL_CONDVAR_INITIALIZE(atrans_cv);
    5050
    51 static ethip_atrans_t *atrans_find(iplink_srv_addr_t *ip_addr)
     51static ethip_atrans_t *atrans_find(addr32_t ip_addr)
    5252{
    5353        list_foreach(atrans_list, link) {
    … …  
    5555                    ethip_atrans_t, atrans_list);
    5656
    57                 if (atrans->ip_addr.ipv4 == ip_addr->ipv4)
     57                if (atrans->ip_addr == ip_addr)
    5858                        return atrans;
    5959        }
    … …  
    6262}
    6363
    64 int atrans_add(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     64int atrans_add(addr32_t ip_addr, addr48_t mac_addr)
    6565{
    6666        ethip_atrans_t *atrans;
    … …  
    7171                return ENOMEM;
    7272
    73         atrans->ip_addr = *ip_addr;
    74         atrans->mac_addr = *mac_addr;
     73        atrans->ip_addr = ip_addr;
     74        addr48(mac_addr, atrans->mac_addr);
    7575
    7676        fibril_mutex_lock(&atrans_list_lock);
    … …  
    8888}
    8989
    90 int atrans_remove(iplink_srv_addr_t *ip_addr)
     90int atrans_remove(addr32_t ip_addr)
    9191{
    9292        ethip_atrans_t *atrans;
    … …  
    106106}
    107107
    108 int atrans_lookup(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     108int atrans_lookup(addr32_t ip_addr, addr48_t mac_addr)
    109109{
    110         ethip_atrans_t *atrans;
    111 
    112110        fibril_mutex_lock(&atrans_list_lock);
    113         atrans = atrans_find(ip_addr);
     111        ethip_atrans_t *atrans = atrans_find(ip_addr);
    114112        if (atrans == NULL) {
    115113                fibril_mutex_unlock(&atrans_list_lock);
    116114                return ENOENT;
    117115        }
    118 
     116       
    119117        fibril_mutex_unlock(&atrans_list_lock);
    120         *mac_addr = atrans->mac_addr;
     118        addr48(atrans->mac_addr, mac_addr);
    121119        return EOK;
    122120}
    … …  
    124122int atrans_wait_timeout(suseconds_t timeout)
    125123{
    126         int rc;
    127 
    128124        fibril_mutex_lock(&atrans_list_lock);
    129         rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
     125        int rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
    130126            timeout);
    131127        fibril_mutex_unlock(&atrans_list_lock);
    132 
     128       
    133129        return rc;
    134130}

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

    r80445cf r4c53333  
    3939
    4040#include <inet/iplink_srv.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    43 extern int atrans_add(iplink_srv_addr_t *, mac48_addr_t *);
    44 extern int atrans_remove(iplink_srv_addr_t *);
    45 extern int atrans_lookup(iplink_srv_addr_t *, mac48_addr_t *);
     44extern int atrans_add(addr32_t, addr48_t);
     45extern int atrans_remove(addr32_t);
     46extern int atrans_lookup(addr32_t, addr48_t);
    4647extern int atrans_wait_timeout(suseconds_t);
    4748

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

    r80445cf r4c53333  
    4444#include <stdio.h>
    4545#include <stdlib.h>
    46 
     46#include <net/socket_codes.h>
    4747#include "arp.h"
    4848#include "ethip.h"
    … …  
    5555static int ethip_open(iplink_srv_t *srv);
    5656static int ethip_close(iplink_srv_t *srv);
    57 static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
     57static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
    5858static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    59 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr);
    60 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr);
     59static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
     60static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    6161
    6262static void ethip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    7373static int ethip_init(void)
    7474{
    75         int rc;
    76 
    7775        async_set_client_connection(ethip_client_conn);
    78 
    79         rc = loc_server_register(NAME);
    80         if (rc != EOK) {
    81                 log_msg(LVL_ERROR, "Failed registering server.");
     76       
     77        int rc = loc_server_register(NAME);
     78        if (rc != EOK) {
     79                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    8280                return rc;
    8381        }
    84 
     82       
    8583        rc = ethip_nic_discovery_start();
    8684        if (rc != EOK)
    8785                return rc;
    88 
     86       
    8987        return EOK;
    9088}
    … …  
    9896        char *svc_name = NULL;
    9997
    100         log_msg(LVL_DEBUG, "ethip_iplink_init()");
     98        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_iplink_init()");
    10199
    102100        iplink_srv_init(&nic->iplink);
    … …  
    106104        rc = asprintf(&svc_name, "net/eth%u", ++link_num);
    107105        if (rc < 0) {
    108                 log_msg(LVL_ERROR, "Out of memory.");
     106                log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory.");
    109107                goto error;
    110108        }
    … …  
    112110        rc = loc_service_register(svc_name, &sid);
    113111        if (rc != EOK) {
    114                 log_msg(LVL_ERROR, "Failed registering service %s.", svc_name);
     112                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name);
    115113                goto error;
    116114        }
    … …  
    120118        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    121119        if (rc != EOK) {
    122                 log_msg(LVL_ERROR, "Failed resolving category 'iplink'.");
     120                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'.");
    123121                goto error;
    124122        }
    … …  
    126124        rc = loc_service_add_to_cat(sid, iplink_cat);
    127125        if (rc != EOK) {
    128                 log_msg(LVL_ERROR, "Failed adding %s to category.", svc_name);
     126                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name);
    129127                goto error;
    130128        }
    … …  
    144142
    145143        sid = (service_id_t)IPC_GET_ARG1(*icall);
    146         log_msg(LVL_DEBUG, "ethip_client_conn(%u)", (unsigned)sid);
     144        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_client_conn(%u)", (unsigned)sid);
    147145        nic = ethip_nic_find_by_iplink_sid(sid);
    148146        if (nic == NULL) {
    149                 log_msg(LVL_WARN, "Uknown service ID.");
     147                log_msg(LOG_DEFAULT, LVL_WARN, "Uknown service ID.");
    150148                return;
    151149        }
    … …  
    156154static int ethip_open(iplink_srv_t *srv)
    157155{
    158         log_msg(LVL_DEBUG, "ethip_open()");
     156        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_open()");
    159157        return EOK;
    160158}
    … …  
    162160static int ethip_close(iplink_srv_t *srv)
    163161{
    164         log_msg(LVL_DEBUG, "ethip_close()");
    165         return EOK;
    166 }
    167 
    168 static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
    169 {
    170         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
     162        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_close()");
     163        return EOK;
     164}
     165
     166static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     167{
     168        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
     169       
     170        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     171       
     172        addr32_t src_v4;
     173        addr128_t src_v6;
     174        uint16_t src_af = inet_addr_get(&sdu->src, &src_v4, &src_v6);
     175       
     176        addr32_t dest_v4;
     177        addr128_t dest_v6;
     178        uint16_t dest_af = inet_addr_get(&sdu->dest, &dest_v4, &dest_v6);
     179       
     180        if (src_af != dest_af)
     181                return EINVAL;
     182       
     183        int rc;
    171184        eth_frame_t frame;
     185       
     186        switch (src_af) {
     187        case AF_INET:
     188                rc = arp_translate(nic, src_v4, dest_v4, frame.dest);
     189                if (rc != EOK) {
     190                        log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IPv4 address 0x%"
     191                            PRIx32, dest_v4);
     192                        return rc;
     193                }
     194               
     195                addr48(nic->mac_addr, frame.src);
     196                frame.etype_len = ETYPE_IP;
     197                frame.data = sdu->data;
     198                frame.size = sdu->size;
     199               
     200                break;
     201        case AF_INET6:
     202                // FIXME TODO
     203                return ENOTSUP;
     204        default:
     205                return EINVAL;
     206        }
     207       
    172208        void *data;
    173209        size_t size;
    174         mac48_addr_t dest_mac_addr;
    175         int rc;
    176 
    177         log_msg(LVL_DEBUG, "ethip_send()");
    178 
    179         rc = arp_translate(nic, &sdu->lsrc, &sdu->ldest, &dest_mac_addr);
    180         if (rc != EOK) {
    181                 log_msg(LVL_WARN, "Failed to look up IP address 0x%" PRIx32,
    182                     sdu->ldest.ipv4);
    183                 return rc;
    184         }
    185 
    186         frame.dest      = dest_mac_addr;
    187         frame.src       = nic->mac_addr;
    188         frame.etype_len = ETYPE_IP;
    189         frame.data = sdu->data;
    190         frame.size = sdu->size;
    191 
    192210        rc = eth_pdu_encode(&frame, &data, &size);
    193211        if (rc != EOK)
    194212                return rc;
    195 
     213       
    196214        rc = ethip_nic_send(nic, data, size);
    197215        free(data);
    198 
     216       
    199217        return rc;
    200218}
    … …  
    202220int ethip_received(iplink_srv_t *srv, void *data, size_t size)
    203221{
    204         log_msg(LVL_DEBUG, "ethip_received(): srv=%p", srv);
    205         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
     222        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv);
     223        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     224       
     225        log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
     226       
    206227        eth_frame_t frame;
    207         iplink_srv_sdu_t sdu;
    208         int rc;
    209 
    210         log_msg(LVL_DEBUG, "ethip_received()");
    211 
    212         log_msg(LVL_DEBUG, " - eth_pdu_decode");
    213         rc = eth_pdu_decode(data, size, &frame);
    214         if (rc != EOK) {
    215                 log_msg(LVL_DEBUG, " - eth_pdu_decode failed");
     228        int rc = eth_pdu_decode(data, size, &frame);
     229        if (rc != EOK) {
     230                log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode failed");
    216231                return rc;
    217232        }
    218 
     233       
     234        iplink_recv_sdu_t sdu;
     235       
    219236        switch (frame.etype_len) {
    220237        case ETYPE_ARP:
    … …  
    222239                break;
    223240        case ETYPE_IP:
    224                 log_msg(LVL_DEBUG, " - construct SDU");
    225                 sdu.lsrc.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1;
    226                 sdu.ldest.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 4;
     241                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
    227242                sdu.data = frame.data;
    228243                sdu.size = frame.size;
    229                 log_msg(LVL_DEBUG, " - call iplink_ev_recv");
    230                 rc = iplink_ev_recv(&nic->iplink, &sdu);
     244                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
     245                rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET);
     246                break;
     247        case ETYPE_IPV6:
     248                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU IPv6");
     249                sdu.data = frame.data;
     250                sdu.size = frame.size;
     251                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
     252                rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET6);
    231253                break;
    232254        default:
    233                 log_msg(LVL_DEBUG, "Unknown ethertype 0x%" PRIx16,
     255                log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ethertype 0x%" PRIx16,
    234256                    frame.etype_len);
    235257        }
    236 
     258       
    237259        free(frame.data);
    238260        return rc;
    … …  
    241263static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu)
    242264{
    243         log_msg(LVL_DEBUG, "ethip_get_mtu()");
     265        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mtu()");
    244266        *mtu = 1500;
    245267        return EOK;
    246268}
    247269
    248 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    249 {
    250         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    251 
    252         log_msg(LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr->ipv4);
     270static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     271{
     272        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     273       
    253274        return ethip_nic_addr_add(nic, addr);
    254275}
    255276
    256 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    257 {
    258         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    259 
    260         log_msg(LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr->ipv4);
    261         return ethip_nic_addr_add(nic, addr);
     277static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     278{
     279        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     280       
     281        return ethip_nic_addr_remove(nic, addr);
    262282}
    263283
    … …  
    268288        printf(NAME ": HelenOS IP over Ethernet service\n");
    269289
    270         if (log_init(NAME, LVL_WARN) != EOK) {
     290        if (log_init(NAME) != EOK) {
    271291                printf(NAME ": Failed to initialize logging.\n");
    272292                return 1;

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

    r80445cf r4c53333  
    4141#include <async.h>
    4242#include <inet/iplink_srv.h>
     43#include <inet/addr.h>
    4344#include <loc.h>
    4445#include <sys/types.h>
    4546
    46 #define MAC48_BROADCAST 0xffffffffffff
    47 
    4847typedef struct {
    4948        link_t addr_list;
    50         iplink_srv_addr_t addr;
     49        inet_addr_t addr;
    5150} ethip_link_addr_t;
    52 
    53 /** IEEE MAC-48 identifier */
    54 typedef struct {
    55         /** MAC Address (in lowest 48 bits) */
    56         uint64_t addr;
    57 } mac48_addr_t;
    5851
    5952typedef struct ethip_nic {
    … …  
    6760
    6861        /** MAC address */
    69         mac48_addr_t mac_addr;
     62        addr48_t mac_addr;
    7063        /** List of IP addresses configured on this link */
    7164        list_t addr_list; /* of ethip_link_addr_t */
    … …  
    7568typedef struct {
    7669        /** Destination Address */
    77         mac48_addr_t dest;
     70        addr48_t dest;
    7871        /** Source Address */
    79         mac48_addr_t src;
     72        addr48_t src;
    8073        /** Ethertype or Length */
    8174        uint16_t etype_len;
    … …  
    10295        arp_opcode_t opcode;
    10396        /** Sender hardware address */
    104         mac48_addr_t sender_hw_addr;
     97        addr48_t sender_hw_addr;
    10598        /** Sender protocol address */
    106         iplink_srv_addr_t sender_proto_addr;
     99        addr32_t sender_proto_addr;
    107100        /** Target hardware address */
    108         mac48_addr_t target_hw_addr;
     101        addr48_t target_hw_addr;
    109102        /** Target protocol address */
    110         iplink_srv_addr_t target_proto_addr;
     103        addr32_t target_proto_addr;
    111104} arp_eth_packet_t;
    112105
    … …  
    114107typedef struct {
    115108        link_t atrans_list;
    116         iplink_srv_addr_t ip_addr;
    117         mac48_addr_t mac_addr;
     109        addr32_t ip_addr;
     110        addr48_t mac_addr;
    118111} ethip_atrans_t;
    119112

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

    r80445cf r4c53333  
    3737#include <adt/list.h>
    3838#include <async.h>
    39 #include <bool.h>
     39#include <stdbool.h>
    4040#include <errno.h>
    4141#include <fibril_synch.h>
    … …  
    6868        rc = loc_category_get_id("nic", &iplink_cat, IPC_FLAG_BLOCKING);
    6969        if (rc != EOK) {
    70                 log_msg(LVL_ERROR, "Failed resolving category 'nic'.");
     70                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'nic'.");
    7171                fibril_mutex_unlock(&ethip_discovery_lock);
    7272                return ENOENT;
    … …  
    7575        rc = loc_category_get_svcs(iplink_cat, &svcs, &count);
    7676        if (rc != EOK) {
    77                 log_msg(LVL_ERROR, "Failed getting list of IP links.");
     77                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links.");
    7878                fibril_mutex_unlock(&ethip_discovery_lock);
    7979                return EIO;
    … …  
    9393
    9494                if (!already_known) {
    95                         log_msg(LVL_DEBUG, "Found NIC '%lu'",
     95                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Found NIC '%lu'",
    9696                            (unsigned long) svcs[i]);
    9797                        rc = ethip_nic_open(svcs[i]);
    9898                        if (rc != EOK)
    99                                 log_msg(LVL_ERROR, "Could not open NIC.");
     99                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open NIC.");
    100100                }
    101101        }
    … …  
    110110
    111111        if (nic == NULL) {
    112                 log_msg(LVL_ERROR, "Failed allocating NIC structure. "
     112                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC structure. "
    113113                    "Out of memory.");
    114114                return NULL;
    … …  
    121121}
    122122
    123 static ethip_link_addr_t *ethip_nic_addr_new(iplink_srv_addr_t *addr)
     123static ethip_link_addr_t *ethip_nic_addr_new(inet_addr_t *addr)
    124124{
    125125        ethip_link_addr_t *laddr = calloc(1, sizeof(ethip_link_addr_t));
    126 
    127126        if (laddr == NULL) {
    128                 log_msg(LVL_ERROR, "Failed allocating NIC address structure. "
     127                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC address structure. "
    129128                    "Out of memory.");
    130129                return NULL;
    131130        }
    132 
     131       
    133132        link_initialize(&laddr->addr_list);
    134         laddr->addr.ipv4 = addr->ipv4;
     133        laddr->addr = *addr;
     134       
    135135        return laddr;
    136136}
    … …  
    150150static int ethip_nic_open(service_id_t sid)
    151151{
    152         ethip_nic_t *nic;
    153         int rc;
    154152        bool in_list = false;
    155153        nic_address_t nic_address;
    156 
    157         log_msg(LVL_DEBUG, "ethip_nic_open()");
    158         nic = ethip_nic_new();
     154       
     155        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_open()");
     156        ethip_nic_t *nic = ethip_nic_new();
    159157        if (nic == NULL)
    160158                return ENOMEM;
    161 
    162         rc = loc_service_get_name(sid, &nic->svc_name);
    163         if (rc != EOK) {
    164                 log_msg(LVL_ERROR, "Failed getting service name.");
    165                 goto error;
    166         }
    167 
     159       
     160        int rc = loc_service_get_name(sid, &nic->svc_name);
     161        if (rc != EOK) {
     162                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name.");
     163                goto error;
     164        }
     165       
    168166        nic->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
    169167        if (nic->sess == NULL) {
    170                 log_msg(LVL_ERROR, "Failed connecting '%s'", nic->svc_name);
    171                 goto error;
    172         }
    173 
     168                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", nic->svc_name);
     169                goto error;
     170        }
     171       
    174172        nic->svc_id = sid;
    175 
     173       
    176174        rc = nic_callback_create(nic->sess, ethip_nic_cb_conn, nic);
    177175        if (rc != EOK) {
    178                 log_msg(LVL_ERROR, "Failed creating callback connection "
     176                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating callback connection "
    179177                    "from '%s'", nic->svc_name);
    180178                goto error;
    181179        }
    182180
    183         log_msg(LVL_DEBUG, "Opened NIC '%s'", nic->svc_name);
     181        log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened NIC '%s'", nic->svc_name);
    184182        list_append(&nic->nic_list, &ethip_nic_list);
    185183        in_list = true;
    … …  
    191189        rc = nic_get_address(nic->sess, &nic_address);
    192190        if (rc != EOK) {
    193                 log_msg(LVL_ERROR, "Error getting MAC address of NIC '%s'.",
     191                log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting MAC address of NIC '%s'.",
    194192                    nic->svc_name);
    195193                goto error;
    196194        }
    197 
    198         mac48_decode(nic_address.address, &nic->mac_addr);
     195       
     196        addr48(nic_address.address, nic->mac_addr);
    199197
    200198        rc = nic_set_state(nic->sess, NIC_STATE_ACTIVE);
    201199        if (rc != EOK) {
    202                 log_msg(LVL_ERROR, "Error activating NIC '%s'.",
     200                log_msg(LOG_DEFAULT, LVL_ERROR, "Error activating NIC '%s'.",
    203201                    nic->svc_name);
    204202                goto error;
    205203        }
    206204
    207         log_msg(LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64,
    208             nic->mac_addr.addr);
     205        log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service,");
    209206
    210207        return EOK;
    … …  
    227224    ipc_call_t *call)
    228225{
    229         log_msg(LVL_DEBUG, "ethip_nic_addr_changed()");
     226        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_changed()");
    230227        async_answer_0(callid, ENOTSUP);
    231228}
    … …  
    238235        size_t size;
    239236
    240         log_msg(LVL_DEBUG, "ethip_nic_received() nic=%p", nic);
     237        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() nic=%p", nic);
    241238
    242239        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    243240        if (rc != EOK) {
    244                 log_msg(LVL_DEBUG, "data_write_accept() failed");
     241                log_msg(LOG_DEFAULT, LVL_DEBUG, "data_write_accept() failed");
    245242                return;
    246243        }
    247244
    248         log_msg(LVL_DEBUG, "Ethernet PDU contents (%zu bytes)",
     245        log_msg(LOG_DEFAULT, LVL_DEBUG, "Ethernet PDU contents (%zu bytes)",
    249246            size);
    250247
    251         log_msg(LVL_DEBUG, "call ethip_received");
     248        log_msg(LOG_DEFAULT, LVL_DEBUG, "call ethip_received");
    252249        rc = ethip_received(&nic->iplink, data, size);
    253         log_msg(LVL_DEBUG, "free data");
     250        log_msg(LOG_DEFAULT, LVL_DEBUG, "free data");
    254251        free(data);
    255252
    256         log_msg(LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc);
     253        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc);
    257254        async_answer_0(callid, rc);
    258255}
    … …  
    261258    ipc_call_t *call)
    262259{
    263         log_msg(LVL_DEBUG, "ethip_nic_device_state()");
     260        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()");
    264261        async_answer_0(callid, ENOTSUP);
    265262}
    … …  
    269266        ethip_nic_t *nic = (ethip_nic_t *)arg;
    270267
    271         log_msg(LVL_DEBUG, "ethnip_nic_cb_conn()");
     268        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethnip_nic_cb_conn()");
    272269
    273270        while (true) {
    … …  
    298295int ethip_nic_discovery_start(void)
    299296{
    300         int rc;
    301 
    302         rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
    303         if (rc != EOK) {
    304                 log_msg(LVL_ERROR, "Failed registering callback for NIC "
     297        int rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
     298        if (rc != EOK) {
     299                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC "
    305300                    "discovery (%d).", rc);
    306301                return rc;
    307302        }
    308 
     303       
    309304        return ethip_nic_check_new();
    310305}
    … …  
    312307ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t iplink_sid)
    313308{
    314         log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid(%u)",
     309        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid(%u)",
    315310            (unsigned) iplink_sid);
    316311
    317312        list_foreach(ethip_nic_list, link) {
    318                 log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element");
     313                log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element");
    319314                ethip_nic_t *nic = list_get_instance(link, ethip_nic_t,
    320315                    nic_list);
    321316
    322317                if (nic->iplink_sid == iplink_sid) {
    323                         log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - found %p", nic);
     318                        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - found %p", nic);
    324319                        return nic;
    325320                }
    326321        }
    327322
    328         log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - not found");
     323        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - not found");
    329324        return NULL;
    330325}
    … …  
    333328{
    334329        int rc;
    335         log_msg(LVL_DEBUG, "ethip_nic_send(size=%zu)", size);
     330        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_send(size=%zu)", size);
    336331        rc = nic_send_frame(nic->sess, data, size);
    337         log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     332        log_msg(LOG_DEFAULT, LVL_DEBUG, "nic_send_frame -> %d", rc);
    338333        return rc;
    339334}
    340335
    341 int ethip_nic_addr_add(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    342 {
    343         ethip_link_addr_t *laddr;
    344 
    345         log_msg(LVL_DEBUG, "ethip_nic_addr_add()");
    346         laddr = ethip_nic_addr_new(addr);
     336int ethip_nic_addr_add(ethip_nic_t *nic, inet_addr_t *addr)
     337{
     338        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
     339       
     340        ethip_link_addr_t *laddr = ethip_nic_addr_new(addr);
    347341        if (laddr == NULL)
    348342                return ENOMEM;
    349 
     343       
    350344        list_append(&laddr->addr_list, &nic->addr_list);
    351345        return EOK;
    352346}
    353347
    354 int ethip_nic_addr_remove(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    355 {
    356         ethip_link_addr_t *laddr;
    357 
    358         log_msg(LVL_DEBUG, "ethip_nic_addr_remove()");
    359 
    360         laddr = ethip_nic_addr_find(nic, addr);
     348int ethip_nic_addr_remove(ethip_nic_t *nic, inet_addr_t *addr)
     349{
     350        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
     351       
     352        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, addr);
    361353        if (laddr == NULL)
    362354                return ENOENT;
    363 
     355       
    364356        list_remove(&laddr->addr_list);
    365357        ethip_link_addr_delete(laddr);
    … …  
    368360
    369361ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *nic,
    370     iplink_srv_addr_t *addr)
    371 {
    372         log_msg(LVL_DEBUG, "ethip_nic_addr_find()");
    373 
     362    inet_addr_t *addr)
     363{
     364        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
     365       
    374366        list_foreach(nic->addr_list, link) {
    375367                ethip_link_addr_t *laddr = list_get_instance(link,
    376368                    ethip_link_addr_t, addr_list);
    377 
    378                 if (addr->ipv4 == laddr->addr.ipv4)
     369               
     370                if (inet_addr_compare(addr, &laddr->addr))
    379371                        return laddr;
    380372        }
    381 
     373       
    382374        return NULL;
    383375}

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

    r80445cf r4c53333  
    3939
    4040#include <ipc/loc.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    … …  
    4445extern ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t);
    4546extern int ethip_nic_send(ethip_nic_t *, void *, size_t);
    46 extern int ethip_nic_addr_add(ethip_nic_t *, iplink_srv_addr_t *);
    47 extern int ethip_nic_addr_remove(ethip_nic_t *, iplink_srv_addr_t *);
    48 extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *,
    49     iplink_srv_addr_t *);
     47extern int ethip_nic_addr_add(ethip_nic_t *, inet_addr_t *);
     48extern int ethip_nic_addr_remove(ethip_nic_t *, inet_addr_t *);
     49extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, inet_addr_t *);
    5050
    5151#endif

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

    r80445cf r4c53333  
    6262
    6363        hdr = (eth_header_t *)data;
    64         mac48_encode(&frame->src, hdr->src);
    65         mac48_encode(&frame->dest, hdr->dest);
     64        addr48(frame->src, hdr->src);
     65        addr48(frame->dest, hdr->dest);
    6666        hdr->etype_len = host2uint16_t_be(frame->etype_len);
    6767
    … …  
    6969            frame->size);
    7070
    71         log_msg(LVL_DEBUG, "Encoding Ethernet frame src=%llx dest=%llx etype=%x",
    72             frame->src, frame->dest, frame->etype_len);
    73         log_msg(LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size);
     71        log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size);
    7472
    7573        *rdata = data;
    … …  
    8381        eth_header_t *hdr;
    8482
    85         log_msg(LVL_DEBUG, "eth_pdu_decode()");
     83        log_msg(LOG_DEFAULT, LVL_DEBUG, "eth_pdu_decode()");
    8684
    8785        if (size < sizeof(eth_header_t)) {
    88                 log_msg(LVL_DEBUG, "PDU too short (%zu)", size);
     86                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
    8987                return EINVAL;
    9088        }
    … …  
    9795                return ENOMEM;
    9896
    99         mac48_decode(hdr->src, &frame->src);
    100         mac48_decode(hdr->dest, &frame->dest);
     97        addr48(hdr->src, frame->src);
     98        addr48(hdr->dest, frame->dest);
    10199        frame->etype_len = uint16_t_be2host(hdr->etype_len);
    102100
    … …  
    104102            frame->size);
    105103
    106         log_msg(LVL_DEBUG, "Decoding Ethernet frame src=%llx dest=%llx etype=%x",
    107             frame->src, frame->dest, frame->etype_len);
    108         log_msg(LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size);
    109 
    110         return EOK;
    111 }
    112 
    113 void mac48_encode(mac48_addr_t *addr, void *buf)
    114 {
    115         uint64_t val;
    116         uint8_t *bbuf = (uint8_t *)buf;
    117         int i;
    118 
    119         val = addr->addr;
    120         for (i = 0; i < MAC48_BYTES; i++)
    121                 bbuf[i] = (val >> (8 * (MAC48_BYTES - i - 1))) & 0xff;
    122 }
    123 
    124 void mac48_decode(void *data, mac48_addr_t *addr)
    125 {
    126         uint64_t val;
    127         uint8_t *bdata = (uint8_t *)data;
    128         int i;
    129 
    130         val = 0;
    131         for (i = 0; i < MAC48_BYTES; i++)
    132                 val |= (uint64_t)bdata[i] << (8 * (MAC48_BYTES - i - 1));
    133 
    134         addr->addr = val;
     104        log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size);
     105
     106        return EOK;
    135107}
    136108
    … …  
    143115        uint16_t fopcode;
    144116
    145         log_msg(LVL_DEBUG, "arp_pdu_encode()");
     117        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_pdu_encode()");
    146118
    147119        size = sizeof(arp_eth_packet_fmt_t);
    … …  
    166138        pfmt->proto_addr_size = IPV4_ADDR_SIZE;
    167139        pfmt->opcode = host2uint16_t_be(fopcode);
    168         mac48_encode(&packet->sender_hw_addr, pfmt->sender_hw_addr);
     140        addr48(packet->sender_hw_addr, pfmt->sender_hw_addr);
    169141        pfmt->sender_proto_addr =
    170             host2uint32_t_be(packet->sender_proto_addr.ipv4);
    171         mac48_encode(&packet->target_hw_addr, pfmt->target_hw_addr);
     142            host2uint32_t_be(packet->sender_proto_addr);
     143        addr48(packet->target_hw_addr, pfmt->target_hw_addr);
    172144        pfmt->target_proto_addr =
    173             host2uint32_t_be(packet->target_proto_addr.ipv4);
     145            host2uint32_t_be(packet->target_proto_addr);
    174146
    175147        *rdata = data;
    … …  
    183155        arp_eth_packet_fmt_t *pfmt;
    184156
    185         log_msg(LVL_DEBUG, "arp_pdu_decode()");
     157        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_pdu_decode()");
    186158
    187159        if (size < sizeof(arp_eth_packet_fmt_t)) {
    188                 log_msg(LVL_DEBUG, "ARP PDU too short (%zu)", size);
     160                log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU too short (%zu)", size);
    189161                return EINVAL;
    190162        }
    … …  
    193165
    194166        if (uint16_t_be2host(pfmt->hw_addr_space) != AHRD_ETHERNET) {
    195                 log_msg(LVL_DEBUG, "HW address space != %u (%" PRIu16 ")",
     167                log_msg(LOG_DEFAULT, LVL_DEBUG, "HW address space != %u (%" PRIu16 ")",
    196168                    AHRD_ETHERNET, uint16_t_be2host(pfmt->hw_addr_space));
    197169                return EINVAL;
    … …  
    199171
    200172        if (uint16_t_be2host(pfmt->proto_addr_space) != 0x0800) {
    201                 log_msg(LVL_DEBUG, "Proto address space != %u (%" PRIu16 ")",
     173                log_msg(LOG_DEFAULT, LVL_DEBUG, "Proto address space != %u (%" PRIu16 ")",
    202174                    ETYPE_IP, uint16_t_be2host(pfmt->proto_addr_space));
    203175                return EINVAL;
    … …  
    205177
    206178        if (pfmt->hw_addr_size != ETH_ADDR_SIZE) {
    207                 log_msg(LVL_DEBUG, "HW address size != %zu (%zu)",
     179                log_msg(LOG_DEFAULT, LVL_DEBUG, "HW address size != %zu (%zu)",
    208180                    (size_t)ETH_ADDR_SIZE, (size_t)pfmt->hw_addr_size);
    209181                return EINVAL;
    … …  
    211183
    212184        if (pfmt->proto_addr_size != IPV4_ADDR_SIZE) {
    213                 log_msg(LVL_DEBUG, "Proto address size != %zu (%zu)",
     185                log_msg(LOG_DEFAULT, LVL_DEBUG, "Proto address size != %zu (%zu)",
    214186                    (size_t)IPV4_ADDR_SIZE, (size_t)pfmt->proto_addr_size);
    215187                return EINVAL;
    … …  
    220192        case AOP_REPLY: packet->opcode = aop_reply; break;
    221193        default:
    222                 log_msg(LVL_DEBUG, "Invalid ARP opcode (%" PRIu16 ")",
     194                log_msg(LOG_DEFAULT, LVL_DEBUG, "Invalid ARP opcode (%" PRIu16 ")",
    223195                    uint16_t_be2host(pfmt->opcode));
    224196                return EINVAL;
    225197        }
    226198
    227         mac48_decode(pfmt->sender_hw_addr, &packet->sender_hw_addr);
    228         packet->sender_proto_addr.ipv4 =
     199        addr48(pfmt->sender_hw_addr, packet->sender_hw_addr);
     200        packet->sender_proto_addr =
    229201            uint32_t_be2host(pfmt->sender_proto_addr);
    230         mac48_decode(pfmt->target_hw_addr, &packet->target_hw_addr);
    231         packet->target_proto_addr.ipv4 =
     202        addr48(pfmt->target_hw_addr, packet->target_hw_addr);
     203        packet->target_proto_addr =
    232204            uint32_t_be2host(pfmt->target_proto_addr);
    233         log_msg(LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr);
    234 
    235         return EOK;
    236 }
    237 
     205        log_msg(LOG_DEFAULT, LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr);
     206
     207        return EOK;
     208}
    238209
    239210/** @}

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

    r80445cf r4c53333  
    4242extern int eth_pdu_encode(eth_frame_t *, void **, size_t *);
    4343extern int eth_pdu_decode(void *, size_t, eth_frame_t *);
    44 extern void mac48_encode(mac48_addr_t *, void *);
    45 extern void mac48_decode(void *, mac48_addr_t *);
    4644extern int arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
    4745extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
    48 
    4946
    5047#endif

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
     41#include <inet/addr.h>
    4142
    42 #define ETH_ADDR_SIZE 6
    43 #define IPV4_ADDR_SIZE 4
    44 #define ETH_FRAME_MIN_SIZE 60
     43#define ETH_ADDR_SIZE       6
     44#define IPV4_ADDR_SIZE      4
     45#define ETH_FRAME_MIN_SIZE  60
    4546
    4647/** Ethernet frame header */
    4748typedef struct {
    4849        /** Destination Address */
    49         uint8_t dest[ETH_ADDR_SIZE];
     50        addr48_t dest;
    5051        /** Source Address */
    51         uint8_t src[ETH_ADDR_SIZE];
     52        addr48_t src;
    5253        /** Ethertype or Length */
    5354        uint16_t etype_len;
    … …  
    6768        uint16_t opcode;
    6869        /** Sender hardware address */
    69         uint8_t sender_hw_addr[ETH_ADDR_SIZE];
     70        addr48_t sender_hw_addr;
    7071        /** Sender protocol address */
    71         uint32_t sender_proto_addr;
     72        addr32_t sender_proto_addr;
    7273        /** Target hardware address */
    73         uint8_t target_hw_addr[ETH_ADDR_SIZE];
     74        addr48_t target_hw_addr;
    7475        /** Target protocol address */
    75         uint32_t target_proto_addr;
     76        addr32_t target_proto_addr;
    7677} __attribute__((packed)) arp_eth_packet_fmt_t;
    7778
    … …  
    8788/** IP Ethertype */
    8889enum ether_type {
    89         ETYPE_ARP = 0x0806,
    90         ETYPE_IP  = 0x0800
     90        ETYPE_ARP  = 0x0806,
     91        ETYPE_IP   = 0x0800,
     92        ETYPE_IPV6 = 0x86DD
    9193};
    92 
    9394
    9495#endif

  • uspace/srv/net/inetsrv/Makefile

    r80445cf r4c53333  
    2828
    2929USPACE_PREFIX = ../../..
    30 BINARY = inet
     30BINARY = inetsrv
    3131
    3232SOURCES = \
    3333        addrobj.c \
    3434        icmp.c \
    35         inet.c \
     35        icmpv6.c \
     36        inetsrv.c \
    3637        inet_link.c \
    37         inet_util.c \
    3838        inetcfg.c \
    3939        inetping.c \
     40        inetping6.c \
    4041        pdu.c \
    4142        reass.c \

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

    r80445cf r4c53333  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
    4544#include "addrobj.h"
    46 #include "inet.h"
     45#include "inetsrv.h"
    4746#include "inet_link.h"
    48 #include "inet_util.h"
     47
     48static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
    4949
    5050static FIBRIL_MUTEX_INITIALIZE(addr_list_lock);
    … …  
    5757
    5858        if (addr == NULL) {
    59                 log_msg(LVL_ERROR, "Failed allocating address object. "
     59                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating address object. "
    6060                    "Out of memory.");
    6161                return NULL;
    … …  
    7777}
    7878
    79 void inet_addrobj_add(inet_addrobj_t *addr)
    80 {
    81         fibril_mutex_lock(&addr_list_lock);
     79int inet_addrobj_add(inet_addrobj_t *addr)
     80{
     81        inet_addrobj_t *aobj;
     82
     83        fibril_mutex_lock(&addr_list_lock);
     84        aobj = inet_addrobj_find_by_name_locked(addr->name, addr->ilink);
     85        if (aobj != NULL) {
     86                /* Duplicate address name */
     87                fibril_mutex_unlock(&addr_list_lock);
     88                return EEXISTS;
     89        }
     90
    8291        list_append(&addr->addr_list, &addr_list);
    8392        fibril_mutex_unlock(&addr_list_lock);
     93
     94        return EOK;
    8495}
    8596
    … …  
    93104/** Find address object matching address @a addr.
    94105 *
    95  * @param addr  Address
    96  * @oaram find  iaf_net to find network (using mask),
    97  *              iaf_addr to find local address (exact match)
     106 * @param addr Address
     107 * @oaram find iaf_net to find network (using mask),
     108 *             iaf_addr to find local address (exact match)
     109 *
    98110 */
    99111inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
    100112{
    101         uint32_t mask;
    102 
    103         log_msg(LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4);
    104 
    105         fibril_mutex_lock(&addr_list_lock);
    106 
     113        fibril_mutex_lock(&addr_list_lock);
     114       
    107115        list_foreach(addr_list, link) {
    108116                inet_addrobj_t *naddr = list_get_instance(link,
    109117                    inet_addrobj_t, addr_list);
    110 
    111                 mask = inet_netmask(naddr->naddr.bits);
    112                 if ((naddr->naddr.ipv4 & mask) == (addr->ipv4 & mask)) {
     118               
     119                if (inet_naddr_compare_mask(&naddr->naddr, addr)) {
    113120                        fibril_mutex_unlock(&addr_list_lock);
    114                         log_msg(LVL_DEBUG, "inet_addrobj_find: found %p",
     121                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
    115122                            naddr);
    116123                        return naddr;
    117124                }
    118125        }
    119 
    120         log_msg(LVL_DEBUG, "inet_addrobj_find: Not found");
    121         fibril_mutex_unlock(&addr_list_lock);
    122 
     126       
     127        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
     128        fibril_mutex_unlock(&addr_list_lock);
     129       
    123130        return NULL;
    124131}
    … …  
    130137 * @return      Address object
    131138 */
    132 inet_addrobj_t *inet_addrobj_find_by_name(const char *name, inet_link_t *ilink)
    133 {
    134         log_msg(LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')",
     139static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *name, inet_link_t *ilink)
     140{
     141        assert(fibril_mutex_is_locked(&addr_list_lock));
     142
     143        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked('%s', '%s')",
    135144            name, ilink->svc_name);
    136145
    137         fibril_mutex_lock(&addr_list_lock);
    138 
    139146        list_foreach(addr_list, link) {
    140147                inet_addrobj_t *naddr = list_get_instance(link,
    … …  
    142149
    143150                if (naddr->ilink == ilink && str_cmp(naddr->name, name) == 0) {
    144                         fibril_mutex_unlock(&addr_list_lock);
    145                         log_msg(LVL_DEBUG, "inet_addrobj_find_by_name: found %p",
     151                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: found %p",
    146152                            naddr);
    147153                        return naddr;
    … …  
    149155        }
    150156
    151         log_msg(LVL_DEBUG, "inet_addrobj_find_by_name: Not found");
    152         fibril_mutex_unlock(&addr_list_lock);
     157        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: Not found");
    153158
    154159        return NULL;
     160}
     161
     162
     163/** Find address object on a link, with a specific name.
     164 *
     165 * @param name  Address object name
     166 * @param ilink Inet link
     167 * @return      Address object
     168 */
     169inet_addrobj_t *inet_addrobj_find_by_name(const char *name, inet_link_t *ilink)
     170{
     171        inet_addrobj_t *aobj;
     172
     173        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')",
     174            name, ilink->svc_name);
     175
     176        fibril_mutex_lock(&addr_list_lock);
     177        aobj = inet_addrobj_find_by_name_locked(name, ilink);
     178        fibril_mutex_unlock(&addr_list_lock);
     179
     180        return aobj;
    155181}
    156182
    … …  
    162188inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t id)
    163189{
    164         log_msg(LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id);
     190        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id);
    165191
    166192        fibril_mutex_lock(&addr_list_lock);
    … …  
    186212{
    187213        inet_addr_t lsrc_addr;
    188         inet_addr_t *ldest_addr;
    189 
    190         lsrc_addr.ipv4 = addr->naddr.ipv4;
    191         ldest_addr = &dgram->dest;
    192 
    193         return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
     214        inet_naddr_addr(&addr->naddr, &lsrc_addr);
     215       
     216        return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest, dgram,
    194217            proto, ttl, df);
    195218}

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
    41 #include "inet.h"
     41#include "inetsrv.h"
    4242
    4343typedef enum {
    … …  
    5050extern inet_addrobj_t *inet_addrobj_new(void);
    5151extern void inet_addrobj_delete(inet_addrobj_t *);
    52 extern void inet_addrobj_add(inet_addrobj_t *);
     52extern int inet_addrobj_add(inet_addrobj_t *);
    5353extern void inet_addrobj_remove(inet_addrobj_t *);
    5454extern inet_addrobj_t *inet_addrobj_find(inet_addr_t *, inet_addrobj_find_t);
    … …  
    5959extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
    6060
    61 
    6261#endif
    6362

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

    r80445cf r4c53333  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 
     42#include <net/socket_codes.h>
    4343#include "icmp.h"
    4444#include "icmp_std.h"
    45 #include "inet.h"
     45#include "inetsrv.h"
    4646#include "inetping.h"
    4747#include "pdu.h"
    … …  
    5757        uint8_t type;
    5858
    59         log_msg(LVL_DEBUG, "icmp_recv()");
     59        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv()");
    6060
    6161        if (dgram->size < 1)
    … …  
    8484        int rc;
    8585
    86         log_msg(LVL_DEBUG, "icmp_recv_echo_request()");
     86        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_request()");
    8787
    8888        if (dgram->size < sizeof(icmp_echo_t))
    … …  
    120120static int icmp_recv_echo_reply(inet_dgram_t *dgram)
    121121{
    122         icmp_echo_t *reply;
    123         inetping_sdu_t sdu;
    124         uint16_t ident;
    125 
    126         log_msg(LVL_DEBUG, "icmp_recv_echo_reply()");
    127 
     122        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
     123       
    128124        if (dgram->size < sizeof(icmp_echo_t))
    129125                return EINVAL;
    130 
    131         reply = (icmp_echo_t *)dgram->data;
    132 
    133         sdu.src = dgram->src;
    134         sdu.dest = dgram->dest;
     126       
     127        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
     128       
     129        inetping_sdu_t sdu;
     130       
     131        uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
     132        if (family != AF_INET)
     133                return EINVAL;
     134       
     135        family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
     136        if (family != AF_INET)
     137                return EINVAL;
     138       
    135139        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    136140        sdu.data = reply + sizeof(icmp_echo_t);
    137141        sdu.size = dgram->size - sizeof(icmp_echo_t);
    138         ident = uint16_t_be2host(reply->ident);
     142       
     143        uint16_t ident = uint16_t_be2host(reply->ident);
    139144
    140145        return inetping_recv(ident, &sdu);
    … …  
    143148int icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    144149{
    145         inet_dgram_t dgram;
    146         icmp_echo_t *request;
    147         void *rdata;
    148         size_t rsize;
    149         uint16_t checksum;
    150         int rc;
    151 
    152         rsize = sizeof(icmp_echo_t) + sdu->size;
    153         rdata = calloc(rsize, 1);
     150        size_t rsize = sizeof(icmp_echo_t) + sdu->size;
     151        void *rdata = calloc(rsize, 1);
    154152        if (rdata == NULL)
    155153                return ENOMEM;
    156 
    157         request = (icmp_echo_t *)rdata;
    158 
     154       
     155        icmp_echo_t *request = (icmp_echo_t *)rdata;
     156       
    159157        request->type = ICMP_ECHO_REQUEST;
    160158        request->code = 0;
    … …  
    162160        request->ident = host2uint16_t_be(ident);
    163161        request->seq_no = host2uint16_t_be(sdu->seq_no);
    164 
     162       
    165163        memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
    166 
    167         checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
     164       
     165        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
    168166        request->checksum = host2uint16_t_be(checksum);
    169 
    170         dgram.src = sdu->src;
    171         dgram.dest = sdu->dest;
     167       
     168        inet_dgram_t dgram;
     169       
     170        inet_addr_set(sdu->src, &dgram.src);
     171        inet_addr_set(sdu->dest, &dgram.dest);
     172       
    172173        dgram.tos = ICMP_TOS;
    173174        dgram.data = rdata;
    174175        dgram.size = rsize;
    175 
    176         rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    177 
     176       
     177        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
     178       
    178179        free(rdata);
    179180        return rc;

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

    r80445cf r4c53333  
    3838#define ICMP_H_
    3939
    40 #include "inet.h"
     40#include "inetsrv.h"
    4141
    4242extern int icmp_recv(inet_dgram_t *);

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

    r80445cf r4c53333  
    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

    r80445cf r4c53333  
    3535 */
    3636
    37 #include <bool.h>
     37#include <stdbool.h>
    3838#include <errno.h>
    3939#include <fibril_synch.h>
    … …  
    4343#include <stdlib.h>
    4444#include <str.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "addrobj.h"
    47 #include "inet.h"
     47#include "inetsrv.h"
    4848#include "inet_link.h"
    4949#include "pdu.h"
    5050
    51 static int inet_link_open(service_id_t sid);
    52 static int inet_iplink_recv(iplink_t *ilink, iplink_sdu_t *sdu);
     51static int inet_link_open(service_id_t);
     52static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, uint16_t);
    5353
    5454static iplink_ev_ops_t inet_iplink_ev_ops = {
    … …  
    5959static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
    6060
    61 static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
    62 {
     61static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, uint16_t af)
     62{
     63        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
     64       
     65        int rc;
    6366        inet_packet_t packet;
    64         int rc;
    65 
    66         log_msg(LVL_DEBUG, "inet_iplink_recv()");
    67         rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
    68         if (rc != EOK) {
    69                 log_msg(LVL_DEBUG, "failed decoding PDU");
    70                 return rc;
    71         }
    72 
    73         log_msg(LVL_DEBUG, "call inet_recv_packet()");
     67       
     68        switch (af) {
     69        case AF_INET:
     70                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     71                break;
     72        case AF_INET6:
     73                rc = inet_pdu_decode6(sdu->data, sdu->size, &packet);
     74                break;
     75        default:
     76                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid address family");
     77                return EINVAL;
     78        }
     79       
     80        if (rc != EOK) {
     81                log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
     82                return rc;
     83        }
     84       
     85        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()");
    7486        rc = inet_recv_packet(&packet);
    75         log_msg(LVL_DEBUG, "call inet_recv_packet -> %d", rc);
     87        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc);
    7688        free(packet.data);
    77 
     89       
    7890        return rc;
    7991}
    … …  
    91103        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    92104        if (rc != EOK) {
    93                 log_msg(LVL_ERROR, "Failed resolving category 'iplink'.");
     105                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'.");
    94106                fibril_mutex_unlock(&inet_discovery_lock);
    95107                return ENOENT;
    … …  
    98110        rc = loc_category_get_svcs(iplink_cat, &svcs, &count);
    99111        if (rc != EOK) {
    100                 log_msg(LVL_ERROR, "Failed getting list of IP links.");
     112                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links.");
    101113                fibril_mutex_unlock(&inet_discovery_lock);
    102114                return EIO;
    … …  
    116128
    117129                if (!already_known) {
    118                         log_msg(LVL_DEBUG, "Found IP link '%lu'",
     130                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Found IP link '%lu'",
    119131                            (unsigned long) svcs[i]);
    120132                        rc = inet_link_open(svcs[i]);
    121133                        if (rc != EOK)
    122                                 log_msg(LVL_ERROR, "Could not open IP link.");
     134                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open IP link.");
    123135                }
    124136        }
    … …  
    133145
    134146        if (ilink == NULL) {
    135                 log_msg(LVL_ERROR, "Failed allocating link structure. "
     147                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating link structure. "
    136148                    "Out of memory.");
    137149                return NULL;
    … …  
    153165{
    154166        inet_link_t *ilink;
    155         iplink_addr_t iaddr;
    156         int rc;
    157 
    158         log_msg(LVL_DEBUG, "inet_link_open()");
     167        inet_addr_t iaddr;
     168        int rc;
     169
     170        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_link_open()");
    159171        ilink = inet_link_new();
    160172        if (ilink == NULL)
    … …  
    166178        rc = loc_service_get_name(sid, &ilink->svc_name);
    167179        if (rc != EOK) {
    168                 log_msg(LVL_ERROR, "Failed getting service name.");
     180                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name.");
    169181                goto error;
    170182        }
    … …  
    172184        ilink->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
    173185        if (ilink->sess == NULL) {
    174                 log_msg(LVL_ERROR, "Failed connecting '%s'", ilink->svc_name);
     186                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", ilink->svc_name);
    175187                goto error;
    176188        }
    … …  
    178190        rc = iplink_open(ilink->sess, &inet_iplink_ev_ops, &ilink->iplink);
    179191        if (rc != EOK) {
    180                 log_msg(LVL_ERROR, "Failed opening IP link '%s'",
     192                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed opening IP link '%s'",
    181193                    ilink->svc_name);
    182194                goto error;
    … …  
    185197        rc = iplink_get_mtu(ilink->iplink, &ilink->def_mtu);
    186198        if (rc != EOK) {
    187                 log_msg(LVL_ERROR, "Failed determinning MTU of link '%s'",
     199                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed determinning MTU of link '%s'",
    188200                    ilink->svc_name);
    189201                goto error;
    190202        }
    191203
    192         log_msg(LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name);
     204        log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name);
    193205        list_append(&ilink->link_list, &inet_link_list);
    194206
    195207        inet_addrobj_t *addr;
     208        inet_addrobj_t *addr6;
    196209
    197210        static int first = 1;
    198         /* XXX For testing: set static IP address 192.168.0.4/24 */
     211       
    199212        addr = inet_addrobj_new();
     213        addr6 = inet_addrobj_new();
     214       
    200215        if (first) {
    201                 addr->naddr.ipv4 = (127 << 24) + (0 << 16) + (0 << 8) + 1;
     216                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
     217                inet_naddr6(&addr6->naddr, 0, 0, 0, 0, 0, 0, 0, 1, 128);
    202218                first = 0;
    203219        } else {
    204                 addr->naddr.ipv4 = (192 << 24) + (168 << 16) + (0 << 8) + 4;
    205         }
    206         addr->naddr.bits = 24;
     220                /*
     221                 * FIXME
     222                 * Setting static IP addresses for testing purposes
     223                 * 10.0.2.15/24
     224                 * fd19:1680::4/120
     225                 */
     226                inet_naddr(&addr->naddr, 10, 0, 2, 15, 24);
     227                inet_naddr6(&addr6->naddr, 0xfd19, 0x1680, 0, 0, 0, 0, 0, 4, 120);
     228        }
     229       
    207230        addr->ilink = ilink;
     231        addr6->ilink = ilink;
    208232        addr->name = str_dup("v4a");
    209         inet_addrobj_add(addr);
    210 
    211         iaddr.ipv4 = addr->naddr.ipv4;
     233        addr6->name = str_dup("v6a");
     234       
     235        rc = inet_addrobj_add(addr);
     236        if (rc != EOK) {
     237                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv4 address.");
     238                inet_addrobj_delete(addr);
     239                /* XXX Roll back */
     240                return rc;
     241        }
     242       
     243        rc = inet_addrobj_add(addr6);
     244        if (rc != EOK) {
     245                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv6 address.");
     246                inet_addrobj_delete(addr6);
     247                /* XXX Roll back */
     248                return rc;
     249        }
     250       
     251        inet_naddr_addr(&addr->naddr, &iaddr);
    212252        rc = iplink_addr_add(ilink->iplink, &iaddr);
    213253        if (rc != EOK) {
    214                 log_msg(LVL_ERROR, "Failed setting IP address on internet link.");
     254                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IPv4 address on internet link.");
     255                inet_addrobj_remove(addr);
     256                inet_addrobj_delete(addr);
    215257                /* XXX Roll back */
    216258                return rc;
    217259        }
    218 
     260       
     261        inet_naddr_addr(&addr6->naddr, &iaddr);
     262        rc = iplink_addr_add(ilink->iplink, &iaddr);
     263        if (rc != EOK) {
     264                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IPv6 address on internet link.");
     265                inet_addrobj_remove(addr6);
     266                inet_addrobj_delete(addr6);
     267                /* XXX Roll back */
     268                return rc;
     269        }
     270       
    219271        return EOK;
    220 
     272       
    221273error:
    222274        if (ilink->iplink != NULL)
    223275                iplink_close(ilink->iplink);
     276       
    224277        inet_link_delete(ilink);
    225278        return rc;
    … …  
    237290        rc = loc_register_cat_change_cb(inet_link_cat_change_cb);
    238291        if (rc != EOK) {
    239                 log_msg(LVL_ERROR, "Failed registering callback for IP link "
     292                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link "
    240293                    "discovery (%d).", rc);
    241294                return rc;
    … …  
    249302    inet_addr_t *ldest, inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    250303{
    251         iplink_sdu_t sdu;
    252         inet_packet_t packet;
    253         int rc;
    254         size_t offs, roffs;
    255 
    256304        /*
    257305         * Fill packet structure. Fragmentation is performed by
    258306         * inet_pdu_encode().
    259307         */
     308       
     309        inet_packet_t packet;
     310       
    260311        packet.src = dgram->src;
    261312        packet.dest = dgram->dest;
    … …  
    266317        packet.data = dgram->data;
    267318        packet.size = dgram->size;
    268 
    269         sdu.lsrc.ipv4 = lsrc->ipv4;
    270         sdu.ldest.ipv4 = ldest->ipv4;
    271 
    272         offs = 0;
     319       
     320        iplink_sdu_t sdu;
     321        size_t offs = 0;
     322        int rc;
     323       
     324        sdu.src = *lsrc;
     325        sdu.dest = *ldest;
     326       
    273327        do {
    274328                /* Encode one fragment */
     329                size_t roffs;
    275330                rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
    276331                    &sdu.size, &roffs);
    277332                if (rc != EOK)
    278333                        return rc;
    279 
     334               
    280335                /* Send the PDU */
    281336                rc = iplink_send(ilink->iplink, &sdu);
    282337                free(sdu.data);
    283 
     338               
    284339                offs = roffs;
    285340        } while (offs < packet.size);
    286 
     341       
    287342        return rc;
    288343}

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
    41 #include "inet.h"
     41#include "inetsrv.h"
    4242
    4343extern int inet_link_discovery_start(void);

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

    r80445cf r4c53333  
    4040#include <sys/types.h>
    4141
    42 /** Internet Datagram header (fixed part) */
     42/** IPv4 Datagram header (fixed part) */
    4343typedef struct {
    4444        /** Version, Internet Header Length */
    … …  
    9090};
    9191
     92/** IPv6 Datagram header (fixed part) */
     93typedef struct {
     94        /** Version, Traffic class first 4 bits */
     95        uint8_t ver_tc;
     96        /** Traffic class (the rest), Flow label */
     97        uint8_t tc_fl[3];
     98        /* Payload length */
     99        uint16_t payload_len;
     100        /** Next header */
     101        uint8_t next;
     102        /** Hop limit */
     103        uint8_t hop_limit;
     104        /** Source address */
     105        uint8_t src_addr[16];
     106        /** Destination address */
     107        uint8_t dest_addr[16];
     108} ip6_header_t;
     109
     110/** IPv6 Datagram Fragment extension header */
     111typedef struct {
     112        /** Next header */
     113        uint8_t next;
     114        /** Reserved */
     115        uint8_t reserved;
     116        /** Fragment Offset, Flags */
     117        uint16_t foff_flags;
     118        /** Identification */
     119        uint32_t id;
     120} ip6_header_fragment_t;
     121
    92122/** Fragment offset is expressed in units of 8 bytes */
    93123#define FRAG_OFFS_UNIT 8

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

    r80445cf r4c53333  
    4646
    4747#include "addrobj.h"
    48 #include "inet.h"
     48#include "inetsrv.h"
    4949#include "inet_link.h"
    5050#include "inetcfg.h"
    … …  
    5656        inet_link_t *ilink;
    5757        inet_addrobj_t *addr;
    58         iplink_addr_t iaddr;
     58        inet_addr_t iaddr;
    5959        int rc;
    6060
    6161        ilink = inet_link_get_by_id(link_id);
    6262        if (ilink == NULL) {
    63                 log_msg(LVL_DEBUG, "Link %lu not found.",
     63                log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %lu not found.",
    6464                    (unsigned long) link_id);
    6565                return ENOENT;
    … …  
    7575        addr->ilink = ilink;
    7676        addr->name = str_dup(name);
    77         inet_addrobj_add(addr);
    78 
    79         iaddr.ipv4 = addr->naddr.ipv4;
     77        rc = inet_addrobj_add(addr);
     78        if (rc != EOK) {
     79                log_msg(LOG_DEFAULT, LVL_DEBUG, "Duplicate address name '%s'.", addr->name);
     80                inet_addrobj_delete(addr);
     81                return rc;
     82        }
     83
     84        inet_naddr_addr(&addr->naddr, &iaddr);
    8085        rc = iplink_addr_add(ilink->iplink, &iaddr);
    8186        if (rc != EOK) {
    82                 log_msg(LVL_ERROR, "Failed setting IP address on internet link.");
     87                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
    8388                inet_addrobj_remove(addr);
    8489                inet_addrobj_delete(addr);
    … …  
    125130        ilink = inet_link_get_by_id(link_id);
    126131        if (ilink == NULL) {
    127                 log_msg(LVL_DEBUG, "Link %zu not found.", (size_t) link_id);
     132                log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %zu not found.", (size_t) link_id);
    128133                return ENOENT;
    129134        }
    … …  
    131136        addr = inet_addrobj_find_by_name(name, ilink);
    132137        if (addr == NULL) {
    133                 log_msg(LVL_DEBUG, "Address '%s' not found.", name);
     138                log_msg(LOG_DEFAULT, LVL_DEBUG, "Address '%s' not found.", name);
    134139                return ENOENT;
    135140        }
    … …  
    223228        sroute = inet_sroute_find_by_name(name);
    224229        if (sroute == NULL) {
    225                 log_msg(LVL_DEBUG, "Static route '%s' not found.", name);
     230                log_msg(LOG_DEFAULT, LVL_DEBUG, "Static route '%s' not found.", name);
    226231                return ENOENT;
    227232        }
    … …  
    231236}
    232237
    233 static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
    234     ipc_call_t *call)
    235 {
     238static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
     239    ipc_call_t *icall)
     240{
     241        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
     242       
     243        sysarg_t link_id = IPC_GET_ARG1(*icall);
     244       
     245        ipc_callid_t callid;
     246        size_t size;
     247        if (!async_data_write_receive(&callid, &size)) {
     248                async_answer_0(callid, EINVAL);
     249                async_answer_0(iid, EINVAL);
     250                return;
     251        }
     252       
     253        if (size != sizeof(inet_naddr_t)) {
     254                async_answer_0(callid, EINVAL);
     255                async_answer_0(iid, EINVAL);
     256                return;
     257        }
     258       
     259        inet_naddr_t naddr;
     260        int rc = async_data_write_finalize(callid, &naddr, size);
     261        if (rc != EOK) {
     262                async_answer_0(callid, rc);
     263                async_answer_0(iid, rc);
     264                return;
     265        }
     266       
    236267        char *name;
    237         inet_naddr_t naddr;
    238         sysarg_t link_id;
    239         sysarg_t addr_id;
    240         int rc;
    241 
    242         log_msg(LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    243 
    244268        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    245269            0, NULL);
    246270        if (rc != EOK) {
    247                 async_answer_0(callid, rc);
    248                 return;
    249         }
    250 
    251         naddr.ipv4 = IPC_GET_ARG1(*call);
    252         naddr.bits = IPC_GET_ARG2(*call);
    253         link_id    = IPC_GET_ARG3(*call);
    254 
    255         addr_id = 0;
     271                async_answer_0(iid, rc);
     272                return;
     273        }
     274       
     275        sysarg_t addr_id = 0;
    256276        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    257277        free(name);
    258         async_answer_1(callid, rc, addr_id);
     278        async_answer_1(iid, rc, addr_id);
    259279}
    260280
    … …  
    264284        int rc;
    265285
    266         log_msg(LVL_DEBUG, "inetcfg_addr_delete_srv()");
     286        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_delete_srv()");
    267287
    268288        addr_id = IPC_GET_ARG1(*call);
    … …  
    272292}
    273293
    274 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
    275 {
    276         ipc_callid_t rcallid;
    277         size_t max_size;
    278 
    279         sysarg_t addr_id;
     294static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     295{
     296        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
     297       
     298        sysarg_t addr_id = IPC_GET_ARG1(*icall);
     299       
    280300        inet_addr_info_t ainfo;
    281         int rc;
    282 
    283         addr_id = IPC_GET_ARG1(*call);
    284         log_msg(LVL_DEBUG, "inetcfg_addr_get_srv()");
    285 
    286         ainfo.naddr.ipv4 = 0;
    287         ainfo.naddr.bits = 0;
     301       
     302        inet_naddr_any(&ainfo.naddr);
    288303        ainfo.ilink = 0;
    289304        ainfo.name = NULL;
    290 
    291         if (!async_data_read_receive(&rcallid, &max_size)) {
    292                 async_answer_0(rcallid, EREFUSED);
    293                 async_answer_0(callid, EREFUSED);
    294                 return;
    295         }
    296 
    297         rc = inetcfg_addr_get(addr_id, &ainfo);
    298         if (rc != EOK) {
    299                 async_answer_0(callid, rc);
    300                 return;
    301         }
    302 
    303         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    304             min(max_size, str_size(ainfo.name)));
     305       
     306        int rc = inetcfg_addr_get(addr_id, &ainfo);
     307        if (rc != EOK) {
     308                async_answer_0(iid, rc);
     309                return;
     310        }
     311       
     312        ipc_callid_t callid;
     313        size_t size;
     314        if (!async_data_read_receive(&callid, &size)) {
     315                async_answer_0(callid, EREFUSED);
     316                async_answer_0(iid, EREFUSED);
     317                return;
     318        }
     319       
     320        if (size != sizeof(inet_naddr_t)) {
     321                async_answer_0(callid, EINVAL);
     322                async_answer_0(iid, EINVAL);
     323                return;
     324        }
     325       
     326        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
     327        if (rc != EOK) {
     328                async_answer_0(callid, rc);
     329                async_answer_0(iid, rc);
     330                return;
     331        }
     332       
     333        if (!async_data_read_receive(&callid, &size)) {
     334                async_answer_0(callid, EREFUSED);
     335                async_answer_0(iid, EREFUSED);
     336                return;
     337        }
     338       
     339        rc = async_data_read_finalize(callid, ainfo.name,
     340            min(size, str_size(ainfo.name)));
    305341        free(ainfo.name);
    306 
    307         async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
    308             ainfo.ilink);
     342       
     343        if (rc != EOK) {
     344                async_answer_0(callid, rc);
     345                async_answer_0(iid, rc);
     346                return;
     347        }
     348       
     349        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
    309350}
    310351
    … …  
    316357        int rc;
    317358
    318         log_msg(LVL_DEBUG, "inetcfg_addr_get_id_srv()");
     359        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_id_srv()");
    319360
    320361        link_id = IPC_GET_ARG1(*call);
    … …  
    343384        int rc;
    344385
    345         log_msg(LVL_DEBUG, "inetcfg_get_addr_list_srv()");
     386        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    346387
    347388        if (!async_data_read_receive(&rcallid, &max_size)) {
    … …  
    366407        async_answer_1(callid, retval, act_size);
    367408}
    368 
    369409
    370410static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    … …  
    377417        int rc;
    378418
    379         log_msg(LVL_DEBUG, "inetcfg_get_link_list_srv()");
     419        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_link_list_srv()");
    380420
    381421        if (!async_data_read_receive(&rcallid, &max_size)) {
    … …  
    410450        int rc;
    411451
    412         log_msg(LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
     452        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
    413453
    414454        if (!async_data_read_receive(&rcallid, &max_size)) {
    … …  
    444484
    445485        link_id = IPC_GET_ARG1(*call);
    446         log_msg(LVL_DEBUG, "inetcfg_link_get_srv()");
     486        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_get_srv()");
    447487
    448488        linfo.name = NULL;
    … …  
    468508}
    469509
    470 static void inetcfg_sroute_create_srv(ipc_callid_t callid,
    471     ipc_call_t *call)
    472 {
     510static void inetcfg_sroute_create_srv(ipc_callid_t iid,
     511    ipc_call_t *icall)
     512{
     513        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     514
     515        ipc_callid_t callid;
     516        size_t size;
     517        if (!async_data_write_receive(&callid, &size)) {
     518                async_answer_0(callid, EINVAL);
     519                async_answer_0(iid, EINVAL);
     520                return;
     521        }
     522       
     523        if (size != sizeof(inet_naddr_t)) {
     524                async_answer_0(callid, EINVAL);
     525                async_answer_0(iid, EINVAL);
     526                return;
     527        }
     528       
     529        inet_naddr_t dest;
     530        int rc = async_data_write_finalize(callid, &dest, size);
     531        if (rc != EOK) {
     532                async_answer_0(callid, rc);
     533                async_answer_0(iid, rc);
     534                return;
     535        }
     536       
     537        if (!async_data_write_receive(&callid, &size)) {
     538                async_answer_0(callid, EINVAL);
     539                async_answer_0(iid, EINVAL);
     540                return;
     541        }
     542       
     543        if (size != sizeof(inet_addr_t)) {
     544                async_answer_0(callid, EINVAL);
     545                async_answer_0(iid, EINVAL);
     546                return;
     547        }
     548       
     549        inet_addr_t router;
     550        rc = async_data_write_finalize(callid, &router, size);
     551        if (rc != EOK) {
     552                async_answer_0(callid, rc);
     553                async_answer_0(iid, rc);
     554                return;
     555        }
     556       
    473557        char *name;
    474         inet_naddr_t dest;
    475         inet_addr_t router;
    476         sysarg_t sroute_id;
    477         int rc;
    478 
    479         log_msg(LVL_DEBUG, "inetcfg_sroute_create_srv()");
    480 
    481558        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    482559            0, NULL);
    483560        if (rc != EOK) {
    484                 async_answer_0(callid, rc);
    485                 return;
    486         }
    487 
    488         dest.ipv4   = IPC_GET_ARG1(*call);
    489         dest.bits   = IPC_GET_ARG2(*call);
    490         router.ipv4 = IPC_GET_ARG3(*call);
    491 
    492         sroute_id = 0;
     561                async_answer_0(iid, rc);
     562                return;
     563        }
     564       
     565        sysarg_t sroute_id = 0;
    493566        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    494567        free(name);
    495         async_answer_1(callid, rc, sroute_id);
     568        async_answer_1(iid, rc, sroute_id);
    496569}
    497570
    … …  
    501574        int rc;
    502575
    503         log_msg(LVL_DEBUG, "inetcfg_sroute_delete_srv()");
     576        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_delete_srv()");
    504577
    505578        sroute_id = IPC_GET_ARG1(*call);
    … …  
    509582}
    510583
    511 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
    512 {
    513         ipc_callid_t rcallid;
    514         size_t max_size;
    515 
    516         sysarg_t sroute_id;
     584static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     585{
     586        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
     587       
     588        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
     589       
    517590        inet_sroute_info_t srinfo;
    518         int rc;
    519 
    520         sroute_id = IPC_GET_ARG1(*call);
    521         log_msg(LVL_DEBUG, "inetcfg_sroute_get_srv()");
    522 
    523         srinfo.dest.ipv4 = 0;
    524         srinfo.dest.bits = 0;
    525         srinfo.router.ipv4 = 0;
     591       
     592        inet_naddr_any(&srinfo.dest);
     593        inet_addr_any(&srinfo.router);
    526594        srinfo.name = NULL;
    527 
    528         if (!async_data_read_receive(&rcallid, &max_size)) {
    529                 async_answer_0(rcallid, EREFUSED);
    530                 async_answer_0(callid, EREFUSED);
    531                 return;
    532         }
    533 
    534         rc = inetcfg_sroute_get(sroute_id, &srinfo);
    535         if (rc != EOK) {
    536                 async_answer_0(callid, rc);
    537                 return;
    538         }
    539 
    540         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    541             min(max_size, str_size(srinfo.name)));
     595       
     596        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
     597        if (rc != EOK) {
     598                async_answer_0(iid, rc);
     599                return;
     600        }
     601       
     602        ipc_callid_t callid;
     603        size_t size;
     604        if (!async_data_read_receive(&callid, &size)) {
     605                async_answer_0(callid, EREFUSED);
     606                async_answer_0(iid, EREFUSED);
     607                return;
     608        }
     609       
     610        if (size != sizeof(inet_naddr_t)) {
     611                async_answer_0(callid, EINVAL);
     612                async_answer_0(iid, EINVAL);
     613                return;
     614        }
     615       
     616        rc = async_data_read_finalize(callid, &srinfo.dest, size);
     617        if (rc != EOK) {
     618                async_answer_0(callid, rc);
     619                async_answer_0(iid, rc);
     620                return;
     621        }
     622       
     623        if (!async_data_read_receive(&callid, &size)) {
     624                async_answer_0(callid, EREFUSED);
     625                async_answer_0(iid, EREFUSED);
     626                return;
     627        }
     628       
     629        if (size != sizeof(inet_addr_t)) {
     630                async_answer_0(callid, EINVAL);
     631                async_answer_0(iid, EINVAL);
     632                return;
     633        }
     634       
     635        rc = async_data_read_finalize(callid, &srinfo.router, size);
     636        if (rc != EOK) {
     637                async_answer_0(callid, rc);
     638                async_answer_0(iid, rc);
     639                return;
     640        }
     641       
     642        if (!async_data_read_receive(&callid, &size)) {
     643                async_answer_0(callid, EREFUSED);
     644                async_answer_0(iid, EREFUSED);
     645                return;
     646        }
     647       
     648        rc = async_data_read_finalize(callid, srinfo.name,
     649            min(size, str_size(srinfo.name)));
    542650        free(srinfo.name);
    543 
    544         async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits,
    545             srinfo.router.ipv4);
     651       
     652        async_answer_0(iid, (sysarg_t) rc);
    546653}
    547654
    … …  
    552659        int rc;
    553660
    554         log_msg(LVL_DEBUG, "inetcfg_sroute_get_id_srv()");
     661        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_id_srv()");
    555662
    556663        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    … …  
    569676void inet_cfg_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    570677{
    571         log_msg(LVL_DEBUG, "inet_cfg_conn()");
     678        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()");
    572679
    573680        /* Accept the connection */

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

    r80445cf r4c53333  
    4343#include <stdlib.h>
    4444#include <sys/types.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "icmp.h"
    4747#include "icmp_std.h"
    48 #include "inet.h"
     48#include "inetsrv.h"
    4949#include "inetping.h"
    5050
    … …  
    5555static uint16_t inetping_ident = 0;
    5656
    57 static inetping_client_t *inetping_client_find(uint16_t);
    58 
    5957static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6058{
    … …  
    6260}
    6361
    64 static int inetping_get_srcaddr(inetping_client_t *client, inet_addr_t *remote,
    65     inet_addr_t *local)
    66 {
    67         return inet_get_srcaddr(remote, ICMP_TOS, local);
     62static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
     63    addr32_t *local)
     64{
     65        inet_addr_t remote_addr;
     66        inet_addr_set(remote, &remote_addr);
     67       
     68        inet_addr_t local_addr;
     69        int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
     70        if (rc != EOK)
     71                return rc;
     72       
     73        uint16_t family = inet_addr_get(&local_addr, local, NULL);
     74        if (family != AF_INET)
     75                return EINVAL;
     76       
     77        return EOK;
     78}
     79
     80static inetping_client_t *inetping_client_find(uint16_t ident)
     81{
     82        fibril_mutex_lock(&client_list_lock);
     83       
     84        list_foreach(client_list, link) {
     85                inetping_client_t *client = list_get_instance(link,
     86                    inetping_client_t, client_list);
     87               
     88                if (client->ident == ident) {
     89                        fibril_mutex_unlock(&client_list_lock);
     90                        return client;
     91                }
     92        }
     93       
     94        fibril_mutex_unlock(&client_list_lock);
     95        return NULL;
    6896}
    6997
    7098int inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
    7199{
    72         inetping_client_t *client;
    73         async_exch_t *exch;
     100        inetping_client_t *client = inetping_client_find(ident);
     101        if (client == NULL) {
     102                log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ICMP ident. Dropping.");
     103                return ENOENT;
     104        }
     105       
     106        async_exch_t *exch = async_exchange_begin(client->sess);
     107       
    74108        ipc_call_t answer;
    75 
    76         client = inetping_client_find(ident);
    77         if (client == NULL) {
    78                 log_msg(LVL_DEBUG, "Unknown ICMP ident. Dropping.");
    79                 return ENOENT;
    80         }
    81 
    82         exch = async_exchange_begin(client->sess);
    83 
    84         aid_t req = async_send_3(exch, INETPING_EV_RECV, sdu->src.ipv4,
    85             sdu->dest.ipv4, sdu->seq_no, &answer);
     109        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
     110            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    86111        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     112       
    87113        async_exchange_end(exch);
    88 
     114       
    89115        if (rc != EOK) {
    90                 async_wait_for(req, NULL);
     116                async_forget(req);
    91117                return rc;
    92118        }
    93 
     119       
    94120        sysarg_t retval;
    95121        async_wait_for(req, &retval);
    96         if (retval != EOK) {
    97                 return retval;
    98         }
    99 
    100         return EOK;
     122       
     123        return (int) retval;
    101124}
    102125
    … …  
    107130        int rc;
    108131
    109         log_msg(LVL_DEBUG, "inetping_send_srv()");
     132        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
    110133
    111134        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    … …  
    116139        }
    117140
    118         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    119         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     141        sdu.src = IPC_GET_ARG1(*call);
     142        sdu.dest = IPC_GET_ARG2(*call);
    120143        sdu.seq_no = IPC_GET_ARG3(*call);
    121144
    … …  
    129152    ipc_callid_t callid, ipc_call_t *call)
    130153{
    131         inet_addr_t remote;
    132         inet_addr_t local;
    133         int rc;
    134 
    135         log_msg(LVL_DEBUG, "inetping_get_srcaddr_srv()");
    136 
    137         remote.ipv4 = IPC_GET_ARG1(*call);
    138         local.ipv4 = 0;
    139 
    140         rc = inetping_get_srcaddr(client, &remote, &local);
    141         async_answer_1(callid, rc, local.ipv4);
     154        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
     155       
     156        uint32_t remote = IPC_GET_ARG1(*call);
     157        uint32_t local = 0;
     158       
     159        int rc = inetping_get_srcaddr(client, remote, &local);
     160        async_answer_1(callid, rc, (sysarg_t) local);
    142161}
    143162
    … …  
    147166        if (sess == NULL)
    148167                return ENOMEM;
    149 
     168       
    150169        client->sess = sess;
    151170        link_initialize(&client->client_list);
    152 
     171       
    153172        fibril_mutex_lock(&client_list_lock);
    154173        client->ident = ++inetping_ident;
    155174        list_append(&client->client_list, &client_list);
    156175        fibril_mutex_unlock(&client_list_lock);
    157 
     176       
    158177        return EOK;
    159178}
    … …  
    163182        async_hangup(client->sess);
    164183        client->sess = NULL;
    165 
     184       
    166185        fibril_mutex_lock(&client_list_lock);
    167186        list_remove(&client->client_list);
    … …  
    169188}
    170189
    171 static inetping_client_t *inetping_client_find(uint16_t ident)
    172 {
    173         fibril_mutex_lock(&client_list_lock);
    174 
    175         list_foreach(client_list, link) {
    176                 inetping_client_t *client = list_get_instance(link,
    177                     inetping_client_t, client_list);
    178 
    179                 if (client->ident == ident) {
    180                         fibril_mutex_unlock(&client_list_lock);
    181                         return client;
    182                 }
    183         }
    184 
    185         fibril_mutex_unlock(&client_list_lock);
    186         return NULL;
    187 }
    188 
    189190void inetping_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    190191{
    191         inetping_client_t client;
    192         int rc;
    193 
    194         log_msg(LVL_DEBUG, "inetping_conn()");
    195 
     192        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
     193       
    196194        /* Accept the connection */
    197195        async_answer_0(iid, EOK);
    198 
    199         rc = inetping_client_init(&client);
     196       
     197        inetping_client_t client;
     198        int rc = inetping_client_init(&client);
    200199        if (rc != EOK)
    201200                return;
    202 
     201       
    203202        while (true) {
    204203                ipc_call_t call;
    205204                ipc_callid_t callid = async_get_call(&call);
    206205                sysarg_t method = IPC_GET_IMETHOD(call);
    207 
     206               
    208207                if (!method) {
    209208                        /* The other side has hung up */
    … …  
    211210                        break;
    212211                }
    213 
     212               
    214213                switch (method) {
    215214                case INETPING_SEND:
    … …  
    223222                }
    224223        }
    225 
     224       
    226225        inetping_client_fini(&client);
    227226}

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

    r80445cf r4c53333  
    3838#define INETPING_H_
    3939
     40#include "inetsrv.h"
     41
    4042extern void inetping_conn(ipc_callid_t, ipc_call_t *, void *);
    4143extern int inetping_recv(uint16_t, inetping_sdu_t *);

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

    r80445cf r4c53333  
    4646#include <stdlib.h>
    4747#include <sys/types.h>
    48 
     48#include <net/socket_codes.h>
    4949#include "addrobj.h"
    5050#include "icmp.h"
    5151#include "icmp_std.h"
    52 #include "inet.h"
     52#include "icmpv6.h"
     53#include "icmpv6_std.h"
     54#include "inetsrv.h"
    5355#include "inetcfg.h"
    5456#include "inetping.h"
     57#include "inetping6.h"
    5558#include "inet_link.h"
    5659#include "reass.h"
    5760#include "sroute.h"
    5861
    59 #define NAME "inet"
     62#define NAME "inetsrv"
    6063
    6164static void inet_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    6669static int inet_init(void)
    6770{
     71        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()");
     72       
     73        async_set_client_connection(inet_client_conn);
     74       
     75        int rc = loc_server_register(NAME);
     76        if (rc != EOK) {
     77                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server (%d).", rc);
     78                return EEXIST;
     79        }
     80       
    6881        service_id_t sid;
    69         int rc;
    70 
    71         log_msg(LVL_DEBUG, "inet_init()");
    72 
    73         async_set_client_connection(inet_client_conn);
    74 
    75         rc = loc_server_register(NAME);
    76         if (rc != EOK) {
    77                 log_msg(LVL_ERROR, "Failed registering server (%d).", rc);
    78                 return EEXIST;
    79         }
    80 
    8182        rc = loc_service_register_with_iface(SERVICE_NAME_INET, &sid,
    8283            INET_PORT_DEFAULT);
    8384        if (rc != EOK) {
    84                 log_msg(LVL_ERROR, "Failed registering service (%d).", rc);
     85                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    8586                return EEXIST;
    8687        }
    87 
     88       
    8889        rc = loc_service_register_with_iface(SERVICE_NAME_INETCFG, &sid,
    8990            INET_PORT_CFG);
    9091        if (rc != EOK) {
    91                 log_msg(LVL_ERROR, "Failed registering service (%d).", rc);
     92                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    9293                return EEXIST;
    9394        }
    94 
     95       
    9596        rc = loc_service_register_with_iface(SERVICE_NAME_INETPING, &sid,
    9697            INET_PORT_PING);
    9798        if (rc != EOK) {
    98                 log_msg(LVL_ERROR, "Failed registering service (%d).", rc);
     99                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    99100                return EEXIST;
    100101        }
     102       
     103        rc = loc_service_register_with_iface(SERVICE_NAME_INETPING6, &sid,
     104            INET_PORT_PING6);
     105        if (rc != EOK) {
     106                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
     107                return EEXIST;
     108        }
     109       
     110        inet_sroute_t *sroute = inet_sroute_new();
     111        if (sroute == NULL) {
     112                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating default route (%d).", rc);
     113                return ENOMEM;
     114        }
     115
     116        inet_naddr(&sroute->dest, 0, 0, 0, 0, 0);
     117        inet_addr(&sroute->router, 10, 0, 2, 2);
     118        sroute->name = str_dup("default");
     119        inet_sroute_add(sroute);
    101120
    102121        rc = inet_link_discovery_start();
    103122        if (rc != EOK)
    104123                return EEXIST;
    105 
     124       
    106125        return EOK;
    107126}
    … …  
    110129    ipc_call_t *call)
    111130{
    112         log_msg(LVL_DEBUG, "inet_callback_create_srv()");
     131        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_callback_create_srv()");
    113132
    114133        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    145164
    146165        if (dir->aobj == NULL) {
    147                 log_msg(LVL_DEBUG, "inet_send: No route to destination.");
     166                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send: No route to destination.");
    148167                return ENOENT;
    149168        }
    … …  
    184203
    185204        /* Take source address from the address object */
    186         local->ipv4 = dir.aobj->naddr.ipv4;
     205        inet_naddr_addr(&dir.aobj->naddr, local);
    187206        return EOK;
    188207}
    189208
    190 static void inet_get_srcaddr_srv(inet_client_t *client, ipc_callid_t callid,
    191     ipc_call_t *call)
    192 {
     209static void inet_get_srcaddr_srv(inet_client_t *client, ipc_callid_t iid,
     210    ipc_call_t *icall)
     211{
     212        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
     213       
     214        uint8_t tos = IPC_GET_ARG1(*icall);
     215       
     216        ipc_callid_t callid;
     217        size_t size;
     218        if (!async_data_write_receive(&callid, &size)) {
     219                async_answer_0(callid, EREFUSED);
     220                async_answer_0(iid, EREFUSED);
     221                return;
     222        }
     223       
     224        if (size != sizeof(inet_addr_t)) {
     225                async_answer_0(callid, EINVAL);
     226                async_answer_0(iid, EINVAL);
     227                return;
     228        }
     229       
    193230        inet_addr_t remote;
    194         uint8_t tos;
     231        int rc = async_data_write_finalize(callid, &remote, size);
     232        if (rc != EOK) {
     233                async_answer_0(callid, rc);
     234                async_answer_0(iid, rc);
     235        }
     236       
    195237        inet_addr_t local;
    196         int rc;
    197 
    198         log_msg(LVL_DEBUG, "inet_get_srcaddr_srv()");
    199 
    200         remote.ipv4 = IPC_GET_ARG1(*call);
    201         tos = IPC_GET_ARG2(*call);
    202         local.ipv4 = 0;
    203 
    204238        rc = inet_get_srcaddr(&remote, tos, &local);
    205         async_answer_1(callid, rc, local.ipv4);
    206 }
    207 
    208 static void inet_send_srv(inet_client_t *client, ipc_callid_t callid,
    209     ipc_call_t *call)
    210 {
     239        if (rc != EOK) {
     240                async_answer_0(iid, rc);
     241                return;
     242        }
     243       
     244        if (!async_data_read_receive(&callid, &size)) {
     245                async_answer_0(callid, EREFUSED);
     246                async_answer_0(iid, EREFUSED);
     247                return;
     248        }
     249       
     250        if (size != sizeof(inet_addr_t)) {
     251                async_answer_0(callid, EINVAL);
     252                async_answer_0(iid, EINVAL);
     253                return;
     254        }
     255       
     256        rc = async_data_read_finalize(callid, &local, size);
     257        if (rc != EOK) {
     258                async_answer_0(callid, rc);
     259                async_answer_0(iid, rc);
     260                return;
     261        }
     262       
     263        async_answer_0(iid, rc);
     264}
     265
     266static void inet_send_srv(inet_client_t *client, ipc_callid_t iid,
     267    ipc_call_t *icall)
     268{
     269        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
     270       
    211271        inet_dgram_t dgram;
    212         uint8_t ttl;
    213         int df;
    214         int rc;
    215 
    216         log_msg(LVL_DEBUG, "inet_send_srv()");
    217 
    218         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    219         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
    220         dgram.tos = IPC_GET_ARG3(*call);
    221         ttl = IPC_GET_ARG4(*call);
    222         df = IPC_GET_ARG5(*call);
    223 
    224         rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
     272       
     273        dgram.tos = IPC_GET_ARG1(*icall);
     274       
     275        uint8_t ttl = IPC_GET_ARG2(*icall);
     276        int df = IPC_GET_ARG3(*icall);
     277       
     278        ipc_callid_t callid;
     279        size_t size;
     280        if (!async_data_write_receive(&callid, &size)) {
     281                async_answer_0(callid, EREFUSED);
     282                async_answer_0(iid, EREFUSED);
     283                return;
     284        }
     285       
     286        if (size != sizeof(inet_addr_t)) {
     287                async_answer_0(callid, EINVAL);
     288                async_answer_0(iid, EINVAL);
     289                return;
     290        }
     291       
     292        int rc = async_data_write_finalize(callid, &dgram.src, size);
    225293        if (rc != EOK) {
    226294                async_answer_0(callid, rc);
    227                 return;
    228         }
    229 
     295                async_answer_0(iid, rc);
     296        }
     297       
     298        if (!async_data_write_receive(&callid, &size)) {
     299                async_answer_0(callid, EREFUSED);
     300                async_answer_0(iid, EREFUSED);
     301                return;
     302        }
     303       
     304        if (size != sizeof(inet_addr_t)) {
     305                async_answer_0(callid, EINVAL);
     306                async_answer_0(iid, EINVAL);
     307                return;
     308        }
     309       
     310        rc = async_data_write_finalize(callid, &dgram.dest, size);
     311        if (rc != EOK) {
     312                async_answer_0(callid, rc);
     313                async_answer_0(iid, rc);
     314        }
     315       
     316        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0,
     317            &dgram.size);
     318        if (rc != EOK) {
     319                async_answer_0(iid, rc);
     320                return;
     321        }
     322       
    230323        rc = inet_send(client, &dgram, client->protocol, ttl, df);
    231 
     324       
    232325        free(dgram.data);
    233         async_answer_0(callid, rc);
     326        async_answer_0(iid, rc);
    234327}
    235328
    … …  
    240333
    241334        proto = IPC_GET_ARG1(*call);
    242         log_msg(LVL_DEBUG, "inet_set_proto_srv(%lu)", (unsigned long) proto);
     335        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_set_proto_srv(%lu)", (unsigned long) proto);
    243336
    244337        if (proto > UINT8_MAX) {
    … …  
    274367        inet_client_t client;
    275368
    276         log_msg(LVL_DEBUG, "inet_default_conn()");
     369        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_default_conn()");
    277370
    278371        /* Accept the connection */
    … …  
    329422                inetping_conn(iid, icall, arg);
    330423                break;
     424        case INET_PORT_PING6:
     425                inetping6_conn(iid, icall, arg);
     426                break;
    331427        default:
    332428                async_answer_0(iid, ENOTSUP);
    … …  
    356452{
    357453        async_exch_t *exch = async_exchange_begin(client->sess);
    358 
     454       
    359455        ipc_call_t answer;
    360         aid_t req = async_send_3(exch, INET_EV_RECV, dgram->src.ipv4,
    361             dgram->dest.ipv4, dgram->tos, &answer);
    362         int rc = async_data_write_start(exch, dgram->data, dgram->size);
     456        aid_t req = async_send_1(exch, INET_EV_RECV, dgram->tos, &answer);
     457       
     458        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     459        if (rc != EOK) {
     460                async_exchange_end(exch);
     461                async_forget(req);
     462                return rc;
     463        }
     464       
     465        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
     466        if (rc != EOK) {
     467                async_exchange_end(exch);
     468                async_forget(req);
     469                return rc;
     470        }
     471       
     472        rc = async_data_write_start(exch, dgram->data, dgram->size);
     473       
    363474        async_exchange_end(exch);
    364 
    365         if (rc != EOK) {
    366                 async_wait_for(req, NULL);
     475       
     476        if (rc != EOK) {
     477                async_forget(req);
    367478                return rc;
    368479        }
    369 
     480       
    370481        sysarg_t retval;
    371482        async_wait_for(req, &retval);
    372         if (retval != EOK)
    373                 return retval;
    374 
    375         return EOK;
     483       
     484        return (int) retval;
    376485}
    377486
    … …  
    380489        inet_client_t *client;
    381490
    382         log_msg(LVL_DEBUG, "inet_recv_dgram_local()");
    383 
    384         /* ICMP messages are handled internally */
     491        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_recv_dgram_local()");
     492
     493        /* ICMP and ICMPv6 messages are handled internally */
    385494        if (proto == IP_PROTO_ICMP)
    386495                return icmp_recv(dgram);
     496       
     497        if (proto == IP_PROTO_ICMPV6)
     498                return icmpv6_recv(dgram);
    387499
    388500        client = inet_client_find(proto);
    389501        if (client == NULL) {
    390                 log_msg(LVL_DEBUG, "No client found for protocol 0x%" PRIx8,
     502                log_msg(LOG_DEFAULT, LVL_DEBUG, "No client found for protocol 0x%" PRIx8,
    391503                    proto);
    392504                return ENOENT;
    … …  
    430542        printf(NAME ": HelenOS Internet Protocol service\n");
    431543
    432         if (log_init(NAME, LVL_WARN) != EOK) {
     544        if (log_init(NAME) != EOK) {
    433545                printf(NAME ": Failed to initialize logging.\n");
    434546                return 1;

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

    r80445cf r4c53333  
    2727 */
    2828
    29 /** @addtogroup inet
     29/** @addtogroup inetsrv
    3030 * @{
    3131 */
    … …  
    3535 */
    3636
    37 #ifndef INET_H_
    38 #define INET_H_
     37#ifndef INETSRV_H_
     38#define INETSRV_H_
    3939
    4040#include <adt/list.h>
    41 #include <bool.h>
     41#include <stdbool.h>
     42#include <inet/addr.h>
    4243#include <inet/iplink.h>
    4344#include <ipc/loc.h>
    … …  
    6263} inetping_client_t;
    6364
    64 /** Host address */
    65 typedef struct {
    66         uint32_t ipv4;
    67 } inet_addr_t;
    68 
    69 /** Network address */
    70 typedef struct {
    71         /** Address */
    72         uint32_t ipv4;
    73         /** Number of valid bits in @c ipv4 */
    74         int bits;
    75 } inet_naddr_t;
     65/** Inetping6 Client */
     66typedef struct {
     67        /** Callback session */
     68        async_sess_t *sess;
     69        /** Session identifier */
     70        uint16_t ident;
     71        /** Link to client list */
     72        link_t client_list;
     73} inetping6_client_t;
    7674
    7775/** Address object info */
    … …  
    184182
    185183typedef struct {
    186         inet_addr_t src;
    187         inet_addr_t dest;
     184        uint32_t src;
     185        uint32_t dest;
    188186        uint16_t seq_no;
    189187        void *data;
    190188        size_t size;
    191189} inetping_sdu_t;
     190
     191typedef struct {
     192        addr128_t src;
     193        addr128_t dest;
     194        uint16_t seq_no;
     195        void *data;
     196        size_t size;
     197} inetping6_sdu_t;
    192198
    193199extern int inet_ev_recv(inet_client_t *, inet_dgram_t *);

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

    r80445cf r4c53333  
    4444#include <mem.h>
    4545#include <stdlib.h>
    46 
    47 #include "inet.h"
     46#include <net/socket_codes.h>
     47#include "inetsrv.h"
    4848#include "inet_std.h"
    4949#include "pdu.h"
    … …  
    106106    void **rdata, size_t *rsize, size_t *roffs)
    107107{
    108         void *data;
    109         size_t size;
    110         ip_header_t *hdr;
    111         size_t hdr_size;
    112         size_t data_offs;
    113         uint16_t chksum;
    114         uint16_t ident;
    115         uint16_t flags_foff;
    116         uint16_t foff;
    117         size_t fragoff_limit;
    118         size_t xfer_size;
    119         size_t spc_avail;
    120         size_t rem_offs;
    121 
     108        addr32_t src_v4;
     109        addr128_t src_v6;
     110        uint16_t src_af = inet_addr_get(&packet->src, &src_v4, &src_v6);
     111       
     112        addr32_t dest_v4;
     113        addr128_t dest_v6;
     114        uint16_t dest_af = inet_addr_get(&packet->dest, &dest_v4, &dest_v6);
     115       
     116        if (src_af != dest_af)
     117                return EINVAL;
     118       
    122119        /* Upper bound for fragment offset field */
    123         fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
    124 
     120        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
     121       
    125122        /* Verify that total size of datagram is within reasonable bounds */
    126123        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
    127124                return ELIMIT;
    128 
    129         hdr_size = sizeof(ip_header_t);
    130         data_offs = ROUND_UP(hdr_size, 4);
    131 
     125       
     126        size_t hdr_size;
     127       
     128        switch (src_af) {
     129        case AF_INET:
     130                hdr_size = sizeof(ip_header_t);
     131                break;
     132        case AF_INET6:
     133                hdr_size = sizeof(ip6_header_t);
     134                break;
     135        default:
     136                assert(false);
     137        }
     138       
     139        size_t data_offs = ROUND_UP(hdr_size, 4);
     140       
    132141        assert(offs % FRAG_OFFS_UNIT == 0);
    133142        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
    134 
     143       
    135144        /* Value for the fragment offset field */
    136         foff = offs / FRAG_OFFS_UNIT;
    137 
     145        uint16_t foff = offs / FRAG_OFFS_UNIT;
     146       
    138147        if (hdr_size >= mtu)
    139148                return EINVAL;
    140 
     149       
    141150        /* Amount of space in the PDU available for payload */
    142         spc_avail = mtu - hdr_size;
     151        size_t spc_avail = mtu - hdr_size;
    143152        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
    144 
     153       
    145154        /* Amount of data (payload) to transfer */
    146         xfer_size = min(packet->size - offs, spc_avail);
    147 
     155        size_t xfer_size = min(packet->size - offs, spc_avail);
     156       
    148157        /* Total PDU size */
    149         size = hdr_size + xfer_size;
    150 
     158        size_t size = hdr_size + xfer_size;
     159       
    151160        /* Offset of remaining payload */
    152         rem_offs = offs + xfer_size;
    153 
     161        size_t rem_offs = offs + xfer_size;
     162       
    154163        /* Flags */
    155         flags_foff =
     164        uint16_t flags_foff =
    156165            (packet->df ? BIT_V(uint16_t, FF_FLAG_DF) : 0) +
    157166            (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
    158167            (foff << FF_FRAGOFF_l);
    159 
    160         data = calloc(size, 1);
     168       
     169        void *data = calloc(size, 1);
    161170        if (data == NULL)
    162171                return ENOMEM;
    163 
     172       
    164173        /* Allocate identifier */
    165174        fibril_mutex_lock(&ip_ident_lock);
    166         ident = ++ip_ident;
     175        uint16_t ident = ++ip_ident;
    167176        fibril_mutex_unlock(&ip_ident_lock);
    168 
     177       
    169178        /* Encode header fields */
    170         hdr = (ip_header_t *)data;
    171         hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    172         hdr->tos = packet->tos;
    173         hdr->tot_len = host2uint16_t_be(size);
    174         hdr->id = host2uint16_t_be(ident);
    175         hdr->flags_foff = host2uint16_t_be(flags_foff);
    176         hdr->ttl = packet->ttl;
    177         hdr->proto = packet->proto;
    178         hdr->chksum = 0;
    179         hdr->src_addr = host2uint32_t_be(packet->src.ipv4);
    180         hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
    181 
    182         /* Compute checksum */
    183         chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *)hdr, hdr_size);
    184         hdr->chksum = host2uint16_t_be(chksum);
    185 
     179        ip_header_t *hdr;
     180        ip6_header_t *hdr6;
     181       
     182        switch (src_af) {
     183        case AF_INET:
     184                hdr = (ip_header_t *) data;
     185               
     186                hdr->ver_ihl =
     187                    (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
     188                hdr->tos = packet->tos;
     189                hdr->tot_len = host2uint16_t_be(size);
     190                hdr->id = host2uint16_t_be(ident);
     191                hdr->flags_foff = host2uint16_t_be(flags_foff);
     192                hdr->ttl = packet->ttl;
     193                hdr->proto = packet->proto;
     194                hdr->chksum = 0;
     195                hdr->src_addr = host2uint32_t_be(src_v4);
     196                hdr->dest_addr = host2uint32_t_be(dest_v4);
     197               
     198                /* Compute checksum */
     199                uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
     200                    (void *) hdr, hdr_size);
     201                hdr->chksum = host2uint16_t_be(chksum);
     202               
     203                break;
     204        case AF_INET6:
     205                // TODO FIXME: fragmentation
     206               
     207                hdr6 = (ip6_header_t *) data;
     208               
     209                hdr6->ver_tc = (6 << (VI_VERSION_l));
     210                memset(hdr6->tc_fl, 0, 3);
     211                hdr6->payload_len = host2uint16_t_be(packet->size);
     212                hdr6->next = packet->proto;
     213                hdr6->hop_limit = packet->ttl;
     214               
     215                host2addr128_t_be(src_v6, hdr6->src_addr);
     216                host2addr128_t_be(dest_v6, hdr6->dest_addr);
     217               
     218                break;
     219        default:
     220                assert(false);
     221        }
     222       
    186223        /* Copy payload */
    187         memcpy((uint8_t *)data + data_offs, packet->data + offs, xfer_size);
    188 
     224        memcpy((uint8_t *) data + data_offs, packet->data + offs, xfer_size);
     225       
    189226        *rdata = data;
    190227        *rsize = size;
    191228        *roffs = rem_offs;
    192 
     229       
    193230        return EOK;
    194231}
    … …  
    196233int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
    197234{
    198         ip_header_t *hdr;
    199         size_t tot_len;
    200         size_t data_offs;
    201         uint8_t version;
    202         uint16_t ident;
    203         uint16_t flags_foff;
    204         uint16_t foff;
    205 
    206         log_msg(LVL_DEBUG, "inet_pdu_decode()");
    207 
     235        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
     236       
    208237        if (size < sizeof(ip_header_t)) {
    209                 log_msg(LVL_DEBUG, "PDU too short (%zu)", size);
    210                 return EINVAL;
    211         }
    212 
    213         hdr = (ip_header_t *)data;
    214 
    215         version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h, VI_VERSION_l,
    216             hdr->ver_ihl);
     238                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
     239                return EINVAL;
     240        }
     241       
     242        ip_header_t *hdr = (ip_header_t *) data;
     243       
     244        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
     245            VI_VERSION_l, hdr->ver_ihl);
    217246        if (version != 4) {
    218                 log_msg(LVL_DEBUG, "Version (%d) != 4", version);
    219                 return EINVAL;
    220         }
    221 
    222         tot_len = uint16_t_be2host(hdr->tot_len);
     247                log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 4", version);
     248                return EINVAL;
     249        }
     250       
     251        size_t tot_len = uint16_t_be2host(hdr->tot_len);
    223252        if (tot_len < sizeof(ip_header_t)) {
    224                 log_msg(LVL_DEBUG, "Total Length too small (%zu)", tot_len);
    225                 return EINVAL;
    226         }
    227 
     253                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length too small (%zu)", tot_len);
     254                return EINVAL;
     255        }
     256       
    228257        if (tot_len > size) {
    229                 log_msg(LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
     258                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
    230259                        tot_len, size);
    231260                return EINVAL;
    232261        }
    233 
    234         ident = uint16_t_be2host(hdr->id);
    235         flags_foff = uint16_t_be2host(hdr->flags_foff);
    236         foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
     262       
     263        uint16_t ident = uint16_t_be2host(hdr->id);
     264        uint16_t flags_foff = uint16_t_be2host(hdr->flags_foff);
     265        uint16_t foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
    237266            flags_foff);
    238267        /* XXX Checksum */
    239 
    240         packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
    241         packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
     268       
     269        inet_addr_set(uint32_t_be2host(hdr->src_addr), &packet->src);
     270        inet_addr_set(uint32_t_be2host(hdr->dest_addr), &packet->dest);
    242271        packet->tos = hdr->tos;
    243272        packet->proto = hdr->proto;
    244273        packet->ttl = hdr->ttl;
    245274        packet->ident = ident;
    246 
     275       
    247276        packet->df = (flags_foff & BIT_V(uint16_t, FF_FLAG_DF)) != 0;
    248277        packet->mf = (flags_foff & BIT_V(uint16_t, FF_FLAG_MF)) != 0;
    249278        packet->offs = foff * FRAG_OFFS_UNIT;
    250 
     279       
    251280        /* XXX IP options */
    252         data_offs = sizeof(uint32_t) * BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h,
    253             VI_IHL_l, hdr->ver_ihl);
    254 
     281        size_t data_offs = sizeof(uint32_t) *
     282            BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h, VI_IHL_l, hdr->ver_ihl);
     283       
    255284        packet->size = tot_len - data_offs;
    256285        packet->data = calloc(packet->size, 1);
    257286        if (packet->data == NULL) {
    258                 log_msg(LVL_WARN, "Out of memory.");
     287                log_msg(LOG_DEFAULT, LVL_WARN, "Out of memory.");
    259288                return ENOMEM;
    260289        }
    261 
    262         memcpy(packet->data, (uint8_t *)data + data_offs, packet->size);
    263 
     290       
     291        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
     292       
    264293        return EOK;
    265294}
    266295
     296int inet_pdu_decode6(void *data, size_t size, inet_packet_t *packet)
     297{
     298        // FIXME TODO
     299        return ENOTSUP;
     300}
     301
    267302/** @}
    268303 */

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
    41 #include "inet.h"
     41#include "inetsrv.h"
    4242
    4343#define INET_CHECKSUM_INIT 0xffff
    … …  
    4848    size_t *, size_t *);
    4949extern int inet_pdu_decode(void *, size_t, inet_packet_t *);
     50extern int inet_pdu_decode6(void *, size_t, inet_packet_t *);
    5051
    5152#endif

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

    r80445cf r4c53333  
    4242#include <stdlib.h>
    4343
    44 #include "inet.h"
     44#include "inetsrv.h"
    4545#include "inet_std.h"
    4646#include "reass.h"
    … …  
    8686        int rc;
    8787
    88         log_msg(LVL_DEBUG, "inet_reass_queue_packet()");
     88        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_reass_queue_packet()");
    8989
    9090        fibril_mutex_lock(&reass_dgram_map_lock);
    … …  
    9595                /* Only happens when we are out of memory */
    9696                fibril_mutex_unlock(&reass_dgram_map_lock);
    97                 log_msg(LVL_DEBUG, "Allocation failed, packet dropped.");
     97                log_msg(LOG_DEFAULT, LVL_DEBUG, "Allocation failed, packet dropped.");
    9898                return ENOMEM;
    9999        }
    … …  
    139139                    dgram_link);
    140140
    141                 if (f1->packet.src.ipv4 == packet->src.ipv4 &&
    142                     f1->packet.dest.ipv4 == packet->dest.ipv4 &&
    143                     f1->packet.proto == packet->proto &&
    144                     f1->packet.ident == packet->ident) {
     141                if ((inet_addr_compare(&f1->packet.src, &packet->src)) &&
     142                    (inet_addr_compare(&f1->packet.dest, &packet->dest)) &&
     143                    (f1->packet.proto == packet->proto) &&
     144                    (f1->packet.ident == packet->ident)) {
    145145                        /* Match */
    146146                        return rdg;

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
    41 #include "inet.h"
     41#include "inetsrv.h"
    4242
    4343extern int inet_reass_queue_packet(inet_packet_t *);

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

    r80445cf r4c53333  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
    4544#include "sroute.h"
    46 #include "inet.h"
     45#include "inetsrv.h"
    4746#include "inet_link.h"
    48 #include "inet_util.h"
    4947
    5048static FIBRIL_MUTEX_INITIALIZE(sroute_list_lock);
    … …  
    5755
    5856        if (sroute == NULL) {
    59                 log_msg(LVL_ERROR, "Failed allocating static route object. "
     57                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating static route object. "
    6058                    "Out of memory.");
    6159                return NULL;
    … …  
    9795inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9896{
    99         uint32_t mask;
    100         inet_sroute_t *best;
    101 
    102         log_msg(LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4);
    103 
    104         fibril_mutex_lock(&sroute_list_lock);
    105 
    106         best = NULL;
    107 
    108         list_foreach(sroute_list, link) {
    109                 inet_sroute_t *sroute = list_get_instance(link,
    110                     inet_sroute_t, sroute_list);
    111 
     97        uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
     98       
     99        inet_sroute_t *best = NULL;
     100        uint8_t best_bits = 0;
     101       
     102        fibril_mutex_lock(&sroute_list_lock);
     103       
     104        list_foreach(sroute_list, link) {
     105                inet_sroute_t *sroute = list_get_instance(link,
     106                    inet_sroute_t, sroute_list);
     107               
     108                uint8_t dest_bits;
     109                uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
     110                    &dest_bits);
     111               
     112                /* Skip comparison with different address family */
     113                if (addr_af != dest_af)
     114                        continue;
     115               
    112116                /* Look for the most specific route */
    113                 if (best != NULL && best->dest.bits >= sroute->dest.bits)
     117                if ((best != NULL) && (best_bits >= dest_bits))
    114118                        continue;
    115 
    116                 mask = inet_netmask(sroute->dest.bits);
    117                 if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) {
     119               
     120                if (inet_naddr_compare_mask(&sroute->dest, addr)) {
     121                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
     122                            sroute);
     123                       
     124                        best = sroute;
     125                        best_bits = dest_bits;
     126                }
     127        }
     128       
     129        if (best == NULL)
     130                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
     131       
     132        fibril_mutex_unlock(&sroute_list_lock);
     133       
     134        return best;
     135}
     136
     137/** Find static route with a specific name.
     138 *
     139 * @param name  Address object name
     140 * @return      Address object
     141 */
     142inet_sroute_t *inet_sroute_find_by_name(const char *name)
     143{
     144        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name('%s')",
     145            name);
     146
     147        fibril_mutex_lock(&sroute_list_lock);
     148
     149        list_foreach(sroute_list, link) {
     150                inet_sroute_t *sroute = list_get_instance(link,
     151                    inet_sroute_t, sroute_list);
     152
     153                if (str_cmp(sroute->name, name) == 0) {
    118154                        fibril_mutex_unlock(&sroute_list_lock);
    119                         log_msg(LVL_DEBUG, "inet_sroute_find: found %p",
     155                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name: found %p",
    120156                            sroute);
    121157                        return sroute;
    … …  
    123159        }
    124160
    125         log_msg(LVL_DEBUG, "inet_sroute_find: Not found");
    126         fibril_mutex_unlock(&sroute_list_lock);
    127 
    128         return NULL;
    129 }
    130 
    131 /** Find static route with a specific name.
    132  *
    133  * @param name  Address object name
    134  * @return      Address object
    135  */
    136 inet_sroute_t *inet_sroute_find_by_name(const char *name)
    137 {
    138         log_msg(LVL_DEBUG, "inet_sroute_find_by_name('%s')",
    139             name);
    140 
    141         fibril_mutex_lock(&sroute_list_lock);
    142 
    143         list_foreach(sroute_list, link) {
    144                 inet_sroute_t *sroute = list_get_instance(link,
    145                     inet_sroute_t, sroute_list);
    146 
    147                 if (str_cmp(sroute->name, name) == 0) {
    148                         fibril_mutex_unlock(&sroute_list_lock);
    149                         log_msg(LVL_DEBUG, "inet_sroute_find_by_name: found %p",
    150                             sroute);
    151                         return sroute;
    152                 }
    153         }
    154 
    155         log_msg(LVL_DEBUG, "inet_sroute_find_by_name: Not found");
     161        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name: Not found");
    156162        fibril_mutex_unlock(&sroute_list_lock);
    157163
    … …  
    166172inet_sroute_t *inet_sroute_get_by_id(sysarg_t id)
    167173{
    168         log_msg(LVL_DEBUG, "inet_sroute_get_by_id(%zu)", (size_t)id);
     174        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_get_by_id(%zu)", (size_t)id);
    169175
    170176        fibril_mutex_lock(&sroute_list_lock);

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
    41 #include "inet.h"
     41#include "inetsrv.h"
    4242
    4343extern inet_sroute_t *inet_sroute_new(void);

  • uspace/srv/net/loopip/Makefile

    r80445cf r4c53333  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2928
    3029USPACE_PREFIX = ../../..
    31 BINARY = gxe_bd
     30BINARY = loopip
    3231
    3332SOURCES = \
    34         gxe_bd.c
     33        loopip.c
    3534
    3635include $(USPACE_PREFIX)/Makefile.common

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

    r80445cf r4c53333  
    3636
    3737#include <adt/list.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <errno.h>
    4040#include <io/log.h>
    … …  
    164164static void tcp_conn_free(tcp_conn_t *conn)
    165165{
    166         log_msg(LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
     166        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
    167167        tcp_tqueue_fini(&conn->retransmit);
    168168
    … …  
    184184void tcp_conn_addref(tcp_conn_t *conn)
    185185{
    186         log_msg(LVL_DEBUG, "%s: tcp_conn_addref(%p)", conn->name, conn);
     186        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
    187187        atomic_inc(&conn->refcnt);
    188188}
    … …  
    196196void tcp_conn_delref(tcp_conn_t *conn)
    197197{
    198         log_msg(LVL_DEBUG, "%s: tcp_conn_delref(%p)", conn->name, conn);
     198        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
    199199
    200200        if (atomic_predec(&conn->refcnt) == 0)
    … …  
    211211void tcp_conn_delete(tcp_conn_t *conn)
    212212{
    213         log_msg(LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
     213        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
    214214
    215215        assert(conn->deleted == false);
    … …  
    245245        tcp_cstate_t old_state;
    246246
    247         log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
     247        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
    248248
    249249        old_state = conn->cstate;
    … …  
    253253        /* Run user callback function */
    254254        if (conn->cstate_cb != NULL) {
    255                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB");
     255                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - run user CB");
    256256                conn->cstate_cb(conn, conn->cstate_cb_arg);
    257257        } else {
    258                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB");
     258                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - no user CB");
    259259        }
    260260
    … …  
    293293        case st_syn_received:
    294294        case st_established:
    295                 log_msg(LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name);
     295                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name);
    296296                tcp_conn_state_set(conn, st_fin_wait_1);
    297297                break;
    298298        case st_close_wait:
    299                 log_msg(LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name);
     299                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name);
    300300                tcp_conn_state_set(conn, st_last_ack);
    301301                break;
    302302        default:
    303                 log_msg(LVL_ERROR, "%s: Connection state %d", conn->name,
     303                log_msg(LOG_DEFAULT, LVL_ERROR, "%s: Connection state %d", conn->name,
    304304                    conn->cstate);
    305305                assert(false);
    … …  
    312312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    313313{
    314         log_msg(LVL_DEBUG, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    315             sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    316 
    317         if (patt->addr.ipv4 != TCP_IPV4_ANY &&
    318             patt->addr.ipv4 != sock->addr.ipv4)
     314        if ((!inet_addr_is_any(&patt->addr)) &&
     315            (!inet_addr_compare(&patt->addr, &sock->addr)))
    319316                return false;
    320317
    321         if (patt->port != TCP_PORT_ANY &&
    322             patt->port != sock->port)
     318        if ((patt->port != TCP_PORT_ANY) &&
     319            (patt->port != sock->port))
    323320                return false;
    324321
    325         log_msg(LVL_DEBUG, " -> match");
     322        log_msg(LOG_DEFAULT, LVL_DEBUG2, " -> match");
    326323
    327324        return true;
    … …  
    331328static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
    332329{
    333         log_msg(LVL_DEBUG, "tcp_sockpair_match(%p, %p)", sp, pattern);
     330        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
    334331
    335332        if (!tcp_socket_match(&sp->local, &pattern->local))
    … …  
    353350tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
    354351{
    355         log_msg(LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356 
     352        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
     353       
    357354        fibril_mutex_lock(&conn_list_lock);
    358 
     355       
    359356        list_foreach(conn_list, link) {
    360357                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    361358                tcp_sockpair_t *csp = &conn->ident;
    362                 log_msg(LVL_DEBUG, "compare with conn (f:(%x,%u), l:(%x,%u))",
    363                     csp->foreign.addr.ipv4, csp->foreign.port,
    364                     csp->local.addr.ipv4, csp->local.port);
     359               
    365360                if (tcp_sockpair_match(sp, csp)) {
    366361                        tcp_conn_addref(conn);
    … …  
    369364                }
    370365        }
    371 
     366       
    372367        fibril_mutex_unlock(&conn_list_lock);
    373368        return NULL;
    … …  
    380375static void tcp_conn_reset(tcp_conn_t *conn)
    381376{
    382         log_msg(LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
     377        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
    383378        tcp_conn_state_set(conn, st_closed);
    384379        conn->reset = true;
    … …  
    398393{
    399394        /* TODO */
    400         log_msg(LVL_DEBUG, "%s: tcp_reset_signal()", conn->name);
     395        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_reset_signal()", conn->name);
    401396}
    402397
    … …  
    422417                return true;
    423418        case st_closed:
    424                 log_msg(LVL_WARN, "state=%d", (int) conn->cstate);
     419                log_msg(LOG_DEFAULT, LVL_WARN, "state=%d", (int) conn->cstate);
    425420                assert(false);
    426421        }
    … …  
    436431static void tcp_conn_sa_listen(tcp_conn_t *conn, tcp_segment_t *seg)
    437432{
    438         log_msg(LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg);
     433        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg);
    439434
    440435        if ((seg->ctrl & CTL_RST) != 0) {
    441                 log_msg(LVL_DEBUG, "Ignoring incoming RST.");
     436                log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring incoming RST.");
    442437                return;
    443438        }
    444439
    445440        if ((seg->ctrl & CTL_ACK) != 0) {
    446                 log_msg(LVL_DEBUG, "Incoming ACK, send acceptable RST.");
     441                log_msg(LOG_DEFAULT, LVL_DEBUG, "Incoming ACK, send acceptable RST.");
    447442                tcp_reply_rst(&conn->ident, seg);
    448443                return;
    … …  
    450445
    451446        if ((seg->ctrl & CTL_SYN) == 0) {
    452                 log_msg(LVL_DEBUG, "SYN not present. Ignoring segment.");
    453                 return;
    454         }
    455 
    456         log_msg(LVL_DEBUG, "Got SYN, sending SYN, ACK.");
     447                log_msg(LOG_DEFAULT, LVL_DEBUG, "SYN not present. Ignoring segment.");
     448                return;
     449        }
     450
     451        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got SYN, sending SYN, ACK.");
    457452
    458453        conn->rcv_nxt = seg->seq + 1;
    … …  
    460455
    461456
    462         log_msg(LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt);
     457        log_msg(LOG_DEFAULT, LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt);
    463458
    464459        if (seg->len > 1)
    465                 log_msg(LVL_WARN, "SYN combined with data, ignoring data.");
     460                log_msg(LOG_DEFAULT, LVL_WARN, "SYN combined with data, ignoring data.");
    466461
    467462        /* XXX select ISS */
    … …  
    493488static void tcp_conn_sa_syn_sent(tcp_conn_t *conn, tcp_segment_t *seg)
    494489{
    495         log_msg(LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg);
     490        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg);
    496491
    497492        if ((seg->ctrl & CTL_ACK) != 0) {
    498                 log_msg(LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u",
     493                log_msg(LOG_DEFAULT, LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u",
    499494                    conn->snd_una, seg->ack, conn->snd_nxt);
    500495                if (!seq_no_ack_acceptable(conn, seg->ack)) {
    501496                        if ((seg->ctrl & CTL_RST) == 0) {
    502                                 log_msg(LVL_WARN, "ACK not acceptable, send RST");
     497                                log_msg(LOG_DEFAULT, LVL_WARN, "ACK not acceptable, send RST");
    503498                                tcp_reply_rst(&conn->ident, seg);
    504499                        } else {
    505                                 log_msg(LVL_WARN, "RST,ACK not acceptable, drop");
     500                                log_msg(LOG_DEFAULT, LVL_WARN, "RST,ACK not acceptable, drop");
    506501                        }
    507502                        return;
    … …  
    512507                /* If we get here, we have either an acceptable ACK or no ACK */
    513508                if ((seg->ctrl & CTL_ACK) != 0) {
    514                         log_msg(LVL_DEBUG, "%s: Connection reset. -> Closed",
     509                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Connection reset. -> Closed",
    515510                            conn->name);
    516511                        /* Reset connection */
    … …  
    518513                        return;
    519514                } else {
    520                         log_msg(LVL_DEBUG, "%s: RST without ACK, drop",
     515                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: RST without ACK, drop",
    521516                            conn->name);
    522517                        return;
    … …  
    527522
    528523        if ((seg->ctrl & CTL_SYN) == 0) {
    529                 log_msg(LVL_DEBUG, "No SYN bit, ignoring segment.");
     524                log_msg(LOG_DEFAULT, LVL_DEBUG, "No SYN bit, ignoring segment.");
    530525                return;
    531526        }
    … …  
    544539        }
    545540
    546         log_msg(LVL_DEBUG, "Sent SYN, got SYN.");
     541        log_msg(LOG_DEFAULT, LVL_DEBUG, "Sent SYN, got SYN.");
    547542
    548543        /*
    … …  
    551546         * will always be accepted as new window setting.
    552547         */
    553         log_msg(LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", "
     548        log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", "
    554549            "SND.WL2 = %" PRIu32, seg->wnd, seg->seq, seg->seq);
    555550        conn->snd_wnd = seg->wnd;
    … …  
    558553
    559554        if (seq_no_syn_acked(conn)) {
    560                 log_msg(LVL_DEBUG, "%s: syn acked -> Established", conn->name);
     555                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn acked -> Established", conn->name);
    561556                tcp_conn_state_set(conn, st_established);
    562557                tcp_tqueue_ctrl_seg(conn, CTL_ACK /* XXX */);
    563558        } else {
    564                 log_msg(LVL_DEBUG, "%s: syn not acked -> Syn-Received",
     559                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn not acked -> Syn-Received",
    565560                    conn->name);
    566561                tcp_conn_state_set(conn, st_syn_received);
    … …  
    582577        tcp_segment_t *pseg;
    583578
    584         log_msg(LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg);
     579        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg);
    585580
    586581        /* Discard unacceptable segments ("old duplicates") */
    587582        if (!seq_no_segment_acceptable(conn, seg)) {
    588                 log_msg(LVL_DEBUG, "Replying ACK to unacceptable segment.");
     583                log_msg(LOG_DEFAULT, LVL_DEBUG, "Replying ACK to unacceptable segment.");
    589584                tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    590585                tcp_segment_delete(seg);
    … …  
    682677        assert(seq_no_in_rcv_wnd(conn, seg->seq));
    683678
    684         log_msg(LVL_WARN, "SYN is in receive window, should send reset. XXX");
     679        log_msg(LOG_DEFAULT, LVL_WARN, "SYN is in receive window, should send reset. XXX");
    685680
    686681        /*
    … …  
    705700        if (!seq_no_ack_acceptable(conn, seg->ack)) {
    706701                /* ACK is not acceptable, send RST. */
    707                 log_msg(LVL_WARN, "Segment ACK not acceptable, sending RST.");
     702                log_msg(LOG_DEFAULT, LVL_WARN, "Segment ACK not acceptable, sending RST.");
    708703                tcp_reply_rst(&conn->ident, seg);
    709704                tcp_segment_delete(seg);
    … …  
    711706        }
    712707
    713         log_msg(LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name);
     708        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name);
    714709
    715710        tcp_conn_state_set(conn, st_established);
    … …  
    730725static cproc_t tcp_conn_seg_proc_ack_est(tcp_conn_t *conn, tcp_segment_t *seg)
    731726{
    732         log_msg(LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg);
    733 
    734         log_msg(LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u",
     727        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg);
     728
     729        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u",
    735730            (unsigned)seg->ack, (unsigned)conn->snd_una,
    736731            (unsigned)conn->snd_nxt);
    737732
    738733        if (!seq_no_ack_acceptable(conn, seg->ack)) {
    739                 log_msg(LVL_DEBUG, "ACK not acceptable.");
     734                log_msg(LOG_DEFAULT, LVL_DEBUG, "ACK not acceptable.");
    740735                if (!seq_no_ack_duplicate(conn, seg->ack)) {
    741                         log_msg(LVL_WARN, "Not acceptable, not duplicate. "
     736                        log_msg(LOG_DEFAULT, LVL_WARN, "Not acceptable, not duplicate. "
    742737                            "Send ACK and drop.");
    743738                        /* Not acceptable, not duplicate. Send ACK and drop. */
    … …  
    746741                        return cp_done;
    747742                } else {
    748                         log_msg(LVL_DEBUG, "Ignoring duplicate ACK.");
     743                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring duplicate ACK.");
    749744                }
    750745        } else {
    … …  
    758753                conn->snd_wl2 = seg->ack;
    759754
    760                 log_msg(LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32
     755                log_msg(LOG_DEFAULT, LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32
    761756                    ", SND.WL1=%" PRIu32 ", SND.WL2=%" PRIu32,
    762757                    conn->snd_wnd, conn->snd_wl1, conn->snd_wl2);
    … …  
    785780
    786781        if (conn->fin_is_acked) {
    787                 log_msg(LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name);
     782                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name);
    788783                tcp_conn_state_set(conn, st_fin_wait_2);
    789784        }
    … …  
    850845
    851846        if (conn->fin_is_acked) {
    852                 log_msg(LVL_DEBUG, "%s: FIN acked -> Closed", conn->name);
     847                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Closed", conn->name);
    853848                tcp_conn_remove(conn);
    854849                tcp_conn_state_set(conn, st_closed);
    … …  
    881876static cproc_t tcp_conn_seg_proc_ack(tcp_conn_t *conn, tcp_segment_t *seg)
    882877{
    883         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)",
     878        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)",
    884879            conn->name, conn, seg);
    885880
    886881        if ((seg->ctrl & CTL_ACK) == 0) {
    887                 log_msg(LVL_WARN, "Segment has no ACK. Dropping.");
     882                log_msg(LOG_DEFAULT, LVL_WARN, "Segment has no ACK. Dropping.");
    888883                tcp_segment_delete(seg);
    889884                return cp_done;
    … …  
    940935        size_t xfer_size;
    941936
    942         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)",
     937        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)",
    943938            conn->name, conn, seg);
    944939
    … …  
    982977        fibril_condvar_broadcast(&conn->rcv_buf_cv);
    983978
    984         log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
     979        log_msg(LOG_DEFAULT, LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
    985980
    986981        /* Advance RCV.NXT */
    … …  
    998993                tcp_conn_trim_seg_to_wnd(conn, seg);
    999994        } else {
    1000                 log_msg(LVL_DEBUG, "%s: Nothing left in segment, dropping "
    1001                     "(xfer_size=%zu, SEG.LEN=%zu, seg->ctrl=%u)",
    1002                     conn->name, xfer_size, seg->len, (unsigned)seg->ctrl);
     995                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Nothing left in segment, dropping "
     996                    "(xfer_size=%zu, SEG.LEN=%" PRIu32 ", seg->ctrl=%u)",
     997                    conn->name, xfer_size, seg->len, (unsigned int) seg->ctrl);
    1003998                /* Nothing left in segment */
    1004999                tcp_segment_delete(seg);
    … …  
    10181013static cproc_t tcp_conn_seg_proc_fin(tcp_conn_t *conn, tcp_segment_t *seg)
    10191014{
    1020         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)",
     1015        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)",
    10211016            conn->name, conn, seg);
    1022         log_msg(LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len,
     1017        log_msg(LOG_DEFAULT, LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len,
    10231018            (unsigned) seg->ctrl);
    10241019
    10251020        /* Only process FIN if no text is left in segment. */
    10261021        if (tcp_segment_text_size(seg) == 0 && (seg->ctrl & CTL_FIN) != 0) {
    1027                 log_msg(LVL_DEBUG, " - FIN found in segment.");
     1022                log_msg(LOG_DEFAULT, LVL_DEBUG, " - FIN found in segment.");
    10281023
    10291024                /* Send ACK */
    … …  
    10421037                case st_syn_received:
    10431038                case st_established:
    1044                         log_msg(LVL_DEBUG, "%s: FIN received -> Close-Wait",
     1039                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Close-Wait",
    10451040                            conn->name);
    10461041                        tcp_conn_state_set(conn, st_close_wait);
    10471042                        break;
    10481043                case st_fin_wait_1:
    1049                         log_msg(LVL_DEBUG, "%s: FIN received -> Closing",
     1044                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Closing",
    10501045                            conn->name);
    10511046                        tcp_conn_state_set(conn, st_closing);
    10521047                        break;
    10531048                case st_fin_wait_2:
    1054                         log_msg(LVL_DEBUG, "%s: FIN received -> Time-Wait",
     1049                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Time-Wait",
    10551050                            conn->name);
    10561051                        tcp_conn_state_set(conn, st_time_wait);
    … …  
    10911086static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg)
    10921087{
    1093         log_msg(LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg);
     1088        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg);
    10941089        tcp_segment_dump(seg);
    10951090
    … …  
    10971092        /* XXX Permit valid ACKs, URGs and RSTs */
    10981093/*      if (!seq_no_segment_acceptable(conn, seg)) {
    1099                 log_msg(LVL_WARN, "Segment not acceptable, dropping.");
     1094                log_msg(LOG_DEFAULT, LVL_WARN, "Segment not acceptable, dropping.");
    11001095                if ((seg->ctrl & CTL_RST) == 0) {
    11011096                        tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    … …  
    11311126         */
    11321127        if (seg->len > 0) {
    1133                 log_msg(LVL_DEBUG, "Re-insert segment %p. seg->len=%zu",
     1128                log_msg(LOG_DEFAULT, LVL_DEBUG, "Re-insert segment %p. seg->len=%zu",
    11341129                    seg, (size_t) seg->len);
    11351130                tcp_iqueue_insert_seg(&conn->incoming, seg);
    … …  
    11461141void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg)
    11471142{
    1148         log_msg(LVL_DEBUG, "%c: tcp_conn_segment_arrived(%p)",
     1143        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)",
    11491144            conn->name, seg);
    11501145
    … …  
    11651160                tcp_conn_sa_queue(conn, seg); break;
    11661161        case st_closed:
    1167                 log_msg(LVL_DEBUG, "state=%d", (int) conn->cstate);
     1162                log_msg(LOG_DEFAULT, LVL_DEBUG, "state=%d", (int) conn->cstate);
    11681163                assert(false);
    11691164        }
    … …  
    11781173        tcp_conn_t *conn = (tcp_conn_t *) arg;
    11791174
    1180         log_msg(LVL_DEBUG, "tw_timeout_func(%p)", conn);
     1175        log_msg(LOG_DEFAULT, LVL_DEBUG, "tw_timeout_func(%p)", conn);
    11811176
    11821177        fibril_mutex_lock(&conn->lock);
    11831178
    11841179        if (conn->cstate == st_closed) {
    1185                 log_msg(LVL_DEBUG, "Connection already closed.");
     1180                log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
    11861181                fibril_mutex_unlock(&conn->lock);
    11871182                tcp_conn_delref(conn);
    … …  
    11891184        }
    11901185
    1191         log_msg(LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name);
     1186        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name);
    11921187        tcp_conn_remove(conn);
    11931188        tcp_conn_state_set(conn, st_closed);
    … …  
    12401235void tcp_unexpected_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    12411236{
    1242         log_msg(LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg);
     1237        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg);
    12431238
    12441239        if ((seg->ctrl & CTL_RST) == 0)
    … …  
    12681263        tcp_segment_t *rseg;
    12691264
    1270         log_msg(LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg);
     1265        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg);
    12711266
    12721267        rseg = tcp_segment_make_rst(seg);

  • uspace/srv/net/tcp/conn.h

    r80445cf r4c53333  
    3636#define CONN_H
    3737
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include "tcp_type.h"
    4040

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

    r80445cf r4c53333  
    6767        tcp_iqueue_entry_t *qe;
    6868        link_t *link;
    69         log_msg(LVL_DEBUG, "tcp_iqueue_insert_seg()");
     69        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_iqueue_insert_seg()");
    7070
    7171        iqe = calloc(1, sizeof(tcp_iqueue_entry_t));
    7272        if (iqe == NULL) {
    73                 log_msg(LVL_ERROR, "Failed allocating IQE.");
     73                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating IQE.");
    7474                return;
    7575        }
    … …  
    108108        link_t *link;
    109109
    110         log_msg(LVL_DEBUG, "tcp_get_ready_seg()");
     110        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_get_ready_seg()");
    111111
    112112        link = list_first(&iqueue->list);
    113113        if (link == NULL) {
    114                 log_msg(LVL_DEBUG, "iqueue is empty");
     114                log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty");
    115115                return ENOENT;
    116116        }
    … …  
    119119
    120120        while (!seq_no_segment_acceptable(iqueue->conn, iqe->seg)) {
    121                 log_msg(LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%"
     121                log_msg(LOG_DEFAULT, LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%"
    122122                    PRIu32 ", RCV.NXT+RCV.WND=%" PRIu32 ", SEG.SEQ=%" PRIu32
    123123                    ", SEG.LEN=%" PRIu32 ")", iqueue->conn->rcv_nxt,
    … …  
    130130                link = list_first(&iqueue->list);
    131131                if (link == NULL) {
    132                         log_msg(LVL_DEBUG, "iqueue is empty");
     132                        log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty");
    133133                        return ENOENT;
    134134                }
    … …  
    139139        /* Do not return segments that are not ready for processing */
    140140        if (!seq_no_segment_ready(iqueue->conn, iqe->seg)) {
    141                 log_msg(LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, "
     141                log_msg(LOG_DEFAULT, LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, "
    142142                    "RCV.NXT=%u, SEG.LEN=%u", iqe->seg->seq,
    143143                    iqueue->conn->rcv_nxt, iqe->seg->len);
    … …  
    145145        }
    146146
    147         log_msg(LVL_DEBUG, "Returning ready segment %p", iqe->seg);
     147        log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning ready segment %p", iqe->seg);
    148148        list_remove(&iqe->link);
    149149        *seg = iqe->seg;

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

    r80445cf r4c53333  
    4444#include <io/log.h>
    4545#include <stdlib.h>
    46 #include <thread.h>
     46#include <fibril.h>
    4747#include "conn.h"
    4848#include "ncsim.h"
    … …  
    7474        link_t *link;
    7575
    76         log_msg(LVL_DEBUG, "tcp_ncsim_bounce_seg()");
     76        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_bounce_seg()");
    7777        tcp_rqueue_bounce_seg(sp, seg);
    7878        return;
    … …  
    8080        if (0 /*random() % 4 == 3*/) {
    8181                /* Drop segment */
    82                 log_msg(LVL_ERROR, "NCSim dropping segment");
     82                log_msg(LOG_DEFAULT, LVL_ERROR, "NCSim dropping segment");
    8383                tcp_segment_delete(seg);
    8484                return;
    … …  
    8787        sqe = calloc(1, sizeof(tcp_squeue_entry_t));
    8888        if (sqe == NULL) {
    89                 log_msg(LVL_ERROR, "Failed allocating SQE.");
     89                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating SQE.");
    9090                return;
    9191        }
    … …  
    119119}
    120120
    121 /** Network condition simulator handler thread. */
    122 static void tcp_ncsim_thread(void *arg)
     121/** Network condition simulator handler fibril. */
     122static int tcp_ncsim_fibril(void *arg)
    123123{
    124124        link_t *link;
    … …  
    126126        int rc;
    127127
    128         log_msg(LVL_DEBUG, "tcp_ncsim_thread()");
    129 
     128        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()");
    130129
    131130        while (true) {
    … …  
    139138                        sqe = list_get_instance(link, tcp_squeue_entry_t, link);
    140139
    141                         log_msg(LVL_DEBUG, "NCSim - Sleep");
     140                        log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - Sleep");
    142141                        rc = fibril_condvar_wait_timeout(&sim_queue_cv,
    143142                            &sim_queue_lock, sqe->delay);
    … …  
    147146                fibril_mutex_unlock(&sim_queue_lock);
    148147
    149                 log_msg(LVL_DEBUG, "NCSim - End Sleep");
     148                log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - End Sleep");
    150149                tcp_rqueue_bounce_seg(&sqe->sp, sqe->seg);
    151150                free(sqe);
    152151        }
     152
     153        /* Not reached */
     154        return 0;
    153155}
    154156
    155 /** Start simulator handler thread. */
    156 void tcp_ncsim_thread_start(void)
     157/** Start simulator handler fibril. */
     158void tcp_ncsim_fibril_start(void)
    157159{
    158         thread_id_t tid;
    159         int rc;
     160        fid_t fid;
    160161
    161         log_msg(LVL_DEBUG, "tcp_ncsim_thread_start()");
     162        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril_start()");
    162163
    163         rc = thread_create(tcp_ncsim_thread, NULL, "ncsim", &tid);
    164         if (rc != EOK) {
    165                 log_msg(LVL_ERROR, "Failed creating ncsim thread.");
     164        fid = fibril_create(tcp_ncsim_fibril, NULL);
     165        if (fid == 0) {
     166                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating ncsim fibril.");
    166167                return;
    167168        }
     169
     170        fibril_add_ready(fid);
    168171}
    169172

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

    r80445cf r4c53333  
    4040extern void tcp_ncsim_init(void);
    4141extern void tcp_ncsim_bounce_seg(tcp_sockpair_t *, tcp_segment_t *);
    42 extern void tcp_ncsim_thread_start(void);
    43 
     42extern void tcp_ncsim_fibril_start(void);
    4443
    4544#endif

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

    r80445cf r4c53333  
    4040#include <mem.h>
    4141#include <stdlib.h>
     42#include <net/socket_codes.h>
    4243#include "pdu.h"
    4344#include "segment.h"
    … …  
    144145}
    145146
    146 static void tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr)
    147 {
    148         phdr->src_addr = host2uint32_t_be(pdu->src_addr.ipv4);
    149         phdr->dest_addr = host2uint32_t_be(pdu->dest_addr.ipv4);
    150         phdr->zero = 0;
    151         phdr->protocol = 6; /* XXX Magic number */
    152         phdr->tcp_length = host2uint16_t_be(pdu->header_size + pdu->text_size);
     147static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
     148    tcp_phdr6_t *phdr6)
     149{
     150        addr32_t src_v4;
     151        addr128_t src_v6;
     152        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     153       
     154        addr32_t dest_v4;
     155        addr128_t dest_v6;
     156        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     157       
     158        assert(src_af == dest_af);
     159       
     160        switch (src_af) {
     161        case AF_INET:
     162                phdr->src = host2uint32_t_be(src_v4);
     163                phdr->dest = host2uint32_t_be(dest_v4);
     164                phdr->zero = 0;
     165                phdr->protocol = IP_PROTO_TCP;
     166                phdr->tcp_length =
     167                    host2uint16_t_be(pdu->header_size + pdu->text_size);
     168                break;
     169        case AF_INET6:
     170                host2addr128_t_be(src_v6, phdr6->src);
     171                host2addr128_t_be(dest_v6, phdr6->dest);
     172                phdr6->tcp_length =
     173                    host2uint32_t_be(pdu->header_size + pdu->text_size);
     174                memset(phdr6->zero, 0, 3);
     175                phdr6->next = IP_PROTO_TCP;
     176                break;
     177        default:
     178                assert(false);
     179        }
     180       
     181        return src_af;
    153182}
    154183
    … …  
    235264        uint16_t cs_phdr;
    236265        uint16_t cs_headers;
    237         uint16_t cs_all;
    238266        tcp_phdr_t phdr;
    239 
    240         tcp_phdr_setup(pdu, &phdr);
    241         cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *)&phdr,
    242             sizeof(tcp_phdr_t));
     267        tcp_phdr6_t phdr6;
     268       
     269        uint16_t af = tcp_phdr_setup(pdu, &phdr, &phdr6);
     270        switch (af) {
     271        case AF_INET:
     272                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
     273                    sizeof(tcp_phdr_t));
     274                break;
     275        case AF_INET6:
     276                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr6,
     277                    sizeof(tcp_phdr6_t));
     278                break;
     279        default:
     280                assert(false);
     281        }
     282       
    243283        cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
    244         cs_all = tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
    245 
    246         return cs_all;
     284        return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
    247285}
    248286
    … …  
    271309
    272310        sp->local.port = uint16_t_be2host(hdr->dest_port);
    273         sp->local.addr = pdu->dest_addr;
     311        sp->local.addr = pdu->dest;
    274312        sp->foreign.port = uint16_t_be2host(hdr->src_port);
    275         sp->foreign.addr = pdu->src_addr;
     313        sp->foreign.addr = pdu->src;
    276314
    277315        *seg = nseg;
    … …  
    290328                return ENOMEM;
    291329
    292         npdu->src_addr = sp->local.addr;
    293         npdu->dest_addr = sp->foreign.addr;
     330        npdu->src = sp->local.addr;
     331        npdu->dest = sp->foreign.addr;
    294332        tcp_header_encode(sp, seg, &npdu->header, &npdu->header_size);
    295333

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

    r80445cf r4c53333  
    3939#include <io/log.h>
    4040#include <stdlib.h>
    41 #include <thread.h>
     41#include <fibril.h>
    4242#include "conn.h"
    4343#include "pdu.h"
    … …  
    7474        tcp_sockpair_t rident;
    7575
    76         log_msg(LVL_DEBUG, "tcp_rqueue_bounce_seg()");
     76        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_bounce_seg()");
    7777
    7878#ifdef BOUNCE_TRANSCODE
    … …  
    8181
    8282        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
    83                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     83                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    8484                return;
    8585        }
    8686
    8787        if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) {
    88                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     88                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    8989                return;
    9090        }
    … …  
    112112{
    113113        tcp_rqueue_entry_t *rqe;
    114         log_msg(LVL_DEBUG, "tcp_rqueue_insert_seg()");
     114        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_insert_seg()");
    115115
    116116        tcp_segment_dump(seg);
    … …  
    118118        rqe = calloc(1, sizeof(tcp_rqueue_entry_t));
    119119        if (rqe == NULL) {
    120                 log_msg(LVL_ERROR, "Failed allocating RQE.");
     120                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating RQE.");
    121121                return;
    122122        }
    … …  
    128128}
    129129
    130 /** Receive queue handler thread. */
    131 static void tcp_rqueue_thread(void *arg)
     130/** Receive queue handler fibril. */
     131static int tcp_rqueue_fibril(void *arg)
    132132{
    133133        link_t *link;
    134134        tcp_rqueue_entry_t *rqe;
    135135
    136         log_msg(LVL_DEBUG, "tcp_rqueue_thread()");
     136        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril()");
    137137
    138138        while (true) {
    … …  
    142142                tcp_as_segment_arrived(&rqe->sp, rqe->seg);
    143143        }
     144
     145        /* Not reached */
     146        return 0;
    144147}
    145148
    146 /** Start receive queue handler thread. */
    147 void tcp_rqueue_thread_start(void)
     149/** Start receive queue handler fibril. */
     150void tcp_rqueue_fibril_start(void)
    148151{
    149         thread_id_t tid;
    150         int rc;
     152        fid_t fid;
    151153
    152         log_msg(LVL_DEBUG, "tcp_rqueue_thread_start()");
     154        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril_start()");
    153155
    154         rc = thread_create(tcp_rqueue_thread, NULL, "rqueue", &tid);
    155         if (rc != EOK) {
    156                 log_msg(LVL_ERROR, "Failed creating rqueue thread.");
     156        fid = fibril_create(tcp_rqueue_fibril, NULL);
     157        if (fid == 0) {
     158                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating rqueue fibril.");
    157159                return;
    158160        }
     161
     162        fibril_add_ready(fid);
    159163}
    160164

  • uspace/srv/net/tcp/rqueue.h

    r80445cf r4c53333  
    4242extern void tcp_rqueue_insert_seg(tcp_sockpair_t *, tcp_segment_t *);
    4343extern void tcp_rqueue_handler(void *);
    44 extern void tcp_rqueue_thread_start(void);
     44extern void tcp_rqueue_fibril_start(void);
    4545
    4646

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

    r80445cf r4c53333  
    248248void tcp_segment_dump(tcp_segment_t *seg)
    249249{
    250         log_msg(LVL_DEBUG, "Segment dump:");
    251         log_msg(LVL_DEBUG, " - ctrl = %u", (unsigned)seg->ctrl);
    252         log_msg(LVL_DEBUG, " - seq = % " PRIu32, seg->seq);
    253         log_msg(LVL_DEBUG, " - ack = % " PRIu32, seg->ack);
    254         log_msg(LVL_DEBUG, " - len = % " PRIu32, seg->len);
    255         log_msg(LVL_DEBUG, " - wnd = % " PRIu32, seg->wnd);
    256         log_msg(LVL_DEBUG, " - up = % " PRIu32, seg->up);
     250        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Segment dump:");
     251        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
     252        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = %" PRIu32, seg->seq);
     253        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = %" PRIu32, seg->ack);
     254        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = %" PRIu32, seg->len);
     255        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = %" PRIu32, seg->wnd);
     256        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = %" PRIu32, seg->up);
    257257}
    258258

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

    r80445cf r4c53333  
    3636
    3737#include <assert.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <sys/types.h>
    4040#include "seq_no.h"

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

    r80445cf r4c53333  
    4242#include <ipc/services.h>
    4343#include <ipc/socket.h>
    44 #include <net/modules.h>
    4544#include <net/socket.h>
    4645#include <ns.h>
    … …  
    5251#include "ucall.h"
    5352
    54 #define FRAGMENT_SIZE 1024
    55 
    5653#define MAX_BACKLOG 128
    5754
    … …  
    6764static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6865static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
     66static int tcp_sock_recv_fibril(void *arg);
    6967
    7068int tcp_sock_init(void)
    7169{
    72         int rc;
    73 
    7470        socket_ports_initialize(&gsock);
    75 
     71       
    7672        async_set_client_connection(tcp_sock_connection);
    77 
    78         rc = service_register(SERVICE_TCP);
     73       
     74        int rc = service_register(SERVICE_TCP);
    7975        if (rc != EOK)
    8076                return EEXIST;
    81 
     77       
    8278        return EOK;
    8379}
    … …  
    8985        socket = (tcp_sockdata_t *)sock_core->specific_data;
    9086        (void)socket;
     87
     88        /* XXX We need to initiate connection cleanup here */
    9189}
    9290
    9391static void tcp_sock_notify_data(socket_core_t *sock_core)
    9492{
    95         log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
     93        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
    9694        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9795        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    98             FRAGMENT_SIZE, 0, 0, 1);
     96            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
    9997        async_exchange_end(exch);
    10098}
    … …  
    102100static void tcp_sock_notify_aconn(socket_core_t *lsock_core)
    103101{
    104         log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
     102        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
    105103        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    106104        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    107             FRAGMENT_SIZE, 0, 0, 0);
     105            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
    108106        async_exchange_end(exch);
    109107}
    110108
     109static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
     110{
     111        tcp_sockdata_t *sock;
     112
     113        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_create()");
     114        *rsock = NULL;
     115
     116        sock = calloc(1, sizeof(tcp_sockdata_t));
     117        if (sock == NULL)
     118                return ENOMEM;
     119
     120        fibril_mutex_initialize(&sock->lock);
     121        sock->client = client;
     122
     123        sock->recv_buffer_used = 0;
     124        sock->recv_error = TCP_EOK;
     125        fibril_mutex_initialize(&sock->recv_buffer_lock);
     126        fibril_condvar_initialize(&sock->recv_buffer_cv);
     127        list_initialize(&sock->ready);
     128
     129        *rsock = sock;
     130        return EOK;
     131}
     132
     133static void tcp_sock_uncreate(tcp_sockdata_t *sock)
     134{
     135        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_uncreate()");
     136        free(sock);
     137}
     138
     139static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
     140{
     141        socket_core_t *sock_core;
     142        int rc;
     143
     144        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_finish_setup()");
     145
     146        sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
     147        if (sock->recv_fibril == 0)
     148                return ENOMEM;
     149
     150        rc = socket_create(&sock->client->sockets, sock->client->sess,
     151            sock, sock_id);
     152
     153        if (rc != EOK) {
     154                fibril_destroy(sock->recv_fibril);
     155                sock->recv_fibril = 0;
     156                return rc;
     157        }
     158
     159        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
     160        assert(sock_core != NULL);
     161        sock->sock_core = sock_core;
     162
     163        return EOK;
     164}
     165
    111166static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    112167{
    113168        tcp_sockdata_t *sock;
    114         socket_core_t *sock_core;
    115169        int sock_id;
    116170        int rc;
    117171        ipc_call_t answer;
    118172
    119         log_msg(LVL_DEBUG, "tcp_sock_socket()");
    120         sock = calloc(sizeof(tcp_sockdata_t), 1);
    121         if (sock == NULL) {
    122                 async_answer_0(callid, ENOMEM);
    123                 return;
    124         }
    125 
    126         fibril_mutex_initialize(&sock->lock);
    127         sock->client = client;
    128         sock->laddr.ipv4 = TCP_IPV4_ANY;
     173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_socket()");
     174
     175        rc = tcp_sock_create(client, &sock);
     176        if (rc != EOK) {
     177                async_answer_0(callid, rc);
     178                return;
     179        }
     180
     181        inet_addr_any(&sock->laddr);
    129182        sock->lconn = NULL;
    130183        sock->backlog = 0;
    131         list_initialize(&sock->ready);
    132184
    133185        sock_id = SOCKET_GET_SOCKET_ID(call);
    134         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     186        rc = tcp_sock_finish_setup(sock, &sock_id);
     187        if (rc != EOK) {
     188                tcp_sock_uncreate(sock);
     189                async_answer_0(callid, rc);
     190                return;
     191        }
     192
     193        SOCKET_SET_SOCKET_ID(answer, sock_id);
     194
     195        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     196        SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
     197       
     198        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     199            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     200}
     201
     202static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     203{
     204        int rc;
     205        struct sockaddr_in *addr;
     206        size_t addr_size;
     207        socket_core_t *sock_core;
     208        tcp_sockdata_t *socket;
     209       
     210        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
     211        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
     212       
     213        addr = NULL;
     214       
     215        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
    135216        if (rc != EOK) {
    136217                async_answer_0(callid, rc);
    137                 return;
    138         }
    139 
    140         sock_core = socket_cores_find(&client->sockets, sock_id);
    141         assert(sock_core != NULL);
    142         sock->sock_core = sock_core;
    143 
    144         refresh_answer(&answer, NULL);
    145         SOCKET_SET_SOCKET_ID(answer, sock_id);
    146 
    147         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    148         SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
    149         answer_call(callid, EOK, &answer, 3);
    150 }
    151 
    152 static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    153 {
    154         int rc;
    155         struct sockaddr *addr;
    156         size_t addr_len;
    157         socket_core_t *sock_core;
    158         tcp_sockdata_t *socket;
    159 
    160         log_msg(LVL_DEBUG, "tcp_sock_bind()");
    161         log_msg(LVL_DEBUG, " - async_data_write_accept");
    162         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    163         if (rc != EOK) {
    164                 async_answer_0(callid, rc);
    165                 return;
    166         }
    167 
    168         log_msg(LVL_DEBUG, " - call socket_bind");
     218                goto out;
     219        }
     220       
     221        if (addr_size != sizeof(struct sockaddr_in)) {
     222                async_answer_0(callid, EINVAL);
     223                goto out;
     224        }
     225       
     226        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    169227        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    170             addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     228            addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    171229            last_used_port);
    172230        if (rc != EOK) {
    173231                async_answer_0(callid, rc);
    174                 return;
    175         }
    176 
    177         log_msg(LVL_DEBUG, " - call socket_cores_find");
     232                goto out;
     233        }
     234       
     235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    178236        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    179         if (sock_core != NULL) {
    180                 socket = (tcp_sockdata_t *)sock_core->specific_data;
    181                 /* XXX Anything to do? */
    182                 (void) socket;
    183         }
    184 
    185         log_msg(LVL_DEBUG, " - success");
     237        if (sock_core == NULL) {
     238                async_answer_0(callid, ENOENT);
     239                goto out;
     240        }
     241       
     242        socket = (tcp_sockdata_t *)sock_core->specific_data;
     243        /* XXX Anything to do? */
     244        (void) socket;
     245       
     246        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    186247        async_answer_0(callid, EOK);
     248       
     249out:
     250        if (addr != NULL)
     251                free(addr);
    187252}
    188253
    … …  
    199264        tcp_sock_lconn_t *lconn;
    200265        int i;
    201 
    202         log_msg(LVL_DEBUG, "tcp_sock_listen()");
     266        int rc;
     267
     268        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    203269
    204270        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    218284                return;
    219285        }
    220 
    221         socket = (tcp_sockdata_t *)sock_core->specific_data;
    222 
     286       
     287        if (sock_core->port <= 0) {
     288                rc = socket_bind_free_port(&gsock, sock_core,
     289                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     290                    last_used_port);
     291                if (rc != EOK) {
     292                        async_answer_0(callid, rc);
     293                        return;
     294                }
     295               
     296                last_used_port = sock_core->port;
     297        }
     298       
     299        socket = (tcp_sockdata_t *) sock_core->specific_data;
     300       
    223301        /*
    224302         * Prepare @c backlog listening connections.
    225303         */
    226304        fibril_mutex_lock(&socket->lock);
    227 
     305       
    228306        socket->backlog = backlog;
    229         socket->lconn = calloc(sizeof(tcp_conn_t *), backlog);
     307        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
    230308        if (socket->lconn == NULL) {
    231309                fibril_mutex_unlock(&socket->lock);
    … …  
    233311                return;
    234312        }
    235 
    236         log_msg(LVL_DEBUG, " - open connections");
    237 
    238         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     313       
     314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
     315       
     316        inet_addr_any(&lsocket.addr);
    239317        lsocket.port = sock_core->port;
    240         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     318       
     319        inet_addr_any(&fsocket.addr);
    241320        fsocket.port = TCP_PORT_ANY;
    242 
     321       
    243322        for (i = 0; i < backlog; i++) {
    244323
    245                 lconn = calloc(sizeof(tcp_sock_lconn_t), 1);
     324                lconn = calloc(1, sizeof(tcp_sock_lconn_t));
    246325                if (lconn == NULL) {
    247326                        /* XXX Clean up */
    … …  
    275354}
    276355
    277 static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    278 {
    279         int rc;
    280         struct sockaddr_in *addr;
    281         int socket_id;
     356static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid,
     357    ipc_call_t call)
     358{
     359        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
     360       
     361        struct sockaddr_in6 *addr6 = NULL;
    282362        size_t addr_len;
    283         socket_core_t *sock_core;
    284         tcp_sockdata_t *socket;
    285         tcp_error_t trc;
    286         tcp_sock_t lsocket;
    287         tcp_sock_t fsocket;
    288 
    289         log_msg(LVL_DEBUG, "tcp_sock_connect()");
    290 
    291         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    292         if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
     363        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
     364        if (rc != EOK) {
    293365                async_answer_0(callid, rc);
    294366                return;
    295367        }
    296 
    297         socket_id = SOCKET_GET_SOCKET_ID(call);
    298 
    299         sock_core = socket_cores_find(&client->sockets, socket_id);
     368       
     369        if ((addr_len != sizeof(struct sockaddr_in)) &&
     370            (addr_len != sizeof(struct sockaddr_in6))) {
     371                async_answer_0(callid, EINVAL);
     372                goto out;
     373        }
     374       
     375        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     376       
     377        int socket_id = SOCKET_GET_SOCKET_ID(call);
     378        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     379            socket_id);
    300380        if (sock_core == NULL) {
    301381                async_answer_0(callid, ENOTSOCK);
    302                 return;
    303         }
    304 
    305         socket = (tcp_sockdata_t *)sock_core->specific_data;
     382                goto out;
     383        }
     384       
     385        tcp_sockdata_t *socket =
     386            (tcp_sockdata_t *) sock_core->specific_data;
     387       
    306388        if (sock_core->port <= 0) {
    307389                rc = socket_bind_free_port(&gsock, sock_core,
    … …  
    310392                if (rc != EOK) {
    311393                        async_answer_0(callid, rc);
    312                         return;
    313                 }
    314 
     394                        goto out;
     395                }
     396               
    315397                last_used_port = sock_core->port;
    316398        }
    317 
     399       
    318400        fibril_mutex_lock(&socket->lock);
    319 
    320         if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
     401       
     402        if (inet_addr_is_any(&socket->laddr)) {
    321403                /* Determine local IP address */
    322                 inet_addr_t loc_addr, rem_addr;
    323 
    324                 rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     404                inet_addr_t loc_addr;
     405                inet_addr_t rem_addr;
     406               
     407                switch (addr->sin_family) {
     408                case AF_INET:
     409                        inet_sockaddr_in_addr(addr, &rem_addr);
     410                        break;
     411                case AF_INET6:
     412                        inet_sockaddr_in6_addr(addr6, &rem_addr);
     413                        break;
     414                default:
     415                        fibril_mutex_unlock(&socket->lock);
     416                        async_answer_0(callid, EINVAL);
     417                        goto out;
     418                }
     419               
    325420                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    326421                if (rc != EOK) {
    327422                        fibril_mutex_unlock(&socket->lock);
    328423                        async_answer_0(callid, rc);
    329                         log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to "
     424                        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
    330425                            "determine local address.");
    331                         return;
    332                 }
    333 
    334                 socket->laddr.ipv4 = loc_addr.ipv4;
    335                 log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    336         }
    337 
    338         lsocket.addr.ipv4 = socket->laddr.ipv4;
     426                        goto out;
     427                }
     428               
     429                socket->laddr = loc_addr;
     430        }
     431       
     432        tcp_sock_t lsocket;
     433        tcp_sock_t fsocket;
     434       
     435        lsocket.addr = socket->laddr;
    339436        lsocket.port = sock_core->port;
    340         fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     437       
     438        switch (addr->sin_family) {
     439        case AF_INET:
     440                inet_sockaddr_in_addr(addr, &fsocket.addr);
     441                break;
     442        case AF_INET6:
     443                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     444                break;
     445        default:
     446                fibril_mutex_unlock(&socket->lock);
     447                async_answer_0(callid, EINVAL);
     448                goto out;
     449        }
     450       
    341451        fsocket.port = uint16_t_be2host(addr->sin_port);
    342 
    343         trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
    344 
     452       
     453        tcp_error_t trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0,
     454            &socket->conn);
     455       
    345456        if (socket->conn != NULL)
    346                 socket->conn->name = (char *)"C";
    347 
     457                socket->conn->name = (char *) "C";
     458       
    348459        fibril_mutex_unlock(&socket->lock);
    349 
     460       
    350461        switch (trc) {
    351462        case TCP_EOK:
    … …  
    358469                assert(false);
    359470        }
    360 
     471       
     472        if (rc == EOK)
     473                fibril_add_ready(socket->recv_fibril);
     474       
    361475        async_answer_0(callid, rc);
    362 
    363         /* Push one fragment notification to client's queue */
    364         tcp_sock_notify_data(sock_core);
    365         log_msg(LVL_DEBUG, "tcp_sock_connect(): notify conn\n");
     476       
     477out:
     478        if (addr6 != NULL)
     479                free(addr6);
    366480}
    367481
    … …  
    372486        int asock_id;
    373487        socket_core_t *sock_core;
    374         socket_core_t *asock_core;
    375488        tcp_sockdata_t *socket;
    376489        tcp_sockdata_t *asocket;
    … …  
    383496        int rc;
    384497
    385         log_msg(LVL_DEBUG, "tcp_sock_accept()");
     498        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept()");
    386499
    387500        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    393506                return;
    394507        }
     508       
     509        if (sock_core->port <= 0) {
     510                rc = socket_bind_free_port(&gsock, sock_core,
     511                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     512                    last_used_port);
     513                if (rc != EOK) {
     514                        async_answer_0(callid, rc);
     515                        return;
     516                }
     517               
     518                last_used_port = sock_core->port;
     519        }
    395520
    396521        socket = (tcp_sockdata_t *)sock_core->specific_data;
    397522        fibril_mutex_lock(&socket->lock);
    398523
    399         log_msg(LVL_DEBUG, " - verify socket->conn");
     524        log_msg(LOG_DEFAULT, LVL_DEBUG, " - verify socket->conn");
    400525        if (socket->conn != NULL) {
    401526                fibril_mutex_unlock(&socket->lock);
    … …  
    419544        /* Replenish listening connection */
    420545
    421         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     546        inet_addr_any(&lsocket.addr);
    422547        lsocket.port = sock_core->port;
    423         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     548       
     549        inet_addr_any(&fsocket.addr);
    424550        fsocket.port = TCP_PORT_ANY;
    425551
    … …  
    442568        /* Allocate socket for accepted connection */
    443569
    444         log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
    445         asocket = calloc(sizeof(tcp_sockdata_t), 1);
    446         if (asocket == NULL) {
    447                 fibril_mutex_unlock(&socket->lock);
    448                 async_answer_0(callid, ENOMEM);
    449                 return;
    450         }
    451 
    452         fibril_mutex_initialize(&asocket->lock);
    453         asocket->client = client;
     570        rc = tcp_sock_create(client, &asocket);
     571        if (rc != EOK) {
     572                fibril_mutex_unlock(&socket->lock);
     573                async_answer_0(callid, rc);
     574                return;
     575        }
     576
    454577        asocket->conn = conn;
    455         log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    456 
    457         rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
     578        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept():create asocket\n");
     579
     580        rc = tcp_sock_finish_setup(asocket, &asock_id);
    458581        if (rc != EOK) {
     582                tcp_sock_uncreate(asocket);
    459583                fibril_mutex_unlock(&socket->lock);
    460584                async_answer_0(callid, rc);
    461585                return;
    462586        }
    463         log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    464 
    465         asock_core = socket_cores_find(&client->sockets, asock_id);
    466         assert(asock_core != NULL);
    467 
    468         refresh_answer(&answer, NULL);
    469 
    470         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     587
     588        fibril_add_ready(asocket->recv_fibril);
     589
     590        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): find acore\n");
     591
     592        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    471593        SOCKET_SET_SOCKET_ID(answer, asock_id);
    472594        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
    473 
    474         answer_call(callid, asock_core->socket_id, &answer, 3);
    475 
     595       
     596        async_answer_3(callid, asocket->sock_core->socket_id,
     597            IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     598            IPC_GET_ARG3(answer));
     599       
    476600        /* Push one fragment notification to client's queue */
    477         log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    478         tcp_sock_notify_data(asock_core);
     601        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    479602        fibril_mutex_unlock(&socket->lock);
    480603}
    … …  
    490613        ipc_callid_t wcallid;
    491614        size_t length;
    492         uint8_t buffer[FRAGMENT_SIZE];
     615        uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
    493616        tcp_error_t trc;
    494617        int rc;
    495618
    496         log_msg(LVL_DEBUG, "tcp_sock_send()");
     619        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()");
    497620        socket_id = SOCKET_GET_SOCKET_ID(call);
    498621        fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    … …  
    521644                }
    522645
    523                 if (length > FRAGMENT_SIZE)
    524                         length = FRAGMENT_SIZE;
     646                if (length > TCP_SOCK_FRAGMENT_SIZE)
     647                        length = TCP_SOCK_FRAGMENT_SIZE;
    525648
    526649                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    557680        }
    558681
    559         refresh_answer(&answer, NULL);
    560         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    561         answer_call(callid, EOK, &answer, 2);
     682        IPC_SET_ARG1(answer, 0);
     683        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     684        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
     685            IPC_GET_ARG2(answer));
    562686        fibril_mutex_unlock(&socket->lock);
    563687}
    … …  
    565689static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    566690{
    567         log_msg(LVL_DEBUG, "tcp_sock_sendto()");
     691        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_sendto()");
    568692        async_answer_0(callid, ENOTSUP);
    569693}
    … …  
    571695static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    572696{
    573         int socket_id;
    574         int flags;
    575         size_t addr_length, length;
    576         socket_core_t *sock_core;
    577         tcp_sockdata_t *socket;
    578         ipc_call_t answer;
    579         ipc_callid_t rcallid;
    580         uint8_t buffer[FRAGMENT_SIZE];
    581         size_t data_len;
    582         xflags_t xflags;
    583         tcp_error_t trc;
    584         struct sockaddr_in addr;
    585         tcp_sock_t *rsock;
    586         int rc;
    587 
    588         log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
    589 
    590         socket_id = SOCKET_GET_SOCKET_ID(call);
    591         flags = SOCKET_GET_FLAGS(call);
    592 
    593         sock_core = socket_cores_find(&client->sockets, socket_id);
     697        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
     698       
     699        int socket_id = SOCKET_GET_SOCKET_ID(call);
     700       
     701        socket_core_t *sock_core =
     702            socket_cores_find(&client->sockets, socket_id);
    594703        if (sock_core == NULL) {
    595704                async_answer_0(callid, ENOTSOCK);
    596705                return;
    597706        }
    598 
    599         socket = (tcp_sockdata_t *)sock_core->specific_data;
     707       
     708        tcp_sockdata_t *socket =
     709            (tcp_sockdata_t *) sock_core->specific_data;
     710       
    600711        fibril_mutex_lock(&socket->lock);
    601 
     712       
    602713        if (socket->conn == NULL) {
    603714                fibril_mutex_unlock(&socket->lock);
    … …  
    605716                return;
    606717        }
    607 
    608         (void)flags;
    609 
    610         trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len,
    611             &xflags);
    612         log_msg(LVL_DEBUG, "**** tcp_uc_receive done");
    613 
     718       
     719        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     720       
     721        fibril_mutex_lock(&socket->recv_buffer_lock);
     722        while ((socket->recv_buffer_used == 0) &&
     723            (socket->recv_error == TCP_EOK)) {
     724                log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
     725                fibril_condvar_wait(&socket->recv_buffer_cv,
     726                    &socket->recv_buffer_lock);
     727        }
     728       
     729        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
     730       
     731        size_t data_len = socket->recv_buffer_used;
     732        tcp_error_t trc = socket->recv_error;
     733        int rc;
     734       
    614735        switch (trc) {
    615736        case TCP_EOK:
    … …  
    626747                assert(false);
    627748        }
    628 
    629         log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
     749       
     750        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
     751       
    630752        if (rc != EOK) {
     753                fibril_mutex_unlock(&socket->recv_buffer_lock);
    631754                fibril_mutex_unlock(&socket->lock);
    632755                async_answer_0(callid, rc);
    633756                return;
    634757        }
    635 
     758       
     759        ipc_callid_t rcallid;
     760       
    636761        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    637                 /* Fill addr */
    638                 rsock = &socket->conn->ident.foreign;
    639                 addr.sin_family = AF_INET;
    640                 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
    641                 addr.sin_port = host2uint16_t_be(rsock->port);
    642 
    643                 log_msg(LVL_DEBUG, "addr read receive");
    644                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     762                /* Fill address */
     763                tcp_sock_t *rsock = &socket->conn->ident.foreign;
     764                struct sockaddr_in addr;
     765                struct sockaddr_in6 addr6;
     766                size_t addr_length;
     767               
     768                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     769                    &addr6);
     770               
     771                switch (addr_af) {
     772                case AF_INET:
     773                        addr.sin_port = host2uint16_t_be(rsock->port);
     774                       
     775                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     776                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     777                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     778                                fibril_mutex_unlock(&socket->lock);
     779                                async_answer_0(callid, EINVAL);
     780                                return;
     781                        }
     782                       
     783                        if (addr_length > sizeof(addr))
     784                                addr_length = sizeof(addr);
     785                       
     786                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     787                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     788                        if (rc != EOK) {
     789                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     790                                fibril_mutex_unlock(&socket->lock);
     791                                async_answer_0(callid, EINVAL);
     792                                return;
     793                        }
     794                       
     795                        break;
     796                case AF_INET6:
     797                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     798                       
     799                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     800                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     801                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     802                                fibril_mutex_unlock(&socket->lock);
     803                                async_answer_0(callid, EINVAL);
     804                                return;
     805                        }
     806                       
     807                        if (addr_length > sizeof(addr6))
     808                                addr_length = sizeof(addr6);
     809                       
     810                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     811                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     812                        if (rc != EOK) {
     813                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     814                                fibril_mutex_unlock(&socket->lock);
     815                                async_answer_0(callid, EINVAL);
     816                                return;
     817                        }
     818                       
     819                        break;
     820                default:
     821                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    645822                        fibril_mutex_unlock(&socket->lock);
    646823                        async_answer_0(callid, EINVAL);
    647824                        return;
    648825                }
    649 
    650                 if (addr_length > sizeof(addr))
    651                         addr_length = sizeof(addr);
    652 
    653                 log_msg(LVL_DEBUG, "addr read finalize");
    654                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    655                 if (rc != EOK) {
    656                         fibril_mutex_unlock(&socket->lock);
    657                         async_answer_0(callid, EINVAL);
    658                         return;
    659                 }
    660         }
    661 
    662         log_msg(LVL_DEBUG, "data read receive");
     826        }
     827       
     828        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     829       
     830        size_t length;
    663831        if (!async_data_read_receive(&rcallid, &length)) {
     832                fibril_mutex_unlock(&socket->recv_buffer_lock);
    664833                fibril_mutex_unlock(&socket->lock);
    665834                async_answer_0(callid, EINVAL);
    666835                return;
    667836        }
    668 
     837       
    669838        if (length > data_len)
    670839                length = data_len;
    671 
    672         log_msg(LVL_DEBUG, "data read finalize");
    673         rc = async_data_read_finalize(rcallid, buffer, length);
    674 
    675         if (length < data_len && rc == EOK)
     840       
     841        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     842       
     843        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
     844       
     845        socket->recv_buffer_used -= length;
     846       
     847        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
     848            socket->recv_buffer_used);
     849       
     850        if (socket->recv_buffer_used > 0) {
     851                memmove(socket->recv_buffer, socket->recv_buffer + length,
     852                    socket->recv_buffer_used);
     853                tcp_sock_notify_data(socket->sock_core);
     854        }
     855       
     856        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     857       
     858        if ((length < data_len) && (rc == EOK))
    676859                rc = EOVERFLOW;
    677 
     860       
     861        ipc_call_t answer;
     862       
    678863        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    679         answer_call(callid, EOK, &answer, 1);
    680 
    681         /* Push one fragment notification to client's queue */
    682         tcp_sock_notify_data(sock_core);
     864        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
     865       
     866        fibril_mutex_unlock(&socket->recv_buffer_lock);
    683867        fibril_mutex_unlock(&socket->lock);
    684868}
    … …  
    691875        tcp_error_t trc;
    692876        int rc;
    693         uint8_t buffer[FRAGMENT_SIZE];
    694         size_t data_len;
    695         xflags_t xflags;
    696 
    697         log_msg(LVL_DEBUG, "tcp_sock_close()");
     877
     878        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    698879        socket_id = SOCKET_GET_SOCKET_ID(call);
    699880
    … …  
    714895                        return;
    715896                }
    716 
    717                 /* Drain incoming data. This should really be done in the background. */
    718                 do {
    719                         trc = tcp_uc_receive(socket->conn, buffer,
    720                             FRAGMENT_SIZE, &data_len, &xflags);
    721                 } while (trc == TCP_EOK);
    722 
    723                 tcp_uc_delete(socket->conn);
    724         }
     897        }
     898
     899        /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
     900        fibril_mutex_lock(&socket->recv_buffer_lock);
     901        socket->sock_core = NULL;
     902        fibril_mutex_unlock(&socket->recv_buffer_lock);
    725903
    726904        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    … …  
    738916static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    739917{
    740         log_msg(LVL_DEBUG, "tcp_sock_getsockopt()");
     918        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_getsockopt()");
    741919        async_answer_0(callid, ENOTSUP);
    742920}
    … …  
    744922static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    745923{
    746         log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
     924        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_setsockopt()");
    747925        async_answer_0(callid, ENOTSUP);
    748926}
    … …  
    755933        tcp_sockdata_t *socket = lconn->socket;
    756934
    757         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
     935        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb()");
    758936        fibril_mutex_lock(&socket->lock);
    759937        assert(conn == lconn->conn);
    … …  
    768946        list_append(&lconn->ready_list, &socket->ready);
    769947
    770         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
     948        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
    771949
    772950        /* Push one accept notification to client's queue */
    … …  
    775953}
    776954
     955static int tcp_sock_recv_fibril(void *arg)
     956{
     957        tcp_sockdata_t *sock = (tcp_sockdata_t *)arg;
     958        size_t data_len;
     959        xflags_t xflags;
     960        tcp_error_t trc;
     961
     962        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recv_fibril()");
     963
     964        fibril_mutex_lock(&sock->recv_buffer_lock);
     965
     966        while (true) {
     967                log_msg(LOG_DEFAULT, LVL_DEBUG, "call tcp_uc_receive()");
     968                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
     969                        fibril_condvar_wait(&sock->recv_buffer_cv,
     970                            &sock->recv_buffer_lock);
     971
     972                trc = tcp_uc_receive(sock->conn, sock->recv_buffer,
     973                    TCP_SOCK_FRAGMENT_SIZE, &data_len, &xflags);
     974
     975                if (trc != TCP_EOK) {
     976                        sock->recv_error = trc;
     977                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     978                        if (sock->sock_core != NULL)
     979                                tcp_sock_notify_data(sock->sock_core);
     980                        break;
     981                }
     982
     983                log_msg(LOG_DEFAULT, LVL_DEBUG, "got data - broadcast recv_buffer_cv");
     984
     985                sock->recv_buffer_used = data_len;
     986                fibril_condvar_broadcast(&sock->recv_buffer_cv);
     987                if (sock->sock_core != NULL)
     988                        tcp_sock_notify_data(sock->sock_core);
     989        }
     990
     991        fibril_mutex_unlock(&sock->recv_buffer_lock);
     992
     993        tcp_uc_delete(sock->conn);
     994
     995        return 0;
     996}
     997
    777998static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    778999{
    … …  
    7921013                        break;
    7931014
    794                 log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
     1015                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
    7951016                    (int)IPC_GET_IMETHOD(call));
    7961017
    … …  
    8351056                }
    8361057        }
     1058
     1059        /* Clean up */
     1060        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: Clean up");
     1061        async_hangup(client.sess);
     1062        socket_cores_release(NULL, &client.sockets, &gsock, tcp_free_sock_data);
    8371063}
    8381064

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

    r80445cf r4c53333  
    3939
    4040#include <sys/types.h>
     41#include <inet/addr.h>
     42
     43#define IP_PROTO_TCP  6
    4144
    4245/** TCP Header (fixed part) */
    … …  
    7275};
    7376
    74 /** TCP pseudo header */
     77/** TCP IPv4 pseudo header */
    7578typedef struct {
    7679        /** Source address */
    77         uint32_t src_addr;
     80        uint32_t src;
    7881        /** Destination address */
    79         uint32_t dest_addr;
     82        uint32_t dest;
    8083        /** Zero */
    8184        uint8_t zero;
    … …  
    8588        uint16_t tcp_length;
    8689} tcp_phdr_t;
     90
     91/** TCP IPv6 pseudo header */
     92typedef struct {
     93        /** Source address */
     94        addr128_t src;
     95        /** Destination address */
     96        addr128_t dest;
     97        /** TCP length */
     98        uint32_t tcp_length;
     99        /** Zeroes */
     100        uint8_t zero[3];
     101        /** Next header */
     102        uint8_t next;
     103} tcp_phdr6_t;
    87104
    88105/** Option kind */

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

    r80445cf r4c53333  
    6969        size_t pdu_raw_size;
    7070
    71         log_msg(LVL_DEBUG, "tcp_inet_ev_recv()");
     71        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv()");
    7272
    7373        pdu_raw = dgram->data;
    … …  
    7676        /* Split into header and payload. */
    7777
    78         log_msg(LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload");
     78        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload");
    7979
    8080        tcp_pdu_t *pdu;
    … …  
    8484
    8585        if (pdu_raw_size < sizeof(tcp_header_t)) {
    86                 log_msg(LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu",
     86                log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu",
    8787                    pdu_raw_size, sizeof(tcp_header_t));
    8888                return EINVAL;
    … …  
    9696
    9797        if (pdu_raw_size < hdr_size) {
    98                 log_msg(LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu",
     98                log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu",
    9999                    pdu_raw_size, hdr_size);
    100100                return EINVAL;
    … …  
    102102
    103103        if (hdr_size < sizeof(tcp_header_t)) {
    104                 log_msg(LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu",
     104                log_msg(LOG_DEFAULT, LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu",
    105105                    hdr_size, sizeof(tcp_header_t));            return EINVAL;
    106106        }
    107107
    108         log_msg(LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu",
     108        log_msg(LOG_DEFAULT, LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu",
    109109            pdu_raw_size, hdr_size);
    110110        pdu = tcp_pdu_create(pdu_raw, hdr_size, pdu_raw + hdr_size,
    111111            pdu_raw_size - hdr_size);
    112112        if (pdu == NULL) {
    113                 log_msg(LVL_WARN, "Failed creating PDU. Dropped.");
     113                log_msg(LOG_DEFAULT, LVL_WARN, "Failed creating PDU. Dropped.");
    114114                return ENOMEM;
    115115        }
    116116
    117         pdu->src_addr.ipv4 = dgram->src.ipv4;
    118         pdu->dest_addr.ipv4 = dgram->dest.ipv4;
    119         log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    120             pdu->src_addr.ipv4, pdu->dest_addr.ipv4);
     117        pdu->src = dgram->src;
     118        pdu->dest = dgram->dest;
    121119
    122120        tcp_received_pdu(pdu);
    … …  
    137135        pdu_raw = malloc(pdu_raw_size);
    138136        if (pdu_raw == NULL) {
    139                 log_msg(LVL_ERROR, "Failed to transmit PDU. Out of memory.");
     137                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU. Out of memory.");
    140138                return;
    141139        }
    … …  
    145143            pdu->text_size);
    146144
    147         dgram.src.ipv4 = pdu->src_addr.ipv4;
    148         dgram.dest.ipv4 = pdu->dest_addr.ipv4;
     145        dgram.src = pdu->src;
     146        dgram.dest = pdu->dest;
    149147        dgram.tos = 0;
    150148        dgram.data = pdu_raw;
    … …  
    153151        rc = inet_send(&dgram, INET_TTL_MAX, 0);
    154152        if (rc != EOK)
    155                 log_msg(LVL_ERROR, "Failed to transmit PDU.");
     153                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU.");
    156154}
    157155
    … …  
    162160        tcp_sockpair_t rident;
    163161
    164         log_msg(LVL_DEBUG, "tcp_received_pdu()");
     162        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_received_pdu()");
    165163
    166164        if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) {
    167                 log_msg(LVL_WARN, "Not enough memory. PDU dropped.");
     165                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. PDU dropped.");
    168166                return;
    169167        }
    … …  
    177175        int rc;
    178176
    179         log_msg(LVL_DEBUG, "tcp_init()");
     177        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()");
    180178
    181179        tcp_rqueue_init();
    182         tcp_rqueue_thread_start();
     180        tcp_rqueue_fibril_start();
    183181
    184182        tcp_ncsim_init();
    185         tcp_ncsim_thread_start();
     183        tcp_ncsim_fibril_start();
    186184
    187185        if (0) tcp_test();
    … …  
    189187        rc = inet_init(IP_PROTO_TCP, &tcp_inet_ev_ops);
    190188        if (rc != EOK) {
    191                 log_msg(LVL_ERROR, "Failed connecting to internet service.");
     189                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service.");
    192190                return ENOENT;
    193191        }
    … …  
    195193        rc = tcp_sock_init();
    196194        if (rc != EOK) {
    197                 log_msg(LVL_ERROR, "Failed initializing socket service.");
     195                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
    198196                return ENOENT;
    199197        }
    … …  
    208206        printf(NAME ": TCP (Transmission Control Protocol) network module\n");
    209207
    210         rc = log_init(NAME, LVL_WARN);
     208        rc = log_init(NAME);
    211209        if (rc != EOK) {
    212210                printf(NAME ": Failed to initialize log.\n");

  • uspace/srv/net/tcp/tcp_type.h

    r80445cf r4c53333  
    3838#include <adt/list.h>
    3939#include <async.h>
    40 #include <bool.h>
     40#include <stdbool.h>
     41#include <fibril.h>
    4142#include <fibril_synch.h>
    4243#include <socket_core.h>
    4344#include <sys/types.h>
     45#include <inet/addr.h>
    4446
    4547struct tcp_conn;
    … …  
    111113
    112114typedef struct {
    113         uint32_t ipv4;
    114 } netaddr_t;
    115 
    116 typedef struct {
    117         netaddr_t addr;
     115        inet_addr_t addr;
    118116        uint16_t port;
    119117} tcp_sock_t;
    120 
    121 enum netaddr {
    122         TCP_IPV4_ANY = 0
    123 };
    124118
    125119enum tcp_port {
    … …  
    312306typedef struct {
    313307        /** Source address */
    314         netaddr_t src_addr;
     308        inet_addr_t src;
    315309        /** Destination address */
    316         netaddr_t dest_addr;
    317 
     310        inet_addr_t dest;
    318311        /** Encoded header */
    319312        void *header;
    … …  
    330323        socket_cores_t sockets;
    331324} tcp_client_t;
     325
     326#define TCP_SOCK_FRAGMENT_SIZE 1024
    332327
    333328typedef struct tcp_sockdata {
    … …  
    341336        tcp_conn_t *conn;
    342337        /** Local address */
    343         netaddr_t laddr;
     338        inet_addr_t laddr;
    344339        /** Backlog size */
    345340        int backlog;
    … …  
    348343        /** List of connections (from lconn) that are ready to be accepted */
    349344        list_t ready;
     345        /** Receiving fibril */
     346        fid_t recv_fibril;
     347        uint8_t recv_buffer[TCP_SOCK_FRAGMENT_SIZE];
     348        size_t recv_buffer_used;
     349        fibril_mutex_t recv_buffer_lock;
     350        fibril_condvar_t recv_buffer_cv;
     351        tcp_error_t recv_error;
    350352} tcp_sockdata_t;
    351353

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

    r80445cf r4c53333  
    3838#include <errno.h>
    3939#include <stdio.h>
    40 #include <thread.h>
     40#include <fibril.h>
    4141#include <str.h>
    4242#include "tcp_type.h"
    … …  
    4747#define RCV_BUF_SIZE 64
    4848
    49 static void test_srv(void *arg)
     49static int test_srv(void *arg)
    5050{
    5151        tcp_conn_t *conn;
    … …  
    5757
    5858        printf("test_srv()\n");
     59       
     60        inet_addr(&lsock.addr, 127, 0, 0, 1);
    5961        lsock.port = 80;
    60         lsock.addr.ipv4 = 0x7f000001;
     62       
     63        inet_addr(&fsock.addr, 127, 0, 0, 1);
    6164        fsock.port = 1024;
    62         fsock.addr.ipv4 = 0x7f000001;
     65       
    6366        printf("S: User open...\n");
    6467        tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
    … …  
    8487
    8588        printf("test_srv() terminating\n");
     89        return 0;
    8690}
    8791
    88 static void test_cli(void *arg)
     92static int test_cli(void *arg)
    8993{
    9094        tcp_conn_t *conn;
    … …  
    9498
    9599        printf("test_cli()\n");
    96 
     100       
     101        inet_addr(&lsock.addr, 127, 0, 0, 1);
    97102        lsock.port = 1024;
    98         lsock.addr.ipv4 = 0x7f000001;
     103       
     104        inet_addr(&fsock.addr, 127, 0, 0, 1);
    99105        fsock.port = 80;
    100         fsock.addr.ipv4 = 0x7f000001;
    101106
    102107        async_usleep(1000*1000*3);
    … …  
    112117        printf("C: User close...\n");
    113118        tcp_uc_close(conn);
     119
     120        return 0;
    114121}
    115122
    116123void tcp_test(void)
    117124{
    118         thread_id_t srv_tid;
    119         thread_id_t cli_tid;
    120         int rc;
     125        fid_t srv_fid;
     126        fid_t cli_fid;
    121127
    122128        printf("tcp_test()\n");
    … …  
    125131
    126132        if (0) {
    127                 rc = thread_create(test_srv, NULL, "test_srv", &srv_tid);
    128                 if (rc != EOK) {
    129                         printf("Failed to create server thread.\n");
     133                srv_fid = fibril_create(test_srv, NULL);
     134                if (srv_fid == 0) {
     135                        printf("Failed to create server fibril.\n");
    130136                        return;
    131137                }
     138
     139                fibril_add_ready(srv_fid);
    132140        }
    133141
    134142        if (0) {
    135                 rc = thread_create(test_cli, NULL, "test_cli", &cli_tid);
    136                 if (rc != EOK) {
    137                         printf("Failed to create client thread.\n");
     143                cli_fid = fibril_create(test_cli, NULL);
     144                if (cli_fid == 0) {
     145                        printf("Failed to create client fibril.\n");
    138146                        return;
    139147                }
     148
     149                fibril_add_ready(cli_fid);
    140150        }
    141151}

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

    r80445cf r4c53333  
    8888        tcp_segment_t *seg;
    8989
    90         log_msg(LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
    9191
    9292        seg = tcp_segment_make_ctrl(ctrl);
    … …  
    9999        tcp_tqueue_entry_t *tqe;
    100100
    101         log_msg(LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
     101        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
    102102            seg);
    103103
    … …  
    109109                rt_seg = tcp_segment_dup(seg);
    110110                if (rt_seg == NULL) {
    111                         log_msg(LVL_ERROR, "Memory allocation failed.");
     111                        log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    112112                        /* XXX Handle properly */
    113113                        return;
    … …  
    116116                tqe = calloc(1, sizeof(tcp_tqueue_entry_t));
    117117                if (tqe == NULL) {
    118                         log_msg(LVL_ERROR, "Memory allocation failed.");
     118                        log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    119119                        /* XXX Handle properly */
    120120                        return;
    … …  
    165165        tcp_segment_t *seg;
    166166
    167         log_msg(LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
     167        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
    168168
    169169        /* Number of free sequence numbers in send window */
    … …  
    172172
    173173        xfer_seqlen = min(snd_buf_seqlen, avail_wnd);
    174         log_msg(LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, "
     174        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %" PRIu32 ", "
    175175            "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd,
    176176            xfer_seqlen);
    … …  
    185185
    186186        if (send_fin) {
    187                 log_msg(LVL_DEBUG, "%s: Sending out FIN.", conn->name);
     187                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Sending out FIN.", conn->name);
    188188                /* We are sending out FIN */
    189189                ctrl = CTL_FIN;
    … …  
    194194        seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size);
    195195        if (seg == NULL) {
    196                 log_msg(LVL_ERROR, "Memory allocation failure.");
     196                log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failure.");
    197197                return;
    198198        }
    … …  
    223223        link_t *cur, *next;
    224224
    225         log_msg(LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
     225        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
    226226            conn);
    227227
    … …  
    239239
    240240                        if ((tqe->seg->ctrl & CTL_FIN) != 0) {
    241                                 log_msg(LVL_DEBUG, "Fin has been acked");
    242                                 log_msg(LVL_DEBUG, "SND.UNA=%" PRIu32
     241                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Fin has been acked");
     242                                log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.UNA=%" PRIu32
    243243                                    " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32,
    244244                                    conn->snd_una, tqe->seg->seq, tqe->seg->len);
    … …  
    267267void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
    268268{
    269         log_msg(LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
     269        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
    270270            conn->name, conn, seg);
    271271
    … …  
    282282void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    283283{
    284         log_msg(LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
    285             sp->foreign.addr.ipv4, sp->foreign.port,
    286             sp->local.addr.ipv4, sp->local.port, seg);
    287 
    288         log_msg(LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
     284        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
    289285            seg->seq, seg->wnd);
    290286
    … …  
    300296
    301297        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
    302                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     298                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    303299                return;
    304300        }
    … …  
    315311        link_t *link;
    316312
    317         log_msg(LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
     313        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
    318314
    319315        fibril_mutex_lock(&conn->lock);
    320316
    321317        if (conn->cstate == st_closed) {
    322                 log_msg(LVL_DEBUG, "Connection already closed.");
     318                log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
    323319                fibril_mutex_unlock(&conn->lock);
    324320                tcp_conn_delref(conn);
    … …  
    328324        link = list_first(&conn->retransmit.list);
    329325        if (link == NULL) {
    330                 log_msg(LVL_DEBUG, "Nothing to retransmit");
     326                log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit");
    331327                fibril_mutex_unlock(&conn->lock);
    332328                tcp_conn_delref(conn);
    … …  
    338334        rt_seg = tcp_segment_dup(tqe->seg);
    339335        if (rt_seg == NULL) {
    340                 log_msg(LVL_ERROR, "Memory allocation failed.");
     336                log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    341337                fibril_mutex_unlock(&conn->lock);
    342338                tcp_conn_delref(conn);
    … …  
    345341        }
    346342
    347         log_msg(LVL_DEBUG, "### %s: retransmitting segment", conn->name);
     343        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmitting segment", conn->name);
    348344        tcp_conn_transmit_segment(tqe->conn, rt_seg);
    349345
    … …  
    358354static void tcp_tqueue_timer_set(tcp_conn_t *conn)
    359355{
    360         log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
     356        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
    361357
    362358        /* Clear first to make sure we update refcnt correctly */
    … …  
    371367static void tcp_tqueue_timer_clear(tcp_conn_t *conn)
    372368{
    373         log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
     369        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
    374370
    375371        if (fibril_timer_clear(conn->retransmit.timer) == fts_active)

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

    r80445cf r4c53333  
    7070        tcp_conn_t *nconn;
    7171
    72         log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
     72        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
    7373            lsock, fsock, acpass == ap_active ? "active" : "passive",
    7474            oflags == tcp_open_nonblock ? "nonblock" : "none", conn);
    … …  
    8888
    8989        /* Wait for connection to be established or reset */
    90         log_msg(LVL_DEBUG, "tcp_uc_open: Wait for connection.");
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Wait for connection.");
    9191        fibril_mutex_lock(&nconn->lock);
    9292        while (nconn->cstate == st_listen ||
    … …  
    9797
    9898        if (nconn->cstate != st_established) {
    99                 log_msg(LVL_DEBUG, "tcp_uc_open: Connection was reset.");
     99                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was reset.");
    100100                assert(nconn->cstate == st_closed);
    101101                fibril_mutex_unlock(&nconn->lock);
    … …  
    104104
    105105        fibril_mutex_unlock(&nconn->lock);
    106         log_msg(LVL_DEBUG, "tcp_uc_open: Connection was established.");
     106        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was established.");
    107107
    108108        *conn = nconn;
    109         log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn);
     109        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open -> %p", nconn);
    110110        return TCP_EOK;
    111111}
    … …  
    118118        size_t xfer_size;
    119119
    120         log_msg(LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
     120        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
    121121
    122122        fibril_mutex_lock(&conn->lock);
    … …  
    141141                buf_free = conn->snd_buf_size - conn->snd_buf_used;
    142142                while (buf_free == 0 && !conn->reset) {
    143                         log_msg(LVL_DEBUG, "%s: buf_free == 0, waiting.",
     143                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: buf_free == 0, waiting.",
    144144                            conn->name);
    145145                        fibril_condvar_wait(&conn->snd_buf_cv, &conn->lock);
    … …  
    175175        size_t xfer_size;
    176176
    177         log_msg(LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
     177        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
    178178
    179179        fibril_mutex_lock(&conn->lock);
    … …  
    186186        /* Wait for data to become available */
    187187        while (conn->rcv_buf_used == 0 && !conn->rcv_buf_fin && !conn->reset) {
    188                 log_msg(LVL_DEBUG, "tcp_uc_receive() - wait for data");
     188                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_receive() - wait for data");
    189189                fibril_condvar_wait(&conn->rcv_buf_cv, &conn->lock);
    190190        }
    … …  
    223223        tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    224224
    225         log_msg(LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes",
     225        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes",
    226226            conn->name, xfer_size);
    227227
    … …  
    234234tcp_error_t tcp_uc_close(tcp_conn_t *conn)
    235235{
    236         log_msg(LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
     236        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
    237237
    238238        fibril_mutex_lock(&conn->lock);
    … …  
    258258void tcp_uc_abort(tcp_conn_t *conn)
    259259{
    260         log_msg(LVL_DEBUG, "tcp_uc_abort()");
     260        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_abort()");
    261261}
    262262
    … …  
    264264void tcp_uc_status(tcp_conn_t *conn, tcp_conn_status_t *cstatus)
    265265{
    266         log_msg(LVL_DEBUG, "tcp_uc_status()");
     266        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_status()");
    267267        cstatus->cstate = conn->cstate;
    268268}
    … …  
    276276void tcp_uc_delete(tcp_conn_t *conn)
    277277{
    278         log_msg(LVL_DEBUG, "tcp_uc_delete()");
     278        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_delete()");
    279279        tcp_conn_delete(conn);
    280280}
    … …  
    282282void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg)
    283283{
    284         log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
     284        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
    285285            conn, cb, arg);
    286286
    … …  
    298298        tcp_conn_t *conn;
    299299
    300         log_msg(LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))",
    301             sp->foreign.addr.ipv4, sp->foreign.port,
    302             sp->local.addr.ipv4, sp->local.port);
    303 
    304300        conn = tcp_conn_find_ref(sp);
    305301        if (conn == NULL) {
    306                 log_msg(LVL_WARN, "No connection found.");
     302                log_msg(LOG_DEFAULT, LVL_WARN, "No connection found.");
    307303                tcp_unexpected_segment(sp, seg);
    308304                return;
    … …  
    312308
    313309        if (conn->cstate == st_closed) {
    314                 log_msg(LVL_WARN, "Connection is closed.");
     310                log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed.");
    315311                tcp_unexpected_segment(sp, seg);
    316312                fibril_mutex_unlock(&conn->lock);
    … …  
    319315        }
    320316
    321         if (conn->ident.foreign.addr.ipv4 == TCP_IPV4_ANY)
    322                 conn->ident.foreign.addr.ipv4 = sp->foreign.addr.ipv4;
     317        if (inet_addr_is_any(&conn->ident.foreign.addr))
     318                conn->ident.foreign.addr = sp->foreign.addr;
     319       
    323320        if (conn->ident.foreign.port == TCP_PORT_ANY)
    324321                conn->ident.foreign.port = sp->foreign.port;
    325         if (conn->ident.local.addr.ipv4 == TCP_IPV4_ANY)
    326                 conn->ident.local.addr.ipv4 = sp->local.addr.ipv4;
     322       
     323        if (inet_addr_is_any(&conn->ident.local.addr))
     324                conn->ident.local.addr = sp->local.addr;
    327325
    328326        tcp_conn_segment_arrived(conn, seg);
    … …  
    339337void tcp_to_user(void)
    340338{
    341         log_msg(LVL_DEBUG, "tcp_to_user()");
     339        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_to_user()");
    342340}
    343341

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

    r80445cf r4c53333  
    3636
    3737#include <adt/list.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <fibril_synch.h>
    4040#include <io/log.h>
    … …  
    8282        if (lsock != NULL)
    8383                assoc->ident.local = *lsock;
     84       
    8485        if (fsock != NULL)
    8586                assoc->ident.foreign = *fsock;
    … …  
    104105static void udp_assoc_free(udp_assoc_t *assoc)
    105106{
    106         log_msg(LVL_DEBUG, "%s: udp_assoc_free(%p)", assoc->name, assoc);
     107        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_free(%p)", assoc->name, assoc);
    107108
    108109        while (!list_empty(&assoc->rcv_queue)) {
    … …  
    127128void udp_assoc_addref(udp_assoc_t *assoc)
    128129{
    129         log_msg(LVL_DEBUG, "%s: upd_assoc_addref(%p)", assoc->name, assoc);
     130        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: upd_assoc_addref(%p)", assoc->name, assoc);
    130131        atomic_inc(&assoc->refcnt);
    131132}
    … …  
    139140void udp_assoc_delref(udp_assoc_t *assoc)
    140141{
    141         log_msg(LVL_DEBUG, "%s: udp_assoc_delref(%p)", assoc->name, assoc);
     142        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_delref(%p)", assoc->name, assoc);
    142143
    143144        if (atomic_predec(&assoc->refcnt) == 0)
    … …  
    154155void udp_assoc_delete(udp_assoc_t *assoc)
    155156{
    156         log_msg(LVL_DEBUG, "%s: udp_assoc_delete(%p)", assoc->name, assoc);
     157        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_delete(%p)", assoc->name, assoc);
    157158
    158159        assert(assoc->deleted == false);
    … …  
    192193void udp_assoc_set_foreign(udp_assoc_t *assoc, udp_sock_t *fsock)
    193194{
    194         log_msg(LVL_DEBUG, "udp_assoc_set_foreign(%p, %p)", assoc, fsock);
     195        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_foreign(%p, %p)", assoc, fsock);
    195196        fibril_mutex_lock(&assoc->lock);
    196197        assoc->ident.foreign = *fsock;
    … …  
    200201/** Set local socket in association.
    201202 *
    202  * @param assoc         Association
    203  * @param fsock         Foreign socket (deeply copied)
     203 * @param assoc Association
     204 * @param lsock Local socket (deeply copied)
     205 *
    204206 */
    205207void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
    206208{
    207         log_msg(LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, lsock);
     209        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, lsock);
    208210        fibril_mutex_lock(&assoc->lock);
    209211        assoc->ident.local = *lsock;
     212        fibril_mutex_unlock(&assoc->lock);
     213}
     214
     215/** Set local port in association.
     216 *
     217 * @param assoc Association
     218 * @param lport Local port
     219 *
     220 */
     221void udp_assoc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
     222{
     223        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %" PRIu16 ")", assoc, lport);
     224        fibril_mutex_lock(&assoc->lock);
     225        assoc->ident.local.port = lport;
    210226        fibril_mutex_unlock(&assoc->lock);
    211227}
    … …  
    228244        int rc;
    229245
    230         log_msg(LVL_DEBUG, "udp_assoc_send(%p, %p, %p)",
     246        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send(%p, %p, %p)",
    231247            assoc, fsock, msg);
    232248
    … …  
    236252                sp.foreign = *fsock;
    237253
    238         if (sp.foreign.addr.ipv4 == 0 || sp.foreign.port == 0)
     254        if ((inet_addr_is_any(&sp.foreign.addr)) ||
     255            (sp.foreign.port == UDP_PORT_ANY))
    239256                return EINVAL;
    240257
    … …  
    261278        udp_rcv_queue_entry_t *rqe;
    262279
    263         log_msg(LVL_DEBUG, "udp_assoc_recv()");
    264 
    265         fibril_mutex_lock(&assoc->lock);
    266         while (list_empty(&assoc->rcv_queue)) {
    267                 log_msg(LVL_DEBUG, "udp_assoc_recv() - waiting");
     280        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv()");
     281
     282        fibril_mutex_lock(&assoc->lock);
     283        while (list_empty(&assoc->rcv_queue) && !assoc->reset) {
     284                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - waiting");
    268285                fibril_condvar_wait(&assoc->rcv_queue_cv, &assoc->lock);
    269286        }
    270287
    271         log_msg(LVL_DEBUG, "udp_assoc_recv() - got a message");
     288        if (assoc->reset) {
     289                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - association was reset");
     290                fibril_mutex_unlock(&assoc->lock);
     291                return ECONNABORTED;
     292        }
     293
     294        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - got a message");
    272295        link = list_first(&assoc->rcv_queue);
    273296        rqe = list_get_instance(link, udp_rcv_queue_entry_t, link);
    … …  
    291314        int rc;
    292315
    293         log_msg(LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg);
     316        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg);
    294317
    295318        assoc = udp_assoc_find_ref(rsp);
    296319        if (assoc == NULL) {
    297                 log_msg(LVL_DEBUG, "No association found. Message dropped.");
     320                log_msg(LOG_DEFAULT, LVL_DEBUG, "No association found. Message dropped.");
    298321                /* XXX Generate ICMP error. */
    299322                /* XXX Might propagate error directly by error return. */
    … …  
    303326        rc = udp_assoc_queue_msg(assoc, rsp, msg);
    304327        if (rc != EOK) {
    305                 log_msg(LVL_DEBUG, "Out of memory. Message dropped.");
     328                log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped.");
    306329                /* XXX Generate ICMP error? */
    307330        }
     331}
     332
     333/** Reset association.
     334 *
     335 * This causes any pendingreceive operations to return immediately with
     336 * UDP_ERESET.
     337 */
     338void udp_assoc_reset(udp_assoc_t *assoc)
     339{
     340        fibril_mutex_lock(&assoc->lock);
     341        assoc->reset = true;
     342        fibril_condvar_broadcast(&assoc->rcv_queue_cv);
     343        fibril_mutex_unlock(&assoc->lock);
    308344}
    309345
    … …  
    313349        udp_rcv_queue_entry_t *rqe;
    314350
    315         log_msg(LVL_DEBUG, "udp_assoc_queue_msg(%p, %p, %p)",
     351        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_queue_msg(%p, %p, %p)",
    316352            assoc, sp, msg);
    317353
    … …  
    336372static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt)
    337373{
    338         log_msg(LVL_DEBUG, "udp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    339             sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    340 
    341         if (patt->addr.ipv4 != UDP_IPV4_ANY &&
    342             patt->addr.ipv4 != sock->addr.ipv4)
     374        if ((!inet_addr_is_any(&patt->addr)) &&
     375            (!inet_addr_compare(&patt->addr, &sock->addr)))
    343376                return false;
    344 
    345         if (patt->port != UDP_PORT_ANY &&
    346             patt->port != sock->port)
     377       
     378        if ((patt->port != UDP_PORT_ANY) &&
     379            (patt->port != sock->port))
    347380                return false;
    348 
    349         log_msg(LVL_DEBUG, " -> match");
    350 
     381       
     382        log_msg(LOG_DEFAULT, LVL_DEBUG, " -> match");
     383       
    351384        return true;
    352385}
    … …  
    355388static bool udp_sockpair_match(udp_sockpair_t *sp, udp_sockpair_t *pattern)
    356389{
    357         log_msg(LVL_DEBUG, "udp_sockpair_match(%p, %p)", sp, pattern);
     390        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sockpair_match(%p, %p)", sp, pattern);
    358391
    359392        if (!udp_socket_match(&sp->local, &pattern->local))
    … …  
    363396                return false;
    364397
    365         log_msg(LVL_DEBUG, "Socket pair matched.");
     398        log_msg(LOG_DEFAULT, LVL_DEBUG, "Socket pair matched.");
    366399        return true;
    367400}
    … …  
    379412static udp_assoc_t *udp_assoc_find_ref(udp_sockpair_t *sp)
    380413{
    381         log_msg(LVL_DEBUG, "udp_assoc_find_ref(%p)", sp);
    382 
     414        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", sp);
     415       
    383416        fibril_mutex_lock(&assoc_list_lock);
    384 
     417       
    385418        list_foreach(assoc_list, link) {
    386419                udp_assoc_t *assoc = list_get_instance(link, udp_assoc_t, link);
    387420                udp_sockpair_t *asp = &assoc->ident;
    388                 log_msg(LVL_DEBUG, "compare with assoc (f:(%x,%u), l:(%x,%u))",
    389                     asp->foreign.addr.ipv4, asp->foreign.port,
    390                     asp->local.addr.ipv4, asp->local.port);
    391 
     421               
    392422                /* Skip unbound associations */
    393423                if (asp->local.port == UDP_PORT_ANY)
    394424                        continue;
    395 
     425               
    396426                if (udp_sockpair_match(sp, asp)) {
    397                         log_msg(LVL_DEBUG, "Returning assoc %p", assoc);
     427                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning assoc %p", assoc);
    398428                        udp_assoc_addref(assoc);
    399429                        fibril_mutex_unlock(&assoc_list_lock);
    … …  
    401431                }
    402432        }
    403 
     433       
    404434        fibril_mutex_unlock(&assoc_list_lock);
    405435        return NULL;
    406436}
    407437
    408 
    409438/**
    410439 * @}

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

    r80445cf r4c53333  
    4747extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4848extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
     49extern void udp_assoc_set_local_port(udp_assoc_t *, uint16_t);
    4950extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
    5051extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);
    5152extern void udp_assoc_received(udp_sockpair_t *, udp_msg_t *);
    52 
     53extern void udp_assoc_reset(udp_assoc_t *);
    5354
    5455#endif

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

    r80445cf r4c53333  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 
     42#include <inet/addr.h>
     43#include <net/socket_codes.h>
    4344#include "msg.h"
    4445#include "pdu.h"
    … …  
    8485}
    8586
    86 static void udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr)
    87 {
    88         phdr->src_addr = host2uint32_t_be(pdu->src.ipv4);
    89         phdr->dest_addr = host2uint32_t_be(pdu->dest.ipv4);
    90         phdr->zero = 0;
    91         phdr->protocol = IP_PROTO_UDP;
    92         phdr->udp_length = host2uint16_t_be(pdu->data_size);
     87static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
     88    udp_phdr6_t *phdr6)
     89{
     90        addr32_t src_v4;
     91        addr128_t src_v6;
     92        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     93       
     94        addr32_t dest_v4;
     95        addr128_t dest_v6;
     96        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     97       
     98        assert(src_af == dest_af);
     99       
     100        switch (src_af) {
     101        case AF_INET:
     102                phdr->src_addr = host2uint32_t_be(src_v4);
     103                phdr->dest_addr = host2uint32_t_be(dest_v4);
     104                phdr->zero = 0;
     105                phdr->protocol = IP_PROTO_UDP;
     106                phdr->udp_length = host2uint16_t_be(pdu->data_size);
     107                break;
     108        case AF_INET6:
     109                host2addr128_t_be(src_v6, phdr6->src_addr);
     110                host2addr128_t_be(dest_v6, phdr6->dest_addr);
     111                phdr6->udp_length = host2uint32_t_be(pdu->data_size);
     112                memset(phdr6->zero, 0, 3);
     113                phdr6->next = IP_PROTO_UDP;
     114                break;
     115        default:
     116                assert(false);
     117        }
     118       
     119        return src_af;
    93120}
    94121
    … …  
    107134{
    108135        uint16_t cs_phdr;
    109         uint16_t cs_all;
    110136        udp_phdr_t phdr;
    111 
    112         udp_phdr_setup(pdu, &phdr);
    113         cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *)&phdr,
    114             sizeof(udp_phdr_t));
    115         cs_all = udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    116 
    117         return cs_all;
     137        udp_phdr6_t phdr6;
     138       
     139        uint16_t af = udp_phdr_setup(pdu, &phdr, &phdr6);
     140        switch (af) {
     141        case AF_INET:
     142                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
     143                    sizeof(udp_phdr_t));
     144                break;
     145        case AF_INET6:
     146                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr6,
     147                    sizeof(udp_phdr6_t));
     148                break;
     149        default:
     150                assert(false);
     151        }
     152       
     153        return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    118154}
    119155

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

    r80445cf r4c53333  
    4343#include <ipc/services.h>
    4444#include <ipc/socket.h>
    45 #include <net/modules.h>
    4645#include <net/socket.h>
    4746#include <ns.h>
    … …  
    5251#include "ucall.h"
    5352
    54 #define FRAGMENT_SIZE 1024
    55 
    5653/** Free ports pool start. */
    5754#define UDP_FREE_PORTS_START            1025
    … …  
    6461
    6562static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     63static int udp_sock_recv_fibril(void *arg);
    6664
    6765int udp_sock_init(void)
    6866{
    69         int rc;
    70 
    7167        socket_ports_initialize(&gsock);
    72 
     68       
    7369        async_set_client_connection(udp_sock_connection);
    74 
    75         rc = service_register(SERVICE_UDP);
     70       
     71        int rc = service_register(SERVICE_UDP);
    7672        if (rc != EOK)
    7773                return EEXIST;
    78 
     74       
    7975        return EOK;
    8076}
    … …  
    8682        socket = (udp_sockdata_t *)sock_core->specific_data;
    8783        (void)socket;
     84
     85        /* XXX We need to force the receive fibril to quit */
    8886}
    8987
    9088static void udp_sock_notify_data(socket_core_t *sock_core)
    9189{
    92         log_msg(LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
    9391        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    94         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    95             FRAGMENT_SIZE, 0, 0, 1);
     92        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) sock_core->socket_id,
     93            UDP_FRAGMENT_SIZE, 0, 0, 1);
    9694        async_exchange_end(exch);
    9795}
    … …  
    105103        ipc_call_t answer;
    106104
    107         log_msg(LVL_DEBUG, "udp_sock_socket()");
    108         sock = calloc(sizeof(udp_sockdata_t), 1);
     105        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_socket()");
     106        sock = calloc(1, sizeof(udp_sockdata_t));
    109107        if (sock == NULL) {
    110108                async_answer_0(callid, ENOMEM);
    … …  
    115113        sock->client = client;
    116114
     115        sock->recv_buffer_used = 0;
     116        sock->recv_error = UDP_EOK;
     117        fibril_mutex_initialize(&sock->recv_buffer_lock);
     118        fibril_condvar_initialize(&sock->recv_buffer_cv);
     119
    117120        rc = udp_uc_create(&sock->assoc);
    118121        if (rc != EOK) {
     122                free(sock);
     123                async_answer_0(callid, rc);
     124                return;
     125        }
     126
     127        sock->recv_fibril = fibril_create(udp_sock_recv_fibril, sock);
     128        if (sock->recv_fibril == 0) {
     129                udp_uc_destroy(sock->assoc);
     130                free(sock);
     131                async_answer_0(callid, ENOMEM);
     132                return;
     133        }
     134
     135        sock_id = SOCKET_GET_SOCKET_ID(call);
     136        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     137        if (rc != EOK) {
     138                fibril_destroy(sock->recv_fibril);
    119139                udp_uc_destroy(sock->assoc);
    120140                free(sock);
    … …  
    123143        }
    124144
    125         sock_id = SOCKET_GET_SOCKET_ID(call);
    126         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    127         if (rc != EOK) {
    128                 async_answer_0(callid, rc);
    129                 return;
    130         }
     145        fibril_add_ready(sock->recv_fibril);
    131146
    132147        sock_core = socket_cores_find(&client->sockets, sock_id);
    133148        assert(sock_core != NULL);
    134149        sock->sock_core = sock_core;
    135 
    136 
    137         refresh_answer(&answer, NULL);
     150       
    138151        SOCKET_SET_SOCKET_ID(answer, sock_id);
    139152
    140         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     153        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
    141154        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    142         answer_call(callid, EOK, &answer, 3);
     155        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     156            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    143157}
    144158
    145159static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    146160{
    147         int rc;
    148         struct sockaddr_in *addr;
    149         size_t addr_size;
    150         socket_core_t *sock_core;
    151         udp_sockdata_t *socket;
    152         udp_sock_t fsock;
    153         udp_error_t urc;
    154 
    155         log_msg(LVL_DEBUG, "udp_sock_bind()");
    156         log_msg(LVL_DEBUG, " - async_data_write_accept");
    157 
    158         addr = NULL;
    159 
    160         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
     161        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
     162        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
     163       
     164        struct sockaddr_in6 *addr6 = NULL;
     165        size_t addr_len;
     166        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
    161167        if (rc != EOK) {
    162168                async_answer_0(callid, rc);
     169                return;
     170        }
     171       
     172        if ((addr_len != sizeof(struct sockaddr_in)) &&
     173            (addr_len != sizeof(struct sockaddr_in6))) {
     174                async_answer_0(callid, EINVAL);
    163175                goto out;
    164176        }
    165 
    166         log_msg(LVL_DEBUG, " - call socket_bind");
     177       
     178        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     179       
     180        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
     181       
    167182        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    168             addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     183            addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    169184            last_used_port);
    170185        if (rc != EOK) {
    … …  
    172187                goto out;
    173188        }
    174 
    175         if (addr_size != sizeof(struct sockaddr_in)) {
    176                 async_answer_0(callid, EINVAL);
    177                 goto out;
    178         }
    179 
    180         log_msg(LVL_DEBUG, " - call socket_cores_find");
    181         sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
     189       
     190        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
     191       
     192        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     193            SOCKET_GET_SOCKET_ID(call));
    182194        if (sock_core == NULL) {
    183195                async_answer_0(callid, ENOENT);
    184196                goto out;
    185197        }
    186 
    187         socket = (udp_sockdata_t *)sock_core->specific_data;
    188 
    189         fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    190         fsock.port = sock_core->port;
    191         urc = udp_uc_set_local(socket->assoc, &fsock);
    192 
     198       
     199        udp_sockdata_t *socket =
     200            (udp_sockdata_t *) sock_core->specific_data;
     201       
     202        udp_sock_t fsocket;
     203       
     204        fsocket.port = sock_core->port;
     205       
     206        switch (addr->sin_family) {
     207        case AF_INET:
     208                inet_sockaddr_in_addr(addr, &fsocket.addr);
     209                break;
     210        case AF_INET6:
     211                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     212                break;
     213        default:
     214                async_answer_0(callid, EINVAL);
     215                goto out;
     216        }
     217       
     218        udp_error_t urc = udp_uc_set_local(socket->assoc, &fsocket);
     219       
    193220        switch (urc) {
    194221        case UDP_EOK:
    … …  
    207234                assert(false);
    208235        }
    209 
    210         udp_sock_notify_data(sock_core);
    211 
    212         log_msg(LVL_DEBUG, " - success");
     236       
     237        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    213238        async_answer_0(callid, rc);
     239       
    214240out:
    215         if (addr != NULL)
    216                 free(addr);
     241        if (addr6 != NULL)
     242                free(addr6);
    217243}
    218244
    219245static void udp_sock_listen(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    220246{
    221         log_msg(LVL_DEBUG, "udp_sock_listen()");
     247        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_listen()");
    222248        async_answer_0(callid, ENOTSUP);
    223249}
    … …  
    225251static void udp_sock_connect(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    226252{
    227         log_msg(LVL_DEBUG, "udp_sock_connect()");
     253        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connect()");
    228254        async_answer_0(callid, ENOTSUP);
    229255}
    … …  
    231257static void udp_sock_accept(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    232258{
    233         log_msg(LVL_DEBUG, "udp_sock_accept()");
     259        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_accept()");
    234260        async_answer_0(callid, ENOTSUP);
    235261}
    … …  
    237263static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    238264{
    239         int socket_id;
    240         int fragments;
    241         int index;
     265        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
     266       
     267        struct sockaddr_in6 *addr6 = NULL;
    242268        struct sockaddr_in *addr;
    243         size_t addr_size;
    244         socket_core_t *sock_core;
    245         udp_sockdata_t *socket;
    246         udp_sock_t fsock, *fsockp;
    247         ipc_call_t answer;
    248         ipc_callid_t wcallid;
    249         size_t length;
    250         uint8_t buffer[FRAGMENT_SIZE];
    251         udp_error_t urc;
    252         int rc;
    253 
    254         log_msg(LVL_DEBUG, "udp_sock_send()");
    255 
    256         addr = NULL;
    257 
     269        udp_sock_t fsocket;
     270        udp_sock_t *fsocket_ptr;
     271       
    258272        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    259                 rc = async_data_write_accept((void **) &addr, false,
    260                     0, 0, 0, &addr_size);
     273                size_t addr_len;
     274                int rc = async_data_write_accept((void **) &addr6, false,
     275                    0, 0, 0, &addr_len);
     276                if (rc != EOK) {
     277                        async_answer_0(callid, rc);
     278                        return;
     279                }
     280               
     281                if ((addr_len != sizeof(struct sockaddr_in)) &&
     282                    (addr_len != sizeof(struct sockaddr_in6))) {
     283                        async_answer_0(callid, EINVAL);
     284                        goto out;
     285                }
     286               
     287                addr = (struct sockaddr_in *) addr6;
     288               
     289                switch (addr->sin_family) {
     290                case AF_INET:
     291                        inet_sockaddr_in_addr(addr, &fsocket.addr);
     292                        break;
     293                case AF_INET6:
     294                        inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     295                        break;
     296                default:
     297                        async_answer_0(callid, EINVAL);
     298                        goto out;
     299                }
     300               
     301                fsocket.port = uint16_t_be2host(addr->sin_port);
     302                fsocket_ptr = &fsocket;
     303        } else
     304                fsocket_ptr = NULL;
     305       
     306        int socket_id = SOCKET_GET_SOCKET_ID(call);
     307       
     308        SOCKET_GET_FLAGS(call);
     309       
     310        socket_core_t *sock_core =
     311            socket_cores_find(&client->sockets, socket_id);
     312        if (sock_core == NULL) {
     313                async_answer_0(callid, ENOTSOCK);
     314                goto out;
     315        }
     316       
     317        udp_sockdata_t *socket =
     318            (udp_sockdata_t *) sock_core->specific_data;
     319       
     320        if (sock_core->port <= 0) {
     321                /* Implicitly bind socket to port */
     322                int rc = socket_bind_free_port(&gsock, sock_core,
     323                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_port);
    261324                if (rc != EOK) {
    262325                        async_answer_0(callid, rc);
    263326                        goto out;
    264327                }
    265 
    266                 if (addr_size != sizeof(struct sockaddr_in)) {
    267                         async_answer_0(callid, EINVAL);
     328               
     329                assert(sock_core->port > 0);
     330               
     331                udp_error_t urc = udp_uc_set_local_port(socket->assoc,
     332                    sock_core->port);
     333               
     334                if (urc != UDP_EOK) {
     335                        // TODO: better error handling
     336                        async_answer_0(callid, EINTR);
    268337                        goto out;
    269338                }
    270 
    271                 fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    272                 fsock.port = uint16_t_be2host(addr->sin_port);
    273                 fsockp = &fsock;
    274         } else {
    275                 fsockp = NULL;
    276         }
    277 
    278         socket_id = SOCKET_GET_SOCKET_ID(call);
    279         fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    280         SOCKET_GET_FLAGS(call);
    281 
    282         sock_core = socket_cores_find(&client->sockets, socket_id);
    283         if (sock_core == NULL) {
    284                 async_answer_0(callid, ENOTSOCK);
    285                 goto out;
    286         }
    287 
    288         if (sock_core->port == 0) {
    289                 /* Implicitly bind socket to port */
    290                 rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    291                     addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    292                     last_used_port);
    293                 if (rc != EOK) {
    294                         async_answer_0(callid, rc);
    295                         goto out;
    296                 }
    297 
    298                 udp_sock_notify_data(sock_core);
    299         }
    300 
    301         socket = (udp_sockdata_t *)sock_core->specific_data;
     339               
     340                last_used_port = sock_core->port;
     341        }
     342       
    302343        fibril_mutex_lock(&socket->lock);
    303 
    304         if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
     344       
     345        if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
    305346                /* Determine local IP address */
    306                 inet_addr_t loc_addr, rem_addr;
    307 
    308                 rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
    309                     socket->assoc->ident.foreign.addr.ipv4;
    310 
    311                 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
     347                inet_addr_t loc_addr;
     348                inet_addr_t rem_addr;
     349               
     350                rem_addr = fsocket_ptr ? fsocket.addr :
     351                    socket->assoc->ident.foreign.addr;
     352               
     353                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    312354                if (rc != EOK) {
    313355                        fibril_mutex_unlock(&socket->lock);
    314356                        async_answer_0(callid, rc);
    315                         log_msg(LVL_DEBUG, "udp_sock_sendto: Failed to "
     357                        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
    316358                            "determine local address.");
    317359                        return;
    318360                }
    319 
    320                 socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    321                 log_msg(LVL_DEBUG, "Local IP address is %x",
    322                     socket->assoc->ident.local.addr.ipv4);
    323         }
    324 
    325 
     361               
     362                socket->assoc->ident.local.addr = loc_addr;
     363        }
     364       
    326365        assert(socket->assoc != NULL);
    327 
    328         for (index = 0; index < fragments; index++) {
     366       
     367        int fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     368        for (int index = 0; index < fragments; index++) {
     369                ipc_callid_t wcallid;
     370                size_t length;
     371               
    329372                if (!async_data_write_receive(&wcallid, &length)) {
    330373                        fibril_mutex_unlock(&socket->lock);
    … …  
    332375                        goto out;
    333376                }
    334 
    335                 if (length > FRAGMENT_SIZE)
    336                         length = FRAGMENT_SIZE;
    337 
    338                 rc = async_data_write_finalize(wcallid, buffer, length);
     377               
     378                if (length > UDP_FRAGMENT_SIZE)
     379                        length = UDP_FRAGMENT_SIZE;
     380               
     381                uint8_t buffer[UDP_FRAGMENT_SIZE];
     382                int rc = async_data_write_finalize(wcallid, buffer, length);
    339383                if (rc != EOK) {
    340384                        fibril_mutex_unlock(&socket->lock);
    … …  
    342386                        goto out;
    343387                }
    344 
    345                 urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
    346 
     388               
     389                udp_error_t urc =
     390                    udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
     391               
    347392                switch (urc) {
    348393                case UDP_EOK:
    349394                        rc = EOK;
    350395                        break;
    351 /*              case TCP_ENOTEXIST:
    352                         rc = ENOTCONN;
    353                         break;
    354                 case TCP_ECLOSING:
    355                         rc = ENOTCONN;
    356                         break;
    357                 case TCP_ERESET:
    358                         rc = ECONNABORTED;
    359                         break;*/
     396                case UDP_ENORES:
     397                        rc = ENOMEM;
     398                        break;
     399                case UDP_EUNSPEC:
     400                        rc = EINVAL;
     401                        break;
     402                case UDP_ENOROUTE:
     403                        rc = EIO;
     404                        break;
    360405                default:
    361406                        assert(false);
    362407                }
    363 
     408               
    364409                if (rc != EOK) {
    365410                        fibril_mutex_unlock(&socket->lock);
    … …  
    368413                }
    369414        }
    370 
    371         refresh_answer(&answer, NULL);
    372         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    373         answer_call(callid, EOK, &answer, 2);
     415       
     416        ipc_call_t answer;
     417       
     418        IPC_SET_ARG1(answer, 0);
     419        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
     420        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
     421            IPC_GET_ARG2(answer));
    374422        fibril_mutex_unlock(&socket->lock);
     423       
    375424out:
    376         if (addr != NULL)
    377                 free(addr);
     425        if (addr6 != NULL)
     426                free(addr6);
    378427}
    379428
    380429static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    381430{
    382         int socket_id;
    383         int flags;
    384         size_t addr_length, length;
    385         socket_core_t *sock_core;
    386         udp_sockdata_t *socket;
    387         ipc_call_t answer;
    388         ipc_callid_t rcallid;
    389         uint8_t buffer[FRAGMENT_SIZE];
    390         size_t data_len;
    391         xflags_t xflags;
    392         udp_error_t urc;
    393         struct sockaddr_in addr;
    394         udp_sock_t rsock;
    395         int rc;
    396 
    397         log_msg(LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
    398 
    399         socket_id = SOCKET_GET_SOCKET_ID(call);
    400         flags = SOCKET_GET_FLAGS(call);
    401 
    402         sock_core = socket_cores_find(&client->sockets, socket_id);
     431        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
     432       
     433        int socket_id = SOCKET_GET_SOCKET_ID(call);
     434       
     435        socket_core_t *sock_core =
     436            socket_cores_find(&client->sockets, socket_id);
    403437        if (sock_core == NULL) {
    404438                async_answer_0(callid, ENOTSOCK);
    405439                return;
    406440        }
    407 
    408         socket = (udp_sockdata_t *)sock_core->specific_data;
     441       
     442        udp_sockdata_t *socket =
     443            (udp_sockdata_t *) sock_core->specific_data;
     444       
    409445        fibril_mutex_lock(&socket->lock);
    410 
     446       
    411447        if (socket->assoc == NULL) {
    412448                fibril_mutex_unlock(&socket->lock);
    … …  
    414450                return;
    415451        }
    416 
    417         (void)flags;
    418 
    419         urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
    420             &xflags, &rsock);
    421         log_msg(LVL_DEBUG, "**** udp_uc_receive done, data_len=%zu", data_len);
    422 
     452       
     453        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     454       
     455        fibril_mutex_lock(&socket->recv_buffer_lock);
     456       
     457        while ((socket->recv_buffer_used == 0) &&
     458            (socket->recv_error == UDP_EOK)) {
     459                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
     460                fibril_condvar_wait(&socket->recv_buffer_cv,
     461                    &socket->recv_buffer_lock);
     462        }
     463       
     464        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
     465       
     466        size_t data_len = socket->recv_buffer_used;
     467        udp_error_t urc = socket->recv_error;
     468       
     469        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
     470       
     471        int rc;
     472       
    423473        switch (urc) {
    424474        case UDP_EOK:
    … …  
    435485                assert(false);
    436486        }
    437 
    438         log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     487       
     488        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     489       
    439490        if (rc != EOK) {
     491                fibril_mutex_unlock(&socket->recv_buffer_lock);
    440492                fibril_mutex_unlock(&socket->lock);
    441493                async_answer_0(callid, rc);
    442494                return;
    443495        }
    444 
     496       
     497        ipc_callid_t rcallid;
     498        size_t addr_size = 0;
     499       
    445500        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    446                 /* Fill addr */
    447                 addr.sin_family = AF_INET;
    448                 addr.sin_addr.s_addr = host2uint32_t_be(rsock.addr.ipv4);
    449                 addr.sin_port = host2uint16_t_be(rsock.port);
    450 
    451                 log_msg(LVL_DEBUG, "addr read receive");
    452                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     501                /* Fill address */
     502                udp_sock_t *rsock = &socket->recv_fsock;
     503                struct sockaddr_in addr;
     504                struct sockaddr_in6 addr6;
     505                size_t addr_length;
     506               
     507                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     508                    &addr6);
     509               
     510                switch (addr_af) {
     511                case AF_INET:
     512                        addr.sin_port = host2uint16_t_be(rsock->port);
     513                       
     514                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     515                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     516                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     517                                fibril_mutex_unlock(&socket->lock);
     518                                async_answer_0(callid, EINVAL);
     519                                return;
     520                        }
     521                       
     522                        if (addr_length > sizeof(addr))
     523                                addr_length = sizeof(addr);
     524                       
     525                        addr_size = sizeof(addr);
     526                       
     527                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     528                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     529                        if (rc != EOK) {
     530                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     531                                fibril_mutex_unlock(&socket->lock);
     532                                async_answer_0(callid, EINVAL);
     533                                return;
     534                        }
     535                       
     536                        break;
     537                case AF_INET6:
     538                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     539                       
     540                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     541                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     542                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     543                                fibril_mutex_unlock(&socket->lock);
     544                                async_answer_0(callid, EINVAL);
     545                                return;
     546                        }
     547                       
     548                        if (addr_length > sizeof(addr6))
     549                                addr_length = sizeof(addr6);
     550                       
     551                        addr_size = sizeof(addr6);
     552                       
     553                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     554                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     555                        if (rc != EOK) {
     556                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     557                                fibril_mutex_unlock(&socket->lock);
     558                                async_answer_0(callid, EINVAL);
     559                                return;
     560                        }
     561                       
     562                        break;
     563                default:
     564                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    453565                        fibril_mutex_unlock(&socket->lock);
    454566                        async_answer_0(callid, EINVAL);
    455567                        return;
    456568                }
    457 
    458                 if (addr_length > sizeof(addr))
    459                         addr_length = sizeof(addr);
    460 
    461                 log_msg(LVL_DEBUG, "addr read finalize");
    462                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    463                 if (rc != EOK) {
    464                         fibril_mutex_unlock(&socket->lock);
    465                         async_answer_0(callid, EINVAL);
    466                         return;
    467                 }
    468         }
    469 
    470         log_msg(LVL_DEBUG, "data read receive");
     569        }
     570       
     571        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     572       
     573        size_t length;
    471574        if (!async_data_read_receive(&rcallid, &length)) {
     575                fibril_mutex_unlock(&socket->recv_buffer_lock);
    472576                fibril_mutex_unlock(&socket->lock);
    473577                async_answer_0(callid, EINVAL);
    474578                return;
    475579        }
    476 
     580       
    477581        if (length > data_len)
    478582                length = data_len;
    479 
    480         log_msg(LVL_DEBUG, "data read finalize");
    481         rc = async_data_read_finalize(rcallid, buffer, length);
    482 
    483         if (length < data_len && rc == EOK)
     583       
     584        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     585       
     586        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
     587       
     588        if ((length < data_len) && (rc == EOK))
    484589                rc = EOVERFLOW;
    485 
    486         log_msg(LVL_DEBUG, "read_data_length <- %zu", length);
     590       
     591        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
     592       
     593        ipc_call_t answer;
     594       
     595        IPC_SET_ARG2(answer, 0);
    487596        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    488         SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    489         answer_call(callid, EOK, &answer, 3);
    490 
    491         /* Push one fragment notification to client's queue */
    492         udp_sock_notify_data(sock_core);
     597        SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
     598        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     599            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     600       
     601        socket->recv_buffer_used = 0;
     602       
     603        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     604        fibril_mutex_unlock(&socket->recv_buffer_lock);
    493605        fibril_mutex_unlock(&socket->lock);
    494606}
    … …  
    496608static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    497609{
    498         int socket_id;
    499         socket_core_t *sock_core;
    500         udp_sockdata_t *socket;
    501         int rc;
    502 
    503         log_msg(LVL_DEBUG, "tcp_sock_close()");
    504         socket_id = SOCKET_GET_SOCKET_ID(call);
    505 
    506         sock_core = socket_cores_find(&client->sockets, socket_id);
     610        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
     611        int socket_id = SOCKET_GET_SOCKET_ID(call);
     612
     613        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - find core");
     614        socket_core_t *sock_core =
     615            socket_cores_find(&client->sockets, socket_id);
    507616        if (sock_core == NULL) {
     617        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - core not found");
    508618                async_answer_0(callid, ENOTSOCK);
    509619                return;
    510620        }
    511621
    512         socket = (udp_sockdata_t *)sock_core->specific_data;
     622        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - spec data");
     623        udp_sockdata_t *socket =
     624            (udp_sockdata_t *) sock_core->specific_data;
     625        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket");
    513626        fibril_mutex_lock(&socket->lock);
    514627
    515         assert(socket->assoc != NULL);
    516         udp_uc_destroy(socket->assoc);
    517 
    518         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     628        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket buffer");
     629        fibril_mutex_lock(&socket->recv_buffer_lock);
     630        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - set socket->sock_core = NULL");
     631        socket->sock_core = NULL;
     632        fibril_mutex_unlock(&socket->recv_buffer_lock);
     633
     634        udp_uc_reset(socket->assoc);
     635
     636        int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    519637            udp_free_sock_data);
    520638        if (rc != EOK) {
     639                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - socket_destroy failed");
    521640                fibril_mutex_unlock(&socket->lock);
    522641                async_answer_0(callid, rc);
    … …  
    524643        }
    525644
     645        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - broadcast recv_buffer_cv");
     646        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     647
    526648        fibril_mutex_unlock(&socket->lock);
    527649        async_answer_0(callid, EOK);
    … …  
    530652static void udp_sock_getsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    531653{
    532         log_msg(LVL_DEBUG, "udp_sock_getsockopt()");
     654        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_getsockopt()");
    533655        async_answer_0(callid, ENOTSUP);
    534656}
    … …  
    536658static void udp_sock_setsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    537659{
    538         log_msg(LVL_DEBUG, "udp_sock_setsockopt()");
     660        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_setsockopt()");
    539661        async_answer_0(callid, ENOTSUP);
     662}
     663
     664static int udp_sock_recv_fibril(void *arg)
     665{
     666        udp_sockdata_t *sock = (udp_sockdata_t *)arg;
     667        udp_error_t urc;
     668        xflags_t xflags;
     669        size_t rcvd;
     670
     671        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril()");
     672
     673        fibril_mutex_lock(&sock->recv_buffer_lock);
     674
     675        while (true) {
     676                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
     677                while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
     678                        fibril_condvar_wait(&sock->recv_buffer_cv,
     679                            &sock->recv_buffer_lock);
     680                }
     681
     682                fibril_mutex_unlock(&sock->recv_buffer_lock);
     683
     684                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
     685                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
     686                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
     687                fibril_mutex_lock(&sock->recv_buffer_lock);
     688                sock->recv_error = urc;
     689
     690                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] udp_uc_receive -> %d", urc);
     691
     692                if (sock->sock_core != NULL)
     693                        udp_sock_notify_data(sock->sock_core);
     694
     695                if (urc != UDP_EOK) {
     696                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
     697                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     698                        fibril_mutex_unlock(&sock->recv_buffer_lock);
     699                        break;
     700                }
     701
     702                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
     703
     704                sock->recv_buffer_used = rcvd;
     705                fibril_condvar_broadcast(&sock->recv_buffer_cv);
     706        }
     707
     708        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() exited loop");
     709        fibril_mutex_unlock(&sock->recv_buffer_lock);
     710        udp_uc_destroy(sock->assoc);
     711
     712        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() terminated");
     713
     714        return 0;
    540715}
    541716
    … …  
    553728
    554729        while (true) {
    555                 log_msg(LVL_DEBUG, "udp_sock_connection: wait");
     730                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: wait");
    556731                callid = async_get_call(&call);
    557732                if (!IPC_GET_IMETHOD(call))
    558733                        break;
    559734
    560                 log_msg(LVL_DEBUG, "udp_sock_connection: METHOD=%d",
     735                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: METHOD=%d",
    561736                    (int)IPC_GET_IMETHOD(call));
    562737
    … …  
    599774                }
    600775        }
     776
     777        /* Clean up */
     778        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: Clean up");
     779        async_hangup(client.sess);
     780        socket_cores_release(NULL, &client.sockets, &gsock, udp_free_sock_data);
    601781}
    602782

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

    r80445cf r4c53333  
    4040#include <sys/types.h>
    4141
    42 #define IP_PROTO_UDP 17
     42#define IP_PROTO_UDP  17
    4343
    4444/** UDP Header */
    … …  
    5454} udp_header_t;
    5555
    56 /** UDP pseudo header */
     56/** UDP IPv4 pseudo header */
    5757typedef struct {
    5858        /** Source address */
    … …  
    6464        /** Protocol */
    6565        uint8_t protocol;
    66         /** TCP length */
     66        /** UDP length */
    6767        uint16_t udp_length;
    6868} udp_phdr_t;
     69
     70/** UDP IPv6 pseudo header */
     71typedef struct {
     72        /** Source address */
     73        addr128_t src_addr;
     74        /** Destination address */
     75        addr128_t dest_addr;
     76        /** UDP length */
     77        uint32_t udp_length;
     78        /** Reserved */
     79        uint8_t zero[3];
     80        /** Next header */
     81        uint8_t next;
     82} udp_phdr6_t;
    6983
    7084#endif

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

    r80445cf r4c53333  
    4747        udp_assoc_t *nassoc;
    4848
    49         log_msg(LVL_DEBUG, "udp_uc_create()");
     49        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_create()");
    5050        nassoc = udp_assoc_new(NULL, NULL);
    5151        if (nassoc == NULL)
    … …  
    5959udp_error_t udp_uc_set_foreign(udp_assoc_t *assoc, udp_sock_t *fsock)
    6060{
    61         log_msg(LVL_DEBUG, "udp_uc_set_foreign(%p, %p)", assoc, fsock);
     61        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_foreign(%p, %p)", assoc, fsock);
    6262
    6363        udp_assoc_set_foreign(assoc, fsock);
    … …  
    6767udp_error_t udp_uc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
    6868{
    69         log_msg(LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock);
     69        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock);
     70       
     71        udp_assoc_set_local(assoc, lsock);
     72        return UDP_EOK;
     73}
    7074
    71         udp_assoc_set_local(assoc, lsock);
     75udp_error_t udp_uc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
     76{
     77        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %" PRIu16 ")", assoc, lport);
     78       
     79        udp_assoc_set_local_port(assoc, lport);
    7280        return UDP_EOK;
    7381}
    … …  
    7987        udp_msg_t msg;
    8088
    81         log_msg(LVL_DEBUG, "%s: udp_uc_send()", assoc->name);
     89        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_uc_send()", assoc->name);
    8290
    8391        msg.data = data;
    … …  
    103111        int rc;
    104112
    105         log_msg(LVL_DEBUG, "%s: udp_uc_receive()", assoc->name);
     113        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_uc_receive()", assoc->name);
    106114        rc = udp_assoc_recv(assoc, &msg, fsock);
     115        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv -> %d", rc);
    107116        switch (rc) {
     117        case EOK:
     118                break;
     119        case ECONNABORTED:
     120                return UDP_ERESET;
     121        default:
     122                assert(false);
    108123        }
    109124
    … …  
    118133void udp_uc_status(udp_assoc_t *assoc, udp_assoc_status_t *astatus)
    119134{
    120         log_msg(LVL_DEBUG, "udp_uc_status()");
     135        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_status()");
    121136//      cstatus->cstate = conn->cstate;
    122137}
    … …  
    124139void udp_uc_destroy(udp_assoc_t *assoc)
    125140{
    126         log_msg(LVL_DEBUG, "udp_uc_destroy()");
     141        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_destroy()");
     142        udp_assoc_reset(assoc);
    127143        udp_assoc_remove(assoc);
    128144        udp_assoc_delete(assoc);
     145}
     146
     147void udp_uc_reset(udp_assoc_t *assoc)
     148{
     149        udp_assoc_reset(assoc);
    129150}
    130151

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

    r80445cf r4c53333  
    4242extern udp_error_t udp_uc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4343extern udp_error_t udp_uc_set_local(udp_assoc_t *, udp_sock_t *);
     44extern udp_error_t udp_uc_set_local_port(udp_assoc_t *, uint16_t);
    4445extern udp_error_t udp_uc_send(udp_assoc_t *, udp_sock_t *, void *, size_t,
    4546    xflags_t);
    … …  
    4849extern void udp_uc_status(udp_assoc_t *, udp_assoc_status_t *);
    4950extern void udp_uc_destroy(udp_assoc_t *);
     51extern void udp_uc_reset(udp_assoc_t *);
    5052
    5153#endif

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

    r80445cf r4c53333  
    5050        int rc;
    5151
    52         log_msg(LVL_DEBUG, "udp_init()");
     52        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_init()");
    5353
    5454        rc = udp_inet_init();
    5555        if (rc != EOK) {
    56                 log_msg(LVL_ERROR, "Failed connecting to internet service.");
     56                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service.");
    5757                return ENOENT;
    5858        }
    … …  
    6060        rc = udp_sock_init();
    6161        if (rc != EOK) {
    62                 log_msg(LVL_ERROR, "Failed initializing socket service.");
     62                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
    6363                return ENOENT;
    6464        }
    … …  
    7373        printf(NAME ": UDP (User Datagram Protocol) service\n");
    7474
    75         rc = log_init(NAME, LVL_WARN);
     75        rc = log_init(NAME);
    7676        if (rc != EOK) {
    7777                printf(NAME ": Failed to initialize log.\n");

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

    r80445cf r4c53333  
    6161        udp_pdu_t *pdu;
    6262
    63         log_msg(LVL_DEBUG, "udp_inet_ev_recv()");
     63        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_inet_ev_recv()");
    6464
    6565        pdu = udp_pdu_new();
    … …  
    6767        pdu->data_size = dgram->size;
    6868
    69         pdu->src.ipv4 = dgram->src.ipv4;
    70         pdu->dest.ipv4 = dgram->dest.ipv4;
    71         log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    72             pdu->src.ipv4, pdu->dest.ipv4);
     69        pdu->src = dgram->src;
     70        pdu->dest = dgram->dest;
    7371
    7472        udp_received_pdu(pdu);
    … …  
    8482        inet_dgram_t dgram;
    8583
    86         log_msg(LVL_DEBUG, "udp_transmit_pdu()");
     84        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_transmit_pdu()");
    8785
    88         dgram.src.ipv4 = pdu->src.ipv4;
    89         dgram.dest.ipv4 = pdu->dest.ipv4;
     86        dgram.src = pdu->src;
     87        dgram.dest = pdu->dest;
    9088        dgram.tos = 0;
    9189        dgram.data = pdu->data;
    … …  
    9492        rc = inet_send(&dgram, INET_TTL_MAX, 0);
    9593        if (rc != EOK)
    96                 log_msg(LVL_ERROR, "Failed to transmit PDU.");
     94                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU.");
    9795
    9896        return rc;
    … …  
    105103        udp_sockpair_t rident;
    106104
    107         log_msg(LVL_DEBUG, "udp_received_pdu()");
     105        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_received_pdu()");
    108106
    109107        if (udp_pdu_decode(pdu, &rident, &dmsg) != EOK) {
    110                 log_msg(LVL_WARN, "Not enough memory. PDU dropped.");
     108                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. PDU dropped.");
    111109                return;
    112110        }
    … …  
    124122        int rc;
    125123
    126         log_msg(LVL_DEBUG, "udp_inet_init()");
     124        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_inet_init()");
    127125
    128126        rc = inet_init(IP_PROTO_UDP, &udp_inet_ev_ops);
    129127        if (rc != EOK) {
    130                 log_msg(LVL_ERROR, "Failed connecting to internet service.");
     128                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service.");
    131129                return ENOENT;
    132130        }

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

    r80445cf r4c53333  
    3636#define UDP_TYPE_H
    3737
     38#include <fibril.h>
    3839#include <fibril_synch.h>
    3940#include <socket_core.h>
    4041#include <sys/types.h>
     42#include <inet/addr.h>
     43
     44#define UDP_FRAGMENT_SIZE 4096
     45
    4146
    4247typedef enum {
    … …  
    4752        UDP_EUNSPEC,
    4853        /* No route to destination */
    49         UDP_ENOROUTE
     54        UDP_ENOROUTE,
     55        /** Association reset by user */
     56        UDP_ERESET
    5057} udp_error_t;
    5158
    5259typedef enum {
    53         XF_DUMMY        = 0x1
     60        XF_DUMMY = 0x1
    5461} xflags_t;
    5562
    56 typedef struct {
    57         uint32_t ipv4;
    58 } netaddr_t;
    59 
    60 enum netaddr {
    61         UDP_IPV4_ANY = 0
    62 };
    63 
    64 enum tcp_port {
     63enum udp_port {
    6564        UDP_PORT_ANY = 0
    6665};
    6766
    6867typedef struct {
    69         netaddr_t addr;
     68        inet_addr_t addr;
    7069        uint16_t port;
    7170} udp_sock_t;
    … …  
    8786typedef struct {
    8887        /** Source address */
    89         netaddr_t src;
     88        inet_addr_t src;
    9089        /** Destination address */
    91         netaddr_t dest;
    92 
     90        inet_addr_t dest;
     91       
    9392        /** Encoded PDU data including header */
    9493        void *data;
    … …  
    114113        /** Association identification (local and foreign socket) */
    115114        udp_sockpair_t ident;
     115
     116        /** True if association was reset by user */
     117        bool reset;
    116118
    117119        /** True if association was deleted by user */
    … …  
    141143        /** Connection */
    142144        udp_assoc_t *assoc;
     145        /** Receiving fibril */
     146        fid_t recv_fibril;
     147        uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
     148        size_t recv_buffer_used;
     149        udp_sock_t recv_fsock;
     150        fibril_mutex_t recv_buffer_lock;
     151        fibril_condvar_t recv_buffer_cv;
     152        udp_error_t recv_error;
    143153} udp_sockdata_t;
    144154
Note: See TracChangeset for help on using the changeset viewer.