Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 2989c7e in mainline


Ignore:
Timestamp:
2015-05-25T21:04:33Z (5 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
ab6326bc
Parents:
58e9dec
Message:

Association map / portrange prototype.

Location:
uspace
Files:
4 added
1 deleted
13 edited
1 moved

Legend:

Unmodified
Added
Removed
  • uspace/Makefile

    r58e9dec r2989c7e  
    221221        lib/draw \
    222222        lib/math \
     223        lib/nettl \
    223224        lib/nic \
    224225        lib/ext4 \
  • uspace/Makefile.common

    r58e9dec r2989c7e  
    155155LIBMBR_PREFIX = $(LIB_PREFIX)/mbr
    156156LIBGPT_PREFIX = $(LIB_PREFIX)/gpt
     157LIBNETTL_PREFIX = $(LIB_PREFIX)/nettl
    157158
    158159LIBURCU_PREFIX = $(LIB_PREFIX)/urcu
  • uspace/lib/nettl/include/nettl/portrng.h

    r58e9dec r2989c7e  
    2727 */
    2828
    29 /** @addtogroup udp
     29/** @addtogroup libnettl
    3030 * @{
    3131 */
    32 /** @file UDP user calls
     32/**
     33 * @file Port range allocator.
    3334 */
    3435
    35 #ifndef UCALL_H
    36 #define UCALL_H
     36#ifndef LIBNETTL_PORTRNG_H_
     37#define LIBNETTL_PORTRNG_H_
    3738
    38 #include <ipc/loc.h>
    39 #include <sys/types.h>
    40 #include "udp_type.h"
     39#include <stdint.h>
    4140
    42 extern udp_error_t udp_uc_create(udp_assoc_t **);
    43 extern void udp_uc_set_iplink(udp_assoc_t *, service_id_t);
    44 extern udp_error_t udp_uc_set_remote(udp_assoc_t *, inet_ep_t *);
    45 extern udp_error_t udp_uc_set_local(udp_assoc_t *, inet_ep_t *);
    46 extern udp_error_t udp_uc_set_local_port(udp_assoc_t *, uint16_t);
    47 extern udp_error_t udp_uc_send(udp_assoc_t *, inet_ep_t *, void *, size_t,
    48     xflags_t);
    49 extern udp_error_t udp_uc_receive(udp_assoc_t *, void *, size_t, size_t *,
    50     xflags_t *, inet_ep_t *);
    51 extern void udp_uc_status(udp_assoc_t *, udp_assoc_status_t *);
    52 extern void udp_uc_destroy(udp_assoc_t *);
    53 extern void udp_uc_reset(udp_assoc_t *);
     41typedef struct {
     42} portrng_t;
     43
     44typedef enum {
     45        pf_allow_system = 0x1
     46} portrng_flags_t;
     47
     48extern int portrng_create(portrng_t **);
     49extern void portrng_destroy(portrng_t *);
     50extern int portrng_alloc_specific(portrng_t *, uint16_t, void *,
     51    portrng_flags_t);
     52extern int portrng_alloc_dynamic(portrng_t *, void *, uint16_t *);
     53extern void portrng_free_port(portrng_t *, uint16_t);
    5454
    5555#endif
  • uspace/srv/net/tcp/Makefile

    r58e9dec r2989c7e  
    2828
    2929USPACE_PREFIX = ../../..
     30
     31LIBS = \
     32        $(LIBNETTL_PREFIX)/libnettl.a
     33
     34EXTRA_CFLAGS += \
     35        -I$(LIBNETTL_PREFIX)/include
     36
    3037BINARY = tcp
    3138
  • uspace/srv/net/tcp/conn.c

    r58e9dec r2989c7e  
    3636
    3737#include <adt/list.h>
    38 #include <stdbool.h>
    3938#include <errno.h>
    4039#include <inet/endpoint.h>
    4140#include <io/log.h>
    4241#include <macros.h>
     42#include <nettl/amap.h>
     43#include <stdbool.h>
    4344#include <stdlib.h>
    4445#include "conn.h"
     
    5657#define TIME_WAIT_TIMEOUT       (2*MAX_SEGMENT_LIFETIME)
    5758
    58 LIST_INITIALIZE(conn_list);
    59 FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
     59static LIST_INITIALIZE(conn_list);
     60static FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
     61static amap_t *amap;
    6062
    6163static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg);
    6264static void tcp_conn_tw_timer_set(tcp_conn_t *conn);
    6365static void tcp_conn_tw_timer_clear(tcp_conn_t *conn);
     66
     67/** Initialize connections. */
     68int tcp_conns_init(void)
     69{
     70        int rc;
     71
     72        rc = amap_create(&amap);
     73        if (rc != EOK) {
     74                assert(rc == ENOMEM);
     75                return ENOMEM;
     76        }
     77
     78        return EOK;
     79}
    6480
    6581/** Create new connection structure.
     
    246262 * Add connection to the connection map.
    247263 */
    248 void tcp_conn_add(tcp_conn_t *conn)
    249 {
     264int tcp_conn_add(tcp_conn_t *conn)
     265{
     266        inet_ep2_t aepp;
     267        int rc;
     268
    250269        tcp_conn_addref(conn);
    251270        fibril_mutex_lock(&conn_list_lock);
     271
     272        rc = amap_insert(amap, &conn->ident, conn, af_allow_system, &aepp);
     273        if (rc != EOK) {
     274                tcp_conn_delref(conn);
     275                fibril_mutex_unlock(&conn_list_lock);
     276                return rc;
     277        }
     278
     279        conn->ident = aepp;
    252280        list_append(&conn->link, &conn_list);
    253281        fibril_mutex_unlock(&conn_list_lock);
     282
     283        return EOK;
    254284}
    255285
     
    261291{
    262292        fibril_mutex_lock(&conn_list_lock);
     293        amap_remove(amap, &conn->ident);
    263294        list_remove(&conn->link);
    264295        fibril_mutex_unlock(&conn_list_lock);
  • uspace/srv/net/tcp/conn.h

    r58e9dec r2989c7e  
    4040#include "tcp_type.h"
    4141
     42extern int tcp_conns_init(void);
    4243extern tcp_conn_t *tcp_conn_new(inet_ep2_t *);
    4344extern void tcp_conn_delete(tcp_conn_t *);
    44 extern void tcp_conn_add(tcp_conn_t *);
     45extern int tcp_conn_add(tcp_conn_t *);
    4546extern void tcp_conn_remove(tcp_conn_t *);
    4647extern void tcp_conn_reset(tcp_conn_t *conn);
  • uspace/srv/net/tcp/service.c

    r58e9dec r2989c7e  
    335335        tcp_conn_t *conn;
    336336        tcp_cconn_t *cconn;
    337         inet_ep2_t cepp;
    338337        int rc;
    339338        tcp_error_t trc;
     
    343342        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl");
    344343
    345         cepp = *epp;
    346 
    347         /* Fill in local address? */
    348         if (inet_addr_is_any(&epp->local.addr)) {
    349                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl: "
    350                     "determine local address");
    351                 rc = inet_get_srcaddr(&epp->remote.addr, 0, &cepp.local.addr);
    352                 if (rc != EOK) {
    353                         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl: "
    354                             "cannot determine local address");
    355                         return rc;
    356                 }
    357         } else {
    358                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl: "
    359                     "local address specified");
    360         }
    361 
    362         /* Allocate local port? */
    363         if (cepp.local.port == 0) {
    364                 cepp.local.port = 49152; /* XXX */
    365                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl: "
    366                     "allocated local port %" PRIu16, cepp.local.port);
    367         } else {
    368                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl: "
    369                     "local port %" PRIu16 " specified", cepp.local.port);
    370         }
    371 
    372         inet_addr_format(&cepp.local.addr, &slocal);
    373         inet_addr_format(&cepp.remote.addr, &sremote);
     344        inet_addr_format(&epp->local.addr, &slocal);
     345        inet_addr_format(&epp->remote.addr, &sremote);
    374346        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create: local=%s remote=%s",
    375347            slocal, sremote);
     
    377349        free(sremote);
    378350
    379         trc = tcp_uc_open(&cepp, ap_active, tcp_open_nonblock, &conn);
     351        trc = tcp_uc_open(epp, ap_active, tcp_open_nonblock, &conn);
    380352        if (trc != TCP_EOK)
    381353                return EIO;
  • uspace/srv/net/tcp/tcp.c

    r58e9dec r2989c7e  
    4545#include <task.h>
    4646
     47#include "conn.h"
    4748#include "ncsim.h"
    4849#include "pdu.h"
     
    179180        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()");
    180181
     182        rc = tcp_conns_init();
     183        if (rc != EOK) {
     184                assert(rc == ENOMEM);
     185                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing connections");
     186                return ENOMEM;
     187        }
     188
    181189        tcp_rqueue_init();
    182190        tcp_rqueue_fibril_start();
  • uspace/srv/net/tcp/ucall.c

    r58e9dec r2989c7e  
    3535 */
    3636
     37#include <errno.h>
    3738#include <fibril_synch.h>
    3839#include <io/log.h>
     
    6869{
    6970        tcp_conn_t *nconn;
     71        int rc;
    7072
    7173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %s, %s, %p)",
     
    7476
    7577        nconn = tcp_conn_new(epp);
    76         tcp_conn_add(nconn);
     78        rc = tcp_conn_add(nconn);
     79        if (rc != EOK) {
     80                tcp_conn_delete(nconn);
     81                return TCP_EEXISTS;
     82        }
     83
    7784        tcp_conn_lock(nconn);
    7885
  • uspace/srv/net/udp/Makefile

    r58e9dec r2989c7e  
    2828
    2929USPACE_PREFIX = ../../..
     30
     31LIBS = \
     32        $(LIBNETTL_PREFIX)/libnettl.a
     33
     34EXTRA_CFLAGS += \
     35        -I$(LIBNETTL_PREFIX)/include
     36
    3037BINARY = udp
    3138
     
    3542        pdu.c \
    3643        service.c \
    37         ucall.c \
    3844        udp.c \
    3945        udp_inet.c
  • uspace/srv/net/udp/assoc.c

    r58e9dec r2989c7e  
    4141#include <inet/endpoint.h>
    4242#include <io/log.h>
     43#include <nettl/amap.h>
    4344#include <stdlib.h>
    4445
     
    4647#include "msg.h"
    4748#include "pdu.h"
    48 #include "ucall.h"
    4949#include "udp_inet.h"
    5050#include "udp_type.h"
    5151
    52 LIST_INITIALIZE(assoc_list);
    53 FIBRIL_MUTEX_INITIALIZE(assoc_list_lock);
     52static LIST_INITIALIZE(assoc_list);
     53static FIBRIL_MUTEX_INITIALIZE(assoc_list_lock);
     54static amap_t *amap;
    5455
    5556static udp_assoc_t *udp_assoc_find_ref(inet_ep2_t *);
     
    5758static bool udp_ep_match(inet_ep_t *, inet_ep_t *);
    5859static bool udp_ep2_match(inet_ep2_t *, inet_ep2_t *);
     60
     61/** Initialize associations. */
     62int udp_assocs_init(void)
     63{
     64        int rc;
     65
     66        rc = amap_create(&amap);
     67        if (rc != EOK) {
     68                assert(rc == ENOMEM);
     69                return ENOMEM;
     70        }
     71
     72        return EOK;
     73}
    5974
    6075/** Create new association structure.
     
    168183 * Add association to the association map.
    169184 */
    170 void udp_assoc_add(udp_assoc_t *assoc)
    171 {
     185int udp_assoc_add(udp_assoc_t *assoc)
     186{
     187        inet_ep2_t aepp;
     188        int rc;
     189
    172190        udp_assoc_addref(assoc);
    173191        fibril_mutex_lock(&assoc_list_lock);
     192
     193        rc = amap_insert(amap, &assoc->ident, assoc, af_allow_system, &aepp);
     194        if (rc != EOK) {
     195                udp_assoc_delref(assoc);
     196                fibril_mutex_unlock(&assoc_list_lock);
     197                return rc;
     198        }
     199
     200        assoc->ident = aepp;
    174201        list_append(&assoc->link, &assoc_list);
    175202        fibril_mutex_unlock(&assoc_list_lock);
     203
     204        return EOK;
    176205}
    177206
     
    183212{
    184213        fibril_mutex_lock(&assoc_list_lock);
     214        amap_remove(amap, &assoc->ident);
    185215        list_remove(&assoc->link);
    186216        fibril_mutex_unlock(&assoc_list_lock);
     
    199229        fibril_mutex_lock(&assoc->lock);
    200230        assoc->ident.local_link = iplink;
    201         fibril_mutex_unlock(&assoc->lock);
    202 }
    203 
    204 /** Set remote endpoint in association.
    205  *
    206  * @param assoc         Association
    207  * @param remote        Remote endpoint (deeply copied)
    208  */
    209 void udp_assoc_set_remote(udp_assoc_t *assoc, inet_ep_t *remote)
    210 {
    211         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_remote(%p, %p)", assoc, remote);
    212         fibril_mutex_lock(&assoc->lock);
    213         assoc->ident.remote = *remote;
    214         fibril_mutex_unlock(&assoc->lock);
    215 }
    216 
    217 /** Set local endpoint in association.
    218  *
    219  * @param assoc Association
    220  * @param local Local endpoint (deeply copied)
    221  *
    222  */
    223 void udp_assoc_set_local(udp_assoc_t *assoc, inet_ep_t *local)
    224 {
    225         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, local);
    226         fibril_mutex_lock(&assoc->lock);
    227         assoc->ident.local = *local;
    228         fibril_mutex_unlock(&assoc->lock);
    229 }
    230 
    231 /** Set local port in association.
    232  *
    233  * @param assoc Association
    234  * @param lport Local port
    235  *
    236  */
    237 void udp_assoc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
    238 {
    239         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %" PRIu16 ")", assoc, lport);
    240         fibril_mutex_lock(&assoc->lock);
    241         assoc->ident.local.port = lport;
    242231        fibril_mutex_unlock(&assoc->lock);
    243232}
  • uspace/srv/net/udp/assoc.h

    r58e9dec r2989c7e  
    4141#include "udp_type.h"
    4242
     43extern int udp_assocs_init(void);
    4344extern udp_assoc_t *udp_assoc_new(inet_ep2_t *, udp_assoc_cb_t *, void *);
    4445extern void udp_assoc_delete(udp_assoc_t *);
    45 extern void udp_assoc_add(udp_assoc_t *);
     46extern int udp_assoc_add(udp_assoc_t *);
    4647extern void udp_assoc_remove(udp_assoc_t *);
    4748extern void udp_assoc_addref(udp_assoc_t *);
    4849extern void udp_assoc_delref(udp_assoc_t *);
    4950extern void udp_assoc_set_iplink(udp_assoc_t *, service_id_t);
    50 extern void udp_assoc_set_remote(udp_assoc_t *, inet_ep_t *);
    51 extern void udp_assoc_set_local(udp_assoc_t *, inet_ep_t *);
    52 extern void udp_assoc_set_local_port(udp_assoc_t *, uint16_t);
    5351extern int udp_assoc_send(udp_assoc_t *, inet_ep_t *, udp_msg_t *);
    5452extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, inet_ep_t *);
  • uspace/srv/net/udp/service.c

    r58e9dec r2989c7e  
    178178        assoc->cb_arg = cassoc;
    179179
    180         udp_assoc_add(assoc);
     180        rc = udp_assoc_add(assoc);
     181        if (rc != EOK) {
     182                udp_cassoc_destroy(cassoc);
     183                udp_assoc_delete(assoc);
     184                return rc;
     185        }
    181186
    182187        *rassoc_id = cassoc->id;
  • uspace/srv/net/udp/udp.c

    r58e9dec r2989c7e  
    4141#include <task.h>
    4242
     43#include "assoc.h"
    4344#include "service.h"
    4445#include "udp_inet.h"
     
    5152
    5253        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_init()");
     54
     55        rc = udp_assocs_init();
     56        if (rc != EOK) {
     57                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing associations.");
     58                return ENOMEM;
     59        }
    5360
    5461        rc = udp_inet_init();
Note: See TracChangeset for help on using the changeset viewer.