Add uip_udp_packet_send2 function

This new function adds two major improvements over uip_udp_packet_send:
- return an error code if the packet send fails before making it to
  the mac layer
- add a mechanism by which applications can be notified when packet
  sending completes along with transmit status from the MAC layer.

Author: bkozak-scanimetrics

core/net/ip/tcpip.c

@@ -77,6 +77,7 @@ extern struct uip_fallback_interface UIP_FALLBACK_INTERFACE;
 #include "rpl/rpl.h"
 #endif
 
+process_event_t tcpip_udp_sent_event;
 process_event_t tcpip_event;
 #if UIP_CONF_ICMP6
 process_event_t tcpip_icmp6_event;
@@ -126,22 +127,22 @@ setup_appstate(uip_tcp_appstate_t* as, void* state)
 /* Called on IP packet output. */
 #if NETSTACK_CONF_WITH_IPV6
 
-static uint8_t (* outputfunc)(const uip_lladdr_t *a);
+static uint8_t (*outputfunc)(const uip_lladdr_t *a, struct tcpip_track *track);
 
 uint8_t
-tcpip_output(const uip_lladdr_t *a)
+tcpip_output_sent(const uip_lladdr_t *a, struct tcpip_track *track)
 {
   int ret;
   if(outputfunc != NULL) {
-    ret = outputfunc(a);
+    ret = outputfunc(a, track);
     return ret;
   }
   UIP_LOG("tcpip_output: Use tcpip_set_outputfunc() to set an output function");
   return 0;
 }
 
 void
-tcpip_set_outputfunc(uint8_t (*f)(const uip_lladdr_t *))
+tcpip_set_outputfunc(uint8_t (*f)(const uip_lladdr_t *, struct tcpip_track *))
 {
   outputfunc = f;
 }
@@ -164,7 +165,20 @@ tcpip_set_outputfunc(uint8_t (*f)(void))
   outputfunc = f;
 }
 #endif
+/*---------------------------------------------------------------------------*/
+void
+tcpip_udp_sent(struct tcpip_track *track, int status)
+{
+  struct uip_udp_conn *conn = track->ptr;
+  struct tcpip_udp_track_status data;
+
+  data.conn = conn;
+  data.status = status;
+  data.track = track;
 
+  process_post_synch(conn->appstate.p, tcpip_udp_sent_event, &data);
+}
+/*---------------------------------------------------------------------------*/
 #if UIP_CONF_IP_FORWARD
 unsigned char tcpip_is_forwarding; /* Forwarding right now? */
 #endif /* UIP_CONF_IP_FORWARD */
@@ -718,7 +732,7 @@ send_nd6_ns(uip_ipaddr_t *nexthop)
 }
 /*---------------------------------------------------------------------------*/
 int
-tcpip_ipv6_output(void)
+tcpip_ipv6_output_tracked(struct tcpip_track *track)
 {
   uip_ipaddr_t ipaddr;
   int err = TCPIP_SUCCESS;
@@ -795,7 +809,7 @@ tcpip_ipv6_output(void)
     linkaddr = NULL;
   }
 
