tftpclient: converting to net sockets
authorAdam Turowski <adam.turowski@inf.ethz.ch>
Thu, 6 Jul 2017 09:20:28 +0000 (11:20 +0200)
committerAdam Turowski <adam.turowski@inf.ethz.ch>
Thu, 6 Jul 2017 09:20:28 +0000 (11:20 +0200)
net_sockets: adding local/remote addresses/ports to the net_socket structure
net,dhcp: adding a possibility of setting of static IP

Signed-off-by: Adam Turowski <adam.turowski@inf.ethz.ch>

20 files changed:
if/net_sockets.if
include/lwip2/lwipopts.h
include/net/dhcp.h
include/net/net.h
include/net_sockets/net_sockets.h
include/net_sockets/net_sockets_types.h
lib/net/dhcp.c
lib/net/net.c
lib/net/netbufs.c
lib/net/netif.c
lib/net/networking_internal.h
lib/net_sockets/net_sockets.c
lib/tftp/Hakefile
lib/tftp/client.c
lib/tftp/common.c
lib/tftp/tftp_internal.h
tools/harness/tests/webserver.py
usr/drivers/net_socket_server/e1000_net_sockets_server.c
usr/tests/net_tests/nfs_throughput/nfs_cat.c
usr/webserver/http_server.c

index 19ac47f..4bfffb5 100644 (file)
@@ -14,11 +14,11 @@ interface net_sockets "Interface for network sockets" {
     rpc new_tcp_socket(out uint32 descriptor);
     rpc delete_socket(in uint32 descriptor, out errval error);
 
-    rpc bind(in uint32 descriptor, in uint32 host_address, in uint16 port, out errval error);
+    rpc bind(in uint32 descriptor, in uint32 host_address, in uint16 port, out errval error, out uint16 bound_port);
     rpc listen(in uint32 descriptor, in uint8 backlog, out errval error);
 
     rpc connect(in uint32 descriptor, in uint32 host_address, in uint16 port, out errval error);
-    message connected(uint32 descriptor, errval error);
+    message connected(uint32 descriptor, errval error, uint32 connected_address, uint16 connected_port);
 
 //    message accepted(uint32 descriptor, uint32 new_descriptor, uint32 host_address, uint16 port, errval error);
 };
index 6c867b9..86027a0 100644 (file)
@@ -444,7 +444,7 @@ struct netif *arp_filter_netif(struct pbuf *p, struct netif *netif, uint16_t typ
 */
 
 #define LWIP_NOASSERT 1
-#define LWIP_DEBUG 1
+//#define LWIP_DEBUG 0
 #define TAPIF_DEBUG      LWIP_DBG_OFF
 #define TUNIF_DEBUG      LWIP_DBG_OFF
 #define UNIXIF_DEBUG     LWIP_DBG_OFF
@@ -462,7 +462,7 @@ struct netif *arp_filter_netif(struct pbuf *p, struct netif *netif, uint16_t typ
 #define IP_REASS_DEBUG   LWIP_DBG_OFF
 #define RAW_DEBUG        LWIP_DBG_OFF
 #define ICMP_DEBUG       LWIP_DBG_OFF
-#define UDP_DEBUG        (LWIP_DBG_ON | LWIP_DBG_TYPES_ON | LWIP_DBG_MIN_LEVEL)
+#define UDP_DEBUG        LWIP_DBG_OFF
 #define TCP_DEBUG        LWIP_DBG_OFF
 #define TCP_INPUT_DEBUG  LWIP_DBG_OFF
 #define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
index f1f6d16..6a3822a 100644 (file)
 #include <net/net.h>
 #include <lwip/ip_addr.h>
 
+#define NET_CONFIG_IP_RECORD_FIELDS "{ ip: %d, gw: %d, netmask: %d }"
+#define NET_CONFIG_CURRENT_IP_RECORD_FORMAT "net.ipconfig " NET_CONFIG_IP_RECORD_FIELDS
+#define NET_CONFIG_CURRENT_IP_RECORD_REGEX "net.ipconfig  {ip: _,  gw: _, netmask: _}"
+#define NET_CONFIG_STATIC_IP_RECORD_FORMAT "net.static_ip " NET_CONFIG_IP_RECORD_FIELDS
+#define NET_CONFIG_STATIC_IP_RECORD_REGEX "net.static_ip  {ip: _,  gw: _, netmask: _}"
+
 /**
  * @brief starts the dhcpd service on the interface
  *
@@ -38,13 +44,23 @@ errval_t dhcpd_stop(void);
 /* functions for querying the current settings */
 
 /**
- * @brief queries the DHCPD settings of the machine
+ * @brief queries the current ip setting of the machine
+ *
+ * @param flags flags to provide
+ *
+ * @return SYS_ERR_OK on success, errval on failure
+ */
+errval_t net_config_current_ip_query(net_flags_t flags);
+
+
+/**
+ * @brief queries the static ip setting of the machine
  *
  * @param flags flags to provide
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-errval_t dhcpd_query(net_flags_t flags);
+errval_t net_config_static_ip_query(net_flags_t flags);
 
 
 /**
@@ -56,7 +72,7 @@ errval_t dhcpd_query(net_flags_t flags);
  *
  * @return
  */
-errval_t dhcpd_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm);
+errval_t netif_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm);
 
 /**
  * @brief sets the IP configuration
@@ -67,6 +83,6 @@ errval_t dhcpd_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_ad
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-errval_t dhcpd_set_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm);
+errval_t netif_set_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm);
 
 #endif /* LIB_NET_INCLUDE_NETWORKING_DHCP_H_ */
index 6e68f4f..b4fb4a8 100644 (file)
@@ -43,6 +43,9 @@ struct eth_addr;
 ///< initalize with default queue
 #define NET_FLAGS_DEFAULT_QUEUE          (1 << 3)
 
+///< do not initalize the net filter
+#define NET_FLAGS_NO_NET_FILTER          (1 << 4)
+
 ///< networking flags
 typedef uint32_t net_flags_t;
 
index 1976f6a..91cf541 100644 (file)
@@ -13,6 +13,12 @@ struct net_socket {
     net_connected_callback_t connected;
     net_accepted_callback_t accepted;
     void *user_state;
+
+    struct in_addr bound_address;
+    uint16_t bound_port;
+    struct in_addr connected_address;
+    uint16_t connected_port;
+
     struct net_socket *prev, *next;
 };
 
index b64c0b7..99168a3 100644 (file)
@@ -9,7 +9,7 @@ struct net_socket;
 typedef void (*net_received_callback_t)(void *user_state, struct net_socket *socket, void *data, size_t size, struct in_addr ip_address, uint16_t port);
 typedef void (*net_sent_callback_t)(void *user_state, struct net_socket *socket, void *data, size_t size);
 typedef void (*net_connected_callback_t)(void *user_state, struct net_socket *socket);
