Changeset fab2746 in mainline for uspace/srv/net


Ignore:
Timestamp:
2015-04-08T21:25:30Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
99ea91b2
Parents:
ba0eac5
Message:

New transport layer API. Only UDP implemented.

Location:
uspace/srv/net
Files:
1 added
2 deleted
14 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    rba0eac5 rfab2746  
    3737#include <adt/list.h>
    3838#include <bitops.h>
     39#include <byteorder.h>
    3940#include <errno.h>
    4041#include <fibril_synch.h>

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

    rba0eac5 rfab2746  
    3636
    3737#include <bitops.h>
     38#include <errno.h>
    3839#include <inet/addr.h>
    3940#include <inet/dnsr.h>
    … …  
    4142#include <io/log.h>
    4243#include <loc.h>
    43 #include <net/in.h>
    44 #include <net/inet.h>
    45 #include <net/socket.h>
    4644#include <stdio.h>
    4745#include <stdlib.h>
    … …  
    6765} dhcp_offer_t;
    6866
    69 static int dhcp_recv_fibril(void *);
     67static void dhcp_recv_msg(udp_assoc_t *, udp_rmsg_t *);
     68static void dhcp_recv_err(udp_assoc_t *, udp_rerr_t *);
     69static void dhcp_link_state(udp_assoc_t *, udp_link_state_t);
     70
     71static udp_cb_t dhcp_transport_cb = {
     72        .recv_msg = dhcp_recv_msg,
     73        .recv_err = dhcp_recv_err,
     74        .link_state = dhcp_link_state
     75};
    7076
    7177int dhcp_send(dhcp_transport_t *dt, void *msg, size_t size)
    7278{
    73         struct sockaddr_in addr;
     79        inet_ep_t ep;
    7480        int rc;
    7581
    76         addr.sin_family = AF_INET;
    77         addr.sin_port = htons(dhcp_server_port);
    78         addr.sin_addr.s_addr = htonl(addr32_broadcast_all_hosts);
     82        inet_ep_init(&ep);
     83        ep.port = dhcp_server_port;
     84        inet_addr_set(addr32_broadcast_all_hosts, &ep.addr);
    7985
    80         rc = sendto(dt->fd, msg, size, 0,
    81             (struct sockaddr *)&addr, sizeof(addr));
     86        rc = udp_assoc_send_msg(dt->assoc, &ep, msg, size);
    8287        if (rc != EOK) {
    83                 log_msg(LOG_DEFAULT, LVL_ERROR, "Sending failed");
     88                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed sending message");
    8489                return rc;
    8590        }
    … …  
    8893}
    8994
    90 static int dhcp_recv_msg(dhcp_transport_t *dt, void **rmsg, size_t *rsize)
     95static void dhcp_recv_msg(udp_assoc_t *assoc, udp_rmsg_t *rmsg)
    9196{
    92         struct sockaddr_in src_addr;
    93         socklen_t src_addr_size;
    94         size_t recv_size;
     97        dhcp_transport_t *dt;
     98        size_t s;
    9599        int rc;
    96100
    97         src_addr_size = sizeof(src_addr);
    98         rc = recvfrom(dt->fd, msgbuf, MAX_MSG_SIZE, 0,
    99             (struct sockaddr *)&src_addr, &src_addr_size);
    100         if (rc < 0) {
    101                 log_msg(LOG_DEFAULT, LVL_ERROR, "recvfrom failed (%d)", rc);
    102                 return rc;
     101        log_msg(LOG_DEFAULT, LVL_NOTE, "dhcp_recv_msg()");
     102
     103        dt = (dhcp_transport_t *)udp_assoc_userptr(assoc);
     104        s = udp_rmsg_size(rmsg);
     105        if (s > MAX_MSG_SIZE)
     106                s = MAX_MSG_SIZE; /* XXX */
     107
     108        rc = udp_rmsg_read(rmsg, 0, msgbuf, s);
     109        if (rc != EOK) {
     110                log_msg(LOG_DEFAULT, LVL_ERROR, "Error receiving message.");
     111                return;
    103112        }
    104113
    105         recv_size = (size_t)rc;
    106         *rmsg = msgbuf;
    107         *rsize = recv_size;
     114        log_msg(LOG_DEFAULT, LVL_NOTE, "dhcp_recv_msg() - call recv_cb");
     115        dt->recv_cb(dt->cb_arg, msgbuf, s);
     116}
    108117
    109         return EOK;
     118static void dhcp_recv_err(udp_assoc_t *assoc, udp_rerr_t *rerr)
     119{
     120        log_msg(LOG_DEFAULT, LVL_WARN, "Ignoring ICMP error");
     121}
     122
     123static void dhcp_link_state(udp_assoc_t *assoc, udp_link_state_t ls)
     124{
     125        log_msg(LOG_DEFAULT, LVL_NOTE, "Link state change");
    110126}
    111127
    … …  
    113129    dhcp_recv_cb_t recv_cb, void *arg)
    114130{
    115         int fd;
    116         struct sockaddr_in laddr;
    117         int fid;
     131        udp_t *udp = NULL;
     132        udp_assoc_t *assoc = NULL;
     133        inet_ep2_t epp;
    118134        int rc;
    119135
    120         log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcptransport_init()");
     136        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_transport_init()");
    121137
    122         laddr.sin_family = AF_INET;
    123         laddr.sin_port = htons(dhcp_client_port);
    124         laddr.sin_addr.s_addr = INADDR_ANY;
     138        inet_ep2_init(&epp);
     139        epp.local.addr.version = ip_v4;
     140        epp.local.port = dhcp_client_port;
     141        epp.local_link = link_id;
    125142
    126         fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
    127         if (fd < 0) {
    128                 rc = EIO;
    129                 goto error;
    130         }
    131 
    132         log_msg(LOG_DEFAULT, LVL_DEBUG, "Bind socket.");
    133         rc = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
     143        rc = udp_create(&udp);
    134144        if (rc != EOK) {
    135145                rc = EIO;
    … …  
    137147        }
    138148
    139         log_msg(LOG_DEFAULT, LVL_DEBUG, "Set socket options");
    140         rc = setsockopt(fd, SOL_SOCKET, SO_IPLINK, &link_id, sizeof(link_id));
     149        rc = udp_assoc_create(udp, &epp, &dhcp_transport_cb, dt, &assoc);
    141150        if (rc != EOK) {
    142151                rc = EIO;
    … …  
    144153        }
    145154
    146         dt->fd = fd;
     155        dt->udp = udp;
     156        dt->assoc = assoc;
    147157        dt->recv_cb = recv_cb;
    148158        dt->cb_arg = arg;
    149159
    150         fid = fibril_create(dhcp_recv_fibril, dt);
    151         if (fid == 0) {
    152                 rc = ENOMEM;
    153                 goto error;
    154         }
    155 
    156         dt->recv_fid = fid;
    157         fibril_add_ready(fid);
    158 
    159160        return EOK;
    160161error:
    161         closesocket(fd);
     162        udp_assoc_destroy(assoc);
     163        udp_destroy(udp);
    162164        return rc;
    163165}
    … …  
    165167void dhcp_transport_fini(dhcp_transport_t *dt)
    166168{
    167         closesocket(dt->fd);
    168 }
    169 
    170 static int dhcp_recv_fibril(void *arg)
    171 {
    172         dhcp_transport_t *dt = (dhcp_transport_t *)arg;
    173         void *msg;
    174         size_t size = (size_t) -1;
    175         int rc;
    176 
    177         while (true) {
    178                 rc = dhcp_recv_msg(dt, &msg, &size);
    179                 if (rc != EOK)
    180                         break;
    181 
    182                 assert(size != (size_t) -1);
    183 
    184                 dt->recv_cb(dt->cb_arg, msg, size);
    185         }
    186 
    187         return EOK;
     169        udp_assoc_destroy(dt->assoc);
     170        udp_destroy(dt->udp);
    188171}
    189172

  • uspace/srv/net/dhcp/transport.h

    rba0eac5 rfab2746  
    3838#define TRANSPORT_H
    3939
     40#include <inet/udp.h>
    4041#include <ipc/loc.h>
    4142#include <sys/types.h>
    … …  
    4748
    4849struct dhcp_transport {
    49         /** Transport socket */
    50         int fd;
     50        /** UDP */
     51        udp_t *udp;
     52        /** UDP association */
     53        udp_assoc_t *assoc;
    5154        /** Receive callback */
    5255        dhcp_recv_cb_t recv_cb;
    5356        /** Callback argument */
    5457        void *cb_arg;
    55         /** Receive fibril ID */
    56         int recv_fid;
    5758};
    5859

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

    rba0eac5 rfab2746  
    3737#include <errno.h>
    3838#include <fibril_synch.h>
     39#include <inet/addr.h>
     40#include <inet/endpoint.h>
     41#include <inet/udp.h>
    3942#include <io/log.h>
    40 #include <net/in.h>
    41 #include <net/inet.h>
    42 #include <net/socket.h>
    4343#include <stdbool.h>
    4444#include <stdlib.h>
    … …  
    7272
    7373static uint8_t recv_buf[RECV_BUF_SIZE];
    74 static fid_t recv_fid;
    75 static int transport_fd = -1;
     74static udp_t *transport_udp;
     75static udp_assoc_t *transport_assoc;
    7676
    7777/** Outstanding requests */
    … …  
    7979static FIBRIL_MUTEX_INITIALIZE(treq_lock);
    8080
    81 static int transport_recv_fibril(void *arg);
     81static void transport_recv_msg(udp_assoc_t *, udp_rmsg_t *);
     82static void transport_recv_err(udp_assoc_t *, udp_rerr_t *);
     83static void transport_link_state(udp_assoc_t *, udp_link_state_t);
     84
     85static udp_cb_t transport_cb = {
     86        .recv_msg = transport_recv_msg,
     87        .recv_err = transport_recv_err,
     88        .link_state = transport_link_state
     89};
    8290
    8391int transport_init(void)
    8492{
    85         struct sockaddr_in laddr;
    86         int fd;
    87         fid_t fid;
     93        inet_ep2_t epp;
    8894        int rc;
    8995
    90         laddr.sin_family = AF_INET;
    91         laddr.sin_port = htons(12345);
    92         laddr.sin_addr.s_addr = INADDR_ANY;
    93 
    94         fd = -1;
    95 
    96         fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
    97         if (fd < 0) {
     96        inet_ep2_init(&epp);
     97
     98        rc = udp_create(&transport_udp);
     99        if (rc != EOK) {
    98100                rc = EIO;
    99101                goto error;
    100102        }
    101103
    102         rc = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
    103         if (rc != EOK)
    104                 goto error;
    105 
    106         transport_fd = fd;
    107 
    108         fid = fibril_create(transport_recv_fibril, NULL);
    109         if (fid == 0)
    110                 goto error;
    111 
    112         fibril_add_ready(fid);
    113         recv_fid = fid;
     104        rc = udp_assoc_create(transport_udp, &epp, &transport_cb, NULL,
     105            &transport_assoc);
     106        if (rc != EOK) {
     107                rc = EIO;
     108                goto error;
     109        }
     110
    114111        return EOK;
    115112error:
    116         log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing network socket.");
    117         if (fd >= 0)
    118                 closesocket(fd);
     113        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing network.");
     114        udp_assoc_destroy(transport_assoc);
     115        udp_destroy(transport_udp);
    119116        return rc;
    120117}
    … …  
    122119void transport_fini(void)
    123120{
    124         if (transport_fd >= 0)
    125                 closesocket(transport_fd);
     121        udp_assoc_destroy(transport_assoc);
     122        udp_destroy(transport_udp);
    126123}
    127124
    … …  
    182179{
    183180        trans_req_t *treq = NULL;
    184         struct sockaddr *saddr = NULL;
    185         socklen_t saddrlen;
    186        
     181        inet_ep_t ep;
     182
    187183        void *req_data;
    188184        size_t req_size;
    … …  
    190186        if (rc != EOK)
    191187                goto error;
    192        
    193         rc = inet_addr_sockaddr(&dns_server_addr, DNS_SERVER_PORT,
    194             &saddr, &saddrlen);
    195         if (rc != EOK) {
    196                 assert(rc == ENOMEM);
    197                 goto error;
    198         }
    199        
     188
     189        inet_ep_init(&ep);
     190        ep.addr = dns_server_addr;
     191        ep.port = DNS_SERVER_PORT;
     192
    200193        size_t ntry = 0;
    201        
     194
    202195        while (ntry < REQ_RETRY_MAX) {
    203                 rc = sendto(transport_fd, req_data, req_size, 0,
    204                     saddr, saddrlen);
     196                rc = udp_assoc_send_msg(transport_assoc, &ep, req_data,
     197                    req_size);
    205198                if (rc != EOK)
    206199                        goto error;
    207                
     200
    208201                treq = treq_create(req);
    209202                if (treq == NULL) {
    … …  
    211204                        goto error;
    212205                }
    213                
     206
    214207                fibril_mutex_lock(&treq->done_lock);
    215208                while (treq->done != true) {
    … …  
    221214                        }
    222215                }
    223                
     216
    224217                fibril_mutex_unlock(&treq->done_lock);
    225                
     218
    226219                if (rc != ETIMEOUT)
    227220                        break;
    228221        }
    229        
     222
    230223        if (ntry >= REQ_RETRY_MAX) {
    231224                rc = EIO;
    232225                goto error;
    233226        }
    234        
     227
    235228        if (treq->status != EOK) {
    236229                rc = treq->status;
    237230                goto error;
    238231        }
    239        
     232
    240233        *rresp = treq->resp;
    241234        treq_destroy(treq);
    242235        free(req_data);
    243         free(saddr);
    244236        return EOK;
    245        
     237
    246238error:
    247239        if (treq != NULL)
    248240                treq_destroy(treq);
    249        
     241
    250242        free(req_data);
    251         free(saddr);
    252243        return rc;
    253244}
    254245
    255 static int transport_recv_msg(dns_message_t **rresp)
    256 {
    257         struct sockaddr_in src_addr;
    258         socklen_t src_addr_size;
    259         size_t recv_size;
    260         dns_message_t *resp;
    261         int rc;
    262 
    263         src_addr_size = sizeof(src_addr);
    264         rc = recvfrom(transport_fd, recv_buf, RECV_BUF_SIZE, 0,
    265             (struct sockaddr *)&src_addr, &src_addr_size);
    266         if (rc < 0) {
    267                 log_msg(LOG_DEFAULT, LVL_ERROR, "recvfrom returns error - %d", rc);
    268                 goto error;
    269         }
    270 
    271         recv_size = (size_t)rc;
    272 
    273         rc = dns_message_decode(recv_buf, recv_size, &resp);
    274         if (rc != EOK) {
    275                 rc = EIO;
    276                 goto error;
    277         }
    278 
    279         *rresp = resp;
    280         return EOK;
    281 
    282 error:
    283         return rc;
    284 }
    285 
    286 static int transport_recv_fibril(void *arg)
     246static void transport_recv_msg(udp_assoc_t *assoc, udp_rmsg_t *rmsg)
    287247{
    288248        dns_message_t *resp = NULL;
    289249        trans_req_t *treq;
     250        size_t size;
     251        inet_ep_t remote_ep;
    290252        int rc;
    291253
    292         while (true) {
    293                 rc = transport_recv_msg(&resp);
    294                 if (rc != EOK)
    295                         continue;
    296 
    297                 assert(resp != NULL);
    298 
    299                 fibril_mutex_lock(&treq_lock);
    300                 treq = treq_match_resp(resp);
    301                 if (treq == NULL) {
    302                         fibril_mutex_unlock(&treq_lock);
    303                         continue;
    304                 }
    305 
    306                 list_remove(&treq->lreq);
     254        size = udp_rmsg_size(rmsg);
     255        if (size > RECV_BUF_SIZE)
     256                size = RECV_BUF_SIZE; /* XXX */
     257
     258        rc = udp_rmsg_read(rmsg, 0, recv_buf, size);
     259        if (rc != EOK) {
     260                log_msg(LOG_DEFAULT, LVL_ERROR, "Error reading message.");
     261                return;
     262        }
     263
     264        udp_rmsg_remote_ep(rmsg, &remote_ep);
     265        /* XXX */
     266
     267        rc = dns_message_decode(recv_buf, size, &resp);
     268        if (rc != EOK) {
     269                log_msg(LOG_DEFAULT, LVL_ERROR, "Error decoding message.");
     270                return;
     271        }
     272
     273        assert(resp != NULL);
     274
     275        fibril_mutex_lock(&treq_lock);
     276        treq = treq_match_resp(resp);
     277        if (treq == NULL) {
    307278                fibril_mutex_unlock(&treq_lock);
    308 
    309                 treq_complete(treq, resp);
    310         }
    311 
    312         return 0;
    313 }
     279                return;
     280        }
     281
     282        list_remove(&treq->lreq);
     283        fibril_mutex_unlock(&treq_lock);
     284
     285        treq_complete(treq, resp);
     286}
     287
     288static void transport_recv_err(udp_assoc_t *assoc, udp_rerr_t *rerr)
     289{
     290        log_msg(LOG_DEFAULT, LVL_WARN, "Ignoring ICMP error");
     291}
     292
     293static void transport_link_state(udp_assoc_t *assoc, udp_link_state_t ls)
     294{
     295        log_msg(LOG_DEFAULT, LVL_NOTE, "Link state change");
     296}
     297
    314298
    315299/** @}

  • uspace/srv/net/tcp/Makefile

    rba0eac5 rfab2746  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBNET_PREFIX)/libnet.a
    31 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    3230BINARY = tcp
    3331
    … …  
    4038        segment.c \
    4139        seq_no.c \
    42         sock.c \
    4340        tcp.c \
    4441        test.c \

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

    rba0eac5 rfab2746  
    4242#include <io/log.h>
    4343#include <stdio.h>
     44#include <stdlib.h>
    4445#include <task.h>
    4546
    … …  
    4748#include "pdu.h"
    4849#include "rqueue.h"
    49 #include "sock.h"
    5050#include "std.h"
    5151#include "tcp.h"
    … …  
    192192        }
    193193
    194         rc = tcp_sock_init();
    195         if (rc != EOK) {
    196                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
    197                 return ENOENT;
    198         }
     194//      rc = tcp_sock_init();
     195//      if (rc != EOK) {
     196//              log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
     197//              return ENOENT;
     198//      }
    199199
    200200        return EOK;

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

    rba0eac5 rfab2746  
    4141#include <fibril.h>
    4242#include <fibril_synch.h>
    43 #include <socket_core.h>
    4443#include <sys/types.h>
    4544#include <inet/addr.h>
    … …  
    321320typedef struct {
    322321        async_sess_t *sess;
    323         socket_cores_t sockets;
     322//      socket_cores_t sockets;
    324323} tcp_client_t;
    325324
    … …  
    330329        fibril_mutex_t lock;
    331330        /** Socket core */
    332         socket_core_t *sock_core;
     331//      socket_core_t *sock_core;
    333332        /** Client */
    334333        tcp_client_t *client;

  • uspace/srv/net/udp/Makefile

    rba0eac5 rfab2746  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBNET_PREFIX)/libnet.a
    31 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    3230BINARY = udp
    3331
    … …  
    3533        assoc.c \
    3634        msg.c \
    37         sock.c \
    3835        pdu.c \
     36        service.c \
    3937        ucall.c \
    4038        udp.c \

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

    rba0eac5 rfab2746  
    3636
    3737#include <adt/list.h>
     38#include <errno.h>
    3839#include <stdbool.h>
    3940#include <fibril_synch.h>
    … …  
    6263 * @return              New association or NULL
    6364 */
    64 udp_assoc_t *udp_assoc_new(udp_sock_t *lsock, udp_sock_t *fsock)
     65udp_assoc_t *udp_assoc_new(udp_sock_t *lsock, udp_sock_t *fsock,
     66    udp_assoc_cb_t *cb, void *cb_arg)
    6567{
    6668        udp_assoc_t *assoc = NULL;
    … …  
    8284        if (lsock != NULL)
    8385                assoc->ident.local = *lsock;
    84        
     86
    8587        if (fsock != NULL)
    8688                assoc->ident.foreign = *fsock;
    8789
     90        assoc->cb = cb;
     91        assoc->cb_arg = cb_arg;
    8892        return assoc;
    8993error:
    … …  
    258262        int rc;
    259263
    260         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send(%p, %p, %p)",
     264        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send(%p, %p, %p)",
    261265            assoc, fsock, msg);
    262266
    … …  
    266270                sp.foreign = *fsock;
    267271
     272        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send - check addr any");
     273
    268274        if ((inet_addr_is_any(&sp.foreign.addr)) ||
    269275            (sp.foreign.port == UDP_PORT_ANY))
    270276                return EINVAL;
    271277
     278        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send - check version");
     279
     280        if (sp.foreign.addr.version != sp.local.addr.version)
     281                return EINVAL;
     282
     283        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send - encode pdu");
     284
    272285        rc = udp_pdu_encode(&sp, msg, &pdu);
    273286        if (rc != EOK)
    274287                return ENOMEM;
    275288
     289        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send - transmit");
     290
    276291        rc = udp_transmit_pdu(pdu);
    277292        udp_pdu_delete(pdu);
    … …  
    280295                return EIO;
    281296
     297        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_send - success");
    282298        return EOK;
    283299}
    … …  
    292308        udp_rcv_queue_entry_t *rqe;
    293309
    294         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv()");
     310        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_recv()");
    295311
    296312        fibril_mutex_lock(&assoc->lock);
    … …  
    303319                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - association was reset");
    304320                fibril_mutex_unlock(&assoc->lock);
    305                 return ECONNABORTED;
     321                return ENXIO;
    306322        }
    307323
    308         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - got a message");
     324        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_recv() - got a message");
    309325        link = list_first(&assoc->rcv_queue);
    310326        rqe = list_get_instance(link, udp_rcv_queue_entry_t, link);
    … …  
    328344        int rc;
    329345
    330         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg);
     346        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_received(%p, %p)", rsp, msg);
    331347
    332348        assoc = udp_assoc_find_ref(rsp);
    333349        if (assoc == NULL) {
    334                 log_msg(LOG_DEFAULT, LVL_DEBUG, "No association found. Message dropped.");
     350                log_msg(LOG_DEFAULT, LVL_NOTE, "No association found. Message dropped.");
    335351                /* XXX Generate ICMP error. */
    336352                /* XXX Might propagate error directly by error return. */
    … …  
    339355        }
    340356
    341         rc = udp_assoc_queue_msg(assoc, rsp, msg);
    342         if (rc != EOK) {
    343                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped.");
     357        if (0) {
     358                rc = udp_assoc_queue_msg(assoc, rsp, msg);
     359                if (rc != EOK) {
     360                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped.");
    344361                /* XXX Generate ICMP error? */
     362                }
    345363        }
     364
     365        log_msg(LOG_DEFAULT, LVL_NOTE, "call assoc->cb->recv_msg");
     366        assoc->cb->recv_msg(assoc->cb_arg, rsp, msg);
    346367}
    347368
    … …  
    387408static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt)
    388409{
    389         log_msg(LOG_DEFAULT, LVL_DEBUG,
    390             "udp_socket_match(sock=(%u), pat=(%u))", sock->port, patt->port);
     410        char *sa, *pa;
     411
     412        sa = pa = (char *)"?";
     413        (void) inet_addr_format(&sock->addr, &sa);
     414        (void) inet_addr_format(&patt->addr, &pa);
     415
     416        log_msg(LOG_DEFAULT, LVL_NOTE,
     417            "udp_socket_match(sock=(%s,%u), pat=(%s,%u))",
     418            sa, sock->port, pa, patt->port);
    391419       
    392420        if ((!inet_addr_is_any(&patt->addr)) &&
    … …  
    394422                return false;
    395423       
     424        log_msg(LOG_DEFAULT, LVL_NOTE, "addr OK");
     425       
    396426        if ((patt->port != UDP_PORT_ANY) &&
    397427            (patt->port != sock->port))
    398428                return false;
    399429       
    400         log_msg(LOG_DEFAULT, LVL_DEBUG, " -> match");
     430        log_msg(LOG_DEFAULT, LVL_NOTE, " -> match");
    401431       
    402432        return true;
    … …  
    430460static udp_assoc_t *udp_assoc_find_ref(udp_sockpair_t *sp)
    431461{
    432         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", sp);
     462        char *la, *ra;
     463
     464        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_find_ref(%p)", sp);
    433465       
    434466        fibril_mutex_lock(&assoc_list_lock);
    435467       
     468        log_msg(LOG_DEFAULT, LVL_NOTE, "associations:");
    436469        list_foreach(assoc_list, link, udp_assoc_t, assoc) {
    437470                udp_sockpair_t *asp = &assoc->ident;
    438471               
     472                la = ra = NULL;
     473
     474                (void) inet_addr_format(&asp->local.addr, &la);
     475                (void) inet_addr_format(&asp->foreign.addr, &ra);
     476
     477                log_msg(LOG_DEFAULT, LVL_NOTE, "find_ref:asp=%p la=%s ra=%s",
     478                    asp, la, ra);
    439479                /* Skip unbound associations */
    440                 if (asp->local.port == UDP_PORT_ANY)
     480                if (asp->local.port == UDP_PORT_ANY) {
     481                        log_msg(LOG_DEFAULT, LVL_NOTE, "skip unbound");
    441482                        continue;
     483                }
    442484               
    443485                if (udp_sockpair_match(sp, asp)) {
    … …  
    446488                        fibril_mutex_unlock(&assoc_list_lock);
    447489                        return assoc;
     490                } else {
     491                        log_msg(LOG_DEFAULT, LVL_NOTE, "not matched");
    448492                }
    449493        }
    450494       
     495        log_msg(LOG_DEFAULT, LVL_NOTE, "associations END");
    451496        fibril_mutex_unlock(&assoc_list_lock);
    452497        return NULL;

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

    rba0eac5 rfab2746  
    4040#include "udp_type.h"
    4141
    42 extern udp_assoc_t *udp_assoc_new(udp_sock_t *, udp_sock_t *);
     42extern udp_assoc_t *udp_assoc_new(udp_sock_t *, udp_sock_t *, udp_assoc_cb_t *,
     43    void *);
    4344extern void udp_assoc_delete(udp_assoc_t *);
    4445extern void udp_assoc_add(udp_assoc_t *);

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

    rba0eac5 rfab2746  
    4141#include <stdlib.h>
    4242#include <inet/addr.h>
    43 #include <net/socket_codes.h>
    4443#include "msg.h"
    4544#include "pdu.h"

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

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @{
    3131 */
    32 /** @file Socket provider
     32/** @file HelenOS service implementation
    3333 */
    3434
    35 #ifndef SOCK_H
    36 #define SOCK_H
     35#ifndef SERVICE_H
     36#define SERVICE_H
    3737
    38 #include <async.h>
    39 
    40 extern int udp_sock_init(void);
     38extern int udp_service_init(void);
    4139
    4240#endif

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

    rba0eac5 rfab2746  
    3535 */
    3636
     37#include <errno.h>
    3738#include <io/log.h>
    3839#include <macros.h>
     40#include <mem.h>
    3941
    4042#include "assoc.h"
    … …  
    4850
    4951        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_create()");
    50         nassoc = udp_assoc_new(NULL, NULL);
     52        nassoc = udp_assoc_new(NULL, NULL, NULL, NULL);
    5153        if (nassoc == NULL)
    5254                return UDP_ENORES;
    … …  
    125127        case EOK:
    126128                break;
    127         case ECONNABORTED:
     129        case ENXIO:
    128130                return UDP_ERESET;
    129131        default:

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

    rba0eac5 rfab2746  
    4141#include <task.h>
    4242
     43#include "service.h"
    4344#include "udp_inet.h"
    44 #include "sock.h"
    4545
    4646#define NAME       "udp"
    … …  
    5858        }
    5959
    60         rc = udp_sock_init();
     60        rc = udp_service_init();
    6161        if (rc != EOK) {
    62                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
     62                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing UDP service.");
    6363                return ENOENT;
    6464        }

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

    rba0eac5 rfab2746  
    3636#define UDP_TYPE_H
    3737
     38#include <async.h>
    3839#include <fibril.h>
    3940#include <fibril_synch.h>
    4041#include <ipc/loc.h>
    41 #include <socket_core.h>
    4242#include <sys/types.h>
    4343#include <inet/addr.h>
    … …  
    9999
    100100typedef struct {
    101         async_sess_t *sess;
    102         socket_cores_t sockets;
    103 } udp_client_t;
     101        void (*recv_msg)(void *, udp_sockpair_t *, udp_msg_t *);
     102} udp_assoc_cb_t;
    104103
    105104/** UDP association
    … …  
    131130        /** Receive queue CV. Broadcast when new datagram is inserted */
    132131        fibril_condvar_t rcv_queue_cv;
     132
     133        udp_assoc_cb_t *cb;
     134        void *cb_arg;
    133135} udp_assoc_t;
    134136
    135137typedef struct {
    136138} udp_assoc_status_t;
    137 
    138 typedef struct udp_sockdata {
    139         /** Lock */
    140         fibril_mutex_t lock;
    141         /** Socket core */
    142         socket_core_t *sock_core;
    143         /** Client */
    144         udp_client_t *client;
    145         /** Connection */
    146         udp_assoc_t *assoc;
    147         /** User-configured IP link */
    148         service_id_t iplink;
    149         /** Receiving fibril */
    150         fid_t recv_fibril;
    151         uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
    152         size_t recv_buffer_used;
    153         udp_sock_t recv_fsock;
    154         fibril_mutex_t recv_buffer_lock;
    155         fibril_condvar_t recv_buffer_cv;
    156         udp_error_t recv_error;
    157 } udp_sockdata_t;
    158139
    159140typedef struct {
    … …  
    166147} udp_rcv_queue_entry_t;
    167148
     149typedef struct udp_cassoc {
     150        /** Association */
     151        udp_assoc_t *assoc;
     152        /** Association ID for the client */
     153        sysarg_t id;
     154        /** Client */
     155        struct udp_client *client;
     156        link_t lclient;
     157} udp_cassoc_t;
     158
     159typedef struct {
     160        /** Link to receive queue */
     161        link_t link;
     162        /** Socket pair */
     163        udp_sockpair_t sp;
     164        /** Message */
     165        udp_msg_t *msg;
     166        /** Client association */
     167        udp_cassoc_t *cassoc;
     168} udp_crcv_queue_entry_t;
     169
     170typedef struct udp_client {
     171        /** Client callback session */
     172        async_sess_t *sess;
     173        /** Client assocations */
     174        list_t cassoc; /* of udp_cassoc_t */
     175        /** Client receive queue */
     176        list_t crcv_queue;
     177} udp_client_t;
     178
    168179#endif
    169180
Note: See TracChangeset for help on using the changeset viewer.