-  if(tcpip_output(linkaddr)) {
+  if(!tcpip_output_sent(linkaddr, track)) {
     err = TCPIP_ERR_NEXTLAYER;
   }
 
@@ -880,6 +894,9 @@ PROCESS_THREAD(tcpip_process, ev, data)
 #endif
 
   tcpip_event = process_alloc_event();
+
+  tcpip_udp_sent_event = process_alloc_event();
+
 #if UIP_CONF_ICMP6
   tcpip_icmp6_event = process_alloc_event();
 #endif /* UIP_CONF_ICMP6 */

core/net/ip/tcpip.h

@@ -70,6 +70,25 @@
 #include "contiki.h"
 
 struct uip_conn;
+struct tcpip_track {
+  void (*callback)(struct tcpip_track *, int);
+  void *ptr;
+
+  enum {
+    FRAG_TRACK_NONE,
+    FRAG_TRACK_UNQUEUED,
+    FRAG_TRACK_ALL_QUEUED,
+    FRAG_TRACK_ERROR
+  } frag_track;
+  int frag_count_queued;
+  int first_fail_status;
+};
+
+struct tcpip_udp_track_status {
+  struct uip_udp_conn *conn;
+  struct tcpip_track *track;
+  int status;
+};
 
 struct tcpip_uipstate {
   struct process *p;
@@ -327,6 +346,14 @@ void tcpip_icmp6_call(uint8_t type);
  * This event is posted to a process whenever a uIP event has occurred.
  */
 CCIF extern process_event_t tcpip_event;
+/** @} */
+/**
+ * The udp sent event
+ *
+ * This event is posted to a process whenever a udp packet has finished sending
+ * (possibly as a result of error).
+ */
+CCIF extern process_event_t tcpip_udp_sent_event;
 
 /**
  * \name TCP/IP packet processing
@@ -349,8 +376,12 @@ CCIF void tcpip_input(void);
  * The eventual parameter is the MAC address of the destination.
  */
 #if NETSTACK_CONF_WITH_IPV6
-uint8_t tcpip_output(const uip_lladdr_t *);
-void tcpip_set_outputfunc(uint8_t (* f)(const uip_lladdr_t *));
+#define tcpip_output(addr) tcpip_output_sent(addr, NULL)
+
+uint8_t tcpip_output_sent(const uip_lladdr_t *, struct tcpip_track *ptr);
+void tcpip_set_outputfunc(
+  uint8_t (*f)(const uip_lladdr_t *, struct tcpip_track *)
+  );
 #else
 uint8_t tcpip_output(void);
 void tcpip_set_outputfunc(uint8_t (* f)(void));
@@ -360,9 +391,15 @@ void tcpip_set_outputfunc(uint8_t (* f)(void));
  * \brief This function does address resolution and then calls tcpip_output
  */
 #if NETSTACK_CONF_WITH_IPV6
-int tcpip_ipv6_output(void);
+#define tcpip_ipv6_output() tcpip_ipv6_output_tracked(NULL)
+int tcpip_ipv6_output_tracked(struct tcpip_track* track);
 #endif
 
+/**
+ * \brief call after sending a udp packet, informs the application
+ */
+void tcpip_udp_sent(struct tcpip_track *track, int status);
+
 /**
  * \brief Is forwarding generally enabled?
  */

core/net/ip/uip-udp-packet.c

@@ -47,9 +47,11 @@ extern uint16_t uip_slen;
 #include <string.h>
 
 /*---------------------------------------------------------------------------*/
-void
-uip_udp_packet_send(struct uip_udp_conn *c, const void *data, int len)
+static int
+send(struct uip_udp_conn *c, const void *data, int len,
+     struct tcpip_track* track)
 {
+  int ret = 0;
 #if UIP_UDP
   if(data != NULL) {
     uip_udp_conn = c;
@@ -67,7 +69,7 @@ uip_udp_packet_send(struct uip_udp_conn *c, const void *data, int len)
 #endif /* UIP_IPV6_MULTICAST */
 
 #if NETSTACK_CONF_WITH_IPV6
-    tcpip_ipv6_output();
+    ret = tcpip_ipv6_output_tracked(track);
 #else
     if(uip_len > 0) {
       tcpip_output();
@@ -76,6 +78,13 @@ uip_udp_packet_send(struct uip_udp_conn *c, const void *data, int len)
   }
   uip_slen = 0;
 #endif /* UIP_UDP */
+  return ret;
+}
+/*---------------------------------------------------------------------------*/
+void
+uip_udp_packet_send(struct uip_udp_conn *c, const void *data, int len)
+{
+  send(c, data, len, NULL);
 }
 /*---------------------------------------------------------------------------*/
 void
@@ -102,3 +111,14 @@ uip_udp_packet_sendto(struct uip_udp_conn *c, const void *data, int len,
   }
 }
 /*---------------------------------------------------------------------------*/
+int
+uip_udp_packet_send2(struct uip_udp_conn *c, const void *data, int len,
+                     struct tcpip_track* track)
+{
+  track->ptr = c;
+  track->callback = tcpip_udp_sent;
+  track->frag_track = FRAG_TRACK_NONE;
+
+  return send(c, data, len, track);
+}
+/*---------------------------------------------------------------------------*/

core/net/ip/uip-udp-packet.h

@@ -42,6 +42,8 @@
 
 #include "net/ip/uip.h"
 
+int uip_udp_packet_send2(struct uip_udp_conn *c, const void *data, int len,
+                          struct tcpip_track* track);
 void uip_udp_packet_send(struct uip_udp_conn *c, const void *data, int len);
 void uip_udp_packet_sendto(struct uip_udp_conn *c, const void *data, int len,
 			   const uip_ipaddr_t *toaddr, uint16_t toport);

core/net/ipv6/sicslowpan.c

@@ -286,7 +286,28 @@ struct sicslowpan_frag_buf {
 };
 
 static struct sicslowpan_frag_buf frag_buf[SICSLOWPAN_FRAGMENT_BUFFERS];
-
+/*---------------------------------------------------------------------------*/
+static void track_frag_start(struct tcpip_track *track)
+{
+  if(track) {
+    track->frag_track = FRAG_TRACK_UNQUEUED;
+    track->frag_count_queued = 0;
+  }
+}
+/*---------------------------------------------------------------------------*/
+static void track_frag_queued(struct tcpip_track *track)
+{
+  if(track) {
+    track->frag_count_queued += 1;
+  }
+}
+/*---------------------------------------------------------------------------*/
+static void track_frag_done(struct tcpip_track *track)
+{
+  if(track && (track->frag_track != FRAG_TRACK_ERROR)) {
+    track->frag_track = FRAG_TRACK_ALL_QUEUED;
+  }
+}
 /*---------------------------------------------------------------------------*/
 static int
 clear_fragments(uint8_t frag_info_index)
@@ -1231,16 +1252,50 @@ packet_sent(void *ptr, int status, int transmissions)
   if(callback != NULL) {
     callback->output_callback(status);
   }
+
+  if(ptr) {
+    struct tcpip_track *track = ptr;
+
+    switch(track->frag_track)
+    {
+    case FRAG_TRACK_NONE:
+       track->callback(track, status);
+       break;
+     case FRAG_TRACK_UNQUEUED:
+       track->frag_count_queued -= 1;
+       if(status != MAC_TX_OK) {
+         track->frag_track = FRAG_TRACK_ERROR;
+       }
+       break;
+     case FRAG_TRACK_ALL_QUEUED:
+       track->frag_count_queued -= 1;
+       if(status != MAC_TX_OK) {
+          track->frag_track = FRAG_TRACK_ERROR;
+          track->first_fail_status = status;
+       } else if(track->frag_count_queued == 0) {
+         track->callback(track, status);
+       }
+       break;
+     case FRAG_TRACK_ERROR:
+       track->frag_count_queued -= 1;
+       if(track->frag_count_queued == 0) {
+         track->callback(track, track->first_fail_status);
+       }
+       break;
+    }
+  }
+
   last_tx_status = status;
 }
 /*--------------------------------------------------------------------*/
 /**
  * \brief This function is called by the 6lowpan code to send out a
  * packet.
  * \param dest the link layer destination address of the packet
+ * \param track data used for calling back into the application on tx done
  */
 static void
-send_packet(linkaddr_t *dest)
+send_packet(linkaddr_t *dest,struct tcpip_track *track)
 {
   /* Set the link layer destination address for the packet as a
    * packetbuf attribute. The MAC layer can access the destination
@@ -1255,7 +1310,7 @@ send_packet(linkaddr_t *dest)
 
   /* Provide a callback function to receive the result of
      a packet transmission. */
-  NETSTACK_LLSEC.send(&packet_sent, NULL);
+  NETSTACK_LLSEC.send(&packet_sent, track);
 
   /* If we are sending multiple packets in a row, we need to let the
      watchdog know that we are still alive. */
@@ -1265,14 +1320,15 @@ send_packet(linkaddr_t *dest)
 /** \brief Take an IP packet and format it to be sent on an 802.15.4
  *  network using 6lowpan.
  *  \param localdest The MAC address of the destination
+ *  \param track data used for calling back into the application on tx done
  *
  *  The IP packet is initially in uip_buf. Its header is compressed
  *  and if necessary it is fragmented. The resulting
  *  packet/fragments are put in packetbuf and delivered to the 802.15.4
  *  MAC.
  */
 static uint8_t
-output(const uip_lladdr_t *localdest)
+output(const uip_lladdr_t *localdest, struct tcpip_track *track)
 {
   int framer_hdrlen;
   int max_payload;
@@ -1409,7 +1465,9 @@ output(const uip_lladdr_t *localdest)
       PRINTFO("could not allocate queuebuf for first fragment, dropping packet\n");
       return 0;
     }
-    send_packet(&dest);
+    track_frag_start(track);
+    track_frag_queued(track);
+    send_packet(&dest, track);
     queuebuf_to_packetbuf(q);
     queuebuf_free(q);
     q = NULL;
@@ -1455,7 +1513,11 @@ output(const uip_lladdr_t *localdest)
         PRINTFO("could not allocate queuebuf, dropping fragment\n");
         return 0;
       }
-      send_packet(&dest);
+      track_frag_queued(track);
+      if((processed_ip_out_len + packetbuf_payload_len) >= uip_len) {
+        track_frag_done(track);
+      }
+      send_packet(&dest, track);
       queuebuf_to_packetbuf(q);
       queuebuf_free(q);
       q = NULL;
@@ -1482,7 +1544,7 @@ output(const uip_lladdr_t *localdest)
     memcpy(packetbuf_ptr + packetbuf_hdr_len, (uint8_t *)UIP_IP_BUF + uncomp_hdr_len,
            uip_len - uncomp_hdr_len);
     packetbuf_set_datalen(uip_len - uncomp_hdr_len + packetbuf_hdr_len);
-    send_packet(&dest);
+    send_packet(&dest, track);
   }
   return 1;
 }

