- wrote clone function for packed
authorJan Hutter <jhutter@hsr.ch>
Thu, 10 Nov 2005 15:38:12 +0000 (15:38 -0000)
committerJan Hutter <jhutter@hsr.ch>
Thu, 10 Nov 2005 15:38:12 +0000 (15:38 -0000)
- test for whole packet functionality

Source/charon/packet.c
Source/charon/packet.h
Source/charon/tests/packet_test.c [new file with mode: 0644]
Source/charon/tests/packet_test.h [new file with mode: 0644]

index 94b58e5..ba2c0cb 100644 (file)
@@ -1,8 +1,8 @@
 /**
- * @file packet.h
- *
- * @brief UDP-Packet, contains data, sender and receiver
- *
+ * @file packet.c
+ * 
+ * @brief UDP-Packet, contains data, sender and receiver.
+ * 
  */
 
 /*
 #include "packet.h"
 
 
-static status_t destroy(packet_t *this)
+/**
+ * Private data of an packet_t object
+ */
+typedef struct private_packet_s private_packet_t;
+
+struct private_packet_s {
+
+       /**
+        * Public part of a packet_t object
+        */
+       packet_t public;
+       
+       /* private functions */
+       
+       /**
+        * @brief helper function to set address used by set_dest & set_source.
+        * 
+        * @param this          calling object_t
+        * @param family        address family
+        * @param saddr         source address
+        * @param address       address as string
+        * @return                      
+        *                                      - SUCCESS if successfuly
+        *                                      - NOT_SUPPORTED if family is not supported
+        */
+       status_t (*set_addr) (private_packet_t *this, int family, struct sockaddr *saddr, char *address, u_int16_t port);
+};
+
+/**
+ * Implements packet_t's destroy function.
+ * See #packet_s.destroy for description.
+ */
+static status_t destroy(private_packet_t *this)
 {
-       if (this->data.ptr != NULL)
+       if (this->public.data.ptr != NULL)
        {
-               allocator_free(this->data.ptr);
+               allocator_free(this->public.data.ptr);
        }
        allocator_free(this);
        return SUCCESS;
 }
 
 /**
- * @brief helper function to set address used by set_dest & set_source
+ * Implements packet_t's clone function.
+ * See #packet_s.clone for description.
+ */
+static status_t clone (private_packet_t *packet, packet_t **clone)
+{
+       *clone = packet_create(packet->public.family);
+       if ((*clone) == NULL)
+       {
+
+               return OUT_OF_RES;
+       }
+
+       
+       (*clone)->sockaddr_len = packet->public.sockaddr_len;
+       (*clone)->source = packet->public.source;
+       (*clone)->destination = packet->public.destination;
+       /* only clone existing chunks :-) */
+       if (packet->public.data.ptr != NULL)
+       {
+               (*clone)->data.ptr = allocator_clone_bytes(packet->public.data.ptr,packet->public.data.len);
+               if ((*clone)->data.ptr == NULL)
+               {
+                       (*clone)->destroy((*clone));
+                       return OUT_OF_RES;
+               }
+               (*clone)->data.len = packet->public.data.len;
+       }
+       return SUCCESS;
+}
+
+/**
+ * Implements private_packet_t's set_addr function.
+ * See #private_packet_t.set_addr for description.
  */
 static status_t set_addr(int family, struct sockaddr *saddr, char *address, u_int16_t port)
 {
@@ -54,39 +118,50 @@ static status_t set_addr(int family, struct sockaddr *saddr, char *address, u_in
        return NOT_SUPPORTED;
 }
 
-status_t set_destination(packet_t *this, char *address, u_int16_t port)
+/**
+ * Implements packet_t's set_destination function.
+ * See #packet_t.set_destination for description.
+ */
+static status_t set_destination(packet_t *this, char *address, u_int16_t port)
 {
        struct sockaddr *saddr = &(this->destination);
        return set_addr(this->family, saddr, address, port);
 }
 
-status_t set_source(packet_t *this, char *address, u_int16_t port)
+/**
+ * Implements packet_t's set_source function.
+ * See #packet_t.set_source for description.
+ */
+static status_t set_source(packet_t *this, char *address, u_int16_t port)
 {
        struct sockaddr *saddr = &(this->source);
        return set_addr(this->family, saddr, address, port);
 }
 
-
+/*
+ * Documented in header
+ */
 packet_t *packet_create(int family)
 {
-       packet_t *this = allocator_alloc_thing(packet_t);
+       private_packet_t *this = allocator_alloc_thing(private_packet_t);
 
-       this->destroy = destroy;
-       this->set_destination = set_destination;
-       this->set_source = set_source;
+       this->public.destroy = (status_t(*) (packet_t *)) destroy;
+       this->public.set_destination = set_destination;
+       this->public.set_source = set_source;
+       this->public.clone = (status_t(*) (packet_t *,packet_t**))clone;
 
-       this->family = family;
+       this->public.family = family;
        switch (family)
        {
                case AF_INET:
-                       this->sockaddr_len = sizeof(struct sockaddr_in);
+                       this->public.sockaddr_len = sizeof(struct sockaddr_in);
                        break;
                default: /* not supported */
                        allocator_free(this);
                        return NULL;
        }
 
-       this->data.len = 0;
-       this->data.ptr = NULL;
-       return this;
+       this->public.data.len = 0;
+       this->public.data.ptr = NULL;
+       return &(this->public);
 }
index 8e5f9e9..1e0785c 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file packet.h
  * 
- * @brief UDP-Packet, contains data, sender and receiver
+ * @brief UDP-Packet, contains data, sender and receiver.
  * 
  */
 
@@ -42,6 +42,10 @@ struct packet_s {
         * Address family, such as AF_INET
         */
        int family;
+       
+       /**
+        * 
+        */
        size_t sockaddr_len;
        
        /**
@@ -62,28 +66,40 @@ struct packet_s {
        /**
         * @brief                       set destination of packet, using address string
         *  
+        * @param packet                calling object
         * @param address       ip address string
         * @param port          port number
-        * @return                      SUCCESS
-        *                                      NOT_SUPPORTED
+        * @return                      SUCCESS
+        *                                      NOT_SUPPORTED
         */
        status_t (*set_destination) (packet_t *packet, char *address, u_int16_t port);
                
        /**
         * @brief                       set destination of packet, using address string
-        *  
+        *
+        * @param packet                calling object  
         * @param address       ip address string
         * @param port          port number
-        * @return                      SUCCESS
-        *                                      NOT_SUPPORTED
+        * @return                      SUCCESS
+        *                                      NOT_SUPPORTED
         */
        status_t (*set_source) (packet_t *packet, char *address, u_int16_t port);
+
+       /**
+        * @brief                       Clones a packet_t object
+        *  
+        * @param packet                calling object
+        * @param clone         pointer to a packet_t object pointer where the new object is stored
+        * @return                      - SUCCESS if successful
+        *                                      - OUT_OF_RES
+        */
+       status_t (*clone) (packet_t *packet, packet_t **clone);
        
        /**
         * @brief                       destroy the packet, freeing contained data
         *  
         * @param packet        packet to destroy       
-        * @return                      SUCCESS
+        * @return                      SUCCESS
         */
        status_t (*destroy) (packet_t *packet);
 };
@@ -92,7 +108,7 @@ struct packet_s {
  * @brief create an empty packet
  *  
  * @param family               address-family, such as AF_INET
- * @return                     NULL when family not supported
+ * @return                     NULL when family not supported
  */
 packet_t *packet_create(int family);
 
diff --git a/Source/charon/tests/packet_test.c b/Source/charon/tests/packet_test.c
new file mode 100644 (file)
index 0000000..f2cb228
--- /dev/null
@@ -0,0 +1,61 @@
+/**
+ * @file packet_test.c
+ *
+ * @brief Tests to test the class type packet_t
+ *
+ */
+
+/*
+ * Copyright (C) 2005 Jan Hutter, Martin Willi
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program 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 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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.
+ */
+
+#include <string.h>
+#include "packet_test.h"
+#include "../allocator.h"
+#include "../packet.h"
+
+
+/*
+ * Described in Header 
+ */
+void test_packet(tester_t *tester)
+{
+       packet_t *packet = packet_create(AF_INET);
+       packet_t *packet2;
+       char * string_to_copy = "aha, soso";
+       
+       packet->data.ptr = allocator_alloc_thing(string_to_copy);
+       packet->data.len = sizeof(string_to_copy);
+       memcpy(packet->data.ptr,string_to_copy,packet->data.len);
+
+       tester->assert_true(tester,(packet != NULL),"NULL pointer check");
+       
+       tester->assert_true(tester,(packet->clone(packet,&packet2) == SUCCESS),"clone call check");
+
+       tester->assert_false(tester,(packet->data.ptr == packet2->data.ptr),"value pointer check");
+       
+       tester->assert_true(tester,(memcmp(packet->data.ptr,packet2->data.ptr,packet->data.len) == 0),"cloned value check");
+
+       tester->assert_true(tester,(packet->family == packet2->family),"cloned value check");
+       tester->assert_true(tester,(packet->sockaddr_len == packet2->sockaddr_len),"cloned value check");
+       tester->assert_true(tester,(memcmp(&(packet->source),&(packet2->source), sizeof(struct sockaddr)) == 0),"cloned value check");
+       tester->assert_true(tester,(memcmp(&(packet->destination),&(packet2->destination), sizeof(struct sockaddr)) == 0),"cloned value check");
+       
+       
+       packet2->destroy(packet2);
+       packet->destroy(packet);
+       
+       
+       
+}
diff --git a/Source/charon/tests/packet_test.h b/Source/charon/tests/packet_test.h
new file mode 100644 (file)
index 0000000..4a4eb8f
--- /dev/null
@@ -0,0 +1,36 @@
+/**
+ * @file packet_test.h
+ *
+ * @brief Tests to test the class type packet_t
+ *
+ */
+
+/*
+ * Copyright (C) 2005 Jan Hutter, Martin Willi
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program 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 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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.
+ */
+
+#ifndef PACKET_TEST_H_
+#define PACKET_TEST_H_
+
+#include "../tester.h"
+
+/**
+ * @brief Test function used to test the packet_t functionality
+ *
+ *
+ * @param tester associated tester_t object
+ */
+void test_packet(tester_t *tester);
+
+#endif /*PACKET_TEST_H_*/