-typedef void (*net_accepted_callback_t)(void *user_state, struct net_socket *accepted_socket, struct in_addr ip_address, uint16_t port);
+typedef void (*net_accepted_callback_t)(void *user_state, struct net_socket *accepted_socket);
 
 struct net_buffer {
     uint32_t size;
index 068e60f..cf56472 100644 (file)
 // lwip includes
 #include <lwip/ip.h>
 #include <lwip/dhcp.h>
+#include <lwip/prot/dhcp.h>
 #include <lwip/timeouts.h>
 
 #include <octopus/octopus.h>
 #include <octopus_server/service.h>
-#include <octopus/trigger.h>
 
 #include <net_interfaces/flags.h>
 #include "networking_internal.h"
 ///< the DHCP timeout in milli seconds
 #define DHCP_TIMEOUT_MSECS (120UL * 1000)
 
-#define DHCP_RECORD_FIELDS "{ ip: %d, gw: %d, netmask: %d }"
-
-
-#define DHCP_RECORD_FORMAT "net.ipconfig " DHCP_RECORD_FIELDS
-
-#define DHCP_RECORD_REGEX "net.ipconfig  {ip: _,  gw: _, netmask: _}"
-
 
 static void dhcpd_timer_callback(void *data)
 {
-    errval_t err;
-
     struct net_state *st = data;
 
     dhcp_fine_tmr();
-
     if ((st->dhcp_ticks % (DHCP_COARSE_TIMER_MSECS / DHCP_FINE_TIMER_MSECS)) == 0) {
         dhcp_coarse_tmr();
     }
-
-    if (!ip_addr_cmp(&st->netif.ip_addr, IP_ADDR_ANY) && st->dhcp_done == 0) {
-
-        NETDEBUG("setting system DHCP record to IP: %s\n",
-                ip4addr_ntoa(netif_ip4_addr(&st->netif)));
-
-        /* register IP with octopus */
-        err = oct_set(DHCP_RECORD_FORMAT, netif_ip4_addr(&st->netif)->addr,
-                      netif_ip4_gw(&st->netif)->addr,
-                      netif_ip4_netmask(&st->netif)->addr);
-        if (err_is_fail(err)) {
-            DEBUG_ERR(err, "failed to set the DHCP record\n");
-        }
-        st->dhcp_done = 1;
-    }
-
     st->dhcp_ticks++;
 }
 
@@ -129,7 +103,7 @@ errval_t dhcpd_start(net_flags_t flags)
 
     if (flags & NET_FLAGS_BLOCKING_INIT) {
         printf("waiting for DHCP to complete \n");
-        while(!dhcpd_has_ip()) {
+        while (!dhcpd_has_ip()) {
             networking_poll();
             if (st->dhcp_ticks > DHCP_TIMEOUT_MSECS / DHCP_FINE_TIMER_MSECS) {
                 dhcpd_stop();
@@ -161,62 +135,68 @@ errval_t dhcpd_stop(void)
 }
 
 
-/* functions for querying the current settings */
-
-
-static void dhcpd_change_event(octopus_mode_t mode, const char* record, void* arg)
+/**
+ * @brief queries the current ip setting of the machine
+ *
+ * @return SYS_ERR_OK on success, errval on failure
+ */
+errval_t net_config_current_ip_query(net_flags_t flags)
 {
     errval_t err;
 
-    struct net_state *st = arg;
-
-    debug_printf("DHCP change event: %s\n", record);
+    NETDEBUG("query current IP...\n");
 
-    if (mode & OCT_ON_SET) {
+    // initialize octopus if not already done
+    err = oct_init();
+    if (err_is_fail(err)) {
+        return err;
+    }
 
-        uint64_t ip, nm, gw;
-        err = oct_read(record, "_" DHCP_RECORD_FIELDS, &ip, &gw, &nm);
+    char* record = NULL;
+    err = oct_get(&record, "net.current_ip");
+    if (err_no(err) == OCT_ERR_NO_RECORD && (flags & NET_FLAGS_BLOCKING_INIT)) {
+        printf("waiting for DHCP to complete");
+        err = oct_wait_for(&record, NET_CONFIG_CURRENT_IP_RECORD_REGEX);
         if (err_is_fail(err)) {
-            DEBUG_ERR(err, "cannot read DHCPD record '%s\n", record);
-            return;
+            return err;
         }
+    } else if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cannot get static ip record\n");
+        return err;
+    }
 
-        struct in_addr ipaddr, netmask, gateway;
-        ipaddr.s_addr = (uint32_t)ip;
-        netmask.s_addr = (uint32_t)nm;
-        gateway.s_addr = (uint32_t)gw;
-
-        debug_printf("DHCP got ip set: %s\n", inet_ntoa(ipaddr));
-        debug_printf("DHCP got gw set: %s\n", inet_ntoa(gateway));
-        debug_printf("DHCP got nm set: %s\n", inet_ntoa(netmask));
-
-        ip_addr_t _ipaddr, _netmask, _gateway;
-        _ipaddr.addr = ipaddr.s_addr;
-        _netmask.addr = netmask.s_addr;
-        _gateway.addr = gateway.s_addr;
-        netif_set_addr(&st->netif, &_ipaddr, &_netmask, &_gateway);
-        netif_set_up(&st->netif);
-
-        st->dhcp_done = true;
+    uint64_t ip, nm, gw;
+    err = oct_read(record, "_" NET_CONFIG_IP_RECORD_FIELDS, &ip, &gw, &nm);
+    if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cannot read current ip record '%s\n", record);
+        free(record);
+        return err;
     }
+    free(record);
 
-    if (mode & OCT_ON_DEL) {
+    struct in_addr ipaddr, netmask, gateway;
+    ipaddr.s_addr = (uint32_t)ip;
+    netmask.s_addr = (uint32_t)nm;
+    gateway.s_addr = (uint32_t)gw;
 
-        /* DHCP has been removed */
-        netif_set_down(&st->netif);
-    }
+    debug_printf("Got current IP set: %s\n", inet_ntoa(ipaddr));
+    debug_printf("Got current GW set: %s\n", inet_ntoa(gateway));
+    debug_printf("Got current NM set: %s\n", inet_ntoa(netmask));
+
+    return SYS_ERR_OK;
 }
 
+
 /**
- * @brief queries the DHCPD settings of the machine
+ * @brief queries the static ip setting of the machine and sets it
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-errval_t dhcpd_query(net_flags_t flags)
+errval_t net_config_static_ip_query(net_flags_t flags)
 {
     errval_t err;
 
-    NETDEBUG("query DHCPD for IP...\n");
+    NETDEBUG("query static IP...\n");
 
     // initialize octopus if not already done
     err = oct_init();
@@ -227,20 +207,35 @@ errval_t dhcpd_query(net_flags_t flags)
     struct net_state *st = get_default_net_state();
     assert(st);
 
-    st->dhcp_ticks = 1;
-    st->dhcp_running = 1;
+    char* record = NULL;
+    err = oct_get(&record, "net.static_ip");
+    if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cannot get static ip record\n");
+        return err;
+    }
 
-    err = oct_trigger_existing_and_watch(DHCP_RECORD_REGEX, dhcpd_change_event,
-                                         st, &st->dhcp_triggerid);
+    uint64_t ip, nm, gw;
+    err = oct_read(record, "_" NET_CONFIG_IP_RECORD_FIELDS, &ip, &gw, &nm);
     if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cannot read static ip record '%s\n", record);
+        free(record);
         return err;
     }
+    free(record);
 
-    if (flags & NET_FLAGS_BLOCKING_INIT) {
-        printf("waiting for DHCP to complete");
-        while(!dhcpd_has_ip()) {
-            event_dispatch(get_default_waitset());
-        }
+    struct in_addr ipaddr, netmask, gateway;
+    ipaddr.s_addr = (uint32_t)ip;
+    netmask.s_addr = (uint32_t)nm;
+    gateway.s_addr = (uint32_t)gw;
+
+    debug_printf("Got static IP set: %s\n", inet_ntoa(ipaddr));
+    debug_printf("Got static GW set: %s\n", inet_ntoa(gateway));
+    debug_printf("Got static NM set: %s\n", inet_ntoa(netmask));
+
+    err = netif_set_ipconfig(&ipaddr, &gateway, &netmask);
+    if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cannot set static ip\n");
+        return err;
     }
 
     return SYS_ERR_OK;
@@ -256,7 +251,7 @@ errval_t dhcpd_query(net_flags_t flags)
  *
  * @return
  */
-errval_t dhcpd_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm)
+errval_t netif_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm)
 {
     struct net_state *st = get_default_net_state();
     if (ip) {
@@ -275,7 +270,7 @@ errval_t dhcpd_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_ad
 }
 
 /**
- * @brief sets the IP configuration
+ * @brief sets the IP configuration, overrides DHCP
  *
  * @param ip    the IP address
  * @param gw    the Gateway
@@ -283,17 +278,13 @@ errval_t dhcpd_get_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_ad
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-errval_t dhcpd_set_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm)
+errval_t netif_set_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_addr *nm)
 {
     errval_t err;
     struct net_state *st = get_default_net_state();
 
-    if (st->dhcp_running == 1) {
-        if (st->dhcp_triggerid) {
-            err = oct_remove_trigger(st->dhcp_triggerid);
-        } else {
-            err = dhcpd_stop();
-        }
+    if (st->dhcp_running == 1) { // stop dhcp, if it's running
+        err = dhcpd_stop();
         if (err_is_fail(err)) {
             return err;
         }
@@ -306,7 +297,5 @@ errval_t dhcpd_set_ipconfig(struct in_addr *ip, struct in_addr *gw, struct in_ad
     netif_set_addr(&st->netif, &_ipaddr, &_netmask, &_gateway);
     netif_set_up(&st->netif);
 
-    st->dhcp_done = true;
-
     return SYS_ERR_OK;
 }
index 6f22689..d3ae9a6 100644 (file)
@@ -214,7 +214,7 @@ static errval_t networking_poll_st(struct net_state *st)
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-static errval_t networking_init_with_queue_st(struct net_state *st,struct devq *q,
+static errval_t networking_init_with_queue_st(struct net_state *st, struct devq *q,
                                               net_flags_t flags)
 {
     errval_t err;
@@ -260,16 +260,17 @@ static errval_t networking_init_with_queue_st(struct net_state *st,struct devq *
         goto out_err1;
     }
 
+    if (!(flags & NET_FLAGS_NO_NET_FILTER)) {
+        NETDEBUG("initializing hw filter...\n");
 
-    NETDEBUG("initializing hw filter...\n");
-
-    // err = net_filter_init(&st->filter, st->cardname);
-    // if (err_is_fail(err)) {
-    //     USER_PANIC("Init filter infrastructure failed: %s \n", err_getstring(err));
-    // }
+        err = net_filter_init(&st->filter, st->cardname);
+        if (err_is_fail(err)) {
+            USER_PANIC("Init filter infrastructure failed: %s \n", err_getstring(err));
+        }
+    }
 
     NETDEBUG("setting default netif...\n");
-   // netif_set_default(&st->netif);
+    netif_set_default(&st->netif);
 
     NETDEBUG("adding RX buffers\n");
     for (int i = 0; i < NETWORKING_BUFFER_RX_POPULATE; i++) {
@@ -295,10 +296,10 @@ static errval_t networking_init_with_queue_st(struct net_state *st,struct devq *
             DEBUG_ERR(err,  "failed to start the ARP service\n");
         }
     } else {
-        /* get IP from dhcpd */
-        err = dhcpd_query(flags);
+        /* get static IP config */
+        err = net_config_static_ip_query(flags);
         if (err_is_fail(err)) {
-            DEBUG_ERR(err, "failed to start DHCP.\n");
+            DEBUG_ERR(err, "failed to set IP.\n");
         }
 
         err = arp_service_subscribe();
@@ -467,7 +468,7 @@ errval_t networking_install_ip_filter(bool tcp, struct in_addr *src,
 
     // get current config
     struct in_addr dst_ip;
-    err = dhcpd_get_ipconfig(&dst_ip, NULL, NULL);
+    err = netif_get_ipconfig(&dst_ip, NULL, NULL);
     if (err_is_fail(err)) {
         return err;
     }
@@ -512,7 +513,7 @@ errval_t networking_remove_ip_filter(bool tcp, struct in_addr *src,
 
     // get current config
     struct in_addr dst_ip;
-    err = dhcpd_get_ipconfig(&dst_ip, NULL, NULL);
+    err = netif_get_ipconfig(&dst_ip, NULL, NULL);
     if (err_is_fail(err)) {
         return err;
     }
index 1210ac9..c2cf3c5 100644 (file)
@@ -255,7 +255,7 @@ void net_buf_free(struct pbuf *p)
     NETDEBUG("pbuf=%p\n", p);
 
     if (p->next) {
-        debug_printf("!!!!!! p->NEXT was not NULL\n");
+        debug_printf("!!!!!! p->NEXT was not NULL (%p)\n", p->next);
     }
 
    // printf("free: %p\n", p);
index 0253f96..565756b 100644 (file)
@@ -15,6 +15,7 @@
 #include <barrelfish/barrelfish.h>
 #include <devif/queue_interface.h>
 #include <net_interfaces/flags.h>
+#include <octopus/octopus.h>
 
 
 #include <lwip/opt.h>
@@ -92,10 +93,7 @@ static err_t net_if_linkoutput(struct netif *netif, struct pbuf *p)
 
 static void net_if_status_cb(struct netif *netif)
 {
-    printf("ip_addr_cmp(&netif->ip_addr, IP_ADDR_ANY)=%u\n",
-            ip_addr_cmp(&netif->ip_addr, IP_ADDR_ANY));
     if (!ip_addr_cmp(&netif->ip_addr, IP_ADDR_ANY)) {
-
         debug_printf("######################################\n");
         debug_printf("# IP Addr %s\n", ip4addr_ntoa(netif_ip4_addr(netif)));
         debug_printf("# GW Addr %s\n", ip4addr_ntoa(netif_ip4_gw(netif)));
@@ -104,6 +102,17 @@ static void net_if_status_cb(struct netif *netif)
 
         netif_set_default(netif);
         printf("setting default interface\n");
+
+        NETDEBUG("setting system ip config record to IP: %s\n",
+                ip4addr_ntoa(netif_ip4_addr(netif)));
+        /* register IP with octopus */
+        errval_t err;
+        err = oct_set(NET_CONFIG_CURRENT_IP_RECORD_FORMAT, netif_ip4_addr(netif)->addr,
+                      netif_ip4_gw(netif)->addr,
+                      netif_ip4_netmask(netif)->addr);
+        if (err_is_fail(err)) {
+            DEBUG_ERR(err, "failed to set the DHCP record\n");
+        }
     }
 }
 
index c8dfe4e..e874882 100644 (file)
@@ -57,7 +57,6 @@ struct net_state {
 
     /* DHCP timer events */
     uint64_t dhcp_ticks;
-    uint64_t dhcp_triggerid;
     struct periodic_event dhcp_timer;
     bool dhcp_done;
     bool dhcp_running;
index bb7302b..546565d 100644 (file)
@@ -5,6 +5,7 @@
 #include <barrelfish/nameservice_client.h>
 #include <if/net_sockets_defs.h>
 #include <net_sockets/net_sockets.h>
+#include <arpa/inet.h>
 
 #include <barrelfish/waitset_chan.h>
 #include <barrelfish/waitset.h>
@@ -62,14 +63,9 @@ static void enqueue(struct net_socket **queue,
     }
 }
 
-struct net_socket * net_udp_socket(void)
+static struct net_socket * allocate_socket(uint32_t descriptor)
 {
-    errval_t err;
     struct net_socket *socket;
-    uint32_t descriptor;
-
-    err = binding->rpc_tx_vtbl.new_udp_socket(binding, &descriptor);
-    assert(err_is_ok(err));
 
     socket = malloc(sizeof(struct net_socket));
     assert(socket);
@@ -79,10 +75,27 @@ struct net_socket * net_udp_socket(void)
     socket->connected = NULL;
     socket->accepted = NULL;
     socket->user_state = NULL;
+    socket->bound_address.s_addr = 0;
+    socket->bound_port = 0;
+    socket->connected_address.s_addr = 0;
+    socket->connected_port = 0;
     enqueue(&sockets, socket);
     return socket;
 }
 
+struct net_socket * net_udp_socket(void)
+{
+    errval_t err;
+    struct net_socket *socket;
+    uint32_t descriptor;
+
+    err = binding->rpc_tx_vtbl.new_udp_socket(binding, &descriptor);
+    assert(err_is_ok(err));
+
+    socket = allocate_socket(descriptor);
+    return socket;
+}
+
 struct net_socket * net_tcp_socket(void)
 {
     errval_t err;
@@ -92,16 +105,7 @@ struct net_socket * net_tcp_socket(void)
     err = binding->rpc_tx_vtbl.new_tcp_socket(binding, &descriptor);
     assert(err_is_ok(err));
 
-    socket = malloc(sizeof(struct net_socket));
-    assert(socket);
-
-    socket->descriptor = descriptor;
-    socket->received = NULL;
-    socket->sent = NULL;
-    socket->connected = NULL;
-    socket->accepted = NULL;
-    socket->user_state = NULL;
-    enqueue(&sockets, socket);
+    socket = allocate_socket(descriptor);
     return socket;
 }
 
@@ -116,7 +120,7 @@ static struct net_socket * get_socket(uint32_t descriptor)
         if (socket == sockets)
             break;
     }
-    debug_printf("%s: %d %p\n", __func__, descriptor, __builtin_return_address(0));
+    debug_printf("%s: socket not found %d %p\n", __func__, descriptor, __builtin_return_address(0));
     assert(0);
     return NULL;
 }
@@ -130,21 +134,24 @@ void net_close(struct net_socket *socket)
 {
     errval_t err, error;
 
-    debug_printf("%s(%d):\n", __func__, socket->descriptor);
+    // debug_printf("%s(%d):\n", __func__, socket->descriptor);
     err = binding->rpc_tx_vtbl.delete_socket(binding, socket->descriptor, &error);
     assert(err_is_ok(err));
     assert(err_is_ok(error));
     dequeue(&sockets, socket);
     free(socket);
-    debug_printf("%s: %ld:%p  %ld:%p\n", __func__, next_free, buffers[next_free], next_used, buffers[next_used]);
+    // debug_printf("%s: %ld:%p  %ld:%p\n", __func__, next_free, buffers[next_free], next_used, buffers[next_used]);
 }
 
 errval_t net_bind(struct net_socket *socket, struct in_addr ip_address, uint16_t port)
 {
     errval_t err, error;
+    uint16_t bound_port;
 
-    err = binding->rpc_tx_vtbl.bind(binding, socket->descriptor, ip_address.s_addr, port, &error);
+    err = binding->rpc_tx_vtbl.bind(binding, socket->descriptor, ip_address.s_addr, port, &error, &bound_port);
     assert(err_is_ok(err));
+    socket->bound_address = ip_address;
+    socket->bound_port = bound_port;
 
     return error;
 }
@@ -235,12 +242,14 @@ errval_t net_connect(struct net_socket *socket, struct in_addr ip_address, uint1
     return error;
 }
 
-static void net_connected(struct net_sockets_binding *b, uint32_t descriptor, errval_t error)
+static void net_connected(struct net_sockets_binding *b, uint32_t descriptor, errval_t error, uint32_t connected_address, uint16_t connected_port)
 {
     struct net_socket *socket = get_socket(descriptor);
     assert(socket->descriptor == descriptor);
     assert(err_is_ok(error));
 
+    socket->connected_address.s_addr = connected_address;
+    socket->connected_port = connected_port;
     assert(socket->connected);
     socket->connected(socket->user_state, socket);
 }
@@ -255,19 +264,10 @@ static void net_accepted(uint32_t descriptor, uint32_t accepted_descriptor, stru
     struct net_socket *socket = get_socket(descriptor);
     assert(socket->descriptor == descriptor);
 
-    struct net_socket *accepted_socket = malloc(sizeof(struct net_socket));
-    assert(accepted_socket);
-
-    accepted_socket->descriptor = accepted_descriptor;
-    accepted_socket->received = NULL;
-    accepted_socket->sent = NULL;
-    accepted_socket->connected = NULL;
-    accepted_socket->accepted = NULL;
-    accepted_socket->user_state = NULL;
-    enqueue(&sockets, accepted_socket);
-
-    assert(socket->accepted);
-    socket->accepted(socket->user_state, accepted_socket, host_address, port);
+    struct net_socket *accepted_socket = allocate_socket(accepted_descriptor);
+    accepted_socket->connected_address = host_address;
+    accepted_socket->connected_port = port;
+    socket->accepted(socket->user_state, accepted_socket);
 }
 
 
@@ -385,7 +385,7 @@ errval_t net_sockets_init(void)
     struct descq_func_pointer f;
     f.notify = q_notify;
 
-    debug_printf("Descriptor queue test started \n");
+    debug_printf("net socket client started \n");
     err = descq_create(&descq_queue, DESCQ_DEFAULT_SIZE, "net_sockets_queue",
                        false, true, true, &queue_id, &f);
     assert(err_is_ok(err));
index 3fdf498..0fcae7e 100644 (file)
@@ -16,7 +16,7 @@
         "client.c", 
         "common.c" 
     ],
-    addLibraries = [ "lwip", "contmng", "net_if_raw"]
+    addLibraries = [ "net_sockets" ]
   },
   build library { 
     target = "tftp_server",
@@ -24,6 +24,6 @@
         "server.c", 
         "common.c" 
     ],