cpu/native/net/tapdev6.c

@@ -98,7 +98,7 @@ static unsigned long lasttime;
 #endif
 
 static void do_send(void);
-uint8_t tapdev_send(const uip_lladdr_t *lladdr);
+uint8_t tapdev_send(const uip_lladdr_t *lladdr, struct tcpip_track *track);
 
 /*---------------------------------------------------------------------------*/
 int
@@ -375,7 +375,7 @@ do_send(void)
 }
 /*---------------------------------------------------------------------------*/
 uint8_t
-tapdev_send(const uip_lladdr_t *lladdr)
+tapdev_send(const uip_lladdr_t *lladdr, struct tcpip_track *track)
 {
   /*
    * If L3 dest is multicast, build L2 multicast address

cpu/native/net/tapdev6.h

@@ -1,3 +1,4 @@
+
 /*
  * Copyright (c) 2003, Adam Dunkels.
  * All rights reserved. 
@@ -39,7 +40,7 @@
 #include "contiki-net.h"
 
 void tapdev_init(void);
-uint8_t tapdev_send(const uip_lladdr_t *lladdr);
+uint8_t tapdev_send(const uip_lladdr_t *lladdr, struct tcpip_track *track);
 uint16_t tapdev_poll(void);
 void tapdev_do_send(void);
 void tapdev_exit(void); //math

cpu/native/net/wpcap.c

@@ -708,7 +708,7 @@ wfall_poll(void)
 /*---------------------------------------------------------------------------*/
 #if NETSTACK_CONF_WITH_IPV6
 uint8_t
-wpcap_send(const uip_lladdr_t *lladdr)
+wpcap_send(const uip_lladdr_t *lladdr, struct tcpip_track *track)
 {
   if(lladdr == NULL) {
 /* the dest must be multicast*/