implemented generic packet queue - it's quite complicated but works ...keyexchange

2 files changed, 158 insertions, 0 deletions

diff --git a/src/packet_queue.h b/src/packet_queue.h
new file mode 100644
index 0000000..df27a85
--- /dev/null
+++ b/src/packet_queue.h
@@ -0,0 +1,109 @@
+/*
+ *  uAnytun
+ *
+ *  uAnytun is a tiny implementation of SATP. Unlike Anytun which is a full
+ *  featured implementation uAnytun has no support for multiple connections
+ *  or synchronisation. It is a small single threaded implementation intended
+ *  to act as a client on small platforms.
+ *  The secure anycast tunneling protocol (satp) defines a protocol used
+ *  for communication between any combination of unicast and anycast
+ *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
+ *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
+ *  ethernet, ip, arp ...). satp directly includes cryptography and
+ *  message authentication based on the methods used by SRTP.  It is
+ *  intended to deliver a generic, scaleable and secure solution for
+ *  tunneling and relaying of packets of any protocol.
+ *
+ *
+ *  Copyright (C) 2007-2014 Christian Pointner <equinox@anytun.org>
+ *
+ *  This file is part of uAnytun.
+ *
+ *  uAnytun is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  any later version.
+ *
+ *  uAnytun is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with uAnytun. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  In addition, as a special exception, the copyright holders give
+ *  permission to link the code of portions of this program with the
+ *  OpenSSL library under certain conditions as described in each
+ *  individual source file, and distribute linked combinations
+ *  including the two.
+ *  You must obey the GNU General Public License in all respects
+ *  for all of the code used other than OpenSSL.  If you modify
+ *  file(s) with this exception, you may extend this exception to your
+ *  version of the file(s), but you are not obligated to do so.  If you
+ *  do not wish to do so, delete this exception statement from your
+ *  version.  If you delete this exception statement from all source
+ *  files in the program, then also delete it here.
+ */
+
+#ifndef UANYTUN_packet_queue_h_INCLUDED
+#define UANYTUN_packet_queue_h_INCLUDED
+
+#define PACKET_QUEUE_FLAGS_USED 0x00000001
+
+struct packet_queue_struct {
+  size_t size_;
+  void* packets_;
+  int* flags_;
+};
+typedef struct packet_queue_struct packet_queue_t;
+
+#define packet_queue_init(TYPE, ...) do {                                \
+    int i;                                                               \
+    for(i = 0; i < TYPE ## _queue.size_; ++i) {                          \
+      TYPE ## _queue.flags_[i] = 0;                                      \
+      TYPE ## _init(&(((TYPE ## _t*)TYPE ## _queue.packets_)[i]), ## __VA_ARGS__); \
+    }                                                                    \
+  } while(0)
+
+#define packet_queue_acquire_next(TYPE, idx) do {                    \
+    idx = -1;                                                        \
+    int i;                                                           \
+    for(i = 0; i < TYPE ## _queue.size_; ++i) {                      \
+      if(!(TYPE ## _queue.flags_[i] & PACKET_QUEUE_FLAGS_USED)) {    \
+        TYPE ## _queue.flags_[i] |= PACKET_QUEUE_FLAGS_USED;         \
+        idx = i;                                                     \
+        break;                                                       \
+      }                                                              \
+    }                                                                \
+  } while(0)
+
+#define packet_queue_release(TYPE, packet) do {                      \
+    int i;                                                           \
+    for(i = 0; i < TYPE ## _queue.size_; ++i) {                      \
+      if(&(((TYPE ## _t*)TYPE ## _queue.packets_)[i]) == packet) {   \
+        TYPE ## _queue.flags_[i] &= ~PACKET_QUEUE_FLAGS_USED;        \
+        break;                                                       \
+      }                                                              \
+    }                                                                \
+  } while(0)
+
+#define packet_queue_get(TYPE, idx) (idx >= 0) && (idx < TYPE ## _queue.size_) ? &(((TYPE ## _t*)TYPE ## _queue.packets_)[idx]) : NULL
+
+
+#define packet_queue_instantiate(SIZE, TYPE)                                         \
+TYPE ## _t TYPE ## _data_array[SIZE];                                                \
+int TYPE ## _flags_array[SIZE];                                                      \
+packet_queue_t TYPE ## _queue = { SIZE, TYPE ## _data_array, TYPE ## _flags_array }; \
+TYPE ## _t* TYPE ## _queue_get_next() {                                              \
+  int idx;                                                                           \
+  packet_queue_acquire_next(TYPE, idx);                                              \
+  return packet_queue_get(TYPE, idx);                                                \
+}                                                                                    \
+void TYPE ## _queue_release(TYPE ## _t* packet) {                                    \
+  packet_queue_release(TYPE, packet);                                                \
+}                                                                                    \
+
+
+#endif
+
diff --git a/src/test_packet_queue.c b/src/test_packet_queue.c
new file mode 100644
index 0000000..e8b3106
--- /dev/null
+++ b/src/test_packet_queue.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+
+#include "datatypes.h"
+
+#include "plain_packet.h"
+#include "encrypted_packet.h"
+#include "packet_queue.h"
+
+packet_queue_instantiate(4, plain_packet);
+packet_queue_instantiate(4, encrypted_packet);
+
+int main(int argc, char* argv[])
+{
+  packet_queue_init(plain_packet);
+  packet_queue_init(encrypted_packet, 10);
+
+  printf("acquire/release:\n");
+
+  plain_packet_t* p1 = plain_packet_queue_get_next();
+  printf("p1 acquire: %08lX\n", p1);
+  plain_packet_t* p2 = plain_packet_queue_get_next();
+  printf("p2 acquire: %08lX\n", p2);
+  encrypted_packet_t* e1 = encrypted_packet_queue_get_next();
+  printf("e1 acquire: %08lX\n", e1);
+  encrypted_packet_t* e2 = encrypted_packet_queue_get_next();
+  printf("e2 acquire: %08lX\n", e2);
+  plain_packet_t* p3 = plain_packet_queue_get_next();
+  printf("p3 acquire: %08lX\n", p3);
+
+  printf("p1 release: %08lX\n", p1);
+  plain_packet_queue_release(p1);
+  printf("e2 release: %08lX\n", e2);
+  encrypted_packet_queue_release(e2);
+  printf("p2 release: %08lX\n", p2);
+  plain_packet_queue_release(p2);
+
+  encrypted_packet_t* e3 = encrypted_packet_queue_get_next();
+  printf("e3 acquire: %08lX\n", p3);
+  plain_packet_t* p4 = plain_packet_queue_get_next();
+  printf("p4 acquire: %08lX\n", p4);
+  encrypted_packet_t* e4 = encrypted_packet_queue_get_next();
+  printf("e4 acquire: %08lX\n", e4);
+  plain_packet_t* p5 = plain_packet_queue_get_next();
+  printf("p5 acquire: %08lX\n", p5);
+  plain_packet_t* p6 = plain_packet_queue_get_next();
+  printf("p6 acquire: %08lX\n", p6);
+
+  return 0;
+}