-    addLibraries = [ "lwip", "contmng", "net_if_raw"]
+    addLibraries = [ "net_sockets" ]
   }
 ]
index fb1a8bb..0d05ba7 100644 (file)
@@ -19,8 +19,8 @@
 #include <barrelfish/waitset.h>
 #include <barrelfish/nameservice_client.h>
 
-#include <lwip/udp.h>
-#include <lwip/init.h>
+#include <net_sockets/net_sockets.h>
+#include <arpa/inet.h>
 
 #include <tftp/tftp.h>
 
@@ -43,7 +43,7 @@ struct tftp_client
     tftp_st_t state;
 
     /* connection information */
-    struct ip_addr server_ip;
+    struct in_addr server_ip;
     uint16_t server_port;
     tftp_mode_t mode;
 
@@ -54,39 +54,29 @@ struct tftp_client
     size_t buflen;
 
     /* connection information */
-    struct udp_pcb *pcb;
-    struct pbuf *p;
+    struct net_socket *pcb;
     void *ppayload;
-    struct udp_pcb *rcv_pcb;
 };
 
 
 struct tftp_client tftp_client;
 
 
-static errval_t tftp_client_send_data(struct udp_pcb *pcb, uint32_t blockno, void *buf,
-                                      uint32_t length, struct ip_addr *addr, u16_t port,
-                                      struct pbuf *p)
+static errval_t tftp_client_send_data(struct net_socket *socket, uint32_t blockno, void *buf,
+                                      uint32_t length, struct in_addr addr, uint16_t port)
 {
-    p->len = TFTP_MAX_MSGSIZE;
-    p->tot_len = TFTP_MAX_MSGSIZE;
-    p->payload = tftp_client.ppayload;
+    void *payload = tftp_client.ppayload;
+    errval_t err;
 
-    size_t offset = set_opcode(p->payload, TFTP_OP_DATA);
-    offset += set_block_no(p->payload + offset, blockno);
+    size_t offset = set_opcode(payload, TFTP_OP_DATA);
+    offset += set_block_no(payload + offset, blockno);
     if (length > TFTP_BLOCKSIZE) {
         length = TFTP_BLOCKSIZE;
     }
 
-    memcpy(p->payload + offset, buf, length);
-    p->len = (uint16_t)length + offset;
-    p->tot_len = (uint16_t)length + offset;
-
-    int r = udp_sendto(pcb, p, addr, port);
-    if (r != ERR_OK) {
-        USER_PANIC("send failed");
-    }
-
+    memcpy(payload + offset, buf, length);
+    err = net_send_to(socket, payload, length + offset, addr, port);
+    assert(err_is_ok(err));
     return SYS_ERR_OK;
 }
 
@@ -97,16 +87,15 @@ static errval_t tftp_client_send_data(struct udp_pcb *pcb, uint32_t blockno, voi
  * ------------------------------------------------------------------------------
  */
 
-static void tftp_client_handle_write(struct udp_pcb *pcb, struct pbuf *pbuf,
-                                     struct ip_addr *addr, u16_t port)
+static void tftp_client_handle_write(struct net_socket *socket, void *data,
+    size_t size, struct in_addr ip_address, uint16_t port)
 {
     USER_PANIC("NYI");
-    tpft_op_t op = get_opcode(pbuf->payload);
+    tpft_op_t op = get_opcode(data);
     uint32_t blockno;
     switch(op) {
         case TFTP_OP_ACK :
-            blockno = get_block_no(pbuf->payload, pbuf->len);
-            assert(pbuf->len == pbuf->tot_len);
+            blockno = get_block_no(data, size);
             if (blockno == TFTP_ERR_INVALID_BUFFER) {
                 TFTP_DEBUG("failed to decode block number in data packet\n");
                 break;
@@ -127,8 +116,8 @@ static void tftp_client_handle_write(struct udp_pcb *pcb, struct pbuf *pbuf,
 
                 tftp_client.block++;
 
-                tftp_client_send_data(pcb, tftp_client.block, tftp_client.buf + offset, length,
-                                      addr, port, tftp_client.p);
+                tftp_client_send_data(socket, tftp_client.block, tftp_client.buf + offset, length,
+                                      ip_address, port);
                 tftp_client.state = TFTP_ST_DATA_SENT;
             } else  {
                 TFTP_DEBUG("got double packet: %u\n", blockno);
@@ -142,31 +131,28 @@ static void tftp_client_handle_write(struct udp_pcb *pcb, struct pbuf *pbuf,
             tftp_client.state = TFTP_ST_ERROR;
             break;
     }
-
-    pbuf_free(pbuf);
 }
 
-static void tftp_client_handle_read(struct udp_pcb *pcb, struct pbuf *pbuf,
-                                    struct ip_addr *addr, u16_t port)
+static void tftp_client_handle_read(struct net_socket *socket, void *data,
+    size_t size, struct in_addr ip_address, uint16_t port)
 {
-    tpft_op_t op = get_opcode(pbuf->payload);
+    tpft_op_t op = get_opcode(data);
     uint32_t blockno;
     switch(op) {
         case TFTP_OP_DATA :
-            blockno = get_block_no(pbuf->payload, pbuf->len);
-            assert(pbuf->len == pbuf->tot_len);
+            blockno = get_block_no(data, size);
             if (blockno == TFTP_ERR_INVALID_BUFFER) {
                 TFTP_DEBUG("failed to decode block number in data packet\n");
                 break;
             }
 
             if (blockno == tftp_client.block) {
-                if (pbuf->len < 5) {
+                if (size < 5) {
                     TFTP_DEBUG("too small pbuf lenth\n");
                 }
 
-                void *buf = pbuf->payload + 4;
-                size_t length = pbuf->len - 4;
+                void *buf = data + 4;
+                size_t length = size - 4;
                 TFTP_DEBUG_PACKETS("received block %u of size %lu bytes\n", blockno, length);
 
                 if (tftp_client.buflen < tftp_client.bytes + length) {
@@ -175,9 +161,9 @@ static void tftp_client_handle_read(struct udp_pcb *pcb, struct pbuf *pbuf,
                 }
                 memcpy(tftp_client.buf + tftp_client.bytes, buf, length);
 
-                int r = tftp_send_ack(pcb, blockno, addr, port, tftp_client.p,
+                int r = tftp_send_ack(socket, blockno, ip_address, port,
                                       tftp_client.ppayload);
-                if (r != ERR_OK) {
+                if (r != SYS_ERR_OK) {
                     tftp_client.state = TFTP_ST_ERROR;
                     break;
                 }
@@ -190,9 +176,9 @@ static void tftp_client_handle_read(struct udp_pcb *pcb, struct pbuf *pbuf,
                 }
             } else  {
                 TFTP_DEBUG("got double packet: %u\n", blockno);
-                int r = tftp_send_ack(pcb, blockno, addr, port, tftp_client.p,
+                int r = tftp_send_ack(socket, blockno, ip_address, port,
                                       tftp_client.ppayload);
-                if (r != ERR_OK) {
+                if (r != SYS_ERR_OK) {
                     tftp_client.state = TFTP_ST_ERROR;
                     break;
                 }
@@ -202,7 +188,7 @@ static void tftp_client_handle_read(struct udp_pcb *pcb, struct pbuf *pbuf,
             break;
         case TFTP_OP_ERROR :
             TFTP_DEBUG("got a error packet\n");
-            get_error(pbuf->payload, pbuf->len);
+            get_error(data, size);
             tftp_client.state = TFTP_ST_ERROR;
             break;
         default:
@@ -210,23 +196,21 @@ static void tftp_client_handle_read(struct udp_pcb *pcb, struct pbuf *pbuf,
             TFTP_DEBUG("unexpected packet\n");
             break;
     }
-
-    pbuf_free(pbuf);
 }
 
 
-static void tftp_client_recv_handler(void *arg, struct udp_pcb *pcb, struct pbuf *pbuf,
-                             struct ip_addr *addr, u16_t port)
+static void tftp_client_recv_handler(void *user_state, struct net_socket *socket,
+    void *data, size_t size, struct in_addr ip_address, uint16_t port)
 {
     switch(tftp_client.state) {
         case TFTP_ST_WRITE_REQ_SENT:
         case TFTP_ST_DATA_SENT :
         case TFTP_ST_LAST_DATA_SENT :
-            tftp_client_handle_write(pcb, pbuf, addr, port);
+            tftp_client_handle_write(socket, data, size, ip_address, port);
             break;
         case TFTP_ST_READ_REQ_SENT :
         case TFTP_ST_ACK_SENT :
-            tftp_client_handle_read(pcb, pbuf, addr, port);
+            tftp_client_handle_read(socket, data, size, ip_address, port);
             break;
         default:
             TFTP_DEBUG("unexpected state: %u\n", tftp_client.state);
@@ -239,29 +223,20 @@ static void new_request(char *path, tpft_op_t opcode)
     size_t path_length = strlen(path);
     assert(strlen(path) + 14 < TFTP_MAX_MSGSIZE);
 
-    struct pbuf *p = tftp_client.p;
-    assert(p);
-
-    p->len = TFTP_MAX_MSGSIZE;
-    p->tot_len = TFTP_MAX_MSGSIZE;
-    p->payload = tftp_client.ppayload;
-
-    memset(p->payload, 0, path_length + 16);
+    void *payload = tftp_client.ppayload;
 
-    size_t length = set_opcode(p->payload, opcode);
+    memset(payload, 0, path_length + 16);
 
-    length += snprintf(p->payload + length, path_length + 1, "%s", path) + 1;
-    length += set_mode(p->payload + length, tftp_client.mode);
+    size_t length = set_opcode(payload, opcode);
 
-    p->len = (uint16_t)length;
-    p->tot_len = (uint16_t)length;
+    length += snprintf(payload + length, path_length + 1, "%s", path) + 1;
+    length += set_mode(payload + length, tftp_client.mode);
 
     TFTP_DEBUG("sending udp payload of %lu bytes\n", length);
 
-
-
-    int r = udp_send(tftp_client.pcb, p);
-    if (r != ERR_OK) {
+    errval_t err;
+    err = net_send_to(tftp_client.pcb, payload, length, tftp_client.server_ip, tftp_client.server_port);
+    if (err != SYS_ERR_OK) {
         TFTP_DEBUG("send failed\n");
     }
 }
@@ -342,13 +317,13 @@ errval_t tftp_client_connect(char *ip, uint16_t port)
 {
     switch(tftp_client.state) {
         case TFTP_ST_INVALID :
-            lwip_init_auto();
-            tftp_client.pcb = udp_new();
+            net_sockets_init();
+            tftp_client.pcb = net_udp_socket();
             TFTP_DEBUG("new connection from uninitialized state\n");
             break;
         case TFTP_ST_CLOSED :
             TFTP_DEBUG("new connection from closed state\n");
-            tftp_client.pcb = udp_new();
+            tftp_client.pcb = net_udp_socket();
             break;
         default:
             TFTP_DEBUG("connection already established, cannot connect\n");
@@ -361,50 +336,40 @@ errval_t tftp_client_connect(char *ip, uint16_t port)
 
     tftp_client.server_port = port;
 
-    struct in_addr peer_ip_gen;
-    int ret = inet_aton(ip, &peer_ip_gen);
+    int ret = inet_aton(ip, &tftp_client.server_ip);
     if (ret == 0) {
         TFTP_DEBUG("Invalid IP addr: %s\n", ip);
         return 1;
     }
-    tftp_client.server_ip.addr = peer_ip_gen.s_addr;
 
     TFTP_DEBUG("connecting to %s:%" PRIu16 "\n", ip, port);
-    tftp_client.rcv_pcb = udp_new();
 
-    int r = udp_bind(tftp_client.rcv_pcb, IP_ADDR_ANY, 0);
-    if (r != ERR_OK) {
+    errval_t r;
+    r = net_bind(tftp_client.pcb, (struct in_addr){(INADDR_ANY)}, 0);
+    if (r != SYS_ERR_OK) {
         USER_PANIC("UDP bind failed");
     }
+    debug_printf("bound to %d\n", tftp_client.pcb->bound_port);
 
-    r = udp_connect(tftp_client.pcb, &tftp_client.server_ip, tftp_client.server_port);
-    if (r != ERR_OK) {
-        USER_PANIC("UDP connect failed");
-    }
-    tftp_client.pcb->local_port = tftp_client.rcv_pcb->local_port;
+    // r = net_connect(tftp_client.pcb, tftp_client.server_ip, tftp_client.server_port, NULL);
+    // if (r != SYS_ERR_OK) {
+    //     USER_PANIC("UDP connect failed");
+    // }
 
     TFTP_DEBUG("registering recv handler\n");
-    udp_recv(tftp_client.pcb, tftp_client_recv_handler, NULL);
-    udp_recv(tftp_client.rcv_pcb, tftp_client_recv_handler, NULL);
+    net_recv(tftp_client.pcb, tftp_client_recv_handler);
 
     tftp_client.state = TFTP_ST_IDLE;
     tftp_client.mode = TFTP_MODE_OCTET;
-    tftp_client.p = pbuf_alloc(PBUF_TRANSPORT, TFTP_MAX_MSGSIZE, PBUF_POOL);
-    if (!tftp_client.p) {
-        USER_PANIC("no buffer");
-    }
-    tftp_client.ppayload = tftp_client.p->payload;
+    tftp_client.ppayload = net_alloc(TFTP_MAX_MSGSIZE);
     TFTP_DEBUG("all set up. connection idle\n");
     return SYS_ERR_OK;
 }
 
 errval_t tftp_client_disconnect(void)
 {
-    pbuf_free(tftp_client.p);
-    udp_remove(tftp_client.pcb);
-    udp_remove(tftp_client.rcv_pcb);
+    net_free(tftp_client.ppayload);
+    net_close(tftp_client.pcb);
     tftp_client.state = TFTP_ST_CLOSED;
     return SYS_ERR_OK;
 }
-
-
index 7a3ed73..35d98b3 100644 (file)
@@ -13,7 +13,7 @@
  */
 
 #include <barrelfish/barrelfish.h>
-#include <lwip/udp.h>
+#include <net_sockets/net_sockets.h>
 
 #include <tftp/tftp.h>
 #include "tftp_internal.h"
  * ------------------------------------------------------------------------------
  */
 
-errval_t tftp_send_ack(struct udp_pcb *pcb, uint32_t blockno,
-                       struct ip_addr *addr, u16_t port,
-                       struct pbuf *p, void *payload)
+errval_t tftp_send_ack(struct net_socket *socket, uint32_t blockno,
+                       struct in_addr addr, uint16_t port,
+                       void *payload)
 {
     TFTP_DEBUG_PACKETS("sending ack(%u)\n", blockno);
 
-    p->len = TFTP_MAX_MSGSIZE;
-    p->tot_len = TFTP_MAX_MSGSIZE;
-    p->payload = payload;
+    memset(payload, 0, sizeof(uint32_t) + sizeof(uint16_t));
 
-    memset(p->payload, 0, sizeof(uint32_t) + sizeof(uint16_t));
+    size_t length = set_opcode(payload, TFTP_OP_ACK);
+    length += set_block_no(payload + length, blockno);
 
-    size_t length = set_opcode(p->payload, TFTP_OP_ACK);
-    length += set_block_no(p->payload + length, blockno);
-
-    p->len = (uint16_t)length +1;
-    p->tot_len = (uint16_t)length+1;
-
-    int r = udp_sendto(pcb, p, addr, port);
-    if (r != ERR_OK) {
-        TFTP_DEBUG("send failed\n");
-    }
+    errval_t err;
+    err = net_send_to(socket, payload, length + 1, addr, port);
+    assert(err_is_ok(err));
 
     return SYS_ERR_OK;
 }
-
index 57ceb5e..2a334af 100644 (file)
@@ -265,7 +265,7 @@ static inline size_t set_block_no(void *buf, uint16_t blockno) {
  * Sending generic messages
  * ------------------------------------------------------------------------------
  */
-errval_t tftp_send_ack(struct udp_pcb *pcb, uint32_t blockno,
-                       struct ip_addr *addr, u16_t port,
-                       struct pbuf *p, void *payload);
+errval_t tftp_send_ack(struct net_socket *socket, uint32_t blockno,
+                       struct in_addr addr, uint16_t port,
+                       void *payload);
 #endif /* TFTP_INTERNAL_H_ */
index 6142ba7..74144bb 100644 (file)
@@ -59,8 +59,7 @@ class WebCommon(TestCommon):
         modules.add_module("e1000_net_sockets_server", ["auto"])
         nfsip = socket.gethostbyname(siteconfig.get('WEBSERVER_NFS_HOST'))
         modules.add_module("webserver", ["core=%d" % machine.get_coreids()[0], #2
-                               cardName, nfsip,
-                                         siteconfig.get('WEBSERVER_NFS_PATH')])
+                               nfsip, siteconfig.get('WEBSERVER_NFS_PATH')])
 #                                         siteconfig.get('WEBSERVER_NFS_TEST_PATH')])
         return modules
 
index 7411238..4d9759f 100644 (file)
 #include <barrelfish/deferred.h>
 #include <barrelfish/nameservice_client.h>
 
+#include <arpa/inet.h>
+
 #include <net/net.h>
+#include <net/dhcp.h>
 
 #include <barrelfish/waitset_chan.h>
 
+#include <octopus/octopus.h>
+#include <octopus_server/service.h>
+#include <octopus/trigger.h>
+
 #include <devif/queue_interface.h>
 #include <devif/backends/descq.h>
 
@@ -204,14 +211,14 @@ static err_t net_tcp_receive(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err
         nb->accepted_descriptor = 0;
         nb->host_address.s_addr = 0;
         nb->port = 0;
-        debug_printf("%s(%d): close\n", __func__, socket->descriptor);
+        // debug_printf("%s(%d): close\n", __func__, socket->descriptor);
         // debug_printf("%s(%d): %p -> %p %p %d\n", __func__, connection->descriptor, buffer, nb->user_callback, nb->user_state, nb->size);
     }
     nc->buffers[nc->next_free] = NULL;
     nc->next_free = (nc->next_free + 1) % NO_OF_BUFFERS;
     assert(sizeof(struct net_buffer) + length <= BUFFER_SIZE);
     
-    debug_printf("%s.%d: enqueue 1 %lx:%ld %d\n", __func__, __LINE__, buffer - nc->buffer_start, sizeof(struct net_buffer) + length, nb->descriptor);
+    // debug_printf("%s.%d: enqueue 1 %lx:%ld %d\n", __func__, __LINE__, buffer - nc->buffer_start, sizeof(struct net_buffer) + length, nb->descriptor);
     err = devq_enqueue((struct devq *)nc->queue, nc->region_id, buffer - nc->buffer_start, sizeof(struct net_buffer) + length,
                        0, 0, 1);
     assert(err_is_ok(err));
@@ -229,7 +236,7 @@ static void net_tcp_error(void *arg, err_t err)
     struct socket_connection *socket = arg;
     // struct network_connection *nc = socket->connection;
     
-    debug_printf("%s(%d): error %d\n", __func__, socket->descriptor, err);
+    // debug_printf("%s(%d): error %d\n", __func__, socket->descriptor, err);
     socket->tcp_socket = NULL; // invalidate
 
     // uint32_t length = 0;
@@ -307,7 +314,7 @@ static err_t net_tcp_accepted(void *arg, struct tcp_pcb *newpcb, err_t error)
     tcp_err(accepted_socket->tcp_socket, net_tcp_error);
     tcp_sent(accepted_socket->tcp_socket, net_tcp_sent);
 
-    debug_printf("%s(%d): -> %d\n", __func__, socket->descriptor, accepted_socket->descriptor);
+    // debug_printf("%s(%d): -> %d\n", __func__, socket->descriptor, accepted_socket->descriptor);
     // errval_t err = nc->binding->tx_vtbl.accepted(nc->binding, BLOCKING_CONT, socket->descriptor, accepted_socket->descriptor, 0, 0, SYS_ERR_OK);
     // assert(err_is_ok(err));
 
@@ -319,9 +326,9 @@ static err_t net_tcp_accepted(void *arg, struct tcp_pcb *newpcb, err_t error)
     nb->size = 0;
     nb->descriptor = socket->descriptor;
     nb->accepted_descriptor = accepted_socket->descriptor;
-    nb->host_address.s_addr = 0;
-    nb->port = 0;
-    debug_printf("%s(%d): accepted %p\n", __func__, socket->descriptor, newpcb);
+    nb->host_address.s_addr = newpcb->remote_ip.addr;
+    nb->port = newpcb->remote_port;
+    // debug_printf("%s(%d): accepted %p\n", __func__, socket->descriptor, newpcb);
 
     nc->buffers[nc->next_free] = NULL;
     nc->next_free = (nc->next_free + 1) % NO_OF_BUFFERS;
@@ -392,7 +399,7 @@ static errval_t net_tcp_socket(struct net_sockets_binding *binding, uint32_t *de
     return SYS_ERR_OK;
 }
 
-static errval_t net_bind(struct net_sockets_binding *binding, uint32_t descriptor, uint32_t ip_address, uint16_t port, errval_t *error)
+static errval_t net_bind(struct net_sockets_binding *binding, uint32_t descriptor, uint32_t ip_address, uint16_t port, errval_t *error, uint16_t *bound_port)
 {
     struct network_connection *nc;
     struct socket_connection *socket;
@@ -412,6 +419,7 @@ static errval_t net_bind(struct net_sockets_binding *binding, uint32_t descripto
         ip.addr = ip_address;
         *error = udp_bind(socket->udp_socket, &ip, port);
         assert(err_is_ok(*error));
+        *bound_port = socket->udp_socket->local_port;
         *error = SYS_ERR_OK;
 
         debug_printf("UDP ECHO bind done.\n");
@@ -419,9 +427,10 @@ static errval_t net_bind(struct net_sockets_binding *binding, uint32_t descripto
         ip_addr_t ip;
 
         ip.addr = ip_address;
-        debug_printf("%s(%d): %x %d\n", __func__, socket->descriptor, ip.addr, port);
+        // debug_printf("%s(%d): %x %d\n", __func__, socket->descriptor, ip.addr, port);
         *error = tcp_bind(socket->tcp_socket, &ip, port);
         assert(err_is_ok(*error));
+        *bound_port = socket->tcp_socket->local_port;
         *error = SYS_ERR_OK;
 
         debug_printf("TCP ECHO bind done.\n");
@@ -444,7 +453,7 @@ static errval_t net_listen(struct net_sockets_binding *binding, uint32_t descrip
     assert(socket);
     assert(socket->tcp_socket);
     socket->tcp_socket = tcp_listen(socket->tcp_socket);
-    debug_printf("%s(%d): listen %p\n", __func__, descriptor, socket->tcp_socket);
+    // debug_printf("%s(%d): listen %p\n", __func__, descriptor, socket->tcp_socket);
     tcp_accept(socket->tcp_socket, net_tcp_accepted);
     tcp_err(socket->tcp_socket, net_tcp_error);
     // socket->tcp_socket = tcp_listen_with_backlog(socket->tcp_socket, backlog);
@@ -459,7 +468,7 @@ static err_t net_tcp_connected(void *arg, struct tcp_pcb *tpcb, err_t error)
     struct socket_connection *socket = arg;
     struct network_connection *nc = socket->connection;
 
-    errval_t err = nc->binding->tx_vtbl.connected(nc->binding, BLOCKING_CONT, socket->descriptor, SYS_ERR_OK);
+    errval_t err = nc->binding->tx_vtbl.connected(nc->binding, BLOCKING_CONT, socket->descriptor, SYS_ERR_OK, tpcb->remote_ip.addr, tpcb->remote_port);
     assert(err_is_ok(err));
 
     return SYS_ERR_OK;
@@ -522,13 +531,13 @@ static errval_t net_delete_socket(struct net_sockets_binding *binding, uint32_t
         tcp_recv(socket->tcp_socket, NULL); // you can receive packets after you close the socket
         // tcp_accept(socket->tcp_socket, NULL);
         err_t e;
-        debug_printf("%s(%d): tcp_close %p\n", __func__, descriptor, socket->tcp_socket);
+        // debug_printf("%s(%d): tcp_close %p\n", __func__, descriptor, socket->tcp_socket);
         e = tcp_close(socket->tcp_socket);
         assert(e == ERR_OK);
     }
 
-    debug_printf("%s(%d):\n", __func__, descriptor);
-    debug_printf("%s: %ld:%p  %ld:%p\n", __func__, nc->next_free, nc->buffers[nc->next_free], nc->next_used, nc->buffers[nc->next_used]);
+    // debug_printf("%s(%d):\n", __func__, descriptor);
+    // debug_printf("%s: %ld:%p  %ld:%p\n", __func__, nc->next_free, nc->buffers[nc->next_free], nc->next_used, nc->buffers[nc->next_used]);
     if (last)
         last->next = socket->next;
     else
@@ -756,13 +765,17 @@ int main(int argc, char *argv[])
     char servicename[64];
     snprintf(servicename, sizeof(servicename), "e1000:%s", argv[2]);
 
+    // err = oct_init();
+    // assert(err_is_ok(err));
+    // err = oct_set(NET_CONFIG_STATIC_IP_RECORD_FORMAT, inet_addr("192.168.0.36"), inet_addr("0.0.0.0"), inet_addr("255.255.255.0"));
+    // assert(err_is_ok(err));
+
     /* connect to the network */
-    err = networking_init(servicename, NET_FLAGS_DO_DHCP);
+    err = networking_init(servicename, NET_FLAGS_DO_DHCP | NET_FLAGS_NO_NET_FILTER | NET_FLAGS_BLOCKING_INIT);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "Failed to initialize the network");
     }
 
-
     struct descq *exp_queue;
     struct descq_func_pointer f;
 
index 3cd3b96..dd052ea 100644 (file)
@@ -22,7 +22,6 @@
 // Specific for barrelfish
 #include <barrelfish/barrelfish.h>
 #include <vfs/vfs.h>
-#include <lwip/init.h>
 #include <barrelfish/nameservice_client.h>
 #include <barrelfish/waitset.h>
 #include <netbench/netbench.h>
@@ -53,7 +52,6 @@ static int cat(char *path)
     assert(buf);
 
     uint64_t start = rdtsc();
-    lwip_benchmark_control(1, BMS_START_REQUEST, 0, 0);
 
     for (; filesize != info.size;) {
        err = vfs_read(vh, buf, 10485760, &size);
@@ -70,7 +68,6 @@ static int cat(char *path)
     // record stop time
     uint64_t stop = rdtsc();
     printf("Everything done\n");
-    lwip_print_interesting_stats();
     double speed = ((filesize/in_seconds(stop - start))/(1024 * 1024));
     if (speed < 50) {
         printf("Warning: NFS throughput too low!! [%f]\n", speed);
index 3b6abb3..1d2d4f6 100644 (file)
@@ -456,13 +456,13 @@ static void http_server_recv(void *arg, struct net_socket *tpcb, void *data, siz
     struct http_conn *conn = arg;
 
     DEBUGPRINT("%d, http_server_recv called\n", conn->request_no);
-    debug_printf("%s(%d): %ld\n", __func__, tpcb->descriptor, size);
+    // debug_printf("%s(%d): %ld\n", __func__, tpcb->descriptor, size);
 
     // check if connection closed
     assert(conn);
     if (size == 0) {
         DEBUGPRINT("%d, closing from http_server_recv\n", conn->request_no);
-debug_printf("%s.%d:\n", __func__, __LINE__);
+// debug_printf("%s.%d:\n", __func__, __LINE__);
         http_server_close(tpcb, conn);
         return;
     }
@@ -548,18 +548,18 @@ invalid:
     DEBUGPRINT("invalid request: %s\n", conn->request);
     DEBUGPRINT("%d: invalid request: %s\n",conn->request_no, conn->request);
     conn->state = HTTP_STATE_CLOSING;
-debug_printf("%s.%d:\n", __func__, __LINE__);
+// debug_printf("%s.%d:\n", __func__, __LINE__);
     http_server_close(tpcb, conn);
     return;
 }
 
-static void http_server_accept(void *arg, struct net_socket *tpcb, struct in_addr ip_address, uint16_t port)
+static void http_server_accept(void *arg, struct net_socket *tpcb)
 {
 // #if TCP_LISTEN_BACKLOG
 //     /* Decrease the listen backlog counter */
 //     struct tcp_pcb_listen *lpcb = (struct tcp_pcb_listen*)arg;
 // #endif
-    debug_printf("%s(%d):\n", __func__, tpcb->descriptor);
+    // debug_printf("%s(%d):\n", __func__, tpcb->descriptor);
     struct http_conn *conn = http_conn_new();
     DEBUGPRINT("accpet called: %s\n", conn->request);
     increment_http_conn_reference (conn);