[hipl-commit] [trunk] Rev 3591: Reformatted lib/core.

  • From: Tim Just <tim.just@xxxxxxxxxxxxxx>
  • To: hipl-commit@xxxxxxxxxxxxx
  • Date: Thu, 11 Feb 2010 01:55:41 +0200

Committer: Tim Just <tim.just@xxxxxxxxxxxxxx>
Date: Thu Feb 11 00:55:24 2010 +0100
Revision: 3591
Revision-id: tim.just@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Branch nick: trunk

Log:
  Reformatted lib/core.

Modified:
  M  lib/core/builder.c
  M  lib/core/builder.c.doxyme
  M  lib/core/builder.h
  M  lib/core/builder.h.doxyme
  M  lib/core/certtools.c
  M  lib/core/certtools.c.doxyme
  M  lib/core/certtools.h
  M  lib/core/certtools.h.doxyme
  M  lib/core/common_defines.h
  M  lib/core/common_defines.h.doxyme
  M  lib/core/debug.c
  M  lib/core/debug.c.doxyme
  M  lib/core/debug.h
  M  lib/core/debug.h.doxyme
  M  lib/core/esp_prot_common.c
  M  lib/core/esp_prot_common.h
  M  lib/core/getendpointinfo.c
  M  lib/core/getendpointinfo.c.doxyme
  M  lib/core/getendpointinfo.h
  M  lib/core/getendpointinfo.h.doxyme
  M  lib/core/hashchain.c
  M  lib/core/hashchain.h
  M  lib/core/hashchain_store.c
  M  lib/core/hashchain_store.h
  M  lib/core/hashtable.c
  M  lib/core/hashtable.c.doxyme
  M  lib/core/hashtable.h
  M  lib/core/hashtable.h.doxyme
  M  lib/core/hashtree.c
  M  lib/core/hashtree.h
  M  lib/core/hip_capability.c
  M  lib/core/hip_capability.c.doxyme
  M  lib/core/hip_capability.h
  M  lib/core/hip_capability.h.doxyme
  M  lib/core/hip_statistics.c
  M  lib/core/hip_statistics.c.doxyme
  M  lib/core/hip_statistics.h
  M  lib/core/hip_statistics.h.doxyme
  M  lib/core/icomm.h
  M  lib/core/icomm.h.doxyme
  M  lib/core/ife.h
  M  lib/core/ife.h.doxyme
  M  lib/core/kerncompat.h
  M  lib/core/kerncompat.h.doxyme
  M  lib/core/linkedlist.c
  M  lib/core/linkedlist.c.doxyme
  M  lib/core/linkedlist.h
  M  lib/core/linkedlist.h.doxyme
  M  lib/core/list.h
  M  lib/core/list.h.doxyme
  M  lib/core/message.c
  M  lib/core/message.c.doxyme
  M  lib/core/message.h
  M  lib/core/message.h.doxyme
  M  lib/core/misc.c
  M  lib/core/misc.c.doxyme
  M  lib/core/misc.h
  M  lib/core/misc.h.doxyme
  M  lib/core/protodefs.h
  M  lib/core/protodefs.h.doxyme
  M  lib/core/sqlitedbapi.c
  M  lib/core/sqlitedbapi.c.doxyme
  M  lib/core/sqlitedbapi.h
  M  lib/core/sqlitedbapi.h.doxyme
  M  lib/core/state.h
  M  lib/core/state.h.doxyme
  M  lib/core/utils.c
  M  lib/core/utils.c.doxyme
  M  lib/core/utils.h
  M  lib/core/utils.h.doxyme

=== modified file 'lib/core/builder.c'
--- lib/core/builder.c  2010-02-08 15:18:06 +0000
+++ lib/core/builder.c  2010-02-10 23:55:24 +0000
@@ -62,7 +62,8 @@
 #include "hipd/input.h"
 #include "lib/tool/crypto.h"
 
-#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
+/* Not needed, already defined in netinet/in.h */
+/* #define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } } */
 
 #ifdef __KERNEL__
 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
@@ -81,41 +82,42 @@
  * - endpoint is not padded
  */
 static void hip_build_endpoint_hdr(struct endpoint_hip *endpoint_hdr,
-                           const char *hostname,
-                           se_hip_flags_t endpoint_flags,
-                           uint8_t host_id_algo,
-                           unsigned int rr_data_len)
+                                   const char *hostname,
+                                   se_hip_flags_t endpoint_flags,
+                                   uint8_t host_id_algo,
+                                   unsigned int rr_data_len)
 {
-       hip_build_param_host_id_hdr_priv(&endpoint_hdr->id.host_id,
-                                   hostname, rr_data_len, host_id_algo);
-       endpoint_hdr->family = PF_HIP;
-       endpoint_hdr->length = sizeof(struct endpoint_hip);
-       endpoint_hdr->flags = endpoint_flags;
-       endpoint_hdr->algo = host_id_algo;
-       _HIP_DEBUG("%d %d %d\n",
-                 sizeof(struct endpoint_hip),
-                 hip_get_param_total_len(&endpoint_hdr->id.host_id),
-                 sizeof(struct hip_host_id));
-       _HIP_DEBUG("endpoint hdr length: %d\n", endpoint_hdr->length);
+    hip_build_param_host_id_hdr_priv(&endpoint_hdr->id.host_id,
+                                     hostname, rr_data_len, host_id_algo);
+    endpoint_hdr->family = PF_HIP;
+    endpoint_hdr->length = sizeof(struct endpoint_hip);
+    endpoint_hdr->flags  = endpoint_flags;
+    endpoint_hdr->algo   = host_id_algo;
+    _HIP_DEBUG("%d %d %d\n",
+               sizeof(struct endpoint_hip),
+               hip_get_param_total_len(&endpoint_hdr->id.host_id),
+               sizeof(struct hip_host_id));
+    _HIP_DEBUG("endpoint hdr length: %d\n", endpoint_hdr->length);
 }
 
 void hip_build_param_host_id_only_priv(struct hip_host_id_priv *host_id,
-                                   const void *rr_data,
-                                   const char *fqdn)
+                                       const void *rr_data,
+                                       const char *fqdn)
 {
-       unsigned int rr_len = ntohs(host_id->hi_length) -
-               sizeof(struct hip_host_id_key_rdata);
-       uint16_t fqdn_len;
-
-       _HIP_DEBUG("hi len: %d\n", ntohs(host_id->hi_length));
-       _HIP_DEBUG("Copying %d bytes\n", rr_len);
-
-       memcpy(host_id->key, rr_data, rr_len);
-
-       fqdn_len = ntohs(host_id->di_type_length) & 0x0FFF;
-       _HIP_DEBUG("fqdn len: %d\n", fqdn_len);
-       if (fqdn_len)
-               memcpy(host_id->hostname, fqdn, fqdn_len);
+    unsigned int rr_len = ntohs(host_id->hi_length) -
+                          sizeof(struct hip_host_id_key_rdata);
+    uint16_t fqdn_len;
+
+    _HIP_DEBUG("hi len: %d\n", ntohs(host_id->hi_length));
+    _HIP_DEBUG("Copying %d bytes\n", rr_len);
+
+    memcpy(host_id->key, rr_data, rr_len);
+
+    fqdn_len = ntohs(host_id->di_type_length) & 0x0FFF;
+    _HIP_DEBUG("fqdn len: %d\n", fqdn_len);
+    if (fqdn_len) {
+        memcpy(host_id->hostname, fqdn, fqdn_len);
+    }
 }
 
 /*
@@ -123,21 +125,21 @@
  * - caller is responsible of reserving enough mem for endpoint
  */
 static void hip_build_endpoint(struct endpoint_hip *endpoint,
-                       const struct endpoint_hip *endpoint_hdr,
-                       const char *hostname,
-                       const unsigned char *key_rr,
-                       unsigned int key_rr_len)
+                               const struct endpoint_hip *endpoint_hdr,
+                               const char *hostname,
+                               const unsigned char *key_rr,
+                               unsigned int key_rr_len)
 {
-       _HIP_DEBUG("len=%d ep=%d rr=%d hostid=%d\n",
-                 endpoint_hdr->length,
-                 sizeof(struct endpoint_hip),
-                 key_rr_len,
-                 sizeof(struct hip_host_id));
-       HIP_ASSERT(endpoint_hdr->length == sizeof(struct endpoint_hip) +
-                  hip_get_param_total_len(&endpoint_hdr->id.host_id) -
-                  sizeof(struct hip_host_id_priv));
-       memcpy(endpoint, endpoint_hdr, sizeof(struct endpoint_hip));
-       hip_build_param_host_id_only_priv(&endpoint->id.host_id, key_rr, 
hostname);
+    _HIP_DEBUG("len=%d ep=%d rr=%d hostid=%d\n",
+               endpoint_hdr->length,
+               sizeof(struct endpoint_hip),
+               key_rr_len,
+               sizeof(struct hip_host_id));
+    HIP_ASSERT(endpoint_hdr->length == sizeof(struct endpoint_hip) +
+               hip_get_param_total_len(&endpoint_hdr->id.host_id) -
+               sizeof(struct hip_host_id_priv));
+    memcpy(endpoint, endpoint_hdr, sizeof(struct endpoint_hip));
+    hip_build_param_host_id_only_priv(&endpoint->id.host_id, key_rr, hostname);
 }
 
 /**
@@ -150,9 +152,10 @@
  * behaviour.
  *
  */
-void hip_msg_init(struct hip_common *msg) {
-       /* note: this is used both for daemon and network messages */
-       memset(msg, 0, HIP_MAX_PACKET);
+void hip_msg_init(struct hip_common *msg)
+{
+    /* note: this is used both for daemon and network messages */
+    memset(msg, 0, HIP_MAX_PACKET);
 }
 
 /**
@@ -162,12 +165,13 @@
  */
 struct hip_common *hip_msg_alloc(void)
 {
-        struct hip_common *ptr;
+    struct hip_common *ptr;
 
-       ptr = HIP_MALLOC(HIP_MAX_PACKET, GFP_ATOMIC);
-        if (ptr)
-               hip_msg_init(ptr);
-        return ptr;
+    ptr = HIP_MALLOC(HIP_MAX_PACKET, GFP_ATOMIC);
+    if (ptr) {
+        hip_msg_init(ptr);
+    }
+    return ptr;
 }
 
 /**
@@ -176,7 +180,7 @@
  */
 void hip_msg_free(struct hip_common *msg)
 {
-       HIP_FREE(msg);
+    HIP_FREE(msg);
 }
 
 /**
@@ -186,11 +190,14 @@
  *
  * @return the real size of HIP header in bytes (host byte order)
  */
-uint16_t hip_convert_msg_total_len_to_bytes(const hip_hdr_len_t len) {
-       return (len == 0) ? 0 : ((len + 1) << 3);
+uint16_t hip_convert_msg_total_len_to_bytes(const hip_hdr_len_t len)
+{
+    return (len == 0) ? 0 : ((len + 1) << 3);
 }
-uint16_t hip_convert_msg_total_len_to_bytes_16(uint16_t len) {
-       return (len == 0) ? 0 : ((len + 1) << 3);
+
+uint16_t hip_convert_msg_total_len_to_bytes_16(uint16_t len)
+{
+    return (len == 0) ? 0 : ((len + 1) << 3);
 }
 
 /**
@@ -199,27 +206,30 @@
  *
  * @return the real, total size of the message in bytes (host byte order).
  */
-uint16_t hip_get_msg_total_len(const struct hip_common *msg) {
-       if (msg->ver_res == HIP_USER_VER_RES) {
-               struct hip_common_user *umsg = (struct hip_common_user *)msg;
-               return hip_convert_msg_total_len_to_bytes_16(umsg->len);
-       } else
-               return hip_convert_msg_total_len_to_bytes(msg->payload_len);
+uint16_t hip_get_msg_total_len(const struct hip_common *msg)
+{
+    if (msg->ver_res == HIP_USER_VER_RES) {
+        struct hip_common_user *umsg = (struct hip_common_user *) msg;
+        return hip_convert_msg_total_len_to_bytes_16(umsg->len);
+    } else {
+        return hip_convert_msg_total_len_to_bytes(msg->payload_len);
+    }
 }
 
-
 /**
  * hip_set_msg_total_len - set the total message length in bytes
  * @param msg pointer to the beginning of the message header
  * @param len the total size of the message in bytes (host byte order)
  */
-void hip_set_msg_total_len(struct hip_common *msg, uint16_t len) {
-       /* assert len % 8 == 0 ? */
-       if (msg->ver_res == HIP_USER_VER_RES && len < HIP_MAX_PACKET) {
-               struct hip_common_user *umsg = (struct hip_common_user *)msg;
-               umsg->len = (len < 8) ? 0 : ((len >> 3) - 1);
-       } else
-               msg->payload_len = (len < 8) ? 0 : ((len >> 3) - 1);
+void hip_set_msg_total_len(struct hip_common *msg, uint16_t len)
+{
+    /* assert len % 8 == 0 ? */
+    if (msg->ver_res == HIP_USER_VER_RES && len < HIP_MAX_PACKET) {
+        struct hip_common_user *umsg = (struct hip_common_user *) msg;
+        umsg->len = (len < 8) ? 0 : ((len >> 3) - 1);
+    } else {
+        msg->payload_len = (len < 8) ? 0 : ((len >> 3) - 1);
+    }
 }
 
 /**
@@ -229,8 +239,9 @@
  * @return the type of the message (in host byte order)
  *
  */
-hip_hdr_type_t hip_get_msg_type(const struct hip_common *msg) {
-       return msg->type_hdr;
+hip_hdr_type_t hip_get_msg_type(const struct hip_common *msg)
+{
+    return msg->type_hdr;
 }
 
 /**
@@ -239,8 +250,9 @@
  * @param type the type of the message (in host byte order)
  *
  */
-void hip_set_msg_type(struct hip_common *msg, hip_hdr_type_t type) {
-       msg->type_hdr = type;
+void hip_set_msg_type(struct hip_common *msg, hip_hdr_type_t type)
+{
+    msg->type_hdr = type;
 }
 
 /**
@@ -250,13 +262,14 @@
  * @return the error value from the message (in host byte order)
  *
  */
-hip_hdr_err_t hip_get_msg_err(const struct hip_common *msg) {
-       /* Note: error value is stored in checksum field for daemon messages.
-          This should be fixed later on by defining an own header for
-          daemon messages. This function should then input void* as
-          the message argument and cast it to the daemon message header
-          structure. */
-       return msg->checksum; /* 1 byte, no ntohs() */
+hip_hdr_err_t hip_get_msg_err(const struct hip_common *msg)
+{
+    /* Note: error value is stored in checksum field for daemon messages.
+     * This should be fixed later on by defining an own header for
+     * daemon messages. This function should then input void* as
+     * the message argument and cast it to the daemon message header
+     * structure. */
+    return msg->checksum;     /* 1 byte, no ntohs() */
 }
 
 /**
@@ -264,25 +277,28 @@
  * @param msg pointer to the beginning of the message header
  * @param err the error value
  */
-void hip_set_msg_err(struct hip_common *msg, hip_hdr_err_t err) {
-       /* note: error value is stored in checksum field for daemon messages */
-       msg->checksum = err;
+void hip_set_msg_err(struct hip_common *msg, hip_hdr_err_t err)
+{
+    /* note: error value is stored in checksum field for daemon messages */
+    msg->checksum = err;
 }
 
 uint16_t hip_get_msg_checksum(struct hip_common *msg)
 {
-     return msg->checksum; /* one byte, no ntohs() */
+    return msg->checksum;  /* one byte, no ntohs() */
 }
 
 /**
  * hip_zero_msg_checksum - zero message checksum
  */
-void hip_zero_msg_checksum(struct hip_common *msg) {
-       msg->checksum = 0; /* one byte, no ntohs() */
+void hip_zero_msg_checksum(struct hip_common *msg)
+{
+    msg->checksum = 0;     /* one byte, no ntohs() */
 }
 
-void hip_set_msg_checksum(struct hip_common *msg, u8 checksum) {
-       msg->checksum = checksum; /* one byte, no ntohs() */
+void hip_set_msg_checksum(struct hip_common *msg, u8 checksum)
+{
+    msg->checksum = checksum;     /* one byte, no ntohs() */
 }
 
 /**
@@ -292,10 +308,11 @@
  * @return the total length of the parameter in bytes (host byte
  * order), including the padding.
  */
-hip_tlv_len_t hip_get_param_total_len(const void *tlv_common) {
-       return HIP_LEN_PAD(sizeof(struct hip_tlv_common) +
-                          ntohs(((const struct hip_tlv_common *)
-                                 tlv_common)->length));
+hip_tlv_len_t hip_get_param_total_len(const void *tlv_common)
+{
+    return HIP_LEN_PAD(sizeof(struct hip_tlv_common) +
+                       ntohs(((const struct hip_tlv_common *)
+                              tlv_common)->length));
 }
 
 /**
@@ -305,8 +322,9 @@
  * @return the length of the parameter in bytes (in host byte order),
  *          excluding padding and the length of "type" and "length" fields
  */
-hip_tlv_len_t hip_get_param_contents_len(const void *tlv_common) {
-       return ntohs(((const struct hip_tlv_common *)tlv_common)->length);
+hip_tlv_len_t hip_get_param_contents_len(const void *tlv_common)
+{
+    return ntohs(((const struct hip_tlv_common *) tlv_common)->length);
 }
 
 /**
@@ -315,9 +333,10 @@
  * @param len the length of the parameter in bytes (in host byte order),
  *              excluding padding and the length of "type" and "length" fields
  */
-void hip_set_param_contents_len(struct hip_tlv_common*tlv_generic,
-                                hip_tlv_len_t len) {
-       tlv_generic->length = htons(len);
+void hip_set_param_contents_len(struct hip_tlv_common *tlv_generic,
+                                hip_tlv_len_t len)
+{
+    tlv_generic->length = htons(len);
 }
 
 /**
@@ -326,8 +345,9 @@
  * @param tlv_common pointer to the parameter
  * @return           the type of the parameter (in host byte order)
  */
-hip_tlv_type_t hip_get_param_type(const void *tlv_common) {
-       return ntohs(((const struct hip_tlv_common *)tlv_common)->type);
+hip_tlv_type_t hip_get_param_type(const void *tlv_common)
+{
+    return ntohs(((const struct hip_tlv_common *) tlv_common)->type);
 }
 
 /**
@@ -335,8 +355,9 @@
  * @param tlv_common pointer to the parameter
  * @param type type of the parameter (in host byte order)
  */
-void hip_set_param_type(struct hip_tlv_common *tlv_generic, hip_tlv_type_t 
type) {
-       tlv_generic->type = htons(type);
+void hip_set_param_type(struct hip_tlv_common *tlv_generic, hip_tlv_type_t 
type)
+{
+    tlv_generic->type = htons(type);
 }
 
 /**
@@ -347,9 +368,11 @@
  */
 /* TODO function is unused - can it be deleted? */
 #if 0
-static void *hip_get_diffie_hellman_param_public_value_contents(const void 
*tlv_common) {
-       return (void *) tlv_common + sizeof(struct hip_diffie_hellman);
+static void *hip_get_diffie_hellman_param_public_value_contents(const void 
*tlv_common)
+{
+    return (void *) tlv_common + sizeof(struct hip_diffie_hellman);
 }
+
 #endif
 
 /**
@@ -361,10 +384,9 @@
  */
 static hip_tlv_len_t hip_get_diffie_hellman_param_public_value_len(const 
struct hip_diffie_hellman *dh)
 {
-       return hip_get_param_contents_len(dh) - sizeof(uint8_t) - 
sizeof(uint16_t);
+    return hip_get_param_contents_len(dh) - sizeof(uint8_t) - sizeof(uint16_t);
 }
 
-
 /**
  * hip_dh_select_key - Selects the stronger DH key according to Moskowitz, R.
  * et al. "Host Identity Protocol"  draft-ietf-hip-base-07.txt, section 5.2.6:
@@ -383,47 +405,46 @@
  */
 struct hip_dh_public_value *hip_dh_select_key(const struct hip_diffie_hellman 
*dhf)
 {
-        struct hip_dh_public_value *dhpv1 = NULL, *dhpv2 = NULL, *err = NULL;
-
-       if ( ntohs(dhf->pub_val.pub_len) ==
-            hip_get_diffie_hellman_param_public_value_len(dhf) ){
-                HIP_DEBUG("Single DHF public value received\n");
-                return (struct hip_dh_public_value *)&dhf->pub_val.group_id;
-       } else {
-
-                dhpv1 = (struct hip_dh_public_value *)&dhf->pub_val.group_id;
-                dhpv2 = (struct hip_dh_public_value *)
-                  (dhf->pub_val.public_value + ntohs(dhf->pub_val.pub_len));
-
-                HIP_IFEL (hip_get_diffie_hellman_param_public_value_len(dhf) !=
-                          ntohs(dhpv1->pub_len) + sizeof(uint8_t) + 
sizeof(uint16_t)
-                          + ntohs(dhpv2->pub_len), dhpv1, "Malformed DHF 
parameter\n");
-
-                HIP_DEBUG("Multiple DHF public values received\n");
-
-                _HIP_DEBUG("dhpv1->group_id= %d   dhpv2->group_id= %d\n",
-                           dhpv1->group_id, dhpv2->group_id);
-                _HIP_DEBUG("dhpv1->pub_len= %d   dhpv2->pub_len= %d\n",
-                           dhpv1->pub_len, dhpv2->pub_len);
-                _HIP_DEBUG("ntohs(dhpv1->pub_len)= %d   ntohs(dhpv2->pub_len)= 
%d\n",
-                           ntohs(dhpv1->pub_len), ntohs(dhpv2->pub_len));
-
-
-
-                /* Selection of a DH key depending on select_dh_key */
-                if ( (select_dh_key == STRONGER_KEY &&
-                      dhpv1->group_id >= dhpv2->group_id) ||
-                     (select_dh_key == WEAKER_KEY &&
-                      dhpv1->group_id <= dhpv2->group_id) )
-                       return dhpv1;
-                else
-                       return dhpv2;
-       }
- out_err:
-       return err;
+    struct hip_dh_public_value *dhpv1 = NULL, *dhpv2 = NULL, *err = NULL;
+
+    if (ntohs(dhf->pub_val.pub_len) ==
+        hip_get_diffie_hellman_param_public_value_len(dhf)) {
+        HIP_DEBUG("Single DHF public value received\n");
+        return (struct hip_dh_public_value *) &dhf->pub_val.group_id;
+    } else {
+        dhpv1 = (struct hip_dh_public_value *) &dhf->pub_val.group_id;
+        dhpv2 = (struct hip_dh_public_value *)
+                (dhf->pub_val.public_value + ntohs(dhf->pub_val.pub_len));
+
+        HIP_IFEL(hip_get_diffie_hellman_param_public_value_len(dhf) !=
+                 ntohs(dhpv1->pub_len) + sizeof(uint8_t) + sizeof(uint16_t)
+                 + ntohs(dhpv2->pub_len), dhpv1, "Malformed DHF parameter\n");
+
+        HIP_DEBUG("Multiple DHF public values received\n");
+
+        _HIP_DEBUG("dhpv1->group_id= %d   dhpv2->group_id= %d\n",
+                   dhpv1->group_id, dhpv2->group_id);
+        _HIP_DEBUG("dhpv1->pub_len= %d   dhpv2->pub_len= %d\n",
+                   dhpv1->pub_len, dhpv2->pub_len);
+        _HIP_DEBUG("ntohs(dhpv1->pub_len)= %d   ntohs(dhpv2->pub_len)= %d\n",
+                   ntohs(dhpv1->pub_len), ntohs(dhpv2->pub_len));
+
+
+
+        /* Selection of a DH key depending on select_dh_key */
+        if ((select_dh_key == STRONGER_KEY &&
+             dhpv1->group_id >= dhpv2->group_id) ||
+            (select_dh_key == WEAKER_KEY &&
+             dhpv1->group_id <= dhpv2->group_id)) {
+            return dhpv1;
+        } else {
+            return dhpv2;
+        }
+    }
+out_err:
+    return err;
 }
 
-
 #if 0
 /**
  * hip_set_param_spi_value - set the spi value in spi_lsi parameter
@@ -433,7 +454,7 @@
  */
 void hip_set_param_spi_value(struct hip_esp_info *esp_info, uint32_t spi)
 {
-       esp_info->spi = htonl(spi);
+    esp_info->spi = htonl(spi);
 }
 
 /**
@@ -444,8 +465,9 @@
  */
 uint32_t hip_get_param_spi_value(const struct hip_esp_info *esp_info)
 {
-       return ntohl(esp_info->spi);
+    return ntohl(esp_info->spi);
 }
+
 #endif
 
 /**
@@ -457,7 +479,7 @@
  */
 uint16_t hip_get_unit_test_suite_param_id(const struct hip_unit_test *test)
 {
-       return ntohs(test->suiteid);
+    return ntohs(test->suiteid);
 }
 
 /**
@@ -469,24 +491,27 @@
  */
 uint16_t hip_get_unit_test_case_param_id(const struct hip_unit_test *test)
 {
-       return ntohs(test->caseid);
-}
-
-uint8_t hip_get_host_id_algo(const struct hip_host_id *host_id) {
-       return host_id->rdata.algorithm; /* 8 bits, no ntons() */
-}
-
-struct hip_locator_info_addr_item *hip_get_locator_first_addr_item(const 
struct hip_locator *locator) {
-       return (struct hip_locator_info_addr_item *) (locator + 1);
-}
+    return ntohs(test->caseid);
+}
+
+uint8_t hip_get_host_id_algo(const struct hip_host_id *host_id)
+{
+    return host_id->rdata.algorithm;     /* 8 bits, no ntons() */
+}
+
+struct hip_locator_info_addr_item *hip_get_locator_first_addr_item(const 
struct hip_locator *locator)
+{
+    return (struct hip_locator_info_addr_item *) (locator + 1);
+}
+
 /* remove by santtu, since the item have type2
-int hip_get_locator_addr_item_count(struct hip_locator *locator) {
-       return (hip_get_param_contents_len(locator) -
-               (sizeof(struct hip_locator) -
-                sizeof(struct hip_tlv_common))) /
-               sizeof(struct hip_locator_info_addr_item);
-}
-*/
+ * int hip_get_locator_addr_item_count(struct hip_locator *locator) {
+ *      return (hip_get_param_contents_len(locator) -
+ *              (sizeof(struct hip_locator) -
+ *               sizeof(struct hip_tlv_common))) /
+ *              sizeof(struct hip_locator_info_addr_item);
+ * }
+ */
 #ifndef __KERNEL__
 
 /**
@@ -503,26 +528,25 @@
  */
 int hip_get_lifetime_value(time_t seconds, uint8_t *lifetime)
 {
-       /* Check that we get a lifetime value between 1 and 255. The minimum
-          lifetime according to the registration draft is 0.004 seconds, but
-          the reverse formula gives zero for that. 15384774.906 seconds is the
-          maximum value. The boundary checks done here are just curiosities
-          since services are usually granted for minutes to a couple of days,
-          but not for milliseconds and days. However, log() gives a range error
-          if "seconds" is zero. */
-       if(seconds == 0) {
-               *lifetime = 0;
-               return -1;
-       }else if(seconds > 15384774) {
-               *lifetime = 255;
-               return -1;
-       }else {
-               *lifetime = (8 * (log(seconds) / log(2))) + 64;
-               return 0;
-       }
+    /* Check that we get a lifetime value between 1 and 255. The minimum
+     * lifetime according to the registration draft is 0.004 seconds, but
+     * the reverse formula gives zero for that. 15384774.906 seconds is the
+     * maximum value. The boundary checks done here are just curiosities
+     * since services are usually granted for minutes to a couple of days,
+     * but not for milliseconds and days. However, log() gives a range error
+     * if "seconds" is zero. */
+    if (seconds == 0) {
+        *lifetime = 0;
+        return -1;
+    } else if (seconds > 15384774)   {
+        *lifetime = 255;
+        return -1;
+    } else {
+        *lifetime = (8 * (log(seconds) / log(2))) + 64;
+        return 0;
+    }
 }
 
-
 /**
  * Translates a service life time from a 8-bit integer value to seconds. The
  * lifetime value is translated to a 8-bit integer value using following
@@ -533,20 +557,22 @@
  * @return          zero on success, -1 on error. Error occurs when @c lifetime
  *                  is zero.
  */
-int hip_get_lifetime_seconds(uint8_t lifetime, time_t *seconds){
-       if(lifetime == 0) {
-               *seconds = 0;
-               return -1;
-       }
-       /* All values between from 1 to 63 give just fractions of a second. */
-       else if(lifetime < 64) {
-               *seconds = 1;
-               return 0;
-       } else {
-               *seconds = pow(2, ((double)((lifetime)-64)/8));
-               return 0;
-       }
+int hip_get_lifetime_seconds(uint8_t lifetime, time_t *seconds)
+{
+    if (lifetime == 0) {
+        *seconds = 0;
+        return -1;
+    }
+    /* All values between from 1 to 63 give just fractions of a second. */
+    else if (lifetime < 64) {
+        *seconds = 1;
+        return 0;
+    } else {
+        *seconds = pow(2, ((double) ((lifetime) - 64) / 8));
+        return 0;
+    }
 }
+
 #endif
 /**
  * hip_check_user_msg_len - check validity of user message length
@@ -555,20 +581,20 @@
  * @return 1 if the message length is valid, or 0 if the message length is
  *          invalid
  */
-int hip_check_user_msg_len(const struct hip_common *msg) {
-       uint16_t len;
-
-       HIP_ASSERT(msg);
-       len = hip_get_msg_total_len(msg);
-
-       if (len < sizeof(struct hip_common) || len > HIP_MAX_PACKET) {
-               return 0;
-       } else {
-               return 1;
-       }
+int hip_check_user_msg_len(const struct hip_common *msg)
+{
+    uint16_t len;
+
+    HIP_ASSERT(msg);
+    len = hip_get_msg_total_len(msg);
+
+    if (len < sizeof(struct hip_common) || len > HIP_MAX_PACKET) {
+        return 0;
+    } else {
+        return 1;
+    }
 }
 
-
 /**
  * hip_check_network_msg_len - check validity of network message length
  * @param msg pointer to the message
@@ -578,20 +604,18 @@
  */
 int hip_check_network_msg_len(const struct hip_common *msg)
 {
-       uint16_t len;
-
-       HIP_ASSERT(msg);
-       len = hip_get_msg_total_len(msg);
-
-       if (len < sizeof(struct hip_common) || len > HIP_MAX_NETWORK_PACKET) {
-               return 0;
-       } else {
-               return 1;
-       }
+    uint16_t len;
+
+    HIP_ASSERT(msg);
+    len = hip_get_msg_total_len(msg);
+
+    if (len < sizeof(struct hip_common) || len > HIP_MAX_NETWORK_PACKET) {
+        return 0;
+    } else {
+        return 1;
+    }
 }
 
-
-
 /**
  * hip_check_network_msg_type - check the type of the network message
  * @param msg pointer to the message
@@ -599,32 +623,33 @@
  * @return 1 if the message type is valid, or 0 if the message type is
  *          invalid
  */
-int hip_check_network_msg_type(const struct hip_common *msg) {
-       int ok = 0;
-       hip_hdr_type_t supported[] =
-               {
-                       HIP_I1,
-                       HIP_R1,
-                       HIP_I2,
-                       HIP_R2,
-                       HIP_UPDATE,
-                       HIP_NOTIFY,
-                       HIP_BOS,
-                       HIP_CLOSE,
-                       HIP_CLOSE_ACK,
-                       HIP_LUPDATE
-               };
-       hip_hdr_type_t i;
-       hip_hdr_type_t type = hip_get_msg_type(msg);
-
-       for (i = 0; i < sizeof(supported) / sizeof(hip_hdr_type_t); i++) {
-               if (type == supported[i]) {
-                       ok = 1;
-                       break;
-               }
-       }
-
-       return ok;
+int hip_check_network_msg_type(const struct hip_common *msg)
+{
+    int ok                     = 0;
+    hip_hdr_type_t supported[] =
+    {
+        HIP_I1,
+        HIP_R1,
+        HIP_I2,
+        HIP_R2,
+        HIP_UPDATE,
+        HIP_NOTIFY,
+        HIP_BOS,
+        HIP_CLOSE,
+        HIP_CLOSE_ACK,
+        HIP_LUPDATE
+    };
+    hip_hdr_type_t i;
+    hip_hdr_type_t type = hip_get_msg_type(msg);
+
+    for (i = 0; i < sizeof(supported) / sizeof(hip_hdr_type_t); i++) {
+        if (type == supported[i]) {
+            ok = 1;
+            break;
+        }
+    }
+
+    return ok;
 }
 
 /**
@@ -635,7 +660,7 @@
  */
 int hip_check_userspace_param_type(const struct hip_tlv_common *param)
 {
-       return 1;
+    return 1;
 }
 
 /**
@@ -656,83 +681,83 @@
  */
 int hip_check_network_param_type(const struct hip_tlv_common *param)
 {
-       int ok = 0;
-       hip_tlv_type_t i;
-       hip_tlv_type_t valid[] =
-               {
-                       HIP_PARAM_ACK,
-                       HIP_PARAM_BLIND_NONCE,
-                        HIP_PARAM_CERT,
-                        HIP_PARAM_DIFFIE_HELLMAN,
-                        HIP_PARAM_ECHO_REQUEST,
-                        HIP_PARAM_ECHO_REQUEST_SIGN,
-                        HIP_PARAM_ECHO_RESPONSE,
-                        HIP_PARAM_ECHO_RESPONSE_SIGN,
-                        HIP_PARAM_ENCRYPTED,
-                        HIP_PARAM_ESP_INFO,
-                        HIP_PARAM_ESP_INFO,
-                        HIP_PARAM_ESP_TRANSFORM,
-                        HIP_PARAM_FROM,
-                       HIP_PARAM_RELAY_FROM,
-                       //add by santtu
-                       HIP_PARAM_RELAY_HMAC,
-                       //end add
-                        HIP_PARAM_HIP_SIGNATURE,
-                        HIP_PARAM_HIP_SIGNATURE2,
-                        HIP_PARAM_HIP_TRANSFORM,
-                        HIP_PARAM_HMAC,
-                        HIP_PARAM_HMAC,
-                        HIP_PARAM_HMAC2,
-                       HIP_PARAM_RVS_HMAC,
-                        HIP_PARAM_HOST_ID,
-                        HIP_PARAM_LOCATOR,
-                       //add by santtu
-                       HIP_PARAM_NAT_TRANSFORM,
-                       HIP_PARAM_NAT_PACING,
-                       HIP_PARAM_STUN,
-                       //end add
-                        HIP_PARAM_NOTIFICATION,
-                        HIP_PARAM_PUZZLE,
-                        HIP_PARAM_R1_COUNTER,
-                        HIP_PARAM_REG_FAILED,
-                        HIP_PARAM_REG_INFO,
-                        HIP_PARAM_REG_REQUEST,
-                        HIP_PARAM_REG_RESPONSE,
-                        HIP_PARAM_SEQ,
-                        HIP_PARAM_SOLUTION,
-                        HIP_PARAM_VIA_RVS,
-                       HIP_PARAM_RELAY_TO,
-                       //add by santtu
-                       HIP_PARAM_REG_FROM,
-                       //end add
-                       HIP_PARAM_ESP_PROT_TRANSFORMS,
-                       HIP_PARAM_ESP_PROT_ANCHOR,
-                       HIP_PARAM_ESP_PROT_BRANCH,
-                       HIP_PARAM_ESP_PROT_SECRET,
-                       HIP_PARAM_ESP_PROT_ROOT
+    int ok                 = 0;
+    hip_tlv_type_t i;
+    hip_tlv_type_t valid[] =
+    {
+        HIP_PARAM_ACK,
+        HIP_PARAM_BLIND_NONCE,
+        HIP_PARAM_CERT,
+        HIP_PARAM_DIFFIE_HELLMAN,
+        HIP_PARAM_ECHO_REQUEST,
+        HIP_PARAM_ECHO_REQUEST_SIGN,
+        HIP_PARAM_ECHO_RESPONSE,
+        HIP_PARAM_ECHO_RESPONSE_SIGN,
+        HIP_PARAM_ENCRYPTED,
+        HIP_PARAM_ESP_INFO,
+        HIP_PARAM_ESP_INFO,
+        HIP_PARAM_ESP_TRANSFORM,
+        HIP_PARAM_FROM,
+        HIP_PARAM_RELAY_FROM,
+        //add by santtu
+        HIP_PARAM_RELAY_HMAC,
+        //end add
+        HIP_PARAM_HIP_SIGNATURE,
+        HIP_PARAM_HIP_SIGNATURE2,
+        HIP_PARAM_HIP_TRANSFORM,
+        HIP_PARAM_HMAC,
+        HIP_PARAM_HMAC,
+        HIP_PARAM_HMAC2,
+        HIP_PARAM_RVS_HMAC,
+        HIP_PARAM_HOST_ID,
+        HIP_PARAM_LOCATOR,
+        //add by santtu
+        HIP_PARAM_NAT_TRANSFORM,
+        HIP_PARAM_NAT_PACING,
+        HIP_PARAM_STUN,
+        //end add
+        HIP_PARAM_NOTIFICATION,
+        HIP_PARAM_PUZZLE,
+        HIP_PARAM_R1_COUNTER,
+        HIP_PARAM_REG_FAILED,
+        HIP_PARAM_REG_INFO,
+        HIP_PARAM_REG_REQUEST,
+        HIP_PARAM_REG_RESPONSE,
+        HIP_PARAM_SEQ,
+        HIP_PARAM_SOLUTION,
+        HIP_PARAM_VIA_RVS,
+        HIP_PARAM_RELAY_TO,
+        //add by santtu
+        HIP_PARAM_REG_FROM,
+        //end add
+        HIP_PARAM_ESP_PROT_TRANSFORMS,
+        HIP_PARAM_ESP_PROT_ANCHOR,
+        HIP_PARAM_ESP_PROT_BRANCH,
+        HIP_PARAM_ESP_PROT_SECRET,
+        HIP_PARAM_ESP_PROT_ROOT
 #ifdef CONFIG_HIP_MIDAUTH
-                      ,HIP_PARAM_ECHO_REQUEST_M,
-                        HIP_PARAM_ECHO_RESPONSE_M,
-                        HIP_PARAM_CHALLENGE_REQUEST,
-                        HIP_PARAM_CHALLENGE_RESPONSE
+        ,                             HIP_PARAM_ECHO_REQUEST_M,
+        HIP_PARAM_ECHO_RESPONSE_M,
+        HIP_PARAM_CHALLENGE_REQUEST,
+        HIP_PARAM_CHALLENGE_RESPONSE
 #endif
-               };
-       hip_tlv_type_t type = hip_get_param_type(param);
-
-       /** @todo check the lengths of the parameters */
-
-       for (i = 0; i < ARRAY_SIZE(valid); i++) {
-               if (!(type & 0x0001)) {
-                       _HIP_DEBUG("Optional param, skip\n");
-                       ok = 1;
-                       break;
-               } else if (type == valid[i]) {
-                       ok = 1;
-                       break;
-               }
-       }
-
-       return ok;
+    };
+    hip_tlv_type_t type = hip_get_param_type(param);
+
+    /** @todo check the lengths of the parameters */
+
+    for (i = 0; i < ARRAY_SIZE(valid); i++) {
+        if (!(type & 0x0001)) {
+            _HIP_DEBUG("Optional param, skip\n");
+            ok = 1;
+            break;
+        } else if (type == valid[i]) {
+            ok = 1;
+            break;
+        }
+    }
+
+    return ok;
 }
 
 /**
@@ -748,27 +773,28 @@
  *              message). Zero is returned on invalid contents length.
  */
 int hip_check_param_contents_len(const struct hip_common *msg,
-                                const struct hip_tlv_common *param) {
-       int ok = 0;
-       int param_len = hip_get_param_total_len(param);
-       void *pos = (void *) param;
-
-       /* Note: the lower limit is not checked, because there really is no
-          lower limit. */
-
-       if (pos == ((void *)msg)) {
-               HIP_ERROR("not a parameter\n");
-       } else if (pos + param_len > ((void *) msg) + HIP_MAX_PACKET) {
-               HIP_DEBUG("param far too long (%d)\n", param_len);
-       } else if (param_len > hip_get_msg_total_len(msg)) {
-               HIP_DEBUG("param too long (%d) msg_len %d\n", param_len,
-                                               hip_get_msg_total_len(msg));
-       } else {
-               _HIP_DEBUG("param length ok (%d) msg_len %d\n", param_len,
-                                               hip_get_msg_total_len(msg));
-               ok = 1;
-       }
-       return ok;
+                                 const struct hip_tlv_common *param)
+{
+    int ok        = 0;
+    int param_len = hip_get_param_total_len(param);
+    void *pos     = (void *) param;
+
+    /* Note: the lower limit is not checked, because there really is no
+     * lower limit. */
+
+    if (pos == ((void *) msg)) {
+        HIP_ERROR("not a parameter\n");
+    } else if (pos + param_len > ((void *) msg) + HIP_MAX_PACKET) {
+        HIP_DEBUG("param far too long (%d)\n", param_len);
+    } else if (param_len > hip_get_msg_total_len(msg)) {
+        HIP_DEBUG("param too long (%d) msg_len %d\n", param_len,
+                  hip_get_msg_total_len(msg));
+    } else {
+        _HIP_DEBUG("param length ok (%d) msg_len %d\n", param_len,
+                   hip_get_msg_total_len(msg));
+        ok = 1;
+    }
+    return ok;
 }
 
 /**
@@ -781,48 +807,47 @@
  *                      NULL if no parameters were found.
  */
 struct hip_tlv_common *hip_get_next_param(const struct hip_common *msg,
-                                         const struct hip_tlv_common 
*current_param)
+                                          const struct hip_tlv_common 
*current_param)
 {
-       struct hip_tlv_common *next_param = NULL;
-       void *pos = (void *) current_param;
-
-       if (!msg) {
-               HIP_ERROR("msg null\n");
-               goto out;
-       }
-
-       if (current_param == NULL) {
-               pos = (void *) msg;
-       }
-
-       if (pos == msg)
-               pos += sizeof(struct hip_common);
-       else
-               pos += hip_get_param_total_len(current_param);
-
-       next_param = (struct hip_tlv_common *) pos;
-
-       /* check that the next parameter does not point
-          a) outside of the message
-          b) out of the buffer with check_param_contents_len()
-          c) to an empty slot in the message */
-       if (((char *) next_param) - ((char *) msg) >=
-           hip_get_msg_total_len(msg) || /* a */
-           !hip_check_param_contents_len(msg, next_param) || /* b */
-           hip_get_param_contents_len(next_param) == 0) {    /* c */
-               _HIP_DEBUG("no more parameters found\n");
-               next_param = NULL;
-       } else {
-               /* next parameter successfully found  */
-               _HIP_DEBUG("next param: type=%d, len=%d\n",
-                         hip_get_param_type(next_param),
-                         hip_get_param_contents_len(next_param));
-       }
-
- out:
-       return next_param;
-
-
+    struct hip_tlv_common *next_param = NULL;
+    void *pos                         = (void *) current_param;
+
+    if (!msg) {
+        HIP_ERROR("msg null\n");
+        goto out;
+    }
+
+    if (current_param == NULL) {
+        pos = (void *) msg;
+    }
+
+    if (pos == msg) {
+        pos += sizeof(struct hip_common);
+    } else {
+        pos += hip_get_param_total_len(current_param);
+    }
+
+    next_param = (struct hip_tlv_common *) pos;
+
+    /* check that the next parameter does not point
+     * a) outside of the message
+     * b) out of the buffer with check_param_contents_len()
+     * c) to an empty slot in the message */
+    if (((char *) next_param) - ((char *) msg) >=
+        hip_get_msg_total_len(msg) ||     /* a */
+        !hip_check_param_contents_len(msg, next_param) ||     /* b */
+        hip_get_param_contents_len(next_param) == 0) {        /* c */
+        _HIP_DEBUG("no more parameters found\n");
+        next_param = NULL;
+    } else {
+        /* next parameter successfully found  */
+        _HIP_DEBUG("next param: type=%d, len=%d\n",
+                   hip_get_param_type(next_param),
+                   hip_get_param_contents_len(next_param));
+    }
+
+out:
+    return next_param;
 }
 
 /**
@@ -831,7 +856,7 @@
  * If there are multiple parameters of the same type, one should use
  * hip_get_next_param() after calling this function to iterate through
  * them all.
-
+ *
  * @param msg        a pointer to the beginning of the message header.
  * @param param_type the type of the parameter to be searched from msg
  *                   (in host byte order)
@@ -841,25 +866,25 @@
  */
 void *hip_get_param(const struct hip_common *msg, hip_tlv_type_t param_type)
 {
-       void *matched = NULL;
-       struct hip_tlv_common *current_param = NULL;
-
-       _HIP_DEBUG("searching for type %d\n", param_type);
-
-       /** @todo Optimize: stop when next parameter's type is greater than the
-          searched one. */
-
-       while((current_param = hip_get_next_param(msg, current_param))
-             != NULL) {
-               _HIP_DEBUG("current param %d\n",
-                          hip_get_param_type(current_param));
-               if (hip_get_param_type(current_param) == param_type) {
-                       matched = current_param;
-                       break;
-               }
-       }
-
-       return matched;
+    void *matched                        = NULL;
+    struct hip_tlv_common *current_param = NULL;
+
+    _HIP_DEBUG("searching for type %d\n", param_type);
+
+    /** @todo Optimize: stop when next parameter's type is greater than the
+     *  searched one. */
+
+    while ((current_param = hip_get_next_param(msg, current_param))
+           != NULL) {
+        _HIP_DEBUG("current param %d\n",
+                   hip_get_param_type(current_param));
+        if (hip_get_param_type(current_param) == param_type) {
+            matched = current_param;
+            break;
+        }
+    }
+
+    return matched;
 }
 
 /**
@@ -875,13 +900,13 @@
  *                   @c param_type were found.
  */
 void *hip_get_param_contents(const struct hip_common *msg,
-                            hip_tlv_type_t param_type)
+                             hip_tlv_type_t param_type)
 {
-
-       void *contents = hip_get_param(msg,param_type);
-       if (contents)
-               contents += sizeof(struct hip_tlv_common);
-       return contents;
+    void *contents = hip_get_param(msg, param_type);
+    if (contents) {
+        contents += sizeof(struct hip_tlv_common);
+    }
+    return contents;
 }
 
 /**
@@ -893,10 +918,9 @@
  */
 void *hip_get_param_contents_direct(const void *tlv_common)
 {
-       return ((void *)tlv_common) + sizeof(struct hip_tlv_common);
+    return ((void *) tlv_common) + sizeof(struct hip_tlv_common);
 }
 
-
 /* hip_get_nth_param - get nth parameter of given type from the message
  * @param msg pointer to the beginning of the message header
  * @param param_type the type of the parameter to be searched from msg
@@ -906,24 +930,25 @@
  * @return the nth parameter from the message if found, else %NULL.
  */
 void *hip_get_nth_param(const struct hip_common *msg,
-                       hip_tlv_type_t param_type, int n)
+                        hip_tlv_type_t param_type, int n)
 {
-       struct hip_tlv_common *param = NULL;
-       int i = 0;
-
-       if (n < 1) {
-               HIP_ERROR("n < 1 (n=%d)\n", n);
-               return NULL;
-       }
-
-       while((param = hip_get_next_param(msg, param))) {
-               if (hip_get_param_type(param) == param_type) {
-                       i++;
-                       if (i == n)
-                               return param;
-               }
-       }
-       return NULL;
+    struct hip_tlv_common *param = NULL;
+    int i                        = 0;
+
+    if (n < 1) {
+        HIP_ERROR("n < 1 (n=%d)\n", n);
+        return NULL;
+    }
+
+    while ((param = hip_get_next_param(msg, param))) {
+        if (hip_get_param_type(param) == param_type) {
+            i++;
+            if (i == n) {
+                return param;
+            }
+        }
+    }
+    return NULL;
 }
 
 /**
@@ -943,47 +968,46 @@
  */
 static void *hip_find_free_param(const struct hip_common *msg)
 {
-       struct hip_tlv_common *current_param = NULL;
-       struct hip_tlv_common *last_used_pos = NULL;
-       void *free_pos = NULL;
-       void *first_pos = ((void *) msg) + sizeof(struct hip_common);
-
-       /* Check for no parameters: this has to be checked separately because
-          we cannot tell from the return value of get_next_param() whether
-          the message was completely full or there just were no parameters.
-          The length is used for checking the existance of parameter, because
-          type field may be zero (SPI_LSI = 0) and therefore it cannot be
-          used for checking the existance. */
-       if (hip_get_param_contents_len((struct hip_tlv_common *) first_pos)
-           == 0) {
-               _HIP_DEBUG("no parameters\n");
-               free_pos = first_pos;
-               goto out;
-       }
-
-       while((current_param = hip_get_next_param(msg, current_param))
-             != NULL) {
-               last_used_pos = current_param;
-               _HIP_DEBUG("not free: type=%d, contents_len=%d\n",
-                         hip_get_param_type(current_param),
-                         hip_get_param_contents_len(current_param));
-       }
-
-       if (last_used_pos == NULL) {
-               free_pos = NULL; /* the message was full */
-       } else {
-               free_pos = ((void *) last_used_pos) +
-                       hip_get_param_total_len(last_used_pos);
-       }
-
- out:
-       return free_pos;
+    struct hip_tlv_common *current_param = NULL;
+    struct hip_tlv_common *last_used_pos = NULL;
+    void *free_pos                       = NULL;
+    void *first_pos                      = ((void *) msg) + sizeof(struct 
hip_common);
+
+    /* Check for no parameters: this has to be checked separately because
+     * we cannot tell from the return value of get_next_param() whether
+     * the message was completely full or there just were no parameters.
+     * The length is used for checking the existance of parameter, because
+     * type field may be zero (SPI_LSI = 0) and therefore it cannot be
+     * used for checking the existance. */
+    if (hip_get_param_contents_len((struct hip_tlv_common *) first_pos)
+        == 0) {
+        _HIP_DEBUG("no parameters\n");
+        free_pos = first_pos;
+        goto out;
+    }
+
+    while ((current_param = hip_get_next_param(msg, current_param))
+           != NULL) {
+        last_used_pos = current_param;
+        _HIP_DEBUG("not free: type=%d, contents_len=%d\n",
+                   hip_get_param_type(current_param),
+                   hip_get_param_contents_len(current_param));
+    }
+
+    if (last_used_pos == NULL) {
+        free_pos = NULL;         /* the message was full */
+    } else {
+        free_pos = ((void *) last_used_pos) +
+                   hip_get_param_total_len(last_used_pos);
+    }
+
+out:
+    return free_pos;
 }
 
-
 /**
  * @brief Updates messsage header length
-  *
+ *
  * This function is called always when a parameter has been added or the
  * daemon/network header was written. This function writes the new
  * header length directly into the message.
@@ -992,43 +1016,43 @@
  */
 void hip_calc_hdr_len(struct hip_common *msg)
 {
-       struct hip_tlv_common *param = NULL;
-       void *pos = (void *) msg;
-
-       /* We cannot call get_next() or get_free() because they need a valid
-          header length which is to be (possibly) calculated now. So, the
-          header length must be calculated manually here. */
-
-       if (hip_get_msg_total_len(msg) == 0) {
-               /* msg len is zero when
-                  1) calling build_param() for the first time
-                  2) calling just the build_hdr() without building
-                     any parameters, e.g. in plain error messages */
-               _HIP_DEBUG("case 1,2\n");
-               hip_set_msg_total_len(msg, sizeof(struct hip_common));
-       } else {
-               /* 3) do nothing, build_param()+ */
-               /* 4) do nothing, build_param()+ and build_hdr() */
-               _HIP_DEBUG("case 3,4\n");
-       }
-
-       pos += hip_get_msg_total_len(msg);
-       param = (struct hip_tlv_common *) pos;
-       if (hip_get_param_contents_len(param) != 0) {
-               /* Case 1 and 3: a new parameter (with a valid length) has
-                  been added and the message length has not been updated. */
-               _HIP_DEBUG("case 1,3\n");
-               hip_set_msg_total_len(msg, hip_get_msg_total_len(msg) +
-                                     hip_get_param_total_len(param));
-               /* XX assert: new pos must be of type 0 (assume only one
-                  header has been added) */
-       } else {
-               /* case 2 and 4: the message length does not need to be
-                  updated */
-               _HIP_DEBUG("case 2,4\n");
-       }
-
-       _HIP_DEBUG("msg len %d\n", hip_get_msg_total_len(msg));
+    struct hip_tlv_common *param = NULL;
+    void *pos                    = (void *) msg;
+
+    /* We cannot call get_next() or get_free() because they need a valid
+     * header length which is to be (possibly) calculated now. So, the
+     * header length must be calculated manually here. */
+
+    if (hip_get_msg_total_len(msg) == 0) {
+        /* msg len is zero when
+         * 1) calling build_param() for the first time
+         * 2) calling just the build_hdr() without building
+         *    any parameters, e.g. in plain error messages */
+        _HIP_DEBUG("case 1,2\n");
+        hip_set_msg_total_len(msg, sizeof(struct hip_common));
+    } else {
+        /* 3) do nothing, build_param()+ */
+        /* 4) do nothing, build_param()+ and build_hdr() */
+        _HIP_DEBUG("case 3,4\n");
+    }
+
+    pos  += hip_get_msg_total_len(msg);
+    param = (struct hip_tlv_common *) pos;
+    if (hip_get_param_contents_len(param) != 0) {
+        /* Case 1 and 3: a new parameter (with a valid length) has
+        *  been added and the message length has not been updated. */
+        _HIP_DEBUG("case 1,3\n");
+        hip_set_msg_total_len(msg, hip_get_msg_total_len(msg) +
+                              hip_get_param_total_len(param));
+        /* XX assert: new pos must be of type 0 (assume only one
+         * header has been added) */
+    } else {
+        /* case 2 and 4: the message length does not need to be
+         * updated */
+        _HIP_DEBUG("case 2,4\n");
+    }
+
+    _HIP_DEBUG("msg len %d\n", hip_get_msg_total_len(msg));
 }
 
 /**
@@ -1047,12 +1071,12 @@
  *                 (in host byte order)
  */
 void hip_calc_generic_param_len(struct hip_tlv_common *tlv_common,
-                             hip_tlv_len_t tlv_size,
-                             hip_tlv_len_t contents_size)
+                                hip_tlv_len_t tlv_size,
+                                hip_tlv_len_t contents_size)
 {
-       hip_set_param_contents_len(tlv_common,
-                                  tlv_size + contents_size -
-                                  sizeof(struct hip_tlv_common));
+    hip_set_param_contents_len(tlv_common,
+                               tlv_size + contents_size -
+                               sizeof(struct hip_tlv_common));
 }
 
 /**
@@ -1066,10 +1090,11 @@
  * it assumes that the length of the header of the TLV is just
  * sizeof(struct hip_tlv_common).
  */
-void hip_calc_param_len(struct hip_tlv_common * tlv_common, hip_tlv_len_t 
contents_size)
+void hip_calc_param_len(struct hip_tlv_common *tlv_common, hip_tlv_len_t 
contents_size)
 {
-       hip_calc_generic_param_len(tlv_common, sizeof(struct hip_tlv_common),
-                                  contents_size);
+    hip_calc_generic_param_len(tlv_common,
+                               sizeof(struct hip_tlv_common),
+                               contents_size);
 }
 
 /**
@@ -1081,44 +1106,43 @@
  */
 void hip_dump_msg(const struct hip_common *msg)
 {
-     struct hip_tlv_common *current_param = NULL;
-     void *contents = NULL;
-     /* The value of the "Length"-field in current parameter. */
-     hip_tlv_len_t len = 0;
-     /* Total length of the parameter (type+length+value+padding), and the
-       length of padding. */
-     size_t total_len = 0, pad_len = 0;
-     HIP_DEBUG("--------------- MSG START ------------------\n");
-
-     HIP_DEBUG("Msg type :      %s (%d)\n",
-              hip_message_type_name(hip_get_msg_type(msg)),
-              hip_get_msg_type(msg));
-     HIP_DEBUG("Msg length:     %d\n", hip_get_msg_total_len(msg));
-     HIP_DEBUG("Msg err:        %d\n", hip_get_msg_err(msg));
-     HIP_DEBUG("Msg controls:   0x%04x\n", msg->control);
-
-     _HIP_DEBUG_HIT("Msg hits:       ", &msg->hits );
-     _HIP_DEBUG_HIT("Msg hitr:       ", &msg->hitr );
-
-     while((current_param = hip_get_next_param(msg, current_param)) != NULL)
-     {
-         len = hip_get_param_contents_len(current_param);
-         /* Formula from base draft section 5.2.1. */
-         total_len = 11 + len - (len +3) % 8;
-         pad_len = total_len - len - sizeof(hip_tlv_type_t)
-              - sizeof(hip_tlv_len_t);
-         contents = hip_get_param_contents_direct(current_param);
-         HIP_DEBUG("Parameter type:%s (%d). Total length: %d (4 type+"\
-                   "length, %d content, %d padding).\n",
-                   hip_param_type_name(hip_get_param_type(current_param)),
-                   hip_get_param_type(current_param),
-                   total_len,
-                   len,
-                   pad_len);
-         HIP_HEXDUMP("Contents:", contents, len);
-         HIP_HEXDUMP("Padding:", contents + len , pad_len);
-     }
-     HIP_DEBUG("---------------- MSG END --------------------\n");
+    struct hip_tlv_common *current_param = NULL;
+    void *contents                       = NULL;
+    /* The value of the "Length"-field in current parameter. */
+    hip_tlv_len_t len                    = 0;
+    /* Total length of the parameter (type+length+value+padding), and the
+     * length of padding. */
+    size_t total_len                     = 0, pad_len = 0;
+    HIP_DEBUG("--------------- MSG START ------------------\n");
+
+    HIP_DEBUG("Msg type :      %s (%d)\n",
+              hip_message_type_name(hip_get_msg_type(msg)),
+              hip_get_msg_type(msg));
+    HIP_DEBUG("Msg length:     %d\n", hip_get_msg_total_len(msg));
+    HIP_DEBUG("Msg err:        %d\n", hip_get_msg_err(msg));
+    HIP_DEBUG("Msg controls:   0x%04x\n", msg->control);
+
+    _HIP_DEBUG_HIT("Msg hits:       ", &msg->hits );
+    _HIP_DEBUG_HIT("Msg hitr:       ", &msg->hitr );
+
+    while ((current_param = hip_get_next_param(msg, current_param)) != NULL) {
+        len       = hip_get_param_contents_len(current_param);
+        /* Formula from base draft section 5.2.1. */
+        total_len = 11 + len - (len + 3) % 8;
+        pad_len   = total_len - len - sizeof(hip_tlv_type_t)
+                    - sizeof(hip_tlv_len_t);
+        contents  = hip_get_param_contents_direct(current_param);
+        HIP_DEBUG("Parameter type:%s (%d). Total length: %d (4 type+" \
+                  "length, %d content, %d padding).\n",
+                  hip_param_type_name(hip_get_param_type(current_param)),
+                  hip_get_param_type(current_param),
+                  total_len,
+                  len,
+                  pad_len);
+        HIP_HEXDUMP("Contents:", contents, len);
+        HIP_HEXDUMP("Padding:", contents + len, pad_len);
+    }
+    HIP_DEBUG("---------------- MSG END --------------------\n");
 }
 
 /**
@@ -1131,117 +1155,118 @@
  * @param msg_type message type number
  * @return         name of the message type
  **/
-char* hip_message_type_name(const uint8_t msg_type){
-       switch (msg_type) {
-       case HIP_I1:            return "HIP_I1";
-       case HIP_R1:            return "HIP_R1";
-       case HIP_I2:            return "HIP_I2";
-       case HIP_R2:            return "HIP_R2";
-       case HIP_UPDATE:        return "HIP_UPDATE";
-       case HIP_NOTIFY:        return "HIP_NOTIFY";
-       case HIP_CLOSE:         return "HIP_CLOSE";
-       case HIP_CLOSE_ACK:     return "HIP_CLOSE_ACK";
-       case HIP_CER:           return "HIP_CER";
-       case HIP_PAYLOAD:       return "HIP_PAYLOAD";
-       case HIP_PSIG:          return "HIP_PSIG";
-       case HIP_TRIG:          return "HIP_TRIG";
+char *hip_message_type_name(const uint8_t msg_type)
+{
+    switch (msg_type) {
+    case HIP_I1:            return "HIP_I1";
+    case HIP_R1:            return "HIP_R1";
+    case HIP_I2:            return "HIP_I2";
+    case HIP_R2:            return "HIP_R2";
+    case HIP_UPDATE:        return "HIP_UPDATE";
+    case HIP_NOTIFY:        return "HIP_NOTIFY";
+    case HIP_CLOSE:         return "HIP_CLOSE";
+    case HIP_CLOSE_ACK:     return "HIP_CLOSE_ACK";
+    case HIP_CER:           return "HIP_CER";
+    case HIP_PAYLOAD:       return "HIP_PAYLOAD";
+    case HIP_PSIG:          return "HIP_PSIG";
+    case HIP_TRIG:          return "HIP_TRIG";
 
-       case SO_HIP_ADD_LOCAL_HI:       return "SO_HIP_ADD_LOCAL_HI";
-       case SO_HIP_DEL_LOCAL_HI:       return "SO_HIP_DEL_LOCAL_HI";
-       case SO_HIP_RUN_UNIT_TEST:      return "SO_HIP_RUN_UNIT_TEST";
-       case SO_HIP_RST:                return "SO_HIP_RST";
-       case SO_HIP_UNIT_TEST:          return "SO_HIP_UNIT_TEST";
-       case SO_HIP_BOS:                return "SO_HIP_BOS";
-       case SO_HIP_NETLINK_DUMMY:      return "SO_HIP_NETLINK_DUMMY";
-       case SO_HIP_CONF_PUZZLE_NEW:    return "SO_HIP_CONF_PUZZLE_NEW";
-       case SO_HIP_CONF_PUZZLE_GET:    return "SO_HIP_CONF_PUZZLE_GET";
-       case SO_HIP_CONF_PUZZLE_SET:    return "SO_HIP_CONF_PUZZLE_SET";
-       case SO_HIP_CONF_PUZZLE_INC:    return "SO_HIP_CONF_PUZZLE_INC";
-       case SO_HIP_CONF_PUZZLE_DEC:    return "SO_HIP_CONF_PUZZLE_DEC";
-       case SO_HIP_SET_OPPORTUNISTIC_MODE: return 
"SO_HIP_SET_OPPORTUNISTIC_MODE";
-       case SO_HIP_SET_BLIND_ON:       return "SO_HIP_SET_BLIND_ON";
-       case SO_HIP_SET_BLIND_OFF:      return "SO_HIP_SET_BLIND_OFF";
-       case SO_HIP_DHT_GW:             return "SO_HIP_DHT_GW";
-       case SO_HIP_SET_DEBUG_ALL:      return "SO_HIP_SET_DEBUG_ALL";
-       case SO_HIP_SET_DEBUG_MEDIUM:   return "SO_HIP_SET_DEBUG_MEDIUM";
-       case SO_HIP_SET_DEBUG_NONE:     return "SO_HIP_SET_DEBUG_NONE";
-       case SO_HIP_MHADDR_ACTIVE:      return "SO_HIP_MHADDR_ACTIVE";
-       case SO_HIP_MHADDR_LAZY:        return "SO_HIP_MHADDR_LAZY";
-       case SO_HIP_RESTART:            return "SO_HIP_RESTART";
-       case SO_HIP_SET_LOCATOR_ON:     return "SO_HIP_SET_LOCATOR_ON";
-       case SO_HIP_SET_LOCATOR_OFF:    return "SO_HIP_SET_LOCATOR_OFF";
-       case SO_HIP_DHT_SET:            return "SO_HIP_DHT_SET";
-       case SO_HIP_DHT_ON:             return "SO_HIP_DHT_ON";
-       case SO_HIP_DHT_OFF:            return "SO_HIP_DHT_OFF";
-       case SO_HIP_HIT_TO_IP_ON:       return "SO_HIP_HIT_TO_IP_ON";
-       case SO_HIP_HIT_TO_IP_OFF:      return "SO_HIP_HIT_TO_IP_OFF";
-       case SO_HIP_HIT_TO_IP_SET:      return "SO_HIP_HIT_TO_IP_SET";
-       case SO_HIP_SET_OPPTCP_ON:      return "SO_HIP_SET_OPPTCP_ON";
-       case SO_HIP_SET_OPPTCP_OFF:     return "SO_HIP_SET_OPPTCP_OFF";
-       case SO_HIP_OPPTCP_SEND_TCP_PACKET: return 
"SO_HIP_OPPTCP_SEND_TCP_PACKET";
-       case SO_HIP_TRANSFORM_ORDER:    return "SO_HIP_TRANSFORM_ORDER";
-       case SO_HIP_OFFER_RVS:          return "SO_HIP_OFFER_RVS";
-       case SO_HIP_CANCEL_RVS:         return "SO_HIP_CANCEL_RVS";
-       case SO_HIP_REINIT_RVS:         return "SO_HIP_REINIT_RVS";
-       case SO_HIP_ADD_DEL_SERVER:     return "SO_HIP_ADD_DEL_SERVER";
-       case SO_HIP_OFFER_HIPRELAY:     return "SO_HIP_OFFER_HIPRELAY";
-       case SO_HIP_CANCEL_HIPRELAY:    return "SO_HIP_CANCEL_HIPRELAY";
-       case SO_HIP_REINIT_RELAY:       return "SO_HIP_REINIT_RELAY";
-       case SO_HIP_ADD_DB_HI:          return "SO_HIP_ADD_DB_HI";
-       case SO_HIP_FIREWALL_PING:      return "SO_HIP_FIREWALL_PING";
-       case SO_HIP_FIREWALL_PING_REPLY: return "SO_HIP_FIREWALL_PING_REPLY";
-       case SO_HIP_FIREWALL_QUIT:      return "SO_HIP_FIREWALL_QUIT";
-       case SO_HIP_AGENT_PING:         return "SO_HIP_AGENT_PING";
-       case SO_HIP_AGENT_PING_REPLY:   return "SO_HIP_AGENT_PING_REPLY";
-       case SO_HIP_AGENT_QUIT:         return "SO_HIP_AGENT_QUIT";
-       case SO_HIP_DAEMON_QUIT:        return "SO_HIP_DAEMON_QUIT";
-       case SO_HIP_I1_REJECT:          return "SO_HIP_I1_REJECT";
-       case SO_HIP_SET_NAT_PLAIN_UDP:  return "SO_HIP_SET_NAT_PLAIN_UDP";
-       case SO_HIP_SET_NAT_NONE:       return "SO_HIP_SET_NAT_NONE";
-       case SO_HIP_SET_HIPPROXY_ON:    return "SO_HIP_SET_HIPPROXY_ON";
-       case SO_HIP_SET_HIPPROXY_OFF:   return "SO_HIP_SET_HIPPROXY_OFF";
-       case SO_HIP_GET_PROXY_LOCAL_ADDRESS: return 
"SO_HIP_GET_PROXY_LOCAL_ADDRESS";
-       case SO_HIP_HIPPROXY_STATUS_REQUEST: return 
"SO_HIP_HIPPROXY_STATUS_REQUEST";
-       case SO_HIP_OPPTCP_UNBLOCK_AND_BLACKLIST: return 
"SO_HIP_OPPTCP_UNBLOCK_AND_BLACKLIST";
-       case SO_HIP_FW_BEX_DONE:        return "SO_HIP_FW_BEX_DONE";
-       case SO_HIP_SET_TCPTIMEOUT_ON:  return "SO_HIP_SET_TCPTIMEOUT_ON";
-       case SO_HIP_SET_TCPTIMEOUT_OFF: return "SO_HIP_SET_TCPTIMEOUT_OFF";
-       case SO_HIP_SET_NAT_ICE_UDP:    return "SO_HIP_SET_NAT_ICE_UDP";
-       case SO_HIP_IPSEC_ADD_SA:       return "SO_HIP_IPSEC_ADD_SA";
-       case SO_HIP_USERSPACE_IPSEC:    return "SO_HIP_USERSPACE_IPSEC";
-       case SO_HIP_ESP_PROT_TFM:       return "SO_HIP_ESP_PROT_TFM";
-       case SO_HIP_BEX_STORE_UPDATE:   return "SO_HIP_BEX_STORE_UPDATE";
-       case SO_HIP_TRIGGER_UPDATE:     return "SO_HIP_TRIGGER_UPDATE";
-       case SO_HIP_ANCHOR_CHANGE:      return "SO_HIP_ANCHOR_CHANGE";
-       case SO_HIP_TRIGGER_BEX:        return "SO_HIP_TRIGGER_BEX";
-         //case SO_HIP_IS_OUR_LSI: return "SO_HIP_IS_OUR_LSI";
-       case SO_HIP_GET_PEER_HIT:       return "SO_HIP_GET_PEER_HIT";
-       case SO_HIP_REGISTER_SAVAHR: return "SO_HIP_REGISTER_SAVAHR";
-       case SO_HIP_GET_SAVAHR_IN_KEYS: return "SO_HIP_GET_SAVAHR_IN_KEYS";
-       case SO_HIP_GET_SAVAHR_OUT_KEYS: return "SO_HIP_GET_SAVAHR_OUT_KEYS";
-         //case SO_HIP_GET_PEER_HIT_BY_LSIS: return 
"SO_HIP_GET_PEER_HIT_BY_LSIS";
-       case SO_HIP_NSUPDATE_ON:        return "SO_HIP_NSUPDATE_ON";
-       case SO_HIP_NSUPDATE_OFF:       return "SO_HIP_NSUPDATE_OFF";
-       case SO_HIP_SET_HI3_ON:         return "SO_HIP_SET_HI3_ON";
-       case SO_HIP_SET_HI3_OFF:        return "SO_HIP_SET_HI3_OFF";
-       case SO_HIP_HEARTBEAT:          return "SO_HIP_HEARTBEAT";
-       case SO_HIP_DHT_SERVING_GW:     return "SO_HIP_DHT_SERVING_GW";
-       case SO_HIP_SET_NAT_PORT:       return "SO_HIP_SET_NAT_PORT";
-       case SO_HIP_SHOTGUN_ON:         return "SO_HIP_SHOTGUN_ON";
-       case SO_HIP_SHOTGUN_OFF:        return "SO_HIP_SHOTGUN_OFF";
-       case SO_HIP_SIGN_BUDDY_X509V3:  return "SO_HIP_SIGN_BUDDY_X509V3";
-       case SO_HIP_SIGN_BUDDY_SPKI:    return "SO_HIP_SIGN_BUDDY_SPKI";
-       case SO_HIP_VERIFY_BUDDY_X509V3: return "SO_HIP_VERIFY_BUDDY_X509V3";
-       case SO_HIP_VERIFY_BUDDY_SPKI:  return "SO_HIP_VERIFY_BUDDY_SPKI";
-       case SO_HIP_MAP_ID_TO_ADDR:     return "SO_HIP_MAP_ID_TO_ADDR";
-       case SO_HIP_OFFER_FULLRELAY:    return "SO_HIP_OFFER_FULLRELAY";
-       case SO_HIP_CANCEL_FULLRELAY:   return "SO_HIP_CANCEL_FULLRELAY";
-       case SO_HIP_REINIT_FULLRELAY:   return "SO_HIP_REINIT_FULLRELAY";
-       case SO_HIP_FIREWALL_START:     return "SO_HIP_FIREWALL_START";
-       case SO_HIP_MANUAL_UPDATE_PACKET: return "SO_HIP_MANUAL_UPDATE_PACKET";
-       default:
-               return "UNDEFINED";
-       }
+    case SO_HIP_ADD_LOCAL_HI:       return "SO_HIP_ADD_LOCAL_HI";
+    case SO_HIP_DEL_LOCAL_HI:       return "SO_HIP_DEL_LOCAL_HI";
+    case SO_HIP_RUN_UNIT_TEST:      return "SO_HIP_RUN_UNIT_TEST";
+    case SO_HIP_RST:                return "SO_HIP_RST";
+    case SO_HIP_UNIT_TEST:          return "SO_HIP_UNIT_TEST";
+    case SO_HIP_BOS:                return "SO_HIP_BOS";
+    case SO_HIP_NETLINK_DUMMY:      return "SO_HIP_NETLINK_DUMMY";
+    case SO_HIP_CONF_PUZZLE_NEW:    return "SO_HIP_CONF_PUZZLE_NEW";
+    case SO_HIP_CONF_PUZZLE_GET:    return "SO_HIP_CONF_PUZZLE_GET";
+    case SO_HIP_CONF_PUZZLE_SET:    return "SO_HIP_CONF_PUZZLE_SET";
+    case SO_HIP_CONF_PUZZLE_INC:    return "SO_HIP_CONF_PUZZLE_INC";
+    case SO_HIP_CONF_PUZZLE_DEC:    return "SO_HIP_CONF_PUZZLE_DEC";
+    case SO_HIP_SET_OPPORTUNISTIC_MODE: return "SO_HIP_SET_OPPORTUNISTIC_MODE";
+    case SO_HIP_SET_BLIND_ON:       return "SO_HIP_SET_BLIND_ON";
+    case SO_HIP_SET_BLIND_OFF:      return "SO_HIP_SET_BLIND_OFF";
+    case SO_HIP_DHT_GW:             return "SO_HIP_DHT_GW";
+    case SO_HIP_SET_DEBUG_ALL:      return "SO_HIP_SET_DEBUG_ALL";
+    case SO_HIP_SET_DEBUG_MEDIUM:   return "SO_HIP_SET_DEBUG_MEDIUM";
+    case SO_HIP_SET_DEBUG_NONE:     return "SO_HIP_SET_DEBUG_NONE";
+    case SO_HIP_MHADDR_ACTIVE:      return "SO_HIP_MHADDR_ACTIVE";
+    case SO_HIP_MHADDR_LAZY:        return "SO_HIP_MHADDR_LAZY";
+    case SO_HIP_RESTART:            return "SO_HIP_RESTART";
+    case SO_HIP_SET_LOCATOR_ON:     return "SO_HIP_SET_LOCATOR_ON";
+    case SO_HIP_SET_LOCATOR_OFF:    return "SO_HIP_SET_LOCATOR_OFF";
+    case SO_HIP_DHT_SET:            return "SO_HIP_DHT_SET";
+    case SO_HIP_DHT_ON:             return "SO_HIP_DHT_ON";
+    case SO_HIP_DHT_OFF:            return "SO_HIP_DHT_OFF";
+    case SO_HIP_HIT_TO_IP_ON:       return "SO_HIP_HIT_TO_IP_ON";
+    case SO_HIP_HIT_TO_IP_OFF:      return "SO_HIP_HIT_TO_IP_OFF";
+    case SO_HIP_HIT_TO_IP_SET:      return "SO_HIP_HIT_TO_IP_SET";
+    case SO_HIP_SET_OPPTCP_ON:      return "SO_HIP_SET_OPPTCP_ON";
+    case SO_HIP_SET_OPPTCP_OFF:     return "SO_HIP_SET_OPPTCP_OFF";
+    case SO_HIP_OPPTCP_SEND_TCP_PACKET: return "SO_HIP_OPPTCP_SEND_TCP_PACKET";
+    case SO_HIP_TRANSFORM_ORDER:    return "SO_HIP_TRANSFORM_ORDER";
+    case SO_HIP_OFFER_RVS:          return "SO_HIP_OFFER_RVS";
+    case SO_HIP_CANCEL_RVS:         return "SO_HIP_CANCEL_RVS";
+    case SO_HIP_REINIT_RVS:         return "SO_HIP_REINIT_RVS";
+    case SO_HIP_ADD_DEL_SERVER:     return "SO_HIP_ADD_DEL_SERVER";
+    case SO_HIP_OFFER_HIPRELAY:     return "SO_HIP_OFFER_HIPRELAY";
+    case SO_HIP_CANCEL_HIPRELAY:    return "SO_HIP_CANCEL_HIPRELAY";
+    case SO_HIP_REINIT_RELAY:       return "SO_HIP_REINIT_RELAY";
+    case SO_HIP_ADD_DB_HI:          return "SO_HIP_ADD_DB_HI";
+    case SO_HIP_FIREWALL_PING:      return "SO_HIP_FIREWALL_PING";
+    case SO_HIP_FIREWALL_PING_REPLY: return "SO_HIP_FIREWALL_PING_REPLY";
+    case SO_HIP_FIREWALL_QUIT:      return "SO_HIP_FIREWALL_QUIT";
+    case SO_HIP_AGENT_PING:         return "SO_HIP_AGENT_PING";
+    case SO_HIP_AGENT_PING_REPLY:   return "SO_HIP_AGENT_PING_REPLY";
+    case SO_HIP_AGENT_QUIT:         return "SO_HIP_AGENT_QUIT";
+    case SO_HIP_DAEMON_QUIT:        return "SO_HIP_DAEMON_QUIT";
+    case SO_HIP_I1_REJECT:          return "SO_HIP_I1_REJECT";
+    case SO_HIP_SET_NAT_PLAIN_UDP:  return "SO_HIP_SET_NAT_PLAIN_UDP";
+    case SO_HIP_SET_NAT_NONE:       return "SO_HIP_SET_NAT_NONE";
+    case SO_HIP_SET_HIPPROXY_ON:    return "SO_HIP_SET_HIPPROXY_ON";
+    case SO_HIP_SET_HIPPROXY_OFF:   return "SO_HIP_SET_HIPPROXY_OFF";
+    case SO_HIP_GET_PROXY_LOCAL_ADDRESS: return 
"SO_HIP_GET_PROXY_LOCAL_ADDRESS";
+    case SO_HIP_HIPPROXY_STATUS_REQUEST: return 
"SO_HIP_HIPPROXY_STATUS_REQUEST";
+    case SO_HIP_OPPTCP_UNBLOCK_AND_BLACKLIST: return 
"SO_HIP_OPPTCP_UNBLOCK_AND_BLACKLIST";
+    case SO_HIP_FW_BEX_DONE:        return "SO_HIP_FW_BEX_DONE";
+    case SO_HIP_SET_TCPTIMEOUT_ON:  return "SO_HIP_SET_TCPTIMEOUT_ON";
+    case SO_HIP_SET_TCPTIMEOUT_OFF: return "SO_HIP_SET_TCPTIMEOUT_OFF";
+    case SO_HIP_SET_NAT_ICE_UDP:    return "SO_HIP_SET_NAT_ICE_UDP";
+    case SO_HIP_IPSEC_ADD_SA:       return "SO_HIP_IPSEC_ADD_SA";
+    case SO_HIP_USERSPACE_IPSEC:    return "SO_HIP_USERSPACE_IPSEC";
+    case SO_HIP_ESP_PROT_TFM:       return "SO_HIP_ESP_PROT_TFM";
+    case SO_HIP_BEX_STORE_UPDATE:   return "SO_HIP_BEX_STORE_UPDATE";
+    case SO_HIP_TRIGGER_UPDATE:     return "SO_HIP_TRIGGER_UPDATE";
+    case SO_HIP_ANCHOR_CHANGE:      return "SO_HIP_ANCHOR_CHANGE";
+    case SO_HIP_TRIGGER_BEX:        return "SO_HIP_TRIGGER_BEX";
+    //case SO_HIP_IS_OUR_LSI: return "SO_HIP_IS_OUR_LSI";
+    case SO_HIP_GET_PEER_HIT:       return "SO_HIP_GET_PEER_HIT";
+    case SO_HIP_REGISTER_SAVAHR: return "SO_HIP_REGISTER_SAVAHR";
+    case SO_HIP_GET_SAVAHR_IN_KEYS: return "SO_HIP_GET_SAVAHR_IN_KEYS";
+    case SO_HIP_GET_SAVAHR_OUT_KEYS: return "SO_HIP_GET_SAVAHR_OUT_KEYS";
+    //case SO_HIP_GET_PEER_HIT_BY_LSIS: return "SO_HIP_GET_PEER_HIT_BY_LSIS";
+    case SO_HIP_NSUPDATE_ON:        return "SO_HIP_NSUPDATE_ON";
+    case SO_HIP_NSUPDATE_OFF:       return "SO_HIP_NSUPDATE_OFF";
+    case SO_HIP_SET_HI3_ON:         return "SO_HIP_SET_HI3_ON";
+    case SO_HIP_SET_HI3_OFF:        return "SO_HIP_SET_HI3_OFF";
+    case SO_HIP_HEARTBEAT:          return "SO_HIP_HEARTBEAT";
+    case SO_HIP_DHT_SERVING_GW:     return "SO_HIP_DHT_SERVING_GW";
+    case SO_HIP_SET_NAT_PORT:       return "SO_HIP_SET_NAT_PORT";
+    case SO_HIP_SHOTGUN_ON:         return "SO_HIP_SHOTGUN_ON";
+    case SO_HIP_SHOTGUN_OFF:        return "SO_HIP_SHOTGUN_OFF";
+    case SO_HIP_SIGN_BUDDY_X509V3:  return "SO_HIP_SIGN_BUDDY_X509V3";
+    case SO_HIP_SIGN_BUDDY_SPKI:    return "SO_HIP_SIGN_BUDDY_SPKI";
+    case SO_HIP_VERIFY_BUDDY_X509V3: return "SO_HIP_VERIFY_BUDDY_X509V3";
+    case SO_HIP_VERIFY_BUDDY_SPKI:  return "SO_HIP_VERIFY_BUDDY_SPKI";
+    case SO_HIP_MAP_ID_TO_ADDR:     return "SO_HIP_MAP_ID_TO_ADDR";
+    case SO_HIP_OFFER_FULLRELAY:    return "SO_HIP_OFFER_FULLRELAY";
+    case SO_HIP_CANCEL_FULLRELAY:   return "SO_HIP_CANCEL_FULLRELAY";
+    case SO_HIP_REINIT_FULLRELAY:   return "SO_HIP_REINIT_FULLRELAY";
+    case SO_HIP_FIREWALL_START:     return "SO_HIP_FIREWALL_START";
+    case SO_HIP_MANUAL_UPDATE_PACKET: return "SO_HIP_MANUAL_UPDATE_PACKET";
+    default:
+        return "UNDEFINED";
+    }
 }
 
 /**
@@ -1250,95 +1275,96 @@
  * @param param_type parameter type number
  * @return      name of the message type
  **/
-char* hip_param_type_name(const hip_tlv_type_t param_type){
-       switch (param_type) {
-       case HIP_PARAM_ACK:             return "HIP_PARAM_ACK";
-       case HIP_PARAM_AGENT_REJECT:    return "HIP_PARAM_AGENT_REJECT";
-       case HIP_PARAM_BLIND_NONCE:     return "HIP_PARAM_BLIND_NONCE";
-       case HIP_PARAM_CERT:            return "HIP_PARAM_CERT";
-       case HIP_PARAM_DH_SHARED_KEY:   return "HIP_PARAM_DH_SHARED_KEY";
-       case HIP_PARAM_DIFFIE_HELLMAN:  return "HIP_PARAM_DIFFIE_HELLMAN";
-       case HIP_PARAM_DSA_SIGN_DATA:   return "HIP_PARAM_DSA_SIGN_DATA";
-       case HIP_PARAM_DST_ADDR:        return "HIP_PARAM_DST_ADDR";
-       case HIP_PARAM_ECHO_REQUEST:    return "HIP_PARAM_ECHO_REQUEST";
-       case HIP_PARAM_ECHO_REQUEST_SIGN: return "HIP_PARAM_ECHO_REQUEST_SIGN";
-       case HIP_PARAM_ECHO_REQUEST_M:  return "HIP_PARAM_ECHO_REQUEST_M";
-       case HIP_PARAM_ECHO_RESPONSE:   return "HIP_PARAM_ECHO_RESPONSE";
-       case HIP_PARAM_ECHO_RESPONSE_SIGN: return 
"HIP_PARAM_ECHO_RESPONSE_SIGN";
-       case HIP_PARAM_ECHO_RESPONSE_M: return "HIP_PARAM_ECHO_RESPONSE_M";
-       case HIP_PARAM_EID_ADDR:        return "HIP_PARAM_EID_ADDR";
-       case HIP_PARAM_EID_ENDPOINT:    return "HIP_PARAM_EID_ENDPOINT";
-       case HIP_PARAM_EID_IFACE:       return "HIP_PARAM_EID_IFACE";
-       case HIP_PARAM_EID_SOCKADDR:    return "HIP_PARAM_EID_SOCKADDR";
-       case HIP_PARAM_ENCAPS_MSG:      return "HIP_PARAM_ENCAPS_MSG";
-       case HIP_PARAM_ENCRYPTED:       return "HIP_PARAM_ENCRYPTED";
-       case HIP_PARAM_ESP_INFO:        return "HIP_PARAM_ESP_INFO";
-       case HIP_PARAM_ESP_TRANSFORM:   return "HIP_PARAM_ESP_TRANSFORM";
-       case HIP_PARAM_FROM_PEER:       return "HIP_PARAM_FROM_PEER";
-       case HIP_PARAM_FROM:            return "HIP_PARAM_FROM";
-       case HIP_PARAM_HA_INFO:         return "HIP_PARAM_HA_INFO";
-       case HIP_PARAM_HASH_CHAIN_ANCHORS: return 
"HIP_PARAM_HASH_CHAIN_ANCHORS";
-       case HIP_PARAM_HASH_CHAIN_PSIG: return "HIP_PARAM_HASH_CHAIN_PSIG";
-       case HIP_PARAM_HASH_CHAIN_VALUE: return "HIP_PARAM_HASH_CHAIN_VALUE";
-       case HIP_PARAM_HIP_SIGNATURE2:  return "HIP_PARAM_HIP_SIGNATURE2";
-       case HIP_PARAM_HIP_SIGNATURE:   return "HIP_PARAM_HIP_SIGNATURE";
-       case HIP_PARAM_HIP_TRANSFORM:   return "HIP_PARAM_HIP_TRANSFORM";
-       case HIP_PARAM_HI:              return "HIP_PARAM_HI";
-       case HIP_PARAM_HIT:             return "HIP_PARAM_HIT";
-       case HIP_PARAM_HIT_LOCAL:       return "HIP_PARAM_HIT_LOCAL";
-       case HIP_PARAM_HIT_PEER:        return "HIP_PARAM_HIT_PEER";
-       case HIP_PARAM_HMAC2:           return "HIP_PARAM_HMAC2";
-       case HIP_PARAM_HMAC:            return "HIP_PARAM_HMAC";
-       case HIP_PARAM_HOST_ID:         return "HIP_PARAM_HOST_ID";
-       case HIP_PARAM_INT:             return "HIP_PARAM_INT";
-       case HIP_PARAM_IPV6_ADDR:       return "HIP_PARAM_IPV6_ADDR";
-       case HIP_PARAM_IPV6_ADDR_LOCAL: return "HIP_PARAM_IPV6_ADDR_LOCAL";
-       case HIP_PARAM_IPV6_ADDR_PEER:  return "HIP_PARAM_IPV6_ADDR_PEER";
-       case HIP_PARAM_KEYS:            return "HIP_PARAM_KEYS";
-       case HIP_PARAM_LOCATOR:         return "HIP_PARAM_LOCATOR";
-       case HIP_PARAM_NOTIFICATION:    return "HIP_PARAM_NOTIFICATION";
-       case HIP_PARAM_OPENDHT_GW_INFO: return "HIP_PARAM_OPENDHT_GW_INFO";
-       case HIP_PARAM_OPENDHT_SET:     return "HIP_PARAM_OPENDHT_SET";
-       case HIP_PARAM_PORTPAIR:        return "HIP_PARAM_PORTPAIR";
-       case HIP_PARAM_PUZZLE:          return "HIP_PARAM_PUZZLE";
-       case HIP_PARAM_CHALLENGE_REQUEST:       return 
"HIP_PARAM_CHALLENGE_REQUEST";
-       case HIP_PARAM_R1_COUNTER:      return "HIP_PARAM_R1_COUNTER";
-       case HIP_PARAM_REG_FAILED:      return "HIP_PARAM_REG_FAILED";
-       case HIP_PARAM_REG_FROM:        return "HIP_PARAM_REG_FROM";
-       case HIP_PARAM_REG_INFO:        return "HIP_PARAM_REG_INFO";
-       case HIP_PARAM_REG_REQUEST:     return "HIP_PARAM_REG_REQUEST";
-       case HIP_PARAM_REG_RESPONSE:    return "HIP_PARAM_REG_RESPONSE";
-       case HIP_PARAM_RELAY_FROM:      return "HIP_PARAM_RELAY_FROM";
-       case HIP_PARAM_RELAY_HMAC:      return "HIP_PARAM_RELAY_HMAC";
-       case HIP_PARAM_RELAY_TO:        return "HIP_PARAM_RELAY_TO";
-       case HIP_PARAM_RVS_HMAC:        return "HIP_PARAM_RVS_HMAC";
-       case HIP_PARAM_SEQ:             return "HIP_PARAM_SEQ";
-       case HIP_PARAM_SOLUTION:        return "HIP_PARAM_SOLUTION";
-       case HIP_PARAM_CHALLENGE_RESPONSE:      return 
"HIP_PARAM_CHALLENGE_RESPONSE";
-       case HIP_PARAM_SRC_ADDR:        return "HIP_PARAM_SRC_ADDR";
-       case HIP_PARAM_TO_PEER:         return "HIP_PARAM_TO_PEER";
-       case HIP_PARAM_UINT:            return "HIP_PARAM_UINT";
-       case HIP_PARAM_UNIT_TEST:       return "HIP_PARAM_UNIT_TEST";
-       case HIP_PARAM_VIA_RVS:         return "HIP_PARAM_VIA_RVS";
-       case HIP_PARAM_PSEUDO_HIT:      return "HIP_PARAM_PSEUDO_HIT";
-       case HIP_PARAM_HCHAIN_ANCHOR:   return "HIP_PARAM_HCHAIN_ANCHOR";
-       case HIP_PARAM_ESP_PROT_TRANSFORMS: return 
"HIP_PARAM_ESP_PROT_TRANSFORMS";
-       case HIP_PARAM_ESP_PROT_ANCHOR: return "HIP_PARAM_ESP_PROT_ANCHOR";
-       case HIP_PARAM_ESP_PROT_BRANCH: return "HIP_PARAM_ESP_PROT_BRANCH";
-       case HIP_PARAM_ESP_PROT_SECRET: return "HIP_PARAM_ESP_PROT_SECRET";
-       case HIP_PARAM_ESP_PROT_ROOT: return "HIP_PARAM_ESP_PROT_ROOT";
-       //add by santtu
-       case HIP_PARAM_NAT_TRANSFORM:   return "HIP_PARAM_NAT_TRANSFORM";
-       case HIP_PARAM_NAT_PACING:      return "HIP_PARAM_NAT_PACING";
-       //end add
-       case HIP_PARAM_LSI:             return "HIP_PARAM_LSI";
-       case HIP_PARAM_SRC_TCP_PORT:    return "HIP_PARAM_SRC_TCP_PORT";
-       case HIP_PARAM_DST_TCP_PORT:    return "HIP_PARAM_DST_TCP_PORT";
-       case HIP_PARAM_STUN:            return "HIP_PARAM_STUN";
-       case HIP_PARAM_HOSTNAME:        return "HIP_PARAM_HOSTNAME";
-       //end add
-       }
-       return "UNDEFINED";
+char *hip_param_type_name(const hip_tlv_type_t param_type)
+{
+    switch (param_type) {
+    case HIP_PARAM_ACK:             return "HIP_PARAM_ACK";
+    case HIP_PARAM_AGENT_REJECT:    return "HIP_PARAM_AGENT_REJECT";
+    case HIP_PARAM_BLIND_NONCE:     return "HIP_PARAM_BLIND_NONCE";
+    case HIP_PARAM_CERT:            return "HIP_PARAM_CERT";
+    case HIP_PARAM_DH_SHARED_KEY:   return "HIP_PARAM_DH_SHARED_KEY";
+    case HIP_PARAM_DIFFIE_HELLMAN:  return "HIP_PARAM_DIFFIE_HELLMAN";
+    case HIP_PARAM_DSA_SIGN_DATA:   return "HIP_PARAM_DSA_SIGN_DATA";
+    case HIP_PARAM_DST_ADDR:        return "HIP_PARAM_DST_ADDR";
+    case HIP_PARAM_ECHO_REQUEST:    return "HIP_PARAM_ECHO_REQUEST";
+    case HIP_PARAM_ECHO_REQUEST_SIGN: return "HIP_PARAM_ECHO_REQUEST_SIGN";
+    case HIP_PARAM_ECHO_REQUEST_M:  return "HIP_PARAM_ECHO_REQUEST_M";
+    case HIP_PARAM_ECHO_RESPONSE:   return "HIP_PARAM_ECHO_RESPONSE";
+    case HIP_PARAM_ECHO_RESPONSE_SIGN: return "HIP_PARAM_ECHO_RESPONSE_SIGN";
+    case HIP_PARAM_ECHO_RESPONSE_M: return "HIP_PARAM_ECHO_RESPONSE_M";
+    case HIP_PARAM_EID_ADDR:        return "HIP_PARAM_EID_ADDR";
+    case HIP_PARAM_EID_ENDPOINT:    return "HIP_PARAM_EID_ENDPOINT";
+    case HIP_PARAM_EID_IFACE:       return "HIP_PARAM_EID_IFACE";
+    case HIP_PARAM_EID_SOCKADDR:    return "HIP_PARAM_EID_SOCKADDR";
+    case HIP_PARAM_ENCAPS_MSG:      return "HIP_PARAM_ENCAPS_MSG";
+    case HIP_PARAM_ENCRYPTED:       return "HIP_PARAM_ENCRYPTED";
+    case HIP_PARAM_ESP_INFO:        return "HIP_PARAM_ESP_INFO";
+    case HIP_PARAM_ESP_TRANSFORM:   return "HIP_PARAM_ESP_TRANSFORM";
+    case HIP_PARAM_FROM_PEER:       return "HIP_PARAM_FROM_PEER";
+    case HIP_PARAM_FROM:            return "HIP_PARAM_FROM";
+    case HIP_PARAM_HA_INFO:         return "HIP_PARAM_HA_INFO";
+    case HIP_PARAM_HASH_CHAIN_ANCHORS: return "HIP_PARAM_HASH_CHAIN_ANCHORS";
+    case HIP_PARAM_HASH_CHAIN_PSIG: return "HIP_PARAM_HASH_CHAIN_PSIG";
+    case HIP_PARAM_HASH_CHAIN_VALUE: return "HIP_PARAM_HASH_CHAIN_VALUE";
+    case HIP_PARAM_HIP_SIGNATURE2:  return "HIP_PARAM_HIP_SIGNATURE2";
+    case HIP_PARAM_HIP_SIGNATURE:   return "HIP_PARAM_HIP_SIGNATURE";
+    case HIP_PARAM_HIP_TRANSFORM:   return "HIP_PARAM_HIP_TRANSFORM";
+    case HIP_PARAM_HI:              return "HIP_PARAM_HI";
+    case HIP_PARAM_HIT:             return "HIP_PARAM_HIT";
+    case HIP_PARAM_HIT_LOCAL:       return "HIP_PARAM_HIT_LOCAL";
+    case HIP_PARAM_HIT_PEER:        return "HIP_PARAM_HIT_PEER";
+    case HIP_PARAM_HMAC2:           return "HIP_PARAM_HMAC2";
+    case HIP_PARAM_HMAC:            return "HIP_PARAM_HMAC";
+    case HIP_PARAM_HOST_ID:         return "HIP_PARAM_HOST_ID";
+    case HIP_PARAM_INT:             return "HIP_PARAM_INT";
+    case HIP_PARAM_IPV6_ADDR:       return "HIP_PARAM_IPV6_ADDR";
+    case HIP_PARAM_IPV6_ADDR_LOCAL: return "HIP_PARAM_IPV6_ADDR_LOCAL";
+    case HIP_PARAM_IPV6_ADDR_PEER:  return "HIP_PARAM_IPV6_ADDR_PEER";
+    case HIP_PARAM_KEYS:            return "HIP_PARAM_KEYS";
+    case HIP_PARAM_LOCATOR:         return "HIP_PARAM_LOCATOR";
+    case HIP_PARAM_NOTIFICATION:    return "HIP_PARAM_NOTIFICATION";
+    case HIP_PARAM_OPENDHT_GW_INFO: return "HIP_PARAM_OPENDHT_GW_INFO";
+    case HIP_PARAM_OPENDHT_SET:     return "HIP_PARAM_OPENDHT_SET";
+    case HIP_PARAM_PORTPAIR:        return "HIP_PARAM_PORTPAIR";
+    case HIP_PARAM_PUZZLE:          return "HIP_PARAM_PUZZLE";
+    case HIP_PARAM_CHALLENGE_REQUEST:       return 
"HIP_PARAM_CHALLENGE_REQUEST";
+    case HIP_PARAM_R1_COUNTER:      return "HIP_PARAM_R1_COUNTER";
+    case HIP_PARAM_REG_FAILED:      return "HIP_PARAM_REG_FAILED";
+    case HIP_PARAM_REG_FROM:        return "HIP_PARAM_REG_FROM";
+    case HIP_PARAM_REG_INFO:        return "HIP_PARAM_REG_INFO";
+    case HIP_PARAM_REG_REQUEST:     return "HIP_PARAM_REG_REQUEST";
+    case HIP_PARAM_REG_RESPONSE:    return "HIP_PARAM_REG_RESPONSE";
+    case HIP_PARAM_RELAY_FROM:      return "HIP_PARAM_RELAY_FROM";
+    case HIP_PARAM_RELAY_HMAC:      return "HIP_PARAM_RELAY_HMAC";
+    case HIP_PARAM_RELAY_TO:        return "HIP_PARAM_RELAY_TO";
+    case HIP_PARAM_RVS_HMAC:        return "HIP_PARAM_RVS_HMAC";
+    case HIP_PARAM_SEQ:             return "HIP_PARAM_SEQ";
+    case HIP_PARAM_SOLUTION:        return "HIP_PARAM_SOLUTION";
+    case HIP_PARAM_CHALLENGE_RESPONSE:      return 
"HIP_PARAM_CHALLENGE_RESPONSE";
+    case HIP_PARAM_SRC_ADDR:        return "HIP_PARAM_SRC_ADDR";
+    case HIP_PARAM_TO_PEER:         return "HIP_PARAM_TO_PEER";
+    case HIP_PARAM_UINT:            return "HIP_PARAM_UINT";
+    case HIP_PARAM_UNIT_TEST:       return "HIP_PARAM_UNIT_TEST";
+    case HIP_PARAM_VIA_RVS:         return "HIP_PARAM_VIA_RVS";
+    case HIP_PARAM_PSEUDO_HIT:      return "HIP_PARAM_PSEUDO_HIT";
+    case HIP_PARAM_HCHAIN_ANCHOR:   return "HIP_PARAM_HCHAIN_ANCHOR";
+    case HIP_PARAM_ESP_PROT_TRANSFORMS: return "HIP_PARAM_ESP_PROT_TRANSFORMS";
+    case HIP_PARAM_ESP_PROT_ANCHOR: return "HIP_PARAM_ESP_PROT_ANCHOR";
+    case HIP_PARAM_ESP_PROT_BRANCH: return "HIP_PARAM_ESP_PROT_BRANCH";
+    case HIP_PARAM_ESP_PROT_SECRET: return "HIP_PARAM_ESP_PROT_SECRET";
+    case HIP_PARAM_ESP_PROT_ROOT: return "HIP_PARAM_ESP_PROT_ROOT";
+    //add by santtu
+    case HIP_PARAM_NAT_TRANSFORM:   return "HIP_PARAM_NAT_TRANSFORM";
+    case HIP_PARAM_NAT_PACING:      return "HIP_PARAM_NAT_PACING";
+    //end add
+    case HIP_PARAM_LSI:             return "HIP_PARAM_LSI";
+    case HIP_PARAM_SRC_TCP_PORT:    return "HIP_PARAM_SRC_TCP_PORT";
+    case HIP_PARAM_DST_TCP_PORT:    return "HIP_PARAM_DST_TCP_PORT";
+    case HIP_PARAM_STUN:            return "HIP_PARAM_STUN";
+    case HIP_PARAM_HOSTNAME:        return "HIP_PARAM_HOSTNAME";
+        //end add
+    }
+    return "UNDEFINED";
 }
 
 /**
@@ -1347,31 +1373,32 @@
  *
  * @return zero if the message was ok, or negative error value on error.
  */
-int hip_check_userspace_msg(const struct hip_common *msg) {
-       struct hip_tlv_common *current_param = NULL;
-       int err = 0;
-
-       if (!hip_check_user_msg_len(msg)) {
-               err = -EMSGSIZE;
-               HIP_ERROR("bad msg len %d\n", hip_get_msg_total_len(msg));
-               goto out;
-       }
-
-       while((current_param = hip_get_next_param(msg, current_param))
-             != NULL) {
-               if(!hip_check_param_contents_len(msg, current_param)) {
-                       err = -EMSGSIZE;
-                       HIP_ERROR("bad param len\n");
-                       break;
-               } else if (!hip_check_userspace_param_type(current_param)) {
-                       err = -EINVAL;
-                       HIP_ERROR("bad param type\n");
-                       break;
-               }
-       }
-
- out:
-       return err;
+int hip_check_userspace_msg(const struct hip_common *msg)
+{
+    struct hip_tlv_common *current_param = NULL;
+    int err                              = 0;
+
+    if (!hip_check_user_msg_len(msg)) {
+        err = -EMSGSIZE;
+        HIP_ERROR("bad msg len %d\n", hip_get_msg_total_len(msg));
+        goto out;
+    }
+
+    while ((current_param = hip_get_next_param(msg, current_param))
+           != NULL) {
+        if (!hip_check_param_contents_len(msg, current_param)) {
+            err = -EMSGSIZE;
+            HIP_ERROR("bad param len\n");
+            break;
+        } else if (!hip_check_userspace_param_type(current_param)) {
+            err = -EINVAL;
+            HIP_ERROR("bad param type\n");
+            break;
+        }
+    }
+
+out:
+    return err;
 }
 
 /**
@@ -1390,41 +1417,41 @@
  */
 int hip_check_network_param_attributes(const struct hip_tlv_common *param)
 {
-       hip_tlv_type_t type = hip_get_param_type(param);
-       int err = 0;
-
-       _HIP_DEBUG("type=%u\n", type);
-
-       switch(type) {
-       case HIP_PARAM_HIP_TRANSFORM:
-       case HIP_PARAM_ESP_TRANSFORM:
-       {
-               /* Search for one supported transform */
-               hip_transform_suite_t suite;
-
-               _HIP_DEBUG("Checking %s transform\n",
-                          type == HIP_PARAM_HIP_TRANSFORM ? "HIP" : "ESP");
-               suite = hip_get_param_transform_suite_id(param, 0);
-               if (suite == 0) {
-                       HIP_ERROR("Could not find suitable %s transform\n",
-                                 type == HIP_PARAM_HIP_TRANSFORM ? "HIP" : 
"ESP");
-                       err = -EPROTONOSUPPORT;
-               }
-               break;
-       }
-       case HIP_PARAM_HOST_ID:
-       {
-               uint8_t algo =
-                       hip_get_host_id_algo((struct hip_host_id *) param);
-               if (algo != HIP_HI_DSA && algo != HIP_HI_RSA) {
-                       err = -EPROTONOSUPPORT;
-                       HIP_ERROR("Host id algo %d not supported\n", algo);
-               }
-               break;
-       }
-       }
-       _HIP_DEBUG("err=%d\n", err);
-       return err;
+    hip_tlv_type_t type = hip_get_param_type(param);
+    int err             = 0;
+
+    _HIP_DEBUG("type=%u\n", type);
+
+    switch (type) {
+    case HIP_PARAM_HIP_TRANSFORM:
+    case HIP_PARAM_ESP_TRANSFORM:
+    {
+        /* Search for one supported transform */
+        hip_transform_suite_t suite;
+
+        _HIP_DEBUG("Checking %s transform\n",
+                   type == HIP_PARAM_HIP_TRANSFORM ? "HIP" : "ESP");
+        suite = hip_get_param_transform_suite_id(param, 0);
+        if (suite == 0) {
+            HIP_ERROR("Could not find suitable %s transform\n",
+                      type == HIP_PARAM_HIP_TRANSFORM ? "HIP" : "ESP");
+            err = -EPROTONOSUPPORT;
+        }
+        break;
+    }
+    case HIP_PARAM_HOST_ID:
+    {
+        uint8_t algo =
+            hip_get_host_id_algo((struct hip_host_id *) param);
+        if (algo != HIP_HI_DSA && algo != HIP_HI_RSA) {
+            err = -EPROTONOSUPPORT;
+            HIP_ERROR("Host id algo %d not supported\n", algo);
+        }
+        break;
+    }
+    }
+    _HIP_DEBUG("err=%d\n", err);
+    return err;
 }
 
 /**
@@ -1435,61 +1462,61 @@
  */
 int hip_check_network_msg(const struct hip_common *msg)
 {
-       struct hip_tlv_common *current_param = NULL;
-       hip_tlv_type_t current_param_type = 0, prev_param_type = 0;
-       int err = 0;
-
-       /* Checksum of the message header is verified in input.c */
-
-       if (!hip_check_network_msg_type(msg)) {
-               err = -EINVAL;
-               HIP_ERROR("bad msg type (%d)\n", hip_get_msg_type(msg));
-               goto out;
-       }
-
-       //check msg length
-       if (!hip_check_network_msg_len(msg)) {
-               err = -EMSGSIZE;
-               HIP_ERROR("bad msg len %d\n", hip_get_msg_total_len(msg));
-               goto out;
-       }
-
-       /* Checking of param types, lengths and ordering. */
-       while((current_param = hip_get_next_param(msg, current_param))
-             != NULL) {
-               current_param_type = hip_get_param_type(current_param);
-               if(!hip_check_param_contents_len(msg, current_param)) {
-                       err = -EMSGSIZE;
-                       HIP_ERROR("bad param len\n");
-                       break;
-               } else if (!hip_check_network_param_type(current_param)) {
-                       err = -EINVAL;
-                       HIP_ERROR("bad param type, current param=%u\n",
-                                 hip_get_param_type(current_param));
-                       break;
-               } else if (current_param_type < prev_param_type &&
-                          ((current_param_type < HIP_LOWER_TRANSFORM_TYPE ||
-                           current_param_type > HIP_UPPER_TRANSFORM_TYPE) &&
-                           (prev_param_type < HIP_LOWER_TRANSFORM_TYPE ||
-                            prev_param_type > HIP_UPPER_TRANSFORM_TYPE))) {
-                       /* According to draft-ietf-hip-base-03 parameter type 
order
-                        * strictly enforced, except for
-                        * HIP_LOWER_TRANSFORM_TYPE - HIP_UPPER_TRANSFORM_TYPE
-                        */
-                       err = -ENOMSG;
-                       HIP_ERROR("Wrong order of parameters (%d, %d)\n",
-                                 prev_param_type, current_param_type);
-                       break;
-               } else if (hip_check_network_param_attributes(current_param)) {
-                       HIP_ERROR("bad param attributes\n");
-                       err = -EINVAL;
-                       break;
-               }
-               prev_param_type = current_param_type;
-       }
-
- out:
-       return err;
+    struct hip_tlv_common *current_param = NULL;
+    hip_tlv_type_t current_param_type    = 0, prev_param_type = 0;
+    int err                              = 0;
+
+    /* Checksum of the message header is verified in input.c */
+
+    if (!hip_check_network_msg_type(msg)) {
+        err = -EINVAL;
+        HIP_ERROR("bad msg type (%d)\n", hip_get_msg_type(msg));
+        goto out;
+    }
+
+    //check msg length
+    if (!hip_check_network_msg_len(msg)) {
+        err = -EMSGSIZE;
+        HIP_ERROR("bad msg len %d\n", hip_get_msg_total_len(msg));
+        goto out;
+    }
+
+    /* Checking of param types, lengths and ordering. */
+    while ((current_param = hip_get_next_param(msg, current_param))
+           != NULL) {
+        current_param_type = hip_get_param_type(current_param);
+        if (!hip_check_param_contents_len(msg, current_param)) {
+            err = -EMSGSIZE;
+            HIP_ERROR("bad param len\n");
+            break;
+        } else if (!hip_check_network_param_type(current_param)) {
+            err = -EINVAL;
+            HIP_ERROR("bad param type, current param=%u\n",
+                      hip_get_param_type(current_param));
+            break;
+        } else if (current_param_type < prev_param_type &&
+                   ((current_param_type < HIP_LOWER_TRANSFORM_TYPE ||
+                     current_param_type > HIP_UPPER_TRANSFORM_TYPE) &&
+                    (prev_param_type < HIP_LOWER_TRANSFORM_TYPE ||
+                             prev_param_type > HIP_UPPER_TRANSFORM_TYPE))) {
+            /* According to draft-ietf-hip-base-03 parameter type order
+             * strictly enforced, except for
+             * HIP_LOWER_TRANSFORM_TYPE - HIP_UPPER_TRANSFORM_TYPE
+             */
+            err = -ENOMSG;
+            HIP_ERROR("Wrong order of parameters (%d, %d)\n",
+                      prev_param_type, current_param_type);
+            break;
+        } else if (hip_check_network_param_attributes(current_param)) {
+            HIP_ERROR("bad param attributes\n");
+            err = -EINVAL;
+            break;
+        }
+        prev_param_type = current_param_type;
+    }
+
+out:
+    return err;
 }
 
 /**
@@ -1514,88 +1541,89 @@
  * @see                  hip_build_param().
  * @see                  hip_build_param_contents().
  */
-static int hip_build_generic_param(struct hip_common *msg, const void 
*parameter_hdr,
-                           hip_tlv_len_t param_hdr_size, const void *contents)
+static int hip_build_generic_param(struct hip_common *msg,
+                                   const void *parameter_hdr,
+                                   hip_tlv_len_t param_hdr_size,
+                                   const void *contents)
 {
-       const struct hip_tlv_common *param =
-               (struct hip_tlv_common *) parameter_hdr;
-       void *src = NULL, *dst = NULL;
-       int err = 0, size = 0;
-       void *max_dst = ((void *) msg) + HIP_MAX_PACKET;
-
-       _HIP_DEBUG("\n");
-
-       if (msg == NULL) {
-               HIP_ERROR("Message is NULL.\n");
-               err = -EFAULT;
-               goto out;
-       }
-
-       if (contents == NULL) {
-               HIP_ERROR("Parameter contents to build is NULL.\n");
-               err = -EFAULT;
-               goto out;
-       }
-
-       if (param_hdr_size < sizeof(struct hip_tlv_common)) {
-               HIP_ERROR("Size of the parameter build is too small.\n");
-               err = -EMSGSIZE;
-               goto out;
-       }
-
-       dst = hip_find_free_param(msg);
-       if (dst == NULL) {
-               err = -EMSGSIZE;
-               HIP_ERROR("The message has no room for new parameters.\n");
-               goto out;
-       }
-
-       _HIP_DEBUG("found free: %d\n", dst - ((void *)msg));
-
-       if (dst + hip_get_param_total_len(param) > max_dst) {
-               err = -EMSGSIZE;
-               _HIP_DEBUG("dst == %d\n",dst);
-               HIP_ERROR("The parameter to build does not fit in the message "\
-                         "because if the parameter would be appended to "\
-                         "the message, maximum HIP packet length would be "\
-                         "exceeded."\
-                         "len: %d\n",
-                         hip_get_param_contents_len(param));
-               goto out;
-       }
-
-       /* copy header */
-       src = (void *) param;
-       size = param_hdr_size;
-       memcpy(dst, src, size);
-
-       /* copy contents  */
-       dst += param_hdr_size;
-       src = (void *) contents;
-       /* Copy the right amount of contents, see jokela draft for TLV
-          format. For example, this skips the algo in struct hip_sig2
-           (which is included in the length), see the
-          build_param_signature2_contents() function below. */
-       size = hip_get_param_contents_len(param) -
-               (param_hdr_size - sizeof(struct hip_tlv_common));
-       memcpy(dst, src, size);
-
-       _HIP_DEBUG("contents copied %d bytes\n", size);
-
-       /* we have to update header length or otherwise hip_find_free_param
-          will fail when it checks the header length */
-       hip_calc_hdr_len(msg);
-       if (hip_get_msg_total_len(msg) == 0) {
-               HIP_ERROR("Could not calculate temporary header length.\n");
-               err = -EFAULT;
-       }
-
-       _HIP_DEBUG("dumping msg, len = %d\n", hip_get_msg_total_len(msg));
-       _HIP_HEXDUMP("build msg: ", (void *) msg,
-                    hip_get_msg_total_len(msg));
- out:
-
-       return err;
+    const struct hip_tlv_common *param = (struct hip_tlv_common *) 
parameter_hdr;
+    void *src                          = NULL, *dst = NULL;
+    int err                            = 0, size = 0;
+    void *max_dst                      = ((void *) msg) + HIP_MAX_PACKET;
+
+    _HIP_DEBUG("\n");
+
+    if (msg == NULL) {
+        HIP_ERROR("Message is NULL.\n");
+        err = -EFAULT;
+        goto out;
+    }
+
+    if (contents == NULL) {
+        HIP_ERROR("Parameter contents to build is NULL.\n");
+        err = -EFAULT;
+        goto out;
+    }
+
+    if (param_hdr_size < sizeof(struct hip_tlv_common)) {
+        HIP_ERROR("Size of the parameter build is too small.\n");
+        err = -EMSGSIZE;
+        goto out;
+    }
+
+    dst = hip_find_free_param(msg);
+    if (dst == NULL) {
+        err = -EMSGSIZE;
+        HIP_ERROR("The message has no room for new parameters.\n");
+        goto out;
+    }
+
+    _HIP_DEBUG("found free: %d\n", dst - ((void *) msg));
+
+    if (dst + hip_get_param_total_len(param) > max_dst) {
+        err = -EMSGSIZE;
+        _HIP_DEBUG("dst == %d\n", dst);
+        HIP_ERROR("The parameter to build does not fit in the message " \
+                  "because if the parameter would be appended to " \
+                  "the message, maximum HIP packet length would be " \
+                  "exceeded." \
+                  "len: %d\n",
+                  hip_get_param_contents_len(param));
+        goto out;
+    }
+
+    /* copy header */
+    src  = (void *) param;
+    size = param_hdr_size;
+    memcpy(dst, src, size);
+
+    /* copy contents  */
+    dst += param_hdr_size;
+    src  = (void *) contents;
+    /* Copy the right amount of contents, see jokela draft for TLV
+     * format. For example, this skips the algo in struct hip_sig2
+     * (which is included in the length), see the
+     * build_param_signature2_contents() function below. */
+    size = hip_get_param_contents_len(param) -
+           (param_hdr_size - sizeof(struct hip_tlv_common));
+    memcpy(dst, src, size);
+
+    _HIP_DEBUG("contents copied %d bytes\n", size);
+
+    /* we have to update header length or otherwise hip_find_free_param
+     * will fail when it checks the header length */
+    hip_calc_hdr_len(msg);
+    if (hip_get_msg_total_len(msg) == 0) {
+        HIP_ERROR("Could not calculate temporary header length.\n");
+        err = -EFAULT;
+    }
+
+    _HIP_DEBUG("dumping msg, len = %d\n", hip_get_msg_total_len(msg));
+    _HIP_HEXDUMP("build msg: ", (void *) msg,
+                 hip_get_msg_total_len(msg));
+out:
+
+    return err;
 }
 
 /**
@@ -1617,19 +1645,19 @@
  * @see                 hip_build_param().
  */
 int hip_build_param_contents(struct hip_common *msg,
-                            const void *contents,
-                            hip_tlv_type_t param_type,
-                            hip_tlv_len_t contents_size)
+                             const void *contents,
+                             hip_tlv_type_t param_type,
+                             hip_tlv_len_t contents_size)
 {
-       struct hip_tlv_common param;
-       hip_set_param_type(&param, param_type);
-       hip_set_param_contents_len((struct hip_tlv_common *) &param, 
contents_size);
-       return hip_build_generic_param(msg, &param,
-                                      sizeof(struct hip_tlv_common),
-                                      contents);
+    struct hip_tlv_common param;
+    hip_set_param_type(&param, param_type);
+    hip_set_param_contents_len((struct hip_tlv_common *) &param, 
contents_size);
+    return hip_build_generic_param(msg,
+                                   &param,
+                                   sizeof(struct hip_tlv_common),
+                                   contents);
 }
 
-
 /**
  * Appends a complete parameter into a HIP message.
  *
@@ -1654,25 +1682,25 @@
  */
 int hip_build_param(struct hip_common *msg, const void *tlv_common)
 {
-       int err = 0;
-       void *contents = ((void *) tlv_common) + sizeof(struct hip_tlv_common);
-
-       if (tlv_common == NULL) {
-               err = -EFAULT;
-               HIP_ERROR("param null\n");
-               goto out;
-       }
-
-       err = hip_build_param_contents(msg, contents,
-                      hip_get_param_type(tlv_common),
-                                      hip_get_param_contents_len(tlv_common));
-        _HIP_DEBUG("tlv_common len %d\n", ((struct hip_tlv_common 
*)tlv_common)->length);
-       if (err) {
-               HIP_ERROR("could not build contents (%d)\n", err);
-       }
-
- out:
-       return err;
+    int err        = 0;
+    void *contents = ((void *) tlv_common) + sizeof(struct hip_tlv_common);
+
+    if (tlv_common == NULL) {
+        err = -EFAULT;
+        HIP_ERROR("param null\n");
+        goto out;
+    }
+
+    err = hip_build_param_contents(msg, contents,
+                                   hip_get_param_type(tlv_common),
+                                   hip_get_param_contents_len(tlv_common));
+    _HIP_DEBUG("tlv_common len %d\n", ((struct hip_tlv_common *) 
tlv_common)->length);
+    if (err) {
+        HIP_ERROR("could not build contents (%d)\n", err);
+    }
+
+out:
+    return err;
 }
 
 /**
@@ -1681,11 +1709,13 @@
  * @param msg user message
  * @param on 1 if requesting for a response, otherwise 0
  */
-void hip_set_msg_response(struct hip_common *msg, uint8_t on) {
-       if (msg->ver_res == HIP_USER_VER_RES)
-               msg->control = on;
-       else
-               msg->payload_proto = on;
+void hip_set_msg_response(struct hip_common *msg, uint8_t on)
+{
+    if (msg->ver_res == HIP_USER_VER_RES) {
+        msg->control = on;
+    } else {
+        msg->payload_proto = on;
+    }
 }
 
 /**
@@ -1694,9 +1724,9 @@
  * @param msg user message
  * @return 1 if message requires response, other 0
  */
-uint8_t hip_get_msg_response(struct hip_common *msg) {
-       return msg->ver_res == HIP_USER_VER_RES ? msg->control
-                                               : msg->payload_proto;
+uint8_t hip_get_msg_response(struct hip_common *msg)
+{
+    return msg->ver_res == HIP_USER_VER_RES ? msg->control : 
msg->payload_proto;
 }
 
 /**
@@ -1717,34 +1747,36 @@
  * @return          zero on success, or negative on error.
  */
 int hip_build_user_hdr(struct hip_common *msg, hip_hdr_type_t base_type,
-                      hip_hdr_err_t err_val)
+                       hip_hdr_err_t err_val)
 {
-       int err = 0;
-
-       _HIP_DEBUG("\n");
-       HIP_IFEL(!msg, -EINVAL, "null msg\n");
-
-       /* build header first and then parameters */
-       HIP_ASSERT(hip_get_msg_total_len(msg) == 0);
-
-       /* Use internal message version of header.
-        * This allows for messages longer than HIP_MAX_NETWORK_PACKET. */
-       msg->ver_res = HIP_USER_VER_RES;
-
-       hip_set_msg_type(msg, base_type);
-       hip_set_msg_err(msg, err_val);
-       /* Note: final header length is usually calculated by the
-          last call to build_param() but it is possible to build a
-          msg with just the header, so we have to calculate the
-          header length anyway. */
-       hip_calc_hdr_len(msg);
-
-       HIP_IFE(hip_get_msg_total_len(msg) == 0, -EMSGSIZE);
-       HIP_IFEL(!hip_check_user_msg_len(msg), -EMSGSIZE, "hipd build hdr: " \
-                       "msg len (%d) invalid\n", hip_get_msg_total_len(msg));
-
- out_err:
-       return err;
+    int err = 0;
+
+    _HIP_DEBUG("\n");
+    HIP_IFEL(!msg, -EINVAL, "null msg\n");
+
+    /* build header first and then parameters */
+    HIP_ASSERT(hip_get_msg_total_len(msg) == 0);
+
+    /* Use internal message version of header.
+     * This allows for messages longer than HIP_MAX_NETWORK_PACKET. */
+    msg->ver_res = HIP_USER_VER_RES;
+
+    hip_set_msg_type(msg, base_type);
+    hip_set_msg_err(msg, err_val);
+    /* Note: final header length is usually calculated by the
+     * last call to build_param() but it is possible to build a
+     * msg with just the header, so we have to calculate the
+     * header length anyway. */
+    hip_calc_hdr_len(msg);
+
+    HIP_IFE(hip_get_msg_total_len(msg) == 0, -EMSGSIZE);
+    HIP_IFEL(!hip_check_user_msg_len(msg),
+             -EMSGSIZE,
+             "hipd build hdr: msg len (%d) invalid\n",
+             hip_get_msg_total_len(msg));
+
+out_err:
+    return err;
 }
 
 /**
@@ -1776,23 +1808,23 @@
  * @note Use @b only accessors to hide byte order and size conversion issues!
  */
 void hip_build_network_hdr(struct hip_common *msg, uint8_t type_hdr,
-                          uint16_t control, const struct in6_addr *hit_sender,
-                          const struct in6_addr *hit_receiver)
+                           uint16_t control, const struct in6_addr *hit_sender,
+                           const struct in6_addr *hit_receiver)
 {
-       /* build header first and then parameters */
-       HIP_ASSERT(hip_get_msg_total_len(msg) == 0);
-
-       msg->payload_proto = IPPROTO_NONE; /* 1 byte, no htons()    */
-       /* Do not touch the length; it is written by param builders */
-       msg->type_hdr = type_hdr;              /* 1 byte, no htons()    */
-       /* version includes the SHIM6 bit */
-       msg->ver_res = (HIP_VER_RES << 4) | 1;   /* 1 byte, no htons() */
-
-       msg->control = htons(control);
-       msg->checksum = htons(0); /* this will be written by xmit */
-
-       ipv6_addr_copy(&msg->hits, hit_sender ? hit_sender : &in6addr_any);
-       ipv6_addr_copy(&msg->hitr, hit_receiver ? hit_receiver : &in6addr_any);
+    /* build header first and then parameters */
+    HIP_ASSERT(hip_get_msg_total_len(msg) == 0);
+
+    msg->payload_proto = IPPROTO_NONE;     /* 1 byte, no htons()    */
+    /* Do not touch the length; it is written by param builders */
+    msg->type_hdr      = type_hdr;             /* 1 byte, no htons()    */
+    /* version includes the SHIM6 bit */
+    msg->ver_res       = (HIP_VER_RES << 4) | 1; /* 1 byte, no htons() */
+
+    msg->control       = htons(control);
+    msg->checksum      = htons(0); /* this will be written by xmit */
+
+    ipv6_addr_copy(&msg->hits, hit_sender ? hit_sender : &in6addr_any);
+    ipv6_addr_copy(&msg->hitr, hit_receiver ? hit_receiver : &in6addr_any);
 }
 
 #ifndef __KERNEL__
@@ -1811,23 +1843,25 @@
  * @see       hip_write_hmac().
  */
 int hip_build_param_hmac(struct hip_common *msg,
-                        const struct hip_crypto_key *key,
+                         const struct hip_crypto_key *key,
                          hip_tlv_type_t param_type)
 {
-       int err = 0;
-       struct hip_hmac hmac;
-
-       hip_set_param_type((struct hip_tlv_common *)  &hmac, param_type);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &hmac, 
sizeof(struct hip_hmac), 0);
-
-       HIP_IFEL(hip_write_hmac(HIP_DIGEST_SHA1_HMAC, key->key, msg,
-                               hip_get_msg_total_len(msg),
-                               hmac.hmac_data), -EFAULT,
-                "Error while building HMAC\n");
-
-       err = hip_build_param(msg, &hmac);
- out_err:
-       return err;
+    int err = 0;
+    struct hip_hmac hmac;
+
+    hip_set_param_type((struct hip_tlv_common *)  &hmac, param_type);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &hmac,
+                               sizeof(struct hip_hmac),
+                               0);
+
+    HIP_IFEL(hip_write_hmac(HIP_DIGEST_SHA1_HMAC, key->key, msg,
+                            hip_get_msg_total_len(msg),
+                            hmac.hmac_data), -EFAULT,
+             "Error while building HMAC\n");
+
+    err = hip_build_param(msg, &hmac);
+out_err:
+    return err;
 }
 
 /**
@@ -1843,38 +1877,40 @@
  * @see       hip_build_param_hmac_contents()
  */
 int hip_build_param_hmac_contents(struct hip_common *msg,
-                        const struct hip_crypto_key *key)
+                                  const struct hip_crypto_key *key)
 {
-
-       return hip_build_param_hmac(msg, key, HIP_PARAM_HMAC);
+    return hip_build_param_hmac(msg, key, HIP_PARAM_HMAC);
 };
 
 int hip_create_msg_pseudo_hmac2(const struct hip_common *msg,
-                               struct hip_common *msg_copy,
-                               struct hip_host_id *host_id) {
-       struct hip_tlv_common *param = NULL;
-       int err = 0;
-
-       HIP_HEXDUMP("host id", host_id,
-                   hip_get_param_total_len(host_id));
-
-       memcpy( msg_copy, msg, sizeof(struct hip_common));
-       hip_set_msg_total_len(msg_copy, 0);
-       hip_zero_msg_checksum(msg_copy);
-
-       /* copy parameters to a temporary buffer to calculate
-          pseudo-hmac (includes the host id) */
-       while((param = hip_get_next_param(msg, param)) &&
-             hip_get_param_type(param) < HIP_PARAM_HMAC2) {
-               HIP_IFEL(hip_build_param(msg_copy, param), -1,
-                        "Failed to build param\n");
-       }
-
-       HIP_IFEL(hip_build_param(msg_copy, host_id), -1,
-                "Failed to append pseudo host id to R2\n");
-
- out_err:
-       return err;
+                                struct hip_common *msg_copy,
+                                struct hip_host_id *host_id)
+{
+    struct hip_tlv_common *param = NULL;
+    int err                      = 0;
+
+    HIP_HEXDUMP("host id", host_id,
+                hip_get_param_total_len(host_id));
+
+    memcpy( msg_copy, msg, sizeof(struct hip_common));
+    hip_set_msg_total_len(msg_copy, 0);
+    hip_zero_msg_checksum(msg_copy);
+
+    /* copy parameters to a temporary buffer to calculate
+     * pseudo-hmac (includes the host id) */
+    while ((param = hip_get_next_param(msg, param)) &&
+           hip_get_param_type(param) < HIP_PARAM_HMAC2)
+    {
+        HIP_IFEL(hip_build_param(msg_copy, param),
+                 -1,
+                 "Failed to build param\n");
+    }
+
+    HIP_IFEL(hip_build_param(msg_copy, host_id), -1,
+             "Failed to append pseudo host id to R2\n");
+
+out_err:
+    return err;
 }
 
 /**
@@ -1893,35 +1929,39 @@
  * @see            hip_write_hmac().
  */
 int hip_build_param_hmac2_contents(struct hip_common *msg,
-                                  struct hip_crypto_key *key,
-                                  struct hip_host_id *host_id)
+                                   struct hip_crypto_key *key,
+                                   struct hip_host_id *host_id)
 {
-       struct hip_hmac hmac2;
-       struct hip_common *msg_copy = NULL;
-       int err = 0;
-
-       HIP_IFEL(!(msg_copy = hip_msg_alloc()), -ENOMEM, "Message alloc\n");
-
-       _HIP_HEXDUMP("HMAC data", msg_copy, hip_get_msg_total_len(msg_copy));
-       _HIP_HEXDUMP("HMAC key\n", key->key, 20);
-
-       HIP_IFEL(hip_create_msg_pseudo_hmac2(msg, msg_copy, host_id), -1,
-                "pseudo hmac pkt failed\n");
-
-       hip_set_param_type((struct hip_tlv_common *)  &hmac2, HIP_PARAM_HMAC2);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &hmac2, 
sizeof(struct hip_hmac), 0);
-
-       HIP_IFEL(hip_write_hmac(HIP_DIGEST_SHA1_HMAC, key->key, msg_copy,
-                               hip_get_msg_total_len(msg_copy),
-                               hmac2.hmac_data), -EFAULT,
-                "Error while building HMAC\n");
-
-       err = hip_build_param(msg, &hmac2);
- out_err:
-       if (msg_copy)
-               HIP_FREE(msg_copy);
-
-       return err;
+    struct hip_hmac hmac2;
+    struct hip_common *msg_copy = NULL;
+    int err                     = 0;
+
+    HIP_IFEL(!(msg_copy = hip_msg_alloc()), -ENOMEM, "Message alloc\n");
+
+    _HIP_HEXDUMP("HMAC data", msg_copy, hip_get_msg_total_len(msg_copy));
+    _HIP_HEXDUMP("HMAC key\n", key->key, 20);
+
+    HIP_IFEL(hip_create_msg_pseudo_hmac2(msg, msg_copy, host_id), -1,
+             "pseudo hmac pkt failed\n");
+
+    hip_set_param_type((struct hip_tlv_common *)  &hmac2, HIP_PARAM_HMAC2);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &hmac2,
+                               sizeof(struct hip_hmac),
+                               0);
+
+    HIP_IFEL(hip_write_hmac(HIP_DIGEST_SHA1_HMAC, key->key, msg_copy,
+                            hip_get_msg_total_len(msg_copy),
+                            hmac2.hmac_data),
+                            -EFAULT,
+             "Error while building HMAC\n");
+
+    err = hip_build_param(msg, &hmac2);
+out_err:
+    if (msg_copy) {
+        HIP_FREE(msg_copy);
+    }
+
+    return err;
 }
 
 /**
@@ -1937,136 +1977,138 @@
  */
 u16 hip_checksum_packet(char *data, struct sockaddr *src, struct sockaddr *dst)
 {
-       u16 checksum = 0;
-       unsigned long sum = 0;
-       int count = 0, length = 0;
-       unsigned short *p = NULL; /* 16-bit */
-       struct pseudo_header pseudoh;
-       struct pseudo_header6 pseudoh6;
-       u32 src_network, dst_network;
-       struct in6_addr *src6, *dst6;
-       struct hip_common *hiph = (struct hip_common *) data;
-
-       if (src->sa_family == AF_INET) {
-               /* IPv4 checksum based on UDP-- Section 6.1.2 */
-               src_network = ((struct sockaddr_in*)src)->sin_addr.s_addr;
-               dst_network = ((struct sockaddr_in*)dst)->sin_addr.s_addr;
-
-               memset(&pseudoh, 0, sizeof(struct pseudo_header));
-               memcpy(&pseudoh.src_addr, &src_network, 4);
-               memcpy(&pseudoh.dst_addr, &dst_network, 4);
-               pseudoh.protocol = IPPROTO_HIP;
-               length = (hiph->payload_len + 1) * 8;
-               pseudoh.packet_length = htons(length);
-
-               count = sizeof(struct pseudo_header); /* count always even 
number */
-               p = (unsigned short*) &pseudoh;
-       } else {
-               /* IPv6 checksum based on IPv6 pseudo-header */
-               src6 = &((struct sockaddr_in6*)src)->sin6_addr;
-               dst6 = &((struct sockaddr_in6*)dst)->sin6_addr;
-
-               memset(&pseudoh6, 0, sizeof(struct pseudo_header6));
-               memcpy(&pseudoh6.src_addr[0], src6, 16);
-               memcpy(&pseudoh6.dst_addr[0], dst6, 16);
-               length = (hiph->payload_len + 1) * 8;
-               pseudoh6.packet_length = htonl(length);
-               pseudoh6.next_hdr = IPPROTO_HIP;
-
-               count = sizeof(struct pseudo_header6); /* count always even 
number */
-               p = (unsigned short*) &pseudoh6;
-       }
-       /*
-        * this checksum algorithm can be found
-        * in RFC 1071 section 4.1
-        */
-
-       /* sum the pseudo-header */
-       /* count and p are initialized above per protocol */
-       while (count > 1) {
-               sum += *p++;
-               count -= 2;
-       }
-
-       /* one's complement sum 16-bit words of data */
-       HIP_DEBUG("Checksumming %d bytes of data.\n", length);
-       count = length;
-       p = (unsigned short*) data;
-       while (count > 1) {
-               sum += *p++;
-               count -= 2;
-       }
-       /* add left-over byte, if any */
-       if (count > 0)
-               sum += (unsigned char)*p;
-
-       /*  Fold 32-bit sum to 16 bits */
-       while (sum>>16)
-               sum = (sum & 0xffff) + (sum >> 16);
-       /* take the one's complement of the sum */
-       checksum = ~sum;
-
-       return(checksum);
+    u16 checksum      = 0;
+    unsigned long sum = 0;
+    int count         = 0, length = 0;
+    unsigned short *p = NULL;     /* 16-bit */
+    struct pseudo_header pseudoh;
+    struct pseudo_header6 pseudoh6;
+    u32 src_network, dst_network;
+    struct in6_addr *src6, *dst6;
+    struct hip_common *hiph = (struct hip_common *) data;
+
+    if (src->sa_family == AF_INET) {
+        /* IPv4 checksum based on UDP-- Section 6.1.2 */
+        src_network = ((struct sockaddr_in *) src)->sin_addr.s_addr;
+        dst_network = ((struct sockaddr_in *) dst)->sin_addr.s_addr;
+
+        memset(&pseudoh, 0, sizeof(struct pseudo_header));
+        memcpy(&pseudoh.src_addr, &src_network, 4);
+        memcpy(&pseudoh.dst_addr, &dst_network, 4);
+        pseudoh.protocol      = IPPROTO_HIP;
+        length                = (hiph->payload_len + 1) * 8;
+        pseudoh.packet_length = htons(length);
+
+        count                 = sizeof(struct pseudo_header); /* count always 
even number */
+        p                     = (unsigned short *) &pseudoh;
+    } else {
+        /* IPv6 checksum based on IPv6 pseudo-header */
+        src6 = &((struct sockaddr_in6 *) src)->sin6_addr;
+        dst6 = &((struct sockaddr_in6 *) dst)->sin6_addr;
+
+        memset(&pseudoh6, 0, sizeof(struct pseudo_header6));
+        memcpy(&pseudoh6.src_addr[0], src6, 16);
+        memcpy(&pseudoh6.dst_addr[0], dst6, 16);
+        length                 = (hiph->payload_len + 1) * 8;
+        pseudoh6.packet_length = htonl(length);
+        pseudoh6.next_hdr      = IPPROTO_HIP;
+
+        count                  = sizeof(struct pseudo_header6); /* count 
always even number */
+        p                      = (unsigned short *) &pseudoh6;
+    }
+    /*
+     * this checksum algorithm can be found
+     * in RFC 1071 section 4.1
+     */
+
+    /* sum the pseudo-header */
+    /* count and p are initialized above per protocol */
+    while (count > 1) {
+        sum   += *p++;
+        count -= 2;
+    }
+
+    /* one's complement sum 16-bit words of data */
+    HIP_DEBUG("Checksumming %d bytes of data.\n", length);
+    count = length;
+    p     = (unsigned short *) data;
+    while (count > 1) {
+        sum   += *p++;
+        count -= 2;
+    }
+    /* add left-over byte, if any */
+    if (count > 0) {
+        sum += (unsigned char) *p;
+    }
+
+    /*  Fold 32-bit sum to 16 bits */
+    while (sum >> 16) {
+        sum = (sum & 0xffff) + (sum >> 16);
+    }
+    /* take the one's complement of the sum */
+    checksum = ~sum;
+
+    return checksum;
 }
 
 int hip_verify_network_header(struct hip_common *hip_common,
-                             struct sockaddr *src, struct sockaddr *dst,
-                             int len)
+                              struct sockaddr *src, struct sockaddr *dst,
+                              int len)
 {
-       int err = 0, plen, checksum;
-
-       plen = hip_get_msg_total_len(hip_common);
-
-        /* Currently no support for piggybacking */
-        HIP_IFEL(len != hip_get_msg_total_len(hip_common), -EINVAL,
-                "Invalid HIP packet length (%d,%d). Dropping\n",
-                len, plen);
-        HIP_IFEL(hip_common->payload_proto != IPPROTO_NONE, -EOPNOTSUPP,
-                "Protocol in packet (%u) was not IPPROTO_NONE. Dropping\n",
-                hip_common->payload_proto);
-       HIP_IFEL(hip_common->ver_res != ((HIP_VER_RES << 4) | 1), -EPROTOTYPE,
-                "Invalid version in received packet. Dropping\n");
-
-       HIP_IFEL(!ipv6_addr_is_hit(&hip_common->hits), -EAFNOSUPPORT,
-                "Received a non-HIT in HIT-source. Dropping\n");
-       HIP_IFEL(!ipv6_addr_is_hit(&hip_common->hitr) &&
-                !ipv6_addr_any(&hip_common->hitr),
-                -EAFNOSUPPORT,
-                "Received a non-HIT or non NULL in HIT-receiver. Dropping\n");
-
-       HIP_IFEL(ipv6_addr_any(&hip_common->hits), -EAFNOSUPPORT,
-                "Received a NULL in HIT-sender. Dropping\n");
-
-        /** @todo handle the RVS case better. */
-        if (ipv6_addr_any(&hip_common->hitr)) {
-                /* Required for e.g. BOS */
-                HIP_DEBUG("Received opportunistic HIT\n");
-       } else {
+    int err = 0, plen, checksum;
+
+    plen = hip_get_msg_total_len(hip_common);
+
+    /* Currently no support for piggybacking */
+    HIP_IFEL(len != hip_get_msg_total_len(hip_common), -EINVAL,
+             "Invalid HIP packet length (%d,%d). Dropping\n",
+             len, plen);
+    HIP_IFEL(hip_common->payload_proto != IPPROTO_NONE, -EOPNOTSUPP,
+             "Protocol in packet (%u) was not IPPROTO_NONE. Dropping\n",
+             hip_common->payload_proto);
+    HIP_IFEL(hip_common->ver_res != ((HIP_VER_RES << 4) | 1), -EPROTOTYPE,
+             "Invalid version in received packet. Dropping\n");
+
+    HIP_IFEL(!ipv6_addr_is_hit(&hip_common->hits), -EAFNOSUPPORT,
+             "Received a non-HIT in HIT-source. Dropping\n");
+    HIP_IFEL(!ipv6_addr_is_hit(&hip_common->hitr) &&
+             !ipv6_addr_any(&hip_common->hitr),
+             -EAFNOSUPPORT,
+             "Received a non-HIT or non NULL in HIT-receiver. Dropping\n");
+
+    HIP_IFEL(ipv6_addr_any(&hip_common->hits), -EAFNOSUPPORT,
+             "Received a NULL in HIT-sender. Dropping\n");
+
+    /** @todo handle the RVS case better. */
+    if (ipv6_addr_any(&hip_common->hitr)) {
+        /* Required for e.g. BOS */
+        HIP_DEBUG("Received opportunistic HIT\n");
+    } else {
 #ifdef CONFIG_HIP_RVS
-                HIP_DEBUG("Received HIT is ours or we are RVS\n");
+        HIP_DEBUG("Received HIT is ours or we are RVS\n");
 #else
-               HIP_IFEL(!hip_hidb_hit_is_our(&hip_common->hitr), -EFAULT,
-                        "Receiver HIT is not ours\n");
+        HIP_IFEL(!hip_hidb_hit_is_our(&hip_common->hitr), -EFAULT,
+                 "Receiver HIT is not ours\n");
 #endif /* CONFIG_HIP_RVS */
-       }
-
-        /* Check checksum. */
-        HIP_DEBUG("dst port is %d  \n", ((struct sockaddr_in *)dst)->sin_port);
-       if (dst->sa_family == AF_INET && ((struct sockaddr_in *)dst)->sin_port) 
{
-               HIP_DEBUG("HIP IPv4 UDP packet: ignoring HIP checksum\n");
-       } else {
-               checksum = hip_common->checksum;
-               hip_common->checksum = 0;
-
-               HIP_IFEL(hip_checksum_packet((char*)hip_common, src, dst)
-                        !=checksum,
-                        -EBADMSG, "HIP checksum failed.\n");
-
-               hip_common->checksum = checksum;
-       }
+    }
+
+    /* Check checksum. */
+    HIP_DEBUG("dst port is %d  \n", ((struct sockaddr_in *) dst)->sin_port);
+    if (dst->sa_family == AF_INET && ((struct sockaddr_in *) dst)->sin_port) {
+        HIP_DEBUG("HIP IPv4 UDP packet: ignoring HIP checksum\n");
+    } else {
+        checksum             = hip_common->checksum;
+        hip_common->checksum = 0;
+
+        HIP_IFEL(hip_checksum_packet((char *) hip_common, src, dst)
+                 != checksum,
+                 -EBADMSG, "HIP checksum failed.\n");
+
+        hip_common->checksum = checksum;
+    }
 
 out_err:
-        return err;
+    return err;
 }
 
 #endif /* __KERNEL__ */
@@ -2084,53 +2126,54 @@
  * Returns: zero on success, or negative on failure
  */
 int hip_build_param_encrypted_aes_sha1(struct hip_common *msg,
-                                       struct hip_tlv_common *param)
+                                       struct hip_tlv_common *param)
 {
-       int rem, err = 0;
-       struct hip_encrypted_aes_sha1 enc;
-       int param_len = hip_get_param_total_len(param);
-       struct hip_tlv_common *common = param;
-       char *param_padded = NULL;
-
-       hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
-       enc.reserved = htonl(0);
-       memset(&enc.iv, 0, 16);
-
-       /* copy the IV *IF* needed, and then the encrypted data */
-
-       /* AES block size must be multiple of 16 bytes */
-       rem = param_len % 16;
-       if (rem) {
-               HIP_DEBUG("Adjusting param size to AES block size\n");
-
-               param_padded = (char *)HIP_MALLOC(param_len + rem, GFP_KERNEL);
-               if (!param_padded) {
-                       err = -ENOMEM;
-                       goto out_err;
-               }
-
-               /* this kind of padding works against Ericsson/OpenSSL
-                  (method 4: RFC2630 method) */
-               /* http://www.di-mgt.com.au/cryptopad.html#exampleaes */
-               memcpy(param_padded, param, param_len);
-               memset(param_padded + param_len, rem, rem);
-
-               common = (struct hip_tlv_common *) param_padded;
-               param_len += rem;
-       }
-
-       hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
-                          sizeof(struct hip_tlv_common) +
-                          param_len);
-
-       err = hip_build_generic_param(msg, &enc, sizeof(enc), common);
-
- out_err:
-
-       if (param_padded)
-               HIP_FREE(param_padded);
-
-       return err;
+    int rem, err = 0;
+    struct hip_encrypted_aes_sha1 enc;
+    int param_len                 = hip_get_param_total_len(param);
+    struct hip_tlv_common *common = param;
+    char *param_padded            = NULL;
+
+    hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
+    enc.reserved = htonl(0);
+    memset(&enc.iv, 0, 16);
+
+    /* copy the IV *IF* needed, and then the encrypted data */
+
+    /* AES block size must be multiple of 16 bytes */
+    rem = param_len % 16;
+    if (rem) {
+        HIP_DEBUG("Adjusting param size to AES block size\n");
+
+        param_padded = (char *) HIP_MALLOC(param_len + rem, GFP_KERNEL);
+        if (!param_padded) {
+            err = -ENOMEM;
+            goto out_err;
+        }
+
+        /* this kind of padding works against Ericsson/OpenSSL
+         * (method 4: RFC2630 method) */
+        /* http://www.di-mgt.com.au/cryptopad.html#exampleaes */
+        memcpy(param_padded, param, param_len);
+        memset(param_padded + param_len, rem, rem);
+
+        common     = (struct hip_tlv_common *) param_padded;
+        param_len += rem;
+    }
+
+    hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
+                       sizeof(struct hip_tlv_common) +
+                       param_len);
+
+    err = hip_build_generic_param(msg, &enc, sizeof(enc), common);
+
+out_err:
+
+    if (param_padded) {
+        HIP_FREE(param_padded);
+    }
+
+    return err;
 }
 
 /**
@@ -2152,27 +2195,27 @@
  * @return zero for success, or non-zero on error
  */
 int hip_build_param_signature2_contents(struct hip_common *msg,
-                                       const void *contents,
-                                       hip_tlv_len_t contents_size,
-                                       uint8_t algorithm)
+                                        const void *contents,
+                                        hip_tlv_len_t contents_size,
+                                        uint8_t algorithm)
 {
-       /* note: if you make changes in this function, make them also in
-          build_param_signature_contents(), because it is almost the same */
-
-       int err = 0;
-       struct hip_sig2 sig2;
-
-       HIP_ASSERT(sizeof(struct hip_sig2) >= sizeof(struct hip_tlv_common));
-
-       hip_set_param_type((struct hip_tlv_common *) &sig2, 
HIP_PARAM_HIP_SIGNATURE2);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &sig2, 
sizeof(struct hip_sig2),
-                                  contents_size);
-       sig2.algorithm = algorithm; /* algo is 8 bits, no htons */
-
-       err = hip_build_generic_param(msg, &sig2,
-                                     sizeof(struct hip_sig2), contents);
-
-       return err;
+    /* note: if you make changes in this function, make them also in
+     * build_param_signature_contents(), because it is almost the same */
+
+    int err = 0;
+    struct hip_sig2 sig2;
+
+    HIP_ASSERT(sizeof(struct hip_sig2) >= sizeof(struct hip_tlv_common));
+
+    hip_set_param_type((struct hip_tlv_common *) &sig2, 
HIP_PARAM_HIP_SIGNATURE2);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &sig2, sizeof(struct 
hip_sig2),
+                               contents_size);
+    sig2.algorithm = algorithm;     /* algo is 8 bits, no htons */
+
+    err            = hip_build_generic_param(msg, &sig2,
+                                             sizeof(struct hip_sig2), 
contents);
+
+    return err;
 }
 
 /**
@@ -2190,27 +2233,27 @@
  * @return zero for success, or non-zero on error
  */
 int hip_build_param_signature_contents(struct hip_common *msg,
-                                      const void *contents,
-                                      hip_tlv_len_t contents_size,
-                                      uint8_t algorithm)
+                                       const void *contents,
+                                       hip_tlv_len_t contents_size,
+                                       uint8_t algorithm)
 {
-       /* note: if you make changes in this function, make them also in
-          build_param_signature_contents2(), because it is almost the same */
-
-       int err = 0;
-       struct hip_sig sig;
-
-       HIP_ASSERT(sizeof(struct hip_sig) >= sizeof(struct hip_tlv_common));
-
-       hip_set_param_type((struct hip_tlv_common *) &sig, 
HIP_PARAM_HIP_SIGNATURE);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &sig, 
sizeof(struct hip_sig),
-                                  contents_size);
-       sig.algorithm = algorithm; /* algo is 8 bits, no htons */
-
-       err = hip_build_generic_param(msg, &sig,
-                                     sizeof(struct hip_sig), contents);
-
-       return err;
+    /* note: if you make changes in this function, make them also in
+     * build_param_signature_contents2(), because it is almost the same */
+
+    int err = 0;
+    struct hip_sig sig;
+
+    HIP_ASSERT(sizeof(struct hip_sig) >= sizeof(struct hip_tlv_common));
+
+    hip_set_param_type((struct hip_tlv_common *) &sig, 
HIP_PARAM_HIP_SIGNATURE);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &sig, sizeof(struct 
hip_sig),
+                               contents_size);
+    sig.algorithm = algorithm;     /* algo is 8 bits, no htons */
+
+    err           = hip_build_generic_param(msg, &sig,
+                                            sizeof(struct hip_sig), contents);
+
+    return err;
 }
 
 /**
@@ -2224,20 +2267,21 @@
  * @return zero for success, or non-zero on error
  */
 int hip_build_param_echo(struct hip_common *msg, void *opaque, int len,
-                        int sign, int request)
+                         int sign, int request)
 {
-       struct hip_echo_request ping;
-       int err;
-
-       if (request)
-               hip_set_param_type((struct hip_tlv_common *) &ping, sign ? 
HIP_PARAM_ECHO_REQUEST_SIGN : HIP_PARAM_ECHO_REQUEST);
-       else
-               hip_set_param_type((struct hip_tlv_common *) &ping, sign ? 
HIP_PARAM_ECHO_RESPONSE_SIGN : HIP_PARAM_ECHO_RESPONSE);
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &ping, len);
-       err = hip_build_generic_param(msg, &ping, sizeof(struct 
hip_echo_request),
-                                     opaque);
-       return err;
+    struct hip_echo_request ping;
+    int err;
+
+    if (request) {
+        hip_set_param_type((struct hip_tlv_common *) &ping, sign ? 
HIP_PARAM_ECHO_REQUEST_SIGN : HIP_PARAM_ECHO_REQUEST);
+    } else {
+        hip_set_param_type((struct hip_tlv_common *) &ping, sign ? 
HIP_PARAM_ECHO_RESPONSE_SIGN : HIP_PARAM_ECHO_RESPONSE);
+    }
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &ping, len);
+    err = hip_build_generic_param(msg, &ping, sizeof(struct hip_echo_request),
+                                  opaque);
+    return err;
 }
 
 /**
@@ -2253,19 +2297,21 @@
 int hip_build_param_echo_m(struct hip_common *msg, void *opaque, int len,
                            int request)
 {
-       struct hip_echo_request_m ping;
-       int err;
-
-       if (request)
-               hip_set_param_type((struct hip_tlv_common *) &ping, 
HIP_PARAM_ECHO_REQUEST_M);
-       else
-               hip_set_param_type((struct hip_tlv_common *) &ping, 
HIP_PARAM_ECHO_RESPONSE_M);
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &ping, len);
-       err = hip_build_generic_param(msg, &ping, sizeof(struct 
hip_echo_request_m),
-                                     opaque);
-       return err;
+    struct hip_echo_request_m ping;
+    int err;
+
+    if (request) {
+        hip_set_param_type((struct hip_tlv_common *) &ping, 
HIP_PARAM_ECHO_REQUEST_M);
+    } else {
+        hip_set_param_type((struct hip_tlv_common *) &ping, 
HIP_PARAM_ECHO_RESPONSE_M);
+    }
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &ping, len);
+    err = hip_build_generic_param(msg, &ping, sizeof(struct 
hip_echo_request_m),
+                                  opaque);
+    return err;
 }
+
 #endif
 
 /**
@@ -2277,22 +2323,22 @@
  */
 int hip_build_param_r1_counter(struct hip_common *msg, uint64_t generation)
 {
-       struct hip_r1_counter r1gen;
-       int err = 0;
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &r1gen,
-                                  sizeof(struct hip_r1_counter) -
-                                  sizeof(struct hip_tlv_common));
-       /* Type 2 (in R1) or 3 (in I2) */
-       hip_set_param_type((struct hip_tlv_common *) &r1gen, 
HIP_PARAM_R1_COUNTER);
-
-       r1gen.reserved = 0;
-
-       r1gen.generation = hton64(generation);
-
-       err = hip_build_param(msg, &r1gen);
-       return err;
+    struct hip_r1_counter r1gen;
+    int err = 0;
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &r1gen,
+                               sizeof(struct hip_r1_counter) -
+                               sizeof(struct hip_tlv_common));
+    /* Type 2 (in R1) or 3 (in I2) */
+    hip_set_param_type((struct hip_tlv_common *) &r1gen, HIP_PARAM_R1_COUNTER);
+
+    r1gen.reserved   = 0;
+
+    r1gen.generation = hton64(generation);
+
+    err              = hip_build_param(msg, &r1gen);
+    return err;
 }
 
 /**
@@ -2308,18 +2354,19 @@
  * @see            <a 
href="http://tools.ietf.org/wg/hip/draft-ietf-hip-rvs/draft-ietf-hip-rvs-05.txt";>
  *                 draft-ietf-hip-rvs-05</a> section 4.2.2.
  */
-int hip_build_param_from(struct hip_common *msg, const struct in6_addr *addr,
-                        const in_port_t not_used)
+int hip_build_param_from(struct hip_common *msg,
+                         const struct in6_addr *addr,
+                         const in_port_t not_used)
 {
-       struct hip_from from;
-       int err = 0;
-
-       hip_set_param_type((struct hip_tlv_common *) &from, HIP_PARAM_FROM);
-       memcpy((struct in6_addr *)&from.address, addr, 16);
-
-       hip_calc_generic_param_len((struct hip_tlv_common *) &from, 
sizeof(struct hip_from), 0);
-       err = hip_build_param(msg, &from);
-       return err;
+    struct hip_from from;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) &from, HIP_PARAM_FROM);
+    memcpy((struct in6_addr *) &from.address, addr, 16);
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) &from, sizeof(struct 
hip_from), 0);
+    err = hip_build_param(msg, &from);
+    return err;
 }
 
 /**
@@ -2333,20 +2380,20 @@
  * @return     zero on success, or negative error value on error.
  */
 int hip_build_param_relay_from(struct hip_common *msg, const struct in6_addr 
*addr,
-                            const in_port_t port)
+                               const in_port_t port)
 {
-       struct hip_relay_from relay_from;
-       int err = 0;
-
-       hip_set_param_type((struct hip_tlv_common *) &relay_from, 
HIP_PARAM_RELAY_FROM);
-       ipv6_addr_copy((struct in6_addr *)&relay_from.address, addr);
-       relay_from.port = htons(port);
-       relay_from.reserved = 0;
-       relay_from.protocol = HIP_NAT_PROTO_UDP;
-       hip_calc_generic_param_len((struct hip_tlv_common *) &relay_from, 
sizeof(relay_from), 0);
-       err = hip_build_param(msg, &relay_from);
-
-       return err;
+    struct hip_relay_from relay_from;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) &relay_from, 
HIP_PARAM_RELAY_FROM);
+    ipv6_addr_copy((struct in6_addr *) &relay_from.address, addr);
+    relay_from.port     = htons(port);
+    relay_from.reserved = 0;
+    relay_from.protocol = HIP_NAT_PROTO_UDP;
+    hip_calc_generic_param_len((struct hip_tlv_common *) &relay_from, 
sizeof(relay_from), 0);
+    err                 = hip_build_param(msg, &relay_from);
+
+    return err;
 }
 
 /**
@@ -2362,18 +2409,18 @@
  *                      draft-ietf-hip-rvs-05</a> section 4.2.3.
  */
 int hip_build_param_via_rvs(struct hip_common *msg,
-                           const struct in6_addr rvs_addresses[])
+                            const struct in6_addr rvs_addresses[])
 {
-       HIP_DEBUG("hip_build_param_rvs() invoked.\n");
-       int err = 0;
-       struct hip_via_rvs viarvs;
+    HIP_DEBUG("hip_build_param_rvs() invoked.\n");
+    int err = 0;
+    struct hip_via_rvs viarvs;
 
-       hip_set_param_type((struct hip_tlv_common *) &viarvs, 
HIP_PARAM_VIA_RVS);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &viarvs, 
sizeof(struct hip_via_rvs),
-                                  sizeof(struct in6_addr));
-       err = hip_build_generic_param(msg, &viarvs, sizeof(struct hip_via_rvs),
-                                     (void *)rvs_addresses);
-       return err;
+    hip_set_param_type((struct hip_tlv_common *) &viarvs, HIP_PARAM_VIA_RVS);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &viarvs, 
sizeof(struct hip_via_rvs),
+                               sizeof(struct in6_addr));
+    err = hip_build_generic_param(msg, &viarvs, sizeof(struct hip_via_rvs),
+                                  (void *) rvs_addresses);
+    return err;
 }
 
 /**
@@ -2389,23 +2436,22 @@
  *             draft, this is now RELAY_TO.
  */
 int hip_build_param_relay_to(struct hip_common *msg,
-                            const in6_addr_t *addr,
-                            const in_port_t port)
+                             const in6_addr_t *addr,
+                             const in_port_t port)
 {
-     struct hip_relay_to relay_to;
-     int err = 0;
-
-     hip_set_param_type((struct hip_tlv_common *) &relay_to, 
HIP_PARAM_RELAY_TO);
-     ipv6_addr_copy((struct in6_addr *)&relay_to.address, addr);
-     relay_to.port = htons(port);
-     relay_to.reserved = 0;
-     relay_to.protocol = HIP_NAT_PROTO_UDP;
-     
-     hip_calc_generic_param_len((struct hip_tlv_common *) &relay_to, 
sizeof(relay_to), 0);
-     err = hip_build_param(msg, &relay_to);
-
-     return err;
-
+    struct hip_relay_to relay_to;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) &relay_to, 
HIP_PARAM_RELAY_TO);
+    ipv6_addr_copy((struct in6_addr *) &relay_to.address, addr);
+    relay_to.port     = htons(port);
+    relay_to.reserved = 0;
+    relay_to.protocol = HIP_NAT_PROTO_UDP;
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) &relay_to, 
sizeof(relay_to), 0);
+    err               = hip_build_param(msg, &relay_to);
+
+    return err;
 }
 
 /* NOTE! Keep this function before REG_REQUEST and REG_RESPONSE parameter
@@ -2429,19 +2475,19 @@
  *                   function is not to be called outside this file.
  */
 static inline int hip_reg_param_core(hip_common_t *msg,
-                                    void *param,
-                                    const uint8_t lifetime,
-                                    const uint8_t *type_list,
-                                    const int type_count)
+                                     void *param,
+                                     const uint8_t lifetime,
+                                     const uint8_t *type_list,
+                                     const int type_count)
 {
-       struct hip_reg_request *rreq = (struct hip_reg_request *) param;
-
-       hip_calc_generic_param_len((struct hip_tlv_common *) rreq, 
sizeof(struct hip_reg_request),
-                                  type_count * sizeof(uint8_t));
-       rreq->lifetime = lifetime;
-
-       return hip_build_generic_param(msg, rreq, sizeof(struct 
hip_reg_request),
-                                      type_list);
+    struct hip_reg_request *rreq = (struct hip_reg_request *) param;
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) rreq, sizeof(struct 
hip_reg_request),
+                               type_count * sizeof(uint8_t));
+    rreq->lifetime = lifetime;
+
+    return hip_build_generic_param(msg, rreq, sizeof(struct hip_reg_request),
+                                   type_list);
 }
 
 /**
@@ -2452,56 +2498,55 @@
  * @param service_count number of registration services in @c service_list.
  * @return              zero on success, non-zero otherwise.
  * @note: gcc gives a weird warning if we use struct srv in the arguments of 
this function.
-   Using void pointer as a workaround */
+ * Using void pointer as a workaround */
 int hip_build_param_reg_info(hip_common_t *msg,
-                            const void *srv_list,
-                            const unsigned int service_count)
+                             const void *srv_list,
+                             const unsigned int service_count)
 {
-       int err = 0, i = 0;
-       const struct hip_srv *service_list = (const struct hip_srv *) srv_list;
-       struct hip_reg_info reg_info;
-       uint8_t reg_type[service_count];
-
-       if(service_count == 0) {
-               return 0;
-       }
-       HIP_DEBUG("Building REG_INFO parameter(s) \n");
-
-       for( ;i < service_count; i++) {
-               if(service_list[0].min_lifetime !=
-                  service_list[i].min_lifetime ||
-                  service_list[0].max_lifetime !=
-                  service_list[i].max_lifetime) {
-                       HIP_INFO("Warning! Multiple min and max lifetime "\
-                                "values for a single REG_INFO parameter "\
-                                "requested. Using lifetime values from "\
-                                "service reg_type %d with all services.\n",
-                                service_list[0].reg_type);
-                       break;
-               }
-
-       }
-
-       for(i = 0; i < service_count; i++) {
-               reg_type[i] = service_list[i].reg_type;
-       }
-
-       _HIP_HEXDUMP("reg_type", reg_type, service_count);
-
-       hip_set_param_type((struct hip_tlv_common *) &reg_info, 
HIP_PARAM_REG_INFO);
-       /* All services should have the same lifetime... */
-       reg_info.min_lifetime = service_list[0].min_lifetime;
-       reg_info.max_lifetime = service_list[0].max_lifetime;
-       hip_calc_generic_param_len((struct hip_tlv_common *) &reg_info, 
sizeof(struct hip_reg_info),
-                                  service_count * 
sizeof(service_list[0].reg_type));
-
-       err = hip_build_generic_param(
-               msg, &reg_info, sizeof(struct hip_reg_info), (void *)reg_type);
-
-       _HIP_DEBUG("Added REG_INFO parameter with %u service%s.\n", 
service_count,
-                  (service_count > 1) ? "s" : "");
-
-       return err;
+    int err                            = 0, i = 0;
+    const struct hip_srv *service_list = (const struct hip_srv *) srv_list;
+    struct hip_reg_info reg_info;
+    uint8_t reg_type[service_count];
+
+    if (service_count == 0) {
+        return 0;
+    }
+    HIP_DEBUG("Building REG_INFO parameter(s) \n");
+
+    for (; i < service_count; i++) {
+        if (service_list[0].min_lifetime !=
+            service_list[i].min_lifetime ||
+            service_list[0].max_lifetime !=
+            service_list[i].max_lifetime) {
+            HIP_INFO("Warning! Multiple min and max lifetime " \
+                     "values for a single REG_INFO parameter " \
+                     "requested. Using lifetime values from " \
+                     "service reg_type %d with all services.\n",
+                     service_list[0].reg_type);
+            break;
+        }
+    }
+
+    for (i = 0; i < service_count; i++) {
+        reg_type[i] = service_list[i].reg_type;
+    }
+
+    _HIP_HEXDUMP("reg_type", reg_type, service_count);
+
+    hip_set_param_type((struct hip_tlv_common *) &reg_info, 
HIP_PARAM_REG_INFO);
+    /* All services should have the same lifetime... */
+    reg_info.min_lifetime = service_list[0].min_lifetime;
+    reg_info.max_lifetime = service_list[0].max_lifetime;
+    hip_calc_generic_param_len((struct hip_tlv_common *) &reg_info, 
sizeof(struct hip_reg_info),
+                               service_count * 
sizeof(service_list[0].reg_type));
+
+    err                   = hip_build_generic_param(
+        msg, &reg_info, sizeof(struct hip_reg_info), (void *) reg_type);
+
+    _HIP_DEBUG("Added REG_INFO parameter with %u service%s.\n", service_count,
+               (service_count > 1) ? "s" : "");
+
+    return err;
 }
 
 /**
@@ -2515,15 +2560,15 @@
  * @return           zero on success, non-zero otherwise.
  */
 int hip_build_param_reg_request(hip_common_t *msg, const uint8_t lifetime,
-                               const uint8_t *type_list, const int type_count)
+                                const uint8_t *type_list, const int type_count)
 {
-       int err = 0;
-       struct hip_reg_request rreq;
-
-       hip_set_param_type((struct hip_tlv_common *) &rreq, 
HIP_PARAM_REG_REQUEST);
-       err = hip_reg_param_core(msg, &rreq, lifetime, type_list, type_count);
-
-       return err;
+    int err = 0;
+    struct hip_reg_request rreq;
+
+    hip_set_param_type((struct hip_tlv_common *) &rreq, HIP_PARAM_REG_REQUEST);
+    err = hip_reg_param_core(msg, &rreq, lifetime, type_list, type_count);
+
+    return err;
 }
 
 /**
@@ -2537,15 +2582,15 @@
  * @return           zero on success, non-zero otherwise.
  */
 int hip_build_param_reg_response(hip_common_t *msg, const uint8_t lifetime,
-                                const uint8_t *type_list, const int type_count)
+                                 const uint8_t *type_list, const int 
type_count)
 {
-       int err = 0;
-       struct hip_reg_response rres;
-
-       hip_set_param_type((struct hip_tlv_common *) &rres, 
HIP_PARAM_REG_RESPONSE);
-       err = hip_reg_param_core(msg, &rres, lifetime, type_list, type_count);
-
-       return err;
+    int err = 0;
+    struct hip_reg_response rres;
+
+    hip_set_param_type((struct hip_tlv_common *) &rres, 
HIP_PARAM_REG_RESPONSE);
+    err = hip_reg_param_core(msg, &rres, lifetime, type_list, type_count);
+
+    return err;
 }
 
 /**
@@ -2559,29 +2604,28 @@
  * @return           zero on success, non-zero otherwise.
  */
 int hip_build_param_reg_failed(struct hip_common *msg, uint8_t failure_type,
-                              uint8_t *type_list, int type_count)
+                               uint8_t *type_list, int type_count)
 {
-       int err = 0;
-       struct hip_reg_failed reg_failed;
-
-       if(type_count == 0) {
-               return 0;
-       }
-
-       hip_set_param_type((struct hip_tlv_common *) &reg_failed, 
HIP_PARAM_REG_FAILED);
-
-       reg_failed.failure_type = failure_type;
-       hip_calc_generic_param_len((struct hip_tlv_common *) &reg_failed, 
sizeof(struct hip_reg_failed),
-                                  type_count * sizeof(type_list[0]));
-
-       err = hip_build_generic_param(
-               msg, &reg_failed, sizeof(struct hip_reg_failed), (void 
*)type_list);
-
-       HIP_DEBUG("Added REG_FAILED parameter with %u service%s.\n", type_count,
-                 (type_count > 1) ? "s" : "");
-
-       return err;
-
+    int err = 0;
+    struct hip_reg_failed reg_failed;
+
+    if (type_count == 0) {
+        return 0;
+    }
+
+    hip_set_param_type((struct hip_tlv_common *) &reg_failed, 
HIP_PARAM_REG_FAILED);
+
+    reg_failed.failure_type = failure_type;
+    hip_calc_generic_param_len((struct hip_tlv_common *) &reg_failed, 
sizeof(struct hip_reg_failed),
+                               type_count * sizeof(type_list[0]));
+
+    err                     = hip_build_generic_param(
+        msg, &reg_failed, sizeof(struct hip_reg_failed), (void *) type_list);
+
+    HIP_DEBUG("Added REG_FAILED parameter with %u service%s.\n", type_count,
+              (type_count > 1) ? "s" : "");
+
+    return err;
 }
 
 /**
@@ -2600,35 +2644,35 @@
  * @return zero for success, or non-zero on error
  */
 int hip_build_param_puzzle(struct hip_common *msg, uint8_t val_K,
-                          uint8_t lifetime, uint32_t opaque, uint64_t random_i)
+                           uint8_t lifetime, uint32_t opaque, uint64_t 
random_i)
 {
-       struct hip_puzzle puzzle;
-       int err = 0;
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &puzzle,
-                                  sizeof(struct hip_puzzle) -
-                                  sizeof(struct hip_tlv_common));
-       /* Type 2 (in R1) or 3 (in I2) */
-       hip_set_param_type((struct hip_tlv_common *) &puzzle, HIP_PARAM_PUZZLE);
-
-       /* only the random_j_k is in host byte order */
-       puzzle.K = val_K;
-       puzzle.lifetime = lifetime;
-
-        // The following line to create random bytes are tried but didn't work!
-        // get_random_bytes(puzzle.opaque, sizeof(puzzle.opaque));
-        puzzle.opaque[0] = opaque & 0xFF;
-       puzzle.opaque[1] = (opaque & 0xFF00) >> 8;
-       /* puzzle.opaque[2] = (opaque & 0xFF0000) >> 16; */
-       puzzle.I = random_i;
+    struct hip_puzzle puzzle;
+    int err = 0;
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &puzzle,
+                               sizeof(struct hip_puzzle) -
+                               sizeof(struct hip_tlv_common));
+    /* Type 2 (in R1) or 3 (in I2) */
+    hip_set_param_type((struct hip_tlv_common *) &puzzle, HIP_PARAM_PUZZLE);
+
+    /* only the random_j_k is in host byte order */
+    puzzle.K         = val_K;
+    puzzle.lifetime  = lifetime;
+
+    // The following line to create random bytes are tried but didn't work!
+    // get_random_bytes(puzzle.opaque, sizeof(puzzle.opaque));
+    puzzle.opaque[0] = opaque & 0xFF;
+    puzzle.opaque[1] = (opaque & 0xFF00) >> 8;
+    /* puzzle.opaque[2] = (opaque & 0xFF0000) >> 16; */
+    puzzle.I         = random_i;
 
     err = hip_build_generic_param(msg, &puzzle,
-                             sizeof(struct hip_tlv_common),
-                             hip_get_param_contents_direct(&puzzle));
-       return err;
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&puzzle));
+    return err;
+}
 
-}
 #ifndef __KERNEL__
 /**
  * hip_build_param_challange_request - build and append a HIP 
challange_request to the message
@@ -2646,35 +2690,37 @@
  * @return zero for success, or non-zero on error
  */
 #ifdef CONFIG_HIP_MIDAUTH
-int hip_build_param_challenge_request( struct hip_common *msg, uint8_t val_K,
-                            uint8_t lifetime, uint8_t *opaque, uint8_t 
opaque_len)
+int hip_build_param_challenge_request(struct hip_common *msg,
+                                      uint8_t val_K,
+                                      uint8_t lifetime,
+                                      uint8_t *opaque,
+                                      uint8_t opaque_len)
 {
-       struct hip_challenge_request puzzle;
-       int err = 0;
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &puzzle,
-                                  sizeof(struct hip_challenge_request) -
-                                  sizeof(struct hip_tlv_common));
-       /* Type 2 (in R1) or 3 (in I2) */
-       hip_set_param_type((struct hip_tlv_common *) &puzzle, 
HIP_PARAM_CHALLENGE_REQUEST);
-
-       /* only the random_j_k is in host byte order */
-       puzzle.K = val_K;
-       puzzle.lifetime = lifetime;
-       memcpy(&puzzle.opaque, opaque, opaque_len);
-
-       err = hip_build_generic_param(msg, &puzzle,
-                                     sizeof(struct hip_tlv_common),
-                                     hip_get_param_contents_direct(&puzzle));
-
-       return err;
-
+    struct hip_challenge_request puzzle;
+    int err = 0;
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &puzzle,
+                               sizeof(struct hip_challenge_request) -
+                               sizeof(struct hip_tlv_common));
+    /* Type 2 (in R1) or 3 (in I2) */
+    hip_set_param_type((struct hip_tlv_common *) &puzzle,
+                       HIP_PARAM_CHALLENGE_REQUEST);
+
+    /* only the random_j_k is in host byte order */
+    puzzle.K        = val_K;
+    puzzle.lifetime = lifetime;
+    memcpy(&puzzle.opaque, opaque, opaque_len);
+
+    err = hip_build_generic_param(msg,
+                                  &puzzle,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&puzzle));
+    return err;
 }
+
 #endif
 
-
-
 /**
  * hip_build_param_solution - build and append a HIP solution into the message
  * @param msg the message where the solution is to be appended
@@ -2689,26 +2735,27 @@
  * @return zero for success, or non-zero on error
  */
 int hip_build_param_solution(struct hip_common *msg, struct hip_puzzle *pz,
-                            uint64_t val_J)
+                             uint64_t val_J)
 {
-       struct hip_solution cookie;
-       int err = 0;
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &cookie,
-                                  sizeof(struct hip_solution) -
-                                  sizeof(struct hip_tlv_common));
-       /* Type 2 (in R1) or 3 (in I2) */
-       hip_set_param_type((struct hip_tlv_common *) &cookie, 
HIP_PARAM_SOLUTION);
-
-       cookie.J = hton64(val_J);
-       memcpy(&cookie.K, &pz->K, 12); /* copy: K (1), reserved (1),
-                                         opaque (2) and I (8 bytes). */
-       cookie.reserved = 0;
-        err = hip_build_generic_param(msg, &cookie,
-                                     sizeof(struct hip_tlv_common),
-                                     hip_get_param_contents_direct(&cookie));
-       return err;
+    struct hip_solution cookie;
+    int err = 0;
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &cookie,
+                               sizeof(struct hip_solution) -
+                               sizeof(struct hip_tlv_common));
+    /* Type 2 (in R1) or 3 (in I2) */
+    hip_set_param_type((struct hip_tlv_common *) &cookie, HIP_PARAM_SOLUTION);
+
+    cookie.J        = hton64(val_J);
+    memcpy(&cookie.K, &pz->K, 12);     /* copy: K (1), reserved (1),
+                                        * opaque (2) and I (8 bytes). */
+    cookie.reserved = 0;
+    err = hip_build_generic_param(msg,
+                                  &cookie,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&cookie));
+    return err;
 }
 
 /**
@@ -2726,29 +2773,31 @@
  */
 #ifdef CONFIG_HIP_MIDAUTH
 int hip_build_param_challenge_response(struct hip_common *msg, struct 
hip_challenge_request *pz,
-                            uint64_t val_J)
+                                       uint64_t val_J)
 {
-       struct hip_challenge_response cookie;
-       int err = 0, opaque_len = 0;
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &cookie,
-                                  sizeof(struct hip_challenge_response) -
-                                  sizeof(struct hip_tlv_common));
-       /* Type 2 (in R1) or 3 (in I2) */
-       hip_set_param_type((struct hip_tlv_common *) &cookie, 
HIP_PARAM_CHALLENGE_RESPONSE);
-
-       cookie.J = hton64(val_J);
-       cookie.K = pz->K;
-       cookie.lifetime = pz->K;
-       opaque_len = (sizeof(pz->opaque) / sizeof(pz->opaque[0]));
-       memcpy(&cookie.opaque, pz->opaque, opaque_len);
-
-        err = hip_build_generic_param(msg, &cookie,
-                                     sizeof(struct hip_tlv_common),
-                                     hip_get_param_contents_direct(&cookie));
-       return err;
+    struct hip_challenge_response cookie;
+    int err = 0, opaque_len = 0;
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &cookie,
+                               sizeof(struct hip_challenge_response) -
+                               sizeof(struct hip_tlv_common));
+    /* Type 2 (in R1) or 3 (in I2) */
+    hip_set_param_type((struct hip_tlv_common *) &cookie, 
HIP_PARAM_CHALLENGE_RESPONSE);
+
+    cookie.J        = hton64(val_J);
+    cookie.K        = pz->K;
+    cookie.lifetime = pz->K;
+    opaque_len      = (sizeof(pz->opaque) / sizeof(pz->opaque[0]));
+    memcpy(&cookie.opaque, pz->opaque, opaque_len);
+
+    err = hip_build_generic_param(msg,
+                                  &cookie,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&cookie));
+    return err;
 }
+
 #endif
 
 /**
@@ -2767,67 +2816,75 @@
  * @return zero on success, or non-zero on error
  */
 int hip_build_param_diffie_hellman_contents(struct hip_common *msg,
-             uint8_t group_id1, void *pubkey1, hip_tlv_len_t pubkey_len1,
-             uint8_t group_id2, void *pubkey2, hip_tlv_len_t pubkey_len2)
+                                            uint8_t group_id1,
+                                            void *pubkey1,
+                                            hip_tlv_len_t pubkey_len1,
+                                            uint8_t group_id2,
+                                            void *pubkey2,
+                                            hip_tlv_len_t pubkey_len2)
 {
-       int err = 0;
-       struct hip_diffie_hellman diffie_hellman;
-       uint8_t *value = NULL, *value_tmp = NULL;
-       hip_tlv_len_t pubkey_len = pubkey_len1 + sizeof(uint8_t) +
-                                  sizeof(uint16_t) + pubkey_len2;
-       uint16_t tmp_pubkey_len2 = 0;
-
-
-       HIP_ASSERT(pubkey_len >= sizeof(struct hip_tlv_common));
-
-       _HIP_ASSERT(sizeof(struct hip_diffie_hellman) == 5);
-
-       hip_set_param_type((struct hip_tlv_common *) &diffie_hellman, 
HIP_PARAM_DIFFIE_HELLMAN);
-
-       if(group_id2 != HIP_MAX_DH_GROUP_ID)
-            pubkey_len = pubkey_len1 + sizeof(uint8_t) +
-                         sizeof(uint16_t) + pubkey_len2;
-       else
-            pubkey_len = pubkey_len1;
-
-       /* Allocating memory for the "value" packet */
-       HIP_IFEL(!(value = value_tmp = HIP_MALLOC((pubkey_len), GFP_ATOMIC)),
-            -1, "Failed to alloc memory for value\n");
-
-       hip_calc_generic_param_len((struct hip_tlv_common *) &diffie_hellman,
-                                  sizeof(struct hip_diffie_hellman),
-                                  pubkey_len);
-       diffie_hellman.pub_val.group_id = group_id1; /* 1 byte, no htons() */
-       diffie_hellman.pub_val.pub_len = htons(pubkey_len1);
-
-       if(group_id2 != HIP_MAX_DH_GROUP_ID){
-            /* Creating "value" by joining the first and second DH values */
-            HIP_DEBUG("group_id2 = %d, htons(pubkey_len2)= %d\n",
-                      group_id2, htons(pubkey_len2));
-
-            memcpy(value_tmp, pubkey1, pubkey_len1);
-            value_tmp += pubkey_len1;
-            *value_tmp++ = group_id2;
-            tmp_pubkey_len2 = htons(pubkey_len2);
-            memcpy(value_tmp, &tmp_pubkey_len2, sizeof(uint16_t));
-            value_tmp += sizeof(uint16_t);
-            memcpy(value_tmp, pubkey2, pubkey_len2);
-       }else
-            memcpy(value_tmp, pubkey1, pubkey_len1);
-
-       err = hip_build_generic_param(msg, &diffie_hellman,
-                                     sizeof(struct hip_diffie_hellman),
-                                     value);
-
-       _HIP_HEXDUMP("Own DH pubkey: ", pubkey, pubkey_len);
-
-  out_err:
-
-       if (value)
-               HIP_FREE(value);
-
-       return err;
+    int err                  = 0;
+    struct hip_diffie_hellman diffie_hellman;
+    uint8_t *value           = NULL, *value_tmp = NULL;
+    hip_tlv_len_t pubkey_len = pubkey_len1 + sizeof(uint8_t) +
+                               sizeof(uint16_t) + pubkey_len2;
+    uint16_t tmp_pubkey_len2 = 0;
+
+
+    HIP_ASSERT(pubkey_len >= sizeof(struct hip_tlv_common));
+
+    _HIP_ASSERT(sizeof(struct hip_diffie_hellman) == 5);
+
+    hip_set_param_type((struct hip_tlv_common *) &diffie_hellman, 
HIP_PARAM_DIFFIE_HELLMAN);
+
+    if (group_id2 != HIP_MAX_DH_GROUP_ID) {
+        pubkey_len = pubkey_len1 + sizeof(uint8_t) +
+                     sizeof(uint16_t) + pubkey_len2;
+    } else {
+        pubkey_len = pubkey_len1;
+    }
+
+    /* Allocating memory for the "value" packet */
+    HIP_IFEL(!(value = value_tmp = HIP_MALLOC((pubkey_len), GFP_ATOMIC)),
+             -1, "Failed to alloc memory for value\n");
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) &diffie_hellman,
+                               sizeof(struct hip_diffie_hellman),
+                               pubkey_len);
+    diffie_hellman.pub_val.group_id = group_id1;     /* 1 byte, no htons() */
+    diffie_hellman.pub_val.pub_len  = htons(pubkey_len1);
+
+    if (group_id2 != HIP_MAX_DH_GROUP_ID) {
+        /* Creating "value" by joining the first and second DH values */
+        HIP_DEBUG("group_id2 = %d, htons(pubkey_len2)= %d\n",
+                  group_id2, htons(pubkey_len2));
+
+        memcpy(value_tmp, pubkey1, pubkey_len1);
+        value_tmp      += pubkey_len1;
+        *value_tmp++    = group_id2;
+        tmp_pubkey_len2 = htons(pubkey_len2);
+        memcpy(value_tmp, &tmp_pubkey_len2, sizeof(uint16_t));
+        value_tmp      += sizeof(uint16_t);
+        memcpy(value_tmp, pubkey2, pubkey_len2);
+    } else {
+        memcpy(value_tmp, pubkey1, pubkey_len1);
+    }
+
+    err = hip_build_generic_param(msg, &diffie_hellman,
+                                  sizeof(struct hip_diffie_hellman),
+                                  value);
+
+    _HIP_HEXDUMP("Own DH pubkey: ", pubkey, pubkey_len);
+
+out_err:
+
+    if (value) {
+        HIP_FREE(value);
+    }
+
+    return err;
 }
+
 #endif
 /**
  * hip_get_transform_max - find out the maximum number of transform suite ids
@@ -2837,22 +2894,22 @@
  */
 uint16_t hip_get_transform_max(hip_tlv_type_t transform_type)
 {
-       uint16_t transform_max = 0;
-
-       switch (transform_type) {
-       case HIP_PARAM_HIP_TRANSFORM:
-               transform_max = HIP_TRANSFORM_HIP_MAX;
-               break;
-       case HIP_PARAM_ESP_TRANSFORM:
-               transform_max = HIP_TRANSFORM_ESP_MAX;
-               break;
-       default:
-               HIP_ERROR("Unknown transform type %d\n", transform_type);
-       }
-
-       return transform_max;
-
+    uint16_t transform_max = 0;
+
+    switch (transform_type) {
+    case HIP_PARAM_HIP_TRANSFORM:
+        transform_max = HIP_TRANSFORM_HIP_MAX;
+        break;
+    case HIP_PARAM_ESP_TRANSFORM:
+        transform_max = HIP_TRANSFORM_ESP_MAX;
+        break;
+    default:
+        HIP_ERROR("Unknown transform type %d\n", transform_type);
+    }
+
+    return transform_max;
 }
+
 /**
  * hip_build_param_esp_transform - build an HIP or ESP transform
  * @param msg the message where the parameter will be appended
@@ -2865,38 +2922,39 @@
  * @return zero on success, or negative on error
  */
 int hip_build_param_esp_transform(struct hip_common *msg,
-                             const hip_transform_suite_t transform_suite[],
-                             const uint16_t transform_count)
+                                  const hip_transform_suite_t 
transform_suite[],
+                                  const uint16_t transform_count)
 {
-       int err = 0;
-       uint16_t i;
-       uint16_t transform_max;
-       struct hip_esp_transform transform_param;
-
-       transform_max = hip_get_transform_max(HIP_PARAM_ESP_TRANSFORM);
-
-       /* Check that the maximum number of transforms is not overflowed */
-       if (transform_max > 0 && transform_count > transform_max) {
-               err = -E2BIG;
-               HIP_ERROR("Too many transforms (%d) for type %d.\n",
-                         transform_count, HIP_PARAM_ESP_TRANSFORM);
-               goto out_err;
-       }
-
-               transform_param.reserved = 0;
-
-       /* Copy and convert transforms to network byte order. */
-       for(i = 0; i < transform_count; i++) {
-                       transform_param.suite_id[i] = htons(transform_suite[i]);
-       }
-
-       hip_set_param_type((struct hip_tlv_common *) &transform_param, 
HIP_PARAM_ESP_TRANSFORM);
-       hip_calc_param_len((struct hip_tlv_common *) &transform_param,
-                                  2+transform_count * 
sizeof(hip_transform_suite_t));
-       err = hip_build_param(msg, &transform_param);
-
- out_err:
-       return err;
+    int err = 0;
+    uint16_t i;
+    uint16_t transform_max;
+    struct hip_esp_transform transform_param;
+
+    transform_max = hip_get_transform_max(HIP_PARAM_ESP_TRANSFORM);
+
+    /* Check that the maximum number of transforms is not overflowed */
+    if (transform_max > 0 && transform_count > transform_max) {
+        err = -E2BIG;
+        HIP_ERROR("Too many transforms (%d) for type %d.\n",
+                  transform_count, HIP_PARAM_ESP_TRANSFORM);
+        goto out_err;
+    }
+
+    transform_param.reserved = 0;
+
+    /* Copy and convert transforms to network byte order. */
+    for (i = 0; i < transform_count; i++) {
+        transform_param.suite_id[i] = htons(transform_suite[i]);
+    }
+
+    hip_set_param_type((struct hip_tlv_common *) &transform_param,
+                       HIP_PARAM_ESP_TRANSFORM);
+    hip_calc_param_len((struct hip_tlv_common *) &transform_param,
+                       2 + transform_count * sizeof(hip_transform_suite_t));
+    err = hip_build_param(msg, &transform_param);
+
+out_err:
+    return err;
 }
 
 /**
@@ -2911,38 +2969,39 @@
  * @return zero on success, or negative on error
  */
 int hip_build_param_hip_transform(struct hip_common *msg,
-                             const hip_transform_suite_t transform_suite[],
-                             const uint16_t transform_count)
+                                  const hip_transform_suite_t 
transform_suite[],
+                                  const uint16_t transform_count)
 {
-       int err = 0;
-       uint16_t i;
-       uint16_t transform_max;
-       struct hip_hip_transform transform_param;
-
-       transform_max = hip_get_transform_max(HIP_PARAM_HIP_TRANSFORM);
-
-
-       /* Check that the maximum number of transforms is not overflowed */
-       if (transform_max > 0 && transform_count > transform_max) {
-               err = -E2BIG;
-               HIP_ERROR("Too many transforms (%d) for type %d.\n",
-                         transform_count, HIP_PARAM_HIP_TRANSFORM);
-               goto out_err;
-       }
-
-
-       /* Copy and convert transforms to network byte order. */
-       for(i = 0; i < transform_count; i++) {
-               transform_param.suite_id[i] = htons(transform_suite[i]);
-       }
-
-       hip_set_param_type((struct hip_tlv_common *) &transform_param, 
HIP_PARAM_HIP_TRANSFORM);
-               hip_calc_param_len((struct hip_tlv_common *) &transform_param,
-                                  transform_count * 
sizeof(hip_transform_suite_t));
-       err = hip_build_param(msg, &transform_param);
-
- out_err:
-       return err;
+    int err = 0;
+    uint16_t i;
+    uint16_t transform_max;
+    struct hip_hip_transform transform_param;
+
+    transform_max = hip_get_transform_max(HIP_PARAM_HIP_TRANSFORM);
+
+
+    /* Check that the maximum number of transforms is not overflowed */
+    if (transform_max > 0 && transform_count > transform_max) {
+        err = -E2BIG;
+        HIP_ERROR("Too many transforms (%d) for type %d.\n",
+                  transform_count, HIP_PARAM_HIP_TRANSFORM);
+        goto out_err;
+    }
+
+
+    /* Copy and convert transforms to network byte order. */
+    for (i = 0; i < transform_count; i++) {
+        transform_param.suite_id[i] = htons(transform_suite[i]);
+    }
+
+    hip_set_param_type((struct hip_tlv_common *) &transform_param,
+                       HIP_PARAM_HIP_TRANSFORM);
+    hip_calc_param_len((struct hip_tlv_common *) &transform_param,
+                       transform_count * sizeof(hip_transform_suite_t));
+    err = hip_build_param(msg, &transform_param);
+
+out_err:
+    return err;
 }
 
 /**
@@ -2953,59 +3012,59 @@
  * @return              the suite id on transform_tlv on index
  * @todo                Remove index and rename.
  */
-hip_transform_suite_t hip_get_param_transform_suite_id(
-       const void *transform_tlv, const uint16_t index)
+hip_transform_suite_t hip_get_param_transform_suite_id(const void 
*transform_tlv,
+                                                       const uint16_t index)
 {
-       /** @todo Why do we have hip_select_esp_transform separately? */
-
-        /* RFC 5201 chapter 6.9.:
-           The I2 MUST have a single value in the HIP_TRANSFORM parameter,
-          which MUST match one of the values offered to the Initiator in
-          the R1 packet. Does this function check this?
-          -Lauri 01.08.2008. */
-       hip_tlv_type_t type;
-       uint16_t supported_hip_tf[] = { HIP_HIP_NULL_SHA1,
-                                       HIP_HIP_3DES_SHA1,
-                                       HIP_HIP_AES_SHA1};
-       uint16_t supported_esp_tf[] = { HIP_ESP_NULL_SHA1,
-                                       HIP_ESP_3DES_SHA1,
-                                       HIP_ESP_AES_SHA1 };
-       uint16_t *table = NULL;
-       uint16_t *tfm;
-       int table_n = 0, pkt_tfms = 0, i;
-
-       _HIP_DEBUG("tfm len = %d\n", hip_get_param_contents_len(transform_tlv));
-
-       type = hip_get_param_type(transform_tlv);
-       if (type == HIP_PARAM_HIP_TRANSFORM) {
-               table = supported_hip_tf;
-               table_n = sizeof(supported_hip_tf)/sizeof(uint16_t);
-               tfm = (void *)transform_tlv+sizeof(struct hip_tlv_common);
-               pkt_tfms = 
hip_get_param_contents_len(transform_tlv)/sizeof(uint16_t);
-       } else if (type == HIP_PARAM_ESP_TRANSFORM) {
-               table = supported_esp_tf;
-               table_n = sizeof(supported_esp_tf)/sizeof(uint16_t);
-               tfm = (void *)transform_tlv+sizeof(struct 
hip_tlv_common)+sizeof(uint16_t);
-               pkt_tfms = 
(hip_get_param_contents_len(transform_tlv)-sizeof(uint16_t))/sizeof(uint16_t);
-       } else {
-               HIP_ERROR("Invalid type %u\n", type);
-               return 0;
-       }
-
-       for (i = 0; i < pkt_tfms; i++, tfm++) {
-               int j;
-               _HIP_DEBUG("testing pkt tfm=%u\n", ntohs(*tfm));
-               for (j = 0; j < table_n; j++) {
-                       if (ntohs(*tfm) == table[j]) {
-                               _HIP_DEBUG("found supported tfm %u, pkt tlv 
index of tfm=%d\n",
-                                         table[j], i);
-                               return table[j];
-                       }
-               }
-       }
-       HIP_ERROR("Usable suite not found.\n");
-
-       return 0;
+    /** @todo Why do we have hip_select_esp_transform separately? */
+
+    /* RFC 5201 chapter 6.9.:
+     * The I2 MUST have a single value in the HIP_TRANSFORM parameter,
+     * which MUST match one of the values offered to the Initiator in
+     * the R1 packet. Does this function check this?
+     * -Lauri 01.08.2008. */
+    hip_tlv_type_t type;
+    uint16_t supported_hip_tf[] = { HIP_HIP_NULL_SHA1,
+                                    HIP_HIP_3DES_SHA1,
+                                    HIP_HIP_AES_SHA1};
+    uint16_t supported_esp_tf[] = { HIP_ESP_NULL_SHA1,
+                                    HIP_ESP_3DES_SHA1,
+                                    HIP_ESP_AES_SHA1 };
+    uint16_t *table             = NULL;
+    uint16_t *tfm;
+    int table_n                 = 0, pkt_tfms = 0, i;
+
+    _HIP_DEBUG("tfm len = %d\n", hip_get_param_contents_len(transform_tlv));
+
+    type = hip_get_param_type(transform_tlv);
+    if (type == HIP_PARAM_HIP_TRANSFORM) {
+        table    = supported_hip_tf;
+        table_n  = sizeof(supported_hip_tf) / sizeof(uint16_t);
+        tfm      = (void *) transform_tlv + sizeof(struct hip_tlv_common);
+        pkt_tfms = hip_get_param_contents_len(transform_tlv) / 
sizeof(uint16_t);
+    } else if (type == HIP_PARAM_ESP_TRANSFORM) {
+        table    = supported_esp_tf;
+        table_n  = sizeof(supported_esp_tf) / sizeof(uint16_t);
+        tfm      = (void *) transform_tlv + sizeof(struct hip_tlv_common) + 
sizeof(uint16_t);
+        pkt_tfms = (hip_get_param_contents_len(transform_tlv) - 
sizeof(uint16_t)) / sizeof(uint16_t);
+    } else {
+        HIP_ERROR("Invalid type %u\n", type);
+        return 0;
+    }
+
+    for (i = 0; i < pkt_tfms; i++, tfm++) {
+        int j;
+        _HIP_DEBUG("testing pkt tfm=%u\n", ntohs(*tfm));
+        for (j = 0; j < table_n; j++) {
+            if (ntohs(*tfm) == table[j]) {
+                _HIP_DEBUG("found supported tfm %u, pkt tlv index of tfm=%d\n",
+                           table[j], i);
+                return table[j];
+            }
+        }
+    }
+    HIP_ERROR("Usable suite not found.\n");
+
+    return 0;
 }
 
 #ifndef __KERNEL__
@@ -3019,39 +3078,41 @@
  * @return 0 on success, otherwise < 0.
  */
 int hip_build_param_locator(struct hip_common *msg,
-                       struct hip_locator_info_addr_item *addresses,
-                       int address_count)
+                            struct hip_locator_info_addr_item *addresses,
+                            int address_count)
 {
-       int err = 0;
-       struct hip_locator *locator_info = NULL;
-       int addrs_len = address_count *
-               (sizeof(struct hip_locator_info_addr_item));
-
-       HIP_IFE(!(locator_info =
-                 malloc(sizeof(struct hip_locator) + addrs_len)), -1);
-
-       hip_set_param_type((struct hip_tlv_common *) locator_info, 
HIP_PARAM_LOCATOR);
-       hip_calc_generic_param_len((struct hip_tlv_common *) locator_info,
-                                  sizeof(struct hip_locator),
-                                  addrs_len);
-       _HIP_DEBUG("params size=%d\n", sizeof(struct hip_locator) -
-                  sizeof(struct hip_tlv_common) +
-                  addrs_len);
-
-       memcpy(locator_info + 1, addresses, addrs_len);
-       HIP_IFE(hip_build_param(msg, locator_info), -1);
-
-       _HIP_DEBUG("msgtotlen=%d addrs_len=%d\n", hip_get_msg_total_len(msg),
-                  addrs_len);
-       //if (addrs_len > 0)
-       //      memcpy((void *)msg+hip_get_msg_total_len(msg)-addrs_len,
-       //             addresses, addrs_len);
-
- out_err:
-       if (locator_info)
-               free(locator_info);
-       return err;
+    int err                          = 0;
+    struct hip_locator *locator_info = NULL;
+    int addrs_len = address_count * (sizeof(struct 
hip_locator_info_addr_item));
+
+    HIP_IFE(!(locator_info = malloc(sizeof(struct hip_locator) + addrs_len)), 
-1);
+
+    hip_set_param_type((struct hip_tlv_common *) locator_info, 
HIP_PARAM_LOCATOR);
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) locator_info,
+                               sizeof(struct hip_locator),
+                               addrs_len);
+
+    _HIP_DEBUG("params size=%d\n", sizeof(struct hip_locator) -
+               sizeof(struct hip_tlv_common) +
+               addrs_len);
+
+    memcpy(locator_info + 1, addresses, addrs_len);
+    HIP_IFE(hip_build_param(msg, locator_info), -1);
+
+    _HIP_DEBUG("msgtotlen=%d addrs_len=%d\n", hip_get_msg_total_len(msg),
+               addrs_len);
+    //if (addrs_len > 0)
+    // memcpy((void *)msg+hip_get_msg_total_len(msg)-addrs_len,
+    //        addresses, addrs_len);
+
+out_err:
+    if (locator_info) {
+        free(locator_info);
+    }
+    return err;
 }
+
 #endif /* !__KERNEL__ */
 
 /**
@@ -3070,53 +3131,69 @@
  *
  * @return 0 on success, otherwise < 0.
  */
-int hip_build_param_keys(struct hip_common *msg, uint16_t operation_id,
-                                               uint16_t alg_id, struct 
in6_addr *addr,
-                                               struct in6_addr *hit, struct 
in6_addr *peer_hit, uint32_t spi, uint32_t spi_old,
-                                               uint16_t key_len, struct 
hip_crypto_key *enc)
+int hip_build_param_keys(struct hip_common *msg,
+                         uint16_t operation_id,
+                         uint16_t alg_id,
+                         struct in6_addr *addr,
+                         struct in6_addr *hit,
+                         struct in6_addr *peer_hit,
+                         uint32_t spi,
+                         uint32_t spi_old,
+                         uint16_t key_len,
+                         struct hip_crypto_key *enc)
 {
-       int err = 0;
-       struct hip_keys keys;
-
-       hip_set_param_type((struct hip_tlv_common *) &keys, HIP_PARAM_KEYS);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &keys, 
sizeof(struct hip_keys), 0);
-
-
-       memcpy((struct in6_addr *)&keys.address, addr, 16);
-       memcpy((struct in6_addr *)&keys.hit, hit, 16);
-        memcpy((struct in6_addr *)&keys.peer_hit, peer_hit, 16);
-       keys.operation = htons(operation_id);
-       keys.alg_id = htons(alg_id);
-       keys.spi = htonl(spi);
-       keys.spi_old = htonl(spi_old);
-       keys.key_len = htons(key_len);
-       memcpy(&keys.enc, enc, sizeof(struct hip_crypto_key));
-
-       err = hip_build_param(msg, &keys);
-       return err;
+    int err = 0;
+    struct hip_keys keys;
+
+    hip_set_param_type((struct hip_tlv_common *) &keys, HIP_PARAM_KEYS);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &keys,
+                               sizeof(struct hip_keys),
+                               0);
+
+
+    memcpy((struct in6_addr *) &keys.address, addr, 16);
+    memcpy((struct in6_addr *) &keys.hit, hit, 16);
+    memcpy((struct in6_addr *) &keys.peer_hit, peer_hit, 16);
+    keys.operation = htons(operation_id);
+    keys.alg_id    = htons(alg_id);
+    keys.spi       = htonl(spi);
+    keys.spi_old   = htonl(spi_old);
+    keys.key_len   = htons(key_len);
+    memcpy(&keys.enc, enc, sizeof(struct hip_crypto_key));
+
+    err            = hip_build_param(msg, &keys);
+    return err;
 }
 
-int hip_build_param_keys_hdr(struct hip_keys *keys, uint16_t operation_id,
-                                               uint16_t alg_id, struct 
in6_addr *addr,
-                                               struct in6_addr *hit, struct 
in6_addr *peer_hit, uint32_t spi, uint32_t spi_old,
-                                               uint16_t key_len, struct 
hip_crypto_key *enc)
+int hip_build_param_keys_hdr(struct hip_keys *keys,
+                             uint16_t operation_id,
+                             uint16_t alg_id,
+                             struct in6_addr *addr,
+                             struct in6_addr *hit,
+                             struct in6_addr *peer_hit,
+                             uint32_t spi,
+                             uint32_t spi_old,
+                             uint16_t key_len,
+                             struct hip_crypto_key *enc)
 {
-       int err = 0;
-
-       hip_set_param_type((struct hip_tlv_common *) keys, HIP_PARAM_KEYS);
-       hip_calc_generic_param_len((struct hip_tlv_common *) keys, 
sizeof(struct hip_keys), 0);
-
-       memcpy((struct in6_addr *)keys->address, addr, 16);
-       memcpy((struct in6_addr *)keys->hit, hit, 16);
-        memcpy((struct in6_addr *)keys->peer_hit, peer_hit, 16);
-       keys->operation = htons(operation_id);
-       keys->alg_id = htons(alg_id);
-       keys->spi = htonl(spi);
-       keys->spi_old = htonl(spi_old);
-       keys->key_len = htons(key_len);
-       memcpy(&keys->enc, enc, sizeof(struct hip_crypto_key));
-
-       return err;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) keys, HIP_PARAM_KEYS);
+    hip_calc_generic_param_len((struct hip_tlv_common *) keys,
+                               sizeof(struct hip_keys),
+                               0);
+
+    memcpy((struct in6_addr *) keys->address, addr, 16);
+    memcpy((struct in6_addr *) keys->hit, hit, 16);
+    memcpy((struct in6_addr *) keys->peer_hit, peer_hit, 16);
+    keys->operation = htons(operation_id);
+    keys->alg_id    = htons(alg_id);
+    keys->spi       = htonl(spi);
+    keys->spi_old   = htonl(spi_old);
+    keys->key_len   = htons(key_len);
+    memcpy(&keys->enc, enc, sizeof(struct hip_crypto_key));
+
+    return err;
 }
 
 /**
@@ -3128,14 +3205,16 @@
  */
 int hip_build_param_seq(struct hip_common *msg, uint32_t update_id)
 {
-       int err = 0;
-       struct hip_seq seq;
+    int err = 0;
+    struct hip_seq seq;
 
-       hip_set_param_type((struct hip_tlv_common *) &seq, HIP_PARAM_SEQ);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &seq, 
sizeof(struct hip_seq), 0);
-       seq.update_id = htonl(update_id);
-       err = hip_build_param(msg, &seq);
-       return err;
+    hip_set_param_type((struct hip_tlv_common *) &seq, HIP_PARAM_SEQ);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &seq,
+                               sizeof(struct hip_seq),
+                               0);
+    seq.update_id = htonl(update_id);
+    err = hip_build_param(msg, &seq);
+    return err;
 }
 
 /**
@@ -3147,15 +3226,18 @@
  */
 int hip_build_param_ack(struct hip_common *msg, uint32_t peer_update_id)
 {
-        int err = 0;
-        struct hip_ack ack;
+    int err = 0;
+    struct hip_ack ack;
 
-        hip_set_param_type((struct hip_tlv_common *) &ack, HIP_PARAM_ACK);
-        hip_calc_generic_param_len((struct hip_tlv_common *) &ack, 
sizeof(struct hip_ack), 0);
-        ack.peer_update_id = htonl(peer_update_id);
-        err = hip_build_param(msg, &ack);
-        return err;
+    hip_set_param_type((struct hip_tlv_common *) &ack, HIP_PARAM_ACK);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &ack,
+                               sizeof(struct hip_ack),
+                               0);
+    ack.peer_update_id = htonl(peer_update_id);
+    err = hip_build_param(msg, &ack);
+    return err;
 }
+
 #ifndef __KERNEL__
 /**
  * hip_build_param_esp_prot_mode - build and append ESP PROT transform 
parameter
@@ -3164,31 +3246,33 @@
  *
  * @return 0 on success, otherwise < 0.
  */
-int hip_build_param_esp_prot_transform(struct hip_common *msg, int 
num_transforms,
-               uint8_t *transforms)
+int hip_build_param_esp_prot_transform(struct hip_common *msg,
+                                       int num_transforms,
+                                       uint8_t *transforms)
 {
-       struct esp_prot_preferred_tfms prot_transforms;
-       int err = 0, i;
-
-       hip_set_param_type((struct hip_tlv_common *) &prot_transforms, 
HIP_PARAM_ESP_PROT_TRANSFORMS);
-
-       /* note: the length cannot be calculated with calc_param_len() */
-       hip_set_param_contents_len((struct hip_tlv_common *) &prot_transforms, 
(num_transforms + 1) * sizeof(uint8_t));
-
-       prot_transforms.num_transforms = num_transforms;
-       HIP_DEBUG("added num_transforms: %u\n", prot_transforms.num_transforms);
-
-       for (i = 0; i < prot_transforms.num_transforms; i++)
-       {
-               prot_transforms.transforms[i] = transforms[i];
-               HIP_DEBUG("added transform %i: %u\n", i + 1, transforms[i]);
-       }
-
-       err = hip_build_generic_param(msg, &prot_transforms,
-                                                     sizeof(struct 
hip_tlv_common),
-                                                     
hip_get_param_contents_direct(&prot_transforms));
-
-       return err;
+    struct esp_prot_preferred_tfms prot_transforms;
+    int err = 0, i;
+
+    hip_set_param_type((struct hip_tlv_common *) &prot_transforms,
+                       HIP_PARAM_ESP_PROT_TRANSFORMS);
+
+    /* note: the length cannot be calculated with calc_param_len() */
+    hip_set_param_contents_len((struct hip_tlv_common *) &prot_transforms,
+                               (num_transforms + 1) * sizeof(uint8_t));
+
+    prot_transforms.num_transforms = num_transforms;
+    HIP_DEBUG("added num_transforms: %u\n", prot_transforms.num_transforms);
+
+    for (i = 0; i < prot_transforms.num_transforms; i++) {
+        prot_transforms.transforms[i] = transforms[i];
+        HIP_DEBUG("added transform %i: %u\n", i + 1, transforms[i]);
+    }
+
+    err = hip_build_generic_param(msg,
+                                  &prot_transforms,
+                                  sizeof(struct hip_tlv_common),
+                                  
hip_get_param_contents_direct(&prot_transforms));
+    return err;
 }
 
 /**
@@ -3201,62 +3285,68 @@
  *
  * @return 0 on success, otherwise < 0.
  */
-int hip_build_param_esp_prot_anchor(struct hip_common *msg, uint8_t transform,
-               unsigned char *active_anchor, unsigned char *next_anchor, int 
hash_length,
-               int hash_item_length)
+int hip_build_param_esp_prot_anchor(struct hip_common *msg,
+                                    uint8_t transform,
+                                    unsigned char *active_anchor,
+                                    unsigned char *next_anchor,
+                                    int hash_length,
+                                    int hash_item_length)
 {
-       int err = 0;
-       //unsigned char *anchors = NULL;
-       struct esp_prot_anchor esp_anchor;
-
-       HIP_ASSERT(msg != NULL);
-       // NULL-active_anchor only allowed for UNUSED-transform
-       HIP_ASSERT((!transform && !active_anchor) || (transform && 
active_anchor));
-       // next_anchor might be NULL
-
-       // set parameter type
-       hip_set_param_type((struct hip_tlv_common *) &esp_anchor, 
HIP_PARAM_ESP_PROT_ANCHOR);
-
-       // set parameter values
-       esp_anchor.transform = transform;
-       esp_anchor.hash_item_length = htonl(hash_item_length);
-
-       // distinguish UNUSED from any other case
-       if (!transform)
-       {
-               // send 1 byte of 0 per anchor in UNUSED case
-               hash_length = 1;
-
-               memset(&esp_anchor.anchors[0], 0, hash_length);
-               memset(&esp_anchor.anchors[hash_length], 0, hash_length);
-
-       } else
-       {
-               memcpy(&esp_anchor.anchors[0], active_anchor, hash_length);
-
-               // send 0 if next_anchor not present
-               if (next_anchor != NULL)
-                       memcpy(&esp_anchor.anchors[hash_length], next_anchor, 
hash_length);
-               else
-                       memset(&esp_anchor.anchors[hash_length], 0, 
hash_length);
-       }
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &esp_anchor, 
sizeof(uint8_t) + sizeof(uint32_t) +
-                       2 * hash_length);
-
-       err = hip_build_generic_param(msg, &esp_anchor,
-                                             sizeof(struct hip_tlv_common),
-                                             
hip_get_param_contents_direct(&esp_anchor));
-
-       HIP_DEBUG("added esp protection transform: %u\n", transform);
-       HIP_DEBUG("added hash item length: %u\n", hash_item_length);
-       HIP_HEXDUMP("added esp protection active_anchor: ", 
&esp_anchor.anchors[0],
-                       hash_length);
-       HIP_HEXDUMP("added esp protection next_anchor: ",
-                       &esp_anchor.anchors[hash_length], hash_length);
-
-       return err;
+    int err = 0;
+    //unsigned char *anchors = NULL;
+    struct esp_prot_anchor esp_anchor;
+
+    HIP_ASSERT(msg != NULL);
+    // NULL-active_anchor only allowed for UNUSED-transform
+    HIP_ASSERT((!transform && !active_anchor) || (transform && active_anchor));
+    // next_anchor might be NULL
+
+    // set parameter type
+    hip_set_param_type((struct hip_tlv_common *) &esp_anchor, 
HIP_PARAM_ESP_PROT_ANCHOR);
+
+    // set parameter values
+    esp_anchor.transform        = transform;
+    esp_anchor.hash_item_length = htonl(hash_item_length);
+
+    // distinguish UNUSED from any other case
+    if (!transform) {
+        // send 1 byte of 0 per anchor in UNUSED case
+        hash_length = 1;
+
+        memset(&esp_anchor.anchors[0], 0, hash_length);
+        memset(&esp_anchor.anchors[hash_length], 0, hash_length);
+    } else {
+        memcpy(&esp_anchor.anchors[0], active_anchor, hash_length);
+
+        // send 0 if next_anchor not present
+        if (next_anchor != NULL) {
+            memcpy(&esp_anchor.anchors[hash_length], next_anchor, hash_length);
+        } else {
+            memset(&esp_anchor.anchors[hash_length], 0, hash_length);
+        }
+    }
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &esp_anchor,
+                               sizeof(uint8_t) + sizeof(uint32_t) + 2
+                                       * hash_length);
+
+    err = hip_build_generic_param(msg,
+                                  &esp_anchor,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&esp_anchor));
+
+    HIP_DEBUG("added esp protection transform: %u\n", transform);
+    HIP_DEBUG("added hash item length: %u\n", hash_item_length);
+    HIP_HEXDUMP("added esp protection active_anchor: ",
+                &esp_anchor.anchors[0],
+                hash_length);
+    HIP_HEXDUMP("added esp protection next_anchor: ",
+                &esp_anchor.anchors[hash_length],
+                hash_length);
+
+    return err;
 }
+
 #endif
 /**
  * hip_build_param_unit_test - build and insert an unit test parameter
@@ -3269,109 +3359,122 @@
  *
  * @return 0 on success, otherwise < 0.
  */
-int hip_build_param_unit_test(struct hip_common *msg, uint16_t suiteid,
-                             uint16_t caseid)
-{
-       int err = 0;
-       struct hip_unit_test ut;
-
-       hip_set_param_type((struct hip_tlv_common *) &ut, HIP_PARAM_UNIT_TEST);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &ut, sizeof(struct 
hip_unit_test), 0);
-       ut.suiteid = htons(suiteid);
-       ut.caseid = htons(caseid);
-
-       err = hip_build_param(msg, &ut);
-       return err;
-}
-
-int hip_build_param_esp_prot_branch(struct hip_common *msg, int anchor_offset,
-               int branch_length, unsigned char *branch_nodes)
-{
-       int err = 0;
-       struct esp_prot_branch branch;
-
-       HIP_ASSERT(msg != NULL);
-       HIP_ASSERT(anchor_offset >= 0);
-       HIP_ASSERT(branch_length > 0);
-       HIP_ASSERT(branch_nodes != NULL);
-
-       // set parameter type
-       hip_set_param_type((struct hip_tlv_common *) &branch, 
HIP_PARAM_ESP_PROT_BRANCH);
-
-       // set parameter values
-       branch.anchor_offset = htonl(anchor_offset);
-       branch.branch_length = htonl(branch_length);
-       memcpy(&branch.branch_nodes[0], branch_nodes, branch_length);
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &branch, 2 * 
sizeof(uint32_t) + branch_length);
-
-       err = hip_build_generic_param(msg, &branch,
-                                             sizeof(struct hip_tlv_common),
-                                             
hip_get_param_contents_direct(&branch));
-
-       HIP_DEBUG("added esp anchor offset: %u\n", branch.anchor_offset);
-       HIP_DEBUG("added esp branch length: %u\n", branch.branch_length);
-       HIP_HEXDUMP("added esp branch: ", &branch.branch_nodes[0], 
branch_length);
-
-       return err;
-}
-
-int hip_build_param_esp_prot_secret(struct hip_common *msg, int secret_length,
-               unsigned char *secret)
-{
-       int err = 0;
-       struct esp_prot_secret esp_secret;
-
-       HIP_ASSERT(msg != NULL);
-       HIP_ASSERT(secret_length > 0);
-       HIP_ASSERT(secret != NULL);
-
-       // set parameter type
-       hip_set_param_type((struct hip_tlv_common *) &esp_secret, 
HIP_PARAM_ESP_PROT_SECRET);
-
-       // set parameter values
-       esp_secret.secret_length = secret_length;
-       memcpy(&esp_secret.secret[0], secret, secret_length);
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &esp_secret, 
sizeof(uint8_t) + secret_length);
-
-       err = hip_build_generic_param(msg, &esp_secret,
-                                             sizeof(struct hip_tlv_common),
-                                             
hip_get_param_contents_direct(&esp_secret));
-
-       HIP_DEBUG("added esp secret length: %u\n", esp_secret.secret_length);
-       HIP_HEXDUMP("added esp secret: ", &esp_secret.secret[0], secret_length);
-
-       return err;
-}
-
-int hip_build_param_esp_prot_root(struct hip_common *msg, uint8_t root_length,
-               unsigned char *root)
-{
-       int err = 0;
-       struct esp_prot_root esp_root;
-
-       HIP_ASSERT(msg != NULL);
-       HIP_ASSERT(root_length > 0);
-       HIP_ASSERT(root != NULL);
-
-       // set parameter type
-       hip_set_param_type((struct hip_tlv_common *) &esp_root, 
HIP_PARAM_ESP_PROT_ROOT);
-
-       // set parameter values
-       esp_root.root_length = root_length;
-       memcpy(&esp_root.root[0], root, root_length);
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &esp_root, 
sizeof(uint8_t) + root_length);
-
-       err = hip_build_generic_param(msg, &esp_root,
-                                             sizeof(struct hip_tlv_common),
-                                             
hip_get_param_contents_direct(&esp_root));
-
-       HIP_DEBUG("added esp root length: %u\n", esp_root.root_length);
-       HIP_HEXDUMP("added esp root: ", &esp_root.root[0], root_length);
-
-       return err;
+int hip_build_param_unit_test(struct hip_common *msg,
+                              uint16_t suiteid,
+                              uint16_t caseid)
+{
+    int err = 0;
+    struct hip_unit_test ut;
+
+    hip_set_param_type((struct hip_tlv_common *) &ut, HIP_PARAM_UNIT_TEST);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &ut,
+                               sizeof(struct hip_unit_test),
+                               0);
+    ut.suiteid = htons(suiteid);
+    ut.caseid  = htons(caseid);
+
+    err        = hip_build_param(msg, &ut);
+    return err;
+}
+
+int hip_build_param_esp_prot_branch(struct hip_common *msg,
+                                    int anchor_offset,
+                                    int branch_length,
+                                    unsigned char *branch_nodes)
+{
+    int err = 0;
+    struct esp_prot_branch branch;
+
+    HIP_ASSERT(msg != NULL);
+    HIP_ASSERT(anchor_offset >= 0);
+    HIP_ASSERT(branch_length > 0);
+    HIP_ASSERT(branch_nodes != NULL);
+
+    // set parameter type
+    hip_set_param_type((struct hip_tlv_common *) &branch, 
HIP_PARAM_ESP_PROT_BRANCH);
+
+    // set parameter values
+    branch.anchor_offset = htonl(anchor_offset);
+    branch.branch_length = htonl(branch_length);
+    memcpy(&branch.branch_nodes[0], branch_nodes, branch_length);
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &branch, 2
+            * sizeof(uint32_t) + branch_length);
+
+    err = hip_build_generic_param(msg,
+                                  &branch,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&branch));
+
+    HIP_DEBUG("added esp anchor offset: %u\n", branch.anchor_offset);
+    HIP_DEBUG("added esp branch length: %u\n", branch.branch_length);
+    HIP_HEXDUMP("added esp branch: ", &branch.branch_nodes[0], branch_length);
+
+    return err;
+}
+
+int hip_build_param_esp_prot_secret(struct hip_common *msg,
+                                    int secret_length,
+                                    unsigned char *secret)
+{
+    int err = 0;
+    struct esp_prot_secret esp_secret;
+
+    HIP_ASSERT(msg != NULL);
+    HIP_ASSERT(secret_length > 0);
+    HIP_ASSERT(secret != NULL);
+
+    // set parameter type
+    hip_set_param_type((struct hip_tlv_common *) &esp_secret, 
HIP_PARAM_ESP_PROT_SECRET);
+
+    // set parameter values
+    esp_secret.secret_length = secret_length;
+    memcpy(&esp_secret.secret[0], secret, secret_length);
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &esp_secret,
+                               sizeof(uint8_t) + secret_length);
+
+    err = hip_build_generic_param(msg, &esp_secret,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&esp_secret));
+
+    HIP_DEBUG("added esp secret length: %u\n", esp_secret.secret_length);
+    HIP_HEXDUMP("added esp secret: ", &esp_secret.secret[0], secret_length);
+
+    return err;
+}
+
+int hip_build_param_esp_prot_root(struct hip_common *msg,
+                                  uint8_t root_length,
+                                  unsigned char *root)
+{
+    int err = 0;
+    struct esp_prot_root esp_root;
+
+    HIP_ASSERT(msg != NULL);
+    HIP_ASSERT(root_length > 0);
+    HIP_ASSERT(root != NULL);
+
+    // set parameter type
+    hip_set_param_type((struct hip_tlv_common *) &esp_root,
+                       HIP_PARAM_ESP_PROT_ROOT);
+
+    // set parameter values
+    esp_root.root_length = root_length;
+    memcpy(&esp_root.root[0], root, root_length);
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &esp_root,
+                               sizeof(uint8_t) + root_length);
+
+    err = hip_build_generic_param(msg,
+                                  &esp_root,
+                                  sizeof(struct hip_tlv_common),
+                                  hip_get_param_contents_direct(&esp_root));
+
+    HIP_DEBUG("added esp root length: %u\n", esp_root.root_length);
+    HIP_HEXDUMP("added esp root: ", &esp_root.root[0], root_length);
+
+    return err;
 }
 
 /**
@@ -3386,26 +3489,33 @@
  *
  * @return zero on success, or negative on failure
  */
-int hip_build_param_esp_info(struct hip_common *msg, uint16_t keymat_index,
-                            uint32_t old_spi, uint32_t new_spi)
+int hip_build_param_esp_info(struct hip_common *msg,
+                             uint16_t keymat_index,
+                             uint32_t old_spi,
+                             uint32_t new_spi)
 {
-       int err = 0;
-       struct hip_esp_info esp_info;
-       _HIP_DEBUG("Add SPI old: 0x%x (nwbo: 0x%x), new: 0x%x (nwbo: 0x%x)\n",
-               old_spi, htonl(old_spi), new_spi, htonl(new_spi));
-       hip_set_param_type((struct hip_tlv_common *) &esp_info, 
HIP_PARAM_ESP_INFO);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &esp_info, 
sizeof(struct hip_esp_info), 0);
-       esp_info.reserved = htonl(0);
-       esp_info.keymat_index = htons(keymat_index);
-       esp_info.old_spi = htonl(old_spi);
-       esp_info.new_spi = htonl(new_spi);
-       _HIP_DEBUG("esp param old: 0x%x , new: 0x%x \n",
-                 esp_info.old_spi, esp_info.new_spi);
-
-       _HIP_DEBUG("keymat index = %d\n", keymat_index);
-       _HIP_HEXDUMP("esp_info:", &esp_info, sizeof(struct hip_esp_info));
-       err = hip_build_param(msg, &esp_info);
-       return err;
+    int err = 0;
+    struct hip_esp_info esp_info;
+    _HIP_DEBUG("Add SPI old: 0x%x (nwbo: 0x%x), new: 0x%x (nwbo: 0x%x)\n",
+            old_spi, htonl(old_spi), new_spi, htonl(new_spi));
+    hip_set_param_type((struct hip_tlv_common *) &esp_info, 
HIP_PARAM_ESP_INFO);
+
+    hip_calc_generic_param_len((struct hip_tlv_common *) &esp_info,
+                               sizeof(struct hip_esp_info),
+                               0);
+
+    esp_info.reserved = htonl(0);
+    esp_info.keymat_index = htons(keymat_index);
+    esp_info.old_spi = htonl(old_spi);
+    esp_info.new_spi = htonl(new_spi);
+
+    _HIP_DEBUG("esp param old: 0x%x , new: 0x%x \n",
+            esp_info.old_spi, esp_info.new_spi);
+    _HIP_DEBUG("keymat index = %d\n", keymat_index);
+    _HIP_HEXDUMP("esp_info:", &esp_info, sizeof(struct hip_esp_info));
+
+    err = hip_build_param(msg, &esp_info);
+    return err;
 }
 
 #if 0
@@ -3421,16 +3531,17 @@
  */
 int hip_build_param_spi(struct hip_common *msg, uint32_t spi)
 {
-        int err = 0;
-        struct hip_spi hspi;
-
-        hip_set_param_type((struct hip_tlv_common *) &hspi, 
HIP_PARAM_ESP_INFO);
-        hip_calc_generic_param_len((struct hip_tlv_common *) &hspi, 
sizeof(struct hip_spi), 0);
-        hspi.spi = htonl(spi);
-
-        err = hip_build_param(msg, &hspi);
-        return err;
+    int err = 0;
+    struct hip_spi hspi;
+
+    hip_set_param_type((struct hip_tlv_common *) &hspi, HIP_PARAM_ESP_INFO);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &hspi, sizeof(struct 
hip_spi), 0);
+    hspi.spi = htonl(spi);
+
+    err      = hip_build_param(msg, &hspi);
+    return err;
 }
+
 #endif
 
 
@@ -3438,11 +3549,11 @@
  *
  */
 /*int hip_build_param_encrypted(struct hip_common *msg,
-                                       struct hip_tlv_common *param)
-{
-       //TODO
-       return 0;
-}*/
+ *                                      struct hip_tlv_common *param)
+ * {
+ *      //TODO
+ *      return 0;
+ * }*/
 
 
 /**
@@ -3458,23 +3569,23 @@
  * Returns: zero on success, or negative on failure
  */
 int hip_build_param_encrypted_3des_sha1(struct hip_common *msg,
-                                       struct hip_tlv_common *param)
+                                        struct hip_tlv_common *param)
 {
-       int err = 0;
-       struct hip_encrypted_3des_sha1 enc;
-
-       hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
-       hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
-                          sizeof(struct hip_tlv_common) +
-                          hip_get_param_total_len(param));
-       enc.reserved = htonl(0);
-       memset(&enc.iv, 0, 8);
-
-       /* copy the IV *IF* needed, and then the encrypted data */
-
-       err = hip_build_generic_param(msg, &enc, sizeof(enc), param);
-
-       return err;
+    int err = 0;
+    struct hip_encrypted_3des_sha1 enc;
+
+    hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
+    hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
+                       sizeof(struct hip_tlv_common) +
+                       hip_get_param_total_len(param));
+    enc.reserved = htonl(0);
+    memset(&enc.iv, 0, 8);
+
+    /* copy the IV *IF* needed, and then the encrypted data */
+
+    err = hip_build_generic_param(msg, &enc, sizeof(enc), param);
+
+    return err;
 }
 
 /**
@@ -3490,113 +3601,122 @@
  * Returns: zero on success, or negative on failure
  */
 int hip_build_param_encrypted_null_sha1(struct hip_common *msg,
-                                       struct hip_tlv_common *param)
+                                        struct hip_tlv_common *param)
 {
-       int err = 0;
-       struct hip_encrypted_null_sha1 enc;
-
-       hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
-       hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
-                          sizeof(struct hip_tlv_common) +
-                          hip_get_param_total_len(param));
-       enc.reserved = htonl(0);
-
-       /* copy the IV *IF* needed, and then the encrypted data */
-
-       err = hip_build_generic_param(msg, &enc, sizeof(enc), param);
-
-       return err;
+    int err = 0;
+    struct hip_encrypted_null_sha1 enc;
+
+    hip_set_param_type((struct hip_tlv_common *) &enc, HIP_PARAM_ENCRYPTED);
+    hip_calc_param_len((struct hip_tlv_common *) &enc, sizeof(enc) -
+                       sizeof(struct hip_tlv_common) +
+                       hip_get_param_total_len(param));
+    enc.reserved = htonl(0);
+
+    /* copy the IV *IF* needed, and then the encrypted data */
+
+    err          = hip_build_generic_param(msg, &enc, sizeof(enc), param);
+
+    return err;
 }
 
 void hip_build_param_host_id_hdr(struct hip_host_id *host_id_hdr,
-                                const char *hostname,
-                                hip_tlv_len_t rr_data_len,
+                                 const char *hostname,
+                                 hip_tlv_len_t rr_data_len,
                                  uint8_t algorithm)
 {
-       uint16_t hi_len = sizeof(struct hip_host_id_key_rdata) + rr_data_len;
-       uint16_t fqdn_len;
-        /* reserve 1 byte for NULL termination */
-       if (hostname)
-               fqdn_len = (strlen(hostname) + 1) & 0x0FFF;
-       else
-               fqdn_len = 0;
-
-       host_id_hdr->hi_length = htons(hi_len);
-       /* length = 12 bits, di_type = 4 bits */
-       host_id_hdr->di_type_length = htons(fqdn_len | 0x1000);
-       /* if the length is 0, then the type should also be zero */
-       if (host_id_hdr->di_type_length == ntohs(0x1000))
-               host_id_hdr->di_type_length = 0;
-
-        hip_set_param_type((struct hip_tlv_common *) host_id_hdr, 
HIP_PARAM_HOST_ID);
-        hip_calc_generic_param_len((struct hip_tlv_common *) host_id_hdr, 
sizeof(struct hip_host_id), 0);
-
-        host_id_hdr->rdata.flags = htons(0x0202); /* key is for a host */
-
-       /* RFC 4034 obsoletes RFC 2535 and flags field differ */
-        host_id_hdr->rdata.protocol = 0xFF; /* RFC 2535 */
-       /* algo is 8 bits, no htons */
-        host_id_hdr->rdata.algorithm = algorithm;
-
-       _HIP_DEBUG("hilen=%d totlen=%d contlen=%d\n",
-                  ntohs(host_id_hdr->hi_length),
-                  hip_get_param_contents_len(host_id_hdr),
-                  hip_get_param_total_len(host_id_hdr));
+    uint16_t hi_len = sizeof(struct hip_host_id_key_rdata) + rr_data_len;
+    uint16_t fqdn_len;
+    /* reserve 1 byte for NULL termination */
+    if (hostname) {
+        fqdn_len = (strlen(hostname) + 1) & 0x0FFF;
+    } else {
+        fqdn_len = 0;
+    }
+
+    host_id_hdr->hi_length      = htons(hi_len);
+    /* length = 12 bits, di_type = 4 bits */
+    host_id_hdr->di_type_length = htons(fqdn_len | 0x1000);
+    /* if the length is 0, then the type should also be zero */
+    if (host_id_hdr->di_type_length == ntohs(0x1000)) {
+        host_id_hdr->di_type_length = 0;
+    }
+
+    hip_set_param_type((struct hip_tlv_common *) host_id_hdr, 
HIP_PARAM_HOST_ID);
+    hip_calc_generic_param_len((struct hip_tlv_common *) host_id_hdr,
+                               sizeof(struct hip_host_id),
+                               0);
+
+    host_id_hdr->rdata.flags     = htons(0x0202); /* key is for a host */
+
+    /* RFC 4034 obsoletes RFC 2535 and flags field differ */
+    host_id_hdr->rdata.protocol  = 0xFF;    /* RFC 2535 */
+    /* algo is 8 bits, no htons */
+    host_id_hdr->rdata.algorithm = algorithm;
+
+    _HIP_DEBUG("hilen=%d totlen=%d contlen=%d\n",
+               ntohs(host_id_hdr->hi_length),
+               hip_get_param_contents_len(host_id_hdr),
+               hip_get_param_total_len(host_id_hdr));
 }
 
 void hip_build_param_host_id_only(struct hip_host_id *host_id,
-                                   const void *rr_data,
-                                   const char *fqdn)
+                                  const void *rr_data,
+                                  const char *fqdn)
 {
-       unsigned int rr_len = ntohs(host_id->hi_length) -
-               sizeof(struct hip_host_id_key_rdata);
-       uint16_t fqdn_len;
-
-       _HIP_DEBUG("hi len: %d\n", ntohs(host_id->hi_length));
-       _HIP_DEBUG("Copying %d bytes\n", rr_len);
-
-       memcpy(host_id->key, rr_data, rr_len);
-
-       fqdn_len = ntohs(host_id->di_type_length) & 0x0FFF;
-       _HIP_DEBUG("fqdn len: %d\n", fqdn_len);
-       if (fqdn_len)
-               memcpy(host_id->hostname, fqdn, fqdn_len);
+    unsigned int rr_len = ntohs(host_id->hi_length) -
+                          sizeof(struct hip_host_id_key_rdata);
+    uint16_t fqdn_len;
+
+    _HIP_DEBUG("hi len: %d\n", ntohs(host_id->hi_length));
+    _HIP_DEBUG("Copying %d bytes\n", rr_len);
+
+    memcpy(host_id->key, rr_data, rr_len);
+
+    fqdn_len = ntohs(host_id->di_type_length) & 0x0FFF;
+    _HIP_DEBUG("fqdn len: %d\n", fqdn_len);
+    if (fqdn_len) {
+        memcpy(host_id->hostname, fqdn, fqdn_len);
+    }
 }
 
 void hip_build_param_host_id_hdr_priv(struct hip_host_id_priv *host_id_hdr,
-                                const char *hostname,
-                                hip_tlv_len_t rr_data_len,
-                                 uint8_t algorithm)
+                                      const char *hostname,
+                                      hip_tlv_len_t rr_data_len,
+                                      uint8_t algorithm)
 {
-       uint16_t hi_len = sizeof(struct hip_host_id_key_rdata) + rr_data_len;
-       uint16_t fqdn_len;
-        /* reserve 1 byte for NULL termination */
-       if (hostname)
-               fqdn_len = (strlen(hostname) + 1) & 0x0FFF;
-       else
-               fqdn_len = 0;
-
-       host_id_hdr->hi_length = htons(hi_len);
-       /* length = 12 bits, di_type = 4 bits */
-       host_id_hdr->di_type_length = htons(fqdn_len | 0x1000);
-       /* if the length is 0, then the type should also be zero */
-       if (host_id_hdr->di_type_length == ntohs(0x1000))
-               host_id_hdr->di_type_length = 0;
-
-        hip_set_param_type((struct hip_tlv_common *) host_id_hdr, 
HIP_PARAM_HOST_ID);
-        hip_calc_generic_param_len((struct hip_tlv_common *) host_id_hdr, 
sizeof(struct hip_host_id_priv), 0);
-
-        host_id_hdr->rdata.flags = htons(0x0202); /* key is for a host */
-
-       /* RFC 4034 obsoletes RFC 2535 and flags field differ */
-        host_id_hdr->rdata.protocol = 0xFF; /* RFC 2535 */
-       /* algo is 8 bits, no htons */
-        host_id_hdr->rdata.algorithm = algorithm;
-
-       _HIP_DEBUG("hilen=%d totlen=%d contlen=%d\n",
-                  ntohs(host_id_hdr->hi_length),
-                  hip_get_param_contents_len(host_id_hdr),
-                  hip_get_param_total_len(host_id_hdr));
+    uint16_t hi_len = sizeof(struct hip_host_id_key_rdata) + rr_data_len;
+    uint16_t fqdn_len;
+    /* reserve 1 byte for NULL termination */
+    if (hostname) {
+        fqdn_len = (strlen(hostname) + 1) & 0x0FFF;
+    } else {
+        fqdn_len = 0;
+    }
+
+    host_id_hdr->hi_length      = htons(hi_len);
+    /* length = 12 bits, di_type = 4 bits */
+    host_id_hdr->di_type_length = htons(fqdn_len | 0x1000);
+    /* if the length is 0, then the type should also be zero */
+    if (host_id_hdr->di_type_length == ntohs(0x1000)) {
+        host_id_hdr->di_type_length = 0;
+    }
+
+    hip_set_param_type((struct hip_tlv_common *) host_id_hdr, 
HIP_PARAM_HOST_ID);
+    hip_calc_generic_param_len((struct hip_tlv_common *) host_id_hdr,
+                               sizeof(struct hip_host_id_priv),
+                               0);
+
+    host_id_hdr->rdata.flags     = htons(0x0202); /* key is for a host */
+
+    /* RFC 4034 obsoletes RFC 2535 and flags field differ */
+    host_id_hdr->rdata.protocol  = 0xFF;    /* RFC 2535 */
+    /* algo is 8 bits, no htons */
+    host_id_hdr->rdata.algorithm = algorithm;
+
+    _HIP_DEBUG("hilen=%d totlen=%d contlen=%d\n",
+               ntohs(host_id_hdr->hi_length),
+               hip_get_param_contents_len(host_id_hdr),
+               hip_get_param_total_len(host_id_hdr));
 }
 
 /**
@@ -3606,90 +3726,93 @@
  *
  */
 int hip_build_param_host_id(struct hip_common *msg,
-                           struct hip_host_id *host_id_hdr,
-                           const void *rr_data,
-                           const char *fqdn)
+                            struct hip_host_id *host_id_hdr,
+                            const void *rr_data,
+                            const char *fqdn)
 {
-       int err = 0;
-       hip_build_param_host_id_only(host_id_hdr, rr_data, fqdn);
-        err = hip_build_param(msg, host_id_hdr);
-       return err;
+    int err = 0;
+    hip_build_param_host_id_only(host_id_hdr, rr_data, fqdn);
+    err = hip_build_param(msg, host_id_hdr);
+    return err;
 }
 
 int hip_build_param_hostname(struct hip_common *msg, const char *hostname)
 {
-       struct hip_tlv_common param;
-       size_t namelen;
-
-       hip_set_param_type(&param, HIP_PARAM_HOSTNAME);
-
-       namelen = strlen(hostname) + 1;
-       if(namelen > HIP_HOST_ID_HOSTNAME_LEN_MAX)
-       {
-         namelen = HIP_HOST_ID_HOSTNAME_LEN_MAX;
-       }
-
-       hip_set_param_contents_len((struct hip_tlv_common *) &param,
-           namelen);
-
-       return hip_build_generic_param(msg, &param,
-           sizeof(struct hip_tlv_common), hostname);
+    struct hip_tlv_common param;
+    size_t namelen;
+
+    hip_set_param_type(&param, HIP_PARAM_HOSTNAME);
+
+    namelen = strlen(hostname) + 1;
+    if (namelen > HIP_HOST_ID_HOSTNAME_LEN_MAX) {
+        namelen = HIP_HOST_ID_HOSTNAME_LEN_MAX;
+    }
+
+    hip_set_param_contents_len((struct hip_tlv_common *) &param,
+                               namelen);
+
+    return hip_build_generic_param(msg,
+                                   &param,
+                                   sizeof(struct hip_tlv_common),
+                                   hostname);
 }
 
-int hip_get_param_host_id_di_type_len(struct hip_host_id *host, char **id, int 
*len)
+int hip_get_param_host_id_di_type_len(struct hip_host_id *host,
+                                      char **id,
+                                      int *len)
 {
-       int type;
-       static char *debuglist[3] = {"none", "FQDN", "NAI"};
-
-       type = ntohs(host->di_type_length);
-       *len = type & 0x0FFF;
-       type = (type & 0xF000) >> 12;
-
-       if (type > 2) {
-               HIP_ERROR("Illegal DI-type: %d\n",type);
-               return -1;
-       }
-
-       *id = debuglist[type];
-       return 0;
+    int type;
+    static char *debuglist[3] = {"none", "FQDN", "NAI"};
+
+    type = ntohs(host->di_type_length);
+    *len = type & 0x0FFF;
+    type = (type & 0xF000) >> 12;
+
+    if (type > 2) {
+        HIP_ERROR("Illegal DI-type: %d\n", type);
+        return -1;
+    }
+
+    *id = debuglist[type];
+    return 0;
 }
 
 char *hip_get_param_host_id_hostname(struct hip_host_id *hostid)
 {
-       return hostid->hostname;
+    return hostid->hostname;
 }
 
 int hip_build_param_eid_endpoint_from_host_id(struct hip_common *msg,
-                                             const struct endpoint_hip 
*endpoint)
+                                              const struct endpoint_hip 
*endpoint)
 {
-       int err = 0;
-
-       HIP_ASSERT(!(endpoint->flags & HIP_ENDPOINT_FLAG_HIT));
-
-       err = hip_build_param_contents(msg, endpoint, HIP_PARAM_EID_ENDPOINT,
-                                      endpoint->length);
-       return err;
+    int err = 0;
+
+    HIP_ASSERT(!(endpoint->flags & HIP_ENDPOINT_FLAG_HIT));
+
+    err = hip_build_param_contents(msg, endpoint, HIP_PARAM_EID_ENDPOINT,
+                                   endpoint->length);
+    return err;
 }
 
 int hip_build_param_eid_endpoint_from_hit(struct hip_common *msg,
-                                         const struct endpoint_hip *endpoint)
+                                          const struct endpoint_hip *endpoint)
 {
-       struct hip_eid_endpoint eid_endpoint;
-       int err = 0;
-
-       HIP_ASSERT(endpoint->flags & HIP_ENDPOINT_FLAG_HIT);
-
-       hip_set_param_type((struct hip_tlv_common *) &eid_endpoint, 
HIP_PARAM_EID_ENDPOINT);
-
-       hip_calc_param_len((struct hip_tlv_common *) &eid_endpoint,
-                          sizeof(struct hip_eid_endpoint) -
-                          sizeof (struct hip_tlv_common));
-
-       memcpy(&eid_endpoint.endpoint, endpoint, sizeof(struct endpoint_hip));
-
-       err = hip_build_param(msg, &eid_endpoint);
-
-       return err;
+    struct hip_eid_endpoint eid_endpoint;
+    int err = 0;
+
+    HIP_ASSERT(endpoint->flags & HIP_ENDPOINT_FLAG_HIT);
+
+    hip_set_param_type((struct hip_tlv_common *) &eid_endpoint, 
HIP_PARAM_EID_ENDPOINT);
+
+    hip_calc_param_len((struct hip_tlv_common *) &eid_endpoint,
+                       sizeof(struct hip_eid_endpoint) -
+                       sizeof(struct hip_tlv_common));
+
+    memcpy(&eid_endpoint.endpoint, endpoint, sizeof(struct endpoint_hip));
+
+    err = hip_build_param(msg, &eid_endpoint);
+
+    return err;
 }
 
 /*
@@ -3703,61 +3826,61 @@
  * parameter need to be padded in the builder interface.
  */
 int hip_build_param_eid_endpoint(struct hip_common *msg,
-                                const struct endpoint_hip *endpoint)
+                                 const struct endpoint_hip *endpoint)
 {
-       int err = 0;
-
-       if (endpoint->flags & HIP_ENDPOINT_FLAG_HIT) {
-               err = hip_build_param_eid_endpoint_from_hit(msg, endpoint);
-       } else {
-               err = hip_build_param_eid_endpoint_from_host_id(msg, endpoint);
-       }
-
-       return err;
+    int err = 0;
+
+    if (endpoint->flags & HIP_ENDPOINT_FLAG_HIT) {
+        err = hip_build_param_eid_endpoint_from_hit(msg, endpoint);
+    } else {
+        err = hip_build_param_eid_endpoint_from_host_id(msg, endpoint);
+    }
+
+    return err;
 }
 
 int hip_build_param_eid_iface(struct hip_common *msg,
-                             hip_eid_iface_type_t if_index)
+                              hip_eid_iface_type_t if_index)
 {
-       int err = 0;
-       struct hip_eid_iface param;
-
-       hip_set_param_type((struct hip_tlv_common *) &param, 
HIP_PARAM_EID_IFACE);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &param, 
sizeof(param), 0);
-       param.if_index = htons(if_index);
-       err = hip_build_param(msg, &param);
-
-       return err;
+    int err = 0;
+    struct hip_eid_iface param;
+
+    hip_set_param_type((struct hip_tlv_common *) &param, HIP_PARAM_EID_IFACE);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &param, 
sizeof(param), 0);
+    param.if_index = htons(if_index);
+    err            = hip_build_param(msg, &param);
+
+    return err;
 }
 
 int hip_build_param_eid_sockaddr(struct hip_common *msg,
                                  struct sockaddr *sockaddr,
                                  size_t sockaddr_len)
 {
-        int err = 0;
-       _HIP_DEBUG("build family=%d, len=%d\n", sockaddr->sa_family,
-                  sockaddr_len);
-        err = hip_build_param_contents(msg, sockaddr, HIP_PARAM_EID_SOCKADDR,
-                                       sockaddr_len);
-        return err;
+    int err = 0;
+    _HIP_DEBUG("build family=%d, len=%d\n", sockaddr->sa_family,
+               sockaddr_len);
+    err = hip_build_param_contents(msg, sockaddr, HIP_PARAM_EID_SOCKADDR,
+                                   sockaddr_len);
+    return err;
 }
 
 int hip_build_param_cert(struct hip_common *msg, uint8_t group, uint8_t count,
-                        uint8_t id, uint8_t type, void *data, size_t size)
+                         uint8_t id, uint8_t type, void *data, size_t size)
 {
-       struct hip_cert cert;
-       int err;
-
-       hip_set_param_type((struct hip_tlv_common *) &cert, HIP_PARAM_CERT);
-       hip_calc_param_len((struct hip_tlv_common *) &cert, sizeof(struct 
hip_cert) -
-                          sizeof(struct hip_tlv_common) + size);
-       cert.cert_group = group;
-       cert.cert_count = count;
-       cert.cert_id = id;
-       cert.cert_type = type;
-       err = hip_build_generic_param(msg, &cert, sizeof(struct hip_cert), 
data);
-
-       return err;
+    struct hip_cert cert;
+    int err;
+
+    hip_set_param_type((struct hip_tlv_common *) &cert, HIP_PARAM_CERT);
+    hip_calc_param_len((struct hip_tlv_common *) &cert, sizeof(struct 
hip_cert) -
+                       sizeof(struct hip_tlv_common) + size);
+    cert.cert_group = group;
+    cert.cert_count = count;
+    cert.cert_id    = id;
+    cert.cert_type  = type;
+
+    err = hip_build_generic_param(msg, &cert, sizeof(struct hip_cert), data);
+    return err;
 }
 
 /**
@@ -3773,57 +3896,64 @@
  * @return zero on success, or negative on failure
  */
 int hip_build_param_notification(struct hip_common *msg, uint16_t msgtype,
-                                void *data, size_t data_len)
+                                 void *data, size_t data_len)
 {
-       int err = 0;
-       struct hip_notification notification;
-
-       hip_set_param_type((struct hip_tlv_common *) &notification, 
HIP_PARAM_NOTIFICATION);
-       hip_calc_param_len((struct hip_tlv_common *) &notification, 
sizeof(struct hip_notification) -
-                          sizeof(struct hip_tlv_common) +
-                          data_len);
-       notification.reserved = 0;
-       notification.msgtype = htons(msgtype);
-
-       err = hip_build_generic_param(msg, &notification,
-                                     sizeof(struct hip_notification),
-                                     data);
-       return err;
+    int err = 0;
+    struct hip_notification notification;
+
+    hip_set_param_type((struct hip_tlv_common *) &notification, 
HIP_PARAM_NOTIFICATION);
+    hip_calc_param_len((struct hip_tlv_common *) &notification,
+                       sizeof(struct hip_notification)
+                               - sizeof(struct hip_tlv_common) + data_len);
+    notification.reserved = 0;
+    notification.msgtype  = htons(msgtype);
+
+    err = hip_build_generic_param(msg,
+                                  &notification,
+                                  sizeof(struct hip_notification),
+                                  data);
+    return err;
 }
 
 int hip_build_param_blind_nonce(struct hip_common *msg, uint16_t nonce)
 {
-       struct hip_blind_nonce param;
-       int err = 0;
-
-       hip_set_param_type((struct hip_tlv_common *) &param, 
HIP_PARAM_BLIND_NONCE);
-       hip_calc_generic_param_len((struct hip_tlv_common *) &param, 
sizeof(param), 0);
-       param.nonce = htons(nonce);
-       err = hip_build_param(msg, &param);
-
-       return err;
+    struct hip_blind_nonce param;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) &param, 
HIP_PARAM_BLIND_NONCE);
+    hip_calc_generic_param_len((struct hip_tlv_common *) &param,
+                               sizeof(param),
+                               0);
+    param.nonce = htons(nonce);
+    err         = hip_build_param(msg, &param);
+
+    return err;
 }
 
-int hip_build_param_heartbeat(struct hip_common *msg, int seconds) {
-       int err = 0;
-       struct hip_heartbeat heartbeat;
-       hip_set_param_type((struct hip_tlv_common *) &heartbeat, 
HIP_PARAM_HEARTBEAT);
-       hip_calc_param_len((struct hip_tlv_common *) &heartbeat, sizeof(struct 
hip_heartbeat) -
-                          sizeof(struct hip_tlv_common));
-       memcpy(&heartbeat.heartbeat, &seconds, sizeof(seconds));
-       err = hip_build_param(msg, &heartbeat);
+int hip_build_param_heartbeat(struct hip_common *msg, int seconds)
+{
+    int err = 0;
+    struct hip_heartbeat heartbeat;
+    hip_set_param_type((struct hip_tlv_common *) &heartbeat,
+                       HIP_PARAM_HEARTBEAT);
+    hip_calc_param_len((struct hip_tlv_common *) &heartbeat,
+                       sizeof(struct hip_heartbeat)
+                               - sizeof(struct hip_tlv_common));
+    memcpy(&heartbeat.heartbeat, &seconds, sizeof(seconds));
+    err = hip_build_param(msg, &heartbeat);
 
-       return err;
+    return err;
 }
 
 int hip_build_param_transform_order(struct hip_common *msg, int order)
 {
     int err = 0;
     struct hip_transformation_order transorder;
-    hip_set_param_type((struct hip_tlv_common *) &transorder, 
HIP_PARAM_TRANSFORM_ORDER);
+    hip_set_param_type((struct hip_tlv_common *) &transorder,
+                       HIP_PARAM_TRANSFORM_ORDER);
     hip_calc_param_len((struct hip_tlv_common *) &transorder,
-                       sizeof(struct hip_transformation_order) -
-                       sizeof(struct hip_tlv_common));
+                       sizeof(struct hip_transformation_order)
+                               - sizeof(struct hip_tlv_common));
     transorder.transorder = order;
     err = hip_build_param(msg, &transorder);
     return err;
@@ -3833,354 +3963,419 @@
 {
     int err = 0;
     struct hip_opendht_set name_info;
-    hip_set_param_type((struct hip_tlv_common *) &name_info, 
HIP_PARAM_OPENDHT_SET);
+    hip_set_param_type((struct hip_tlv_common *) &name_info,
+                       HIP_PARAM_OPENDHT_SET);
     hip_calc_param_len((struct hip_tlv_common *) &name_info,
-                       sizeof(struct hip_opendht_set) -
-                       sizeof(struct hip_tlv_common));
+                       sizeof(struct hip_opendht_set)
+                               - sizeof(struct hip_tlv_common));
     strcpy(name_info.name, name);
     err = hip_build_param(msg, &name_info);
     return err;
 }
 
 int hip_build_param_opendht_gw_info(struct hip_common *msg,
-                                   struct in6_addr *addr,
-                                   uint32_t ttl,
-                                   uint16_t port,
-                                   char* host_name)
+                                    struct in6_addr *addr,
+                                    uint32_t ttl,
+                                    uint16_t port,
+                                    char *host_name)
 {
-       int err = 0;
-       struct hip_opendht_gw_info gw_info;
+    int err = 0;
+    struct hip_opendht_gw_info gw_info;
 
-       hip_set_param_type((struct hip_tlv_common *) &gw_info, 
HIP_PARAM_OPENDHT_GW_INFO);
-       hip_calc_param_len((struct hip_tlv_common *) &gw_info,
-                          sizeof(struct hip_opendht_gw_info) -
-                          sizeof(struct hip_tlv_common));
-       gw_info.ttl = ttl;
-       gw_info.port = htons(port);
-       //added +1 because the \0 was not being copied at the end of the string
-       if (host_name != NULL)
-               memcpy(&gw_info.host_name, host_name, strlen(host_name) + 1);
-       else
-               memset(&gw_info.host_name, '\0', sizeof(gw_info.host_name));
-       ipv6_addr_copy(&gw_info.addr, addr);
-       err = hip_build_param(msg, &gw_info);
-       return err;
+    hip_set_param_type((struct hip_tlv_common *) &gw_info,
+                       HIP_PARAM_OPENDHT_GW_INFO);
+    hip_calc_param_len((struct hip_tlv_common *) &gw_info,
+                       sizeof(struct hip_opendht_gw_info)
+                               - sizeof(struct hip_tlv_common));
+    gw_info.ttl = ttl;
+    gw_info.port = htons(port);
+    //added +1 because the \0 was not being copied at the end of the string
+    if (host_name != NULL) {
+        memcpy(&gw_info.host_name, host_name, strlen(host_name) + 1);
+    } else {
+        memset(&gw_info.host_name, '\0', sizeof(gw_info.host_name));
+    }
+    ipv6_addr_copy(&gw_info.addr, addr);
+    err = hip_build_param(msg, &gw_info);
+    return err;
 }
 
 #ifndef __KERNEL__
-int hip_build_param_cert_spki_info(struct hip_common * msg,
-                                   struct hip_cert_spki_info * cert_info)
-{
-       int err = 0;
-       struct hip_cert_spki_info local;
-       memset(&local, '\0', sizeof(struct hip_cert_spki_info));
-       memcpy(&local, cert_info, sizeof(struct hip_cert_spki_info));
-       hip_set_param_type((struct hip_tlv_common *) &local, 
HIP_PARAM_CERT_SPKI_INFO);
-       hip_calc_param_len((struct hip_tlv_common *) &local,
-                          sizeof(struct hip_cert_spki_info) -
-                          sizeof(struct hip_tlv_common));
-       _HIP_DEBUG("Param len spki_info %d\n", htons(local.length));
-       err = hip_build_param(msg, &local);
-       return err;
-}
-
-int hip_build_param_cert_x509_req(struct hip_common * msg,
-                                   struct in6_addr * addr)
-{
-       int err = 0;
-       struct hip_cert_x509_req subj;
-
-       hip_set_param_type((struct hip_tlv_common *) &subj, 
HIP_PARAM_CERT_X509_REQ);
-       hip_calc_param_len((struct hip_tlv_common *) &subj,
-                       sizeof(struct hip_cert_x509_req) -
-                       sizeof(struct hip_tlv_common));
-       ipv6_addr_copy(&subj.addr, addr);
-       err = hip_build_param(msg, &subj);
-       return err;
-}
-
-int hip_build_param_cert_x509_ver(struct hip_common * msg,
-                                  char * der, int len)
-{
-       int err = 0;
-       struct hip_cert_x509_resp subj;
-
-       hip_set_param_type((struct hip_tlv_common *) &subj, 
HIP_PARAM_CERT_X509_REQ);
-       hip_calc_param_len((struct hip_tlv_common *) &subj,
-                       sizeof(struct hip_cert_x509_resp) -
-                       sizeof(struct hip_tlv_common));
-       memcpy(&subj.der, der, len);
-       subj.der_len = len;
-       err = hip_build_param(msg, &subj);
-       return err;
-}
-
-int hip_build_param_cert_x509_resp(struct hip_common * msg,
-                                   char * der, int len)
-{
-       int err = 0;
-       struct hip_cert_x509_resp local;
-       hip_set_param_type((struct hip_tlv_common *) &local, 
HIP_PARAM_CERT_X509_RESP);
-       hip_calc_param_len((struct hip_tlv_common *) &local,
-                       sizeof(struct hip_cert_x509_resp) -
-                       sizeof(struct hip_tlv_common));
-       memcpy(&local.der, der, len);
-       local.der_len = len;
-       err = hip_build_param(msg, &local);
-       return err;
-}
-
-int hip_build_param_hip_hdrr_info(struct hip_common * msg,
-                                   struct hip_hdrr_info * hdrr_info)
-{
-       int err = 0;
-       hip_set_param_type((struct hip_tlv_common *) hdrr_info, 
HIP_PARAM_HDRR_INFO);
-       hip_calc_param_len((struct hip_tlv_common *) hdrr_info,
-                          sizeof(struct hip_hdrr_info) -
-                          sizeof(struct hip_tlv_common));
-       err = hip_build_param(msg, hdrr_info);
-       return err;
-}
-
-int hip_build_param_hip_uadb_info(struct hip_common *msg, struct hip_uadb_info 
*uadb_info)
-{
-       int err = 0;
-       hip_set_param_type((struct hip_tlv_common *) uadb_info, 
HIP_PARAM_UADB_INFO);
-       hip_calc_param_len((struct hip_tlv_common *) uadb_info,
-                          sizeof(struct hip_uadb_info) -
-                          sizeof(struct hip_tlv_common));
-       err = hip_build_param(msg, uadb_info);
-       return err;
+int hip_build_param_cert_spki_info(struct hip_common *msg,
+                                   struct hip_cert_spki_info *cert_info)
+{
+    int err = 0;
+    struct hip_cert_spki_info local;
+    memset(&local, '\0', sizeof(struct hip_cert_spki_info));
+    memcpy(&local, cert_info, sizeof(struct hip_cert_spki_info));
+    hip_set_param_type((struct hip_tlv_common *) &local,
+                       HIP_PARAM_CERT_SPKI_INFO);
+    hip_calc_param_len((struct hip_tlv_common *) &local,
+                       sizeof(struct hip_cert_spki_info)
+                               - sizeof(struct hip_tlv_common));
+    _HIP_DEBUG("Param len spki_info %d\n", htons(local.length));
+    err = hip_build_param(msg, &local);
+    return err;
+}
+
+int hip_build_param_cert_x509_req(struct hip_common *msg, struct in6_addr 
*addr)
+{
+    int err = 0;
+    struct hip_cert_x509_req subj;
+
+    hip_set_param_type((struct hip_tlv_common *) &subj, 
HIP_PARAM_CERT_X509_REQ);
+    hip_calc_param_len((struct hip_tlv_common *) &subj,
+                       sizeof(struct hip_cert_x509_req)
+                               - sizeof(struct hip_tlv_common));
+    ipv6_addr_copy(&subj.addr, addr);
+    err = hip_build_param(msg, &subj);
+    return err;
+}
+
+int hip_build_param_cert_x509_ver(struct hip_common *msg, char *der, int len)
+{
+    int err = 0;
+    struct hip_cert_x509_resp subj;
+
+    hip_set_param_type((struct hip_tlv_common *) &subj, 
HIP_PARAM_CERT_X509_REQ);
+    hip_calc_param_len((struct hip_tlv_common *) &subj,
+                       sizeof(struct hip_cert_x509_resp)
+                               - sizeof(struct hip_tlv_common));
+    memcpy(&subj.der, der, len);
+    subj.der_len = len;
+    err = hip_build_param(msg, &subj);
+    return err;
+}
+
+int hip_build_param_cert_x509_resp(struct hip_common *msg, char *der, int len)
+{
+    int err = 0;
+    struct hip_cert_x509_resp local;
+    hip_set_param_type((struct hip_tlv_common *) &local,
+                       HIP_PARAM_CERT_X509_RESP);
+    hip_calc_param_len((struct hip_tlv_common *) &local,
+                       sizeof(struct hip_cert_x509_resp)
+                               - sizeof(struct hip_tlv_common));
+    memcpy(&local.der, der, len);
+    local.der_len = len;
+    err           = hip_build_param(msg, &local);
+    return err;
+}
+
+int hip_build_param_hip_hdrr_info(struct hip_common *msg,
+                                  struct hip_hdrr_info *hdrr_info)
+{
+    int err = 0;
+    hip_set_param_type((struct hip_tlv_common *) hdrr_info, 
HIP_PARAM_HDRR_INFO);
+    hip_calc_param_len((struct hip_tlv_common *) hdrr_info,
+                       sizeof(struct hip_hdrr_info)
+                               - sizeof(struct hip_tlv_common));
+    err = hip_build_param(msg, hdrr_info);
+    return err;
+}
+
+int hip_build_param_hip_uadb_info(struct hip_common *msg,
+                                  struct hip_uadb_info *uadb_info)
+{
+    int err = 0;
+    hip_set_param_type((struct hip_tlv_common *) uadb_info, 
HIP_PARAM_UADB_INFO);
+    hip_calc_param_len((struct hip_tlv_common *) uadb_info,
+                       sizeof(struct hip_uadb_info)
+                               - sizeof(struct hip_tlv_common));
+    err = hip_build_param(msg, uadb_info);
+    return err;
 }
 
 int hip_build_param_hit_to_ip_set(struct hip_common *msg, const char *name)
 {
     int err = 0;
     struct hip_hit_to_ip_set name_info;
-    hip_set_param_type((struct hip_tlv_common *) &name_info, 
HIP_PARAM_HIT_TO_IP_SET);
+    hip_set_param_type((struct hip_tlv_common *) &name_info,
+                       HIP_PARAM_HIT_TO_IP_SET);
     hip_calc_param_len((struct hip_tlv_common *) &name_info,
-                       sizeof(struct hip_hit_to_ip_set) -
-                       sizeof(struct hip_tlv_common));
+                       sizeof(struct hip_hit_to_ip_set)
+                               - sizeof(struct hip_tlv_common));
     strcpy(name_info.name, name);
     err = hip_build_param(msg, &name_info);
 
     return err;
 }
 
-int dsa_to_hip_endpoint(DSA *dsa, struct endpoint_hip **endpoint,
-                       se_hip_flags_t endpoint_flags, const char *hostname)
-{
-  int err = 0;
-  unsigned char *dsa_key_rr = NULL;
-  int dsa_key_rr_len;
-  struct endpoint_hip endpoint_hdr;
-
-  _HIP_DEBUG("dsa_to_hip_endpoint called\n");
-
-  dsa_key_rr_len = dsa_to_dns_key_rr(dsa, &dsa_key_rr);
-  if (dsa_key_rr_len <= 0) {
-    HIP_ERROR("dsa_key_rr_len <= 0\n");
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  hip_build_endpoint_hdr(&endpoint_hdr, hostname, endpoint_flags,
-                        HIP_HI_DSA, dsa_key_rr_len);
-
-  *endpoint = malloc(endpoint_hdr.length);
-  if (!(*endpoint)) {
-    err = -ENOMEM;
-    goto out_err;
-  }
-  memset(*endpoint, 0, endpoint_hdr.length);
-
-  _HIP_DEBUG("Allocated %d bytes for endpoint\n", endpoint_hdr.length);
-  hip_build_endpoint(*endpoint, &endpoint_hdr, hostname,
-                    dsa_key_rr, dsa_key_rr_len);
-  _HIP_HEXDUMP("endpoint contains: ", *endpoint, endpoint_hdr.length);
-
- out_err:
-
-  if (dsa_key_rr)
-    free(dsa_key_rr);
-
-  return err;
-}
-
-int rsa_to_hip_endpoint(RSA *rsa, struct endpoint_hip **endpoint,
-                       se_hip_flags_t endpoint_flags, const char *hostname)
-{
-  int err = 0;
-  unsigned char *rsa_key_rr = NULL;
-  int rsa_key_rr_len;
-  struct endpoint_hip endpoint_hdr;
-
-  HIP_DEBUG("rsa_to_hip_endpoint called\n");
-
-  rsa_key_rr_len = rsa_to_dns_key_rr(rsa, &rsa_key_rr);
-  if (rsa_key_rr_len <= 0) {
-    HIP_ERROR("rsa_key_rr_len <= 0\n");
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  hip_build_endpoint_hdr(&endpoint_hdr, hostname, endpoint_flags,
-                        HIP_HI_RSA, rsa_key_rr_len);
-
-    *endpoint = malloc(endpoint_hdr.length);
-  if (!(*endpoint)) {
-    err = -ENOMEM;
-    goto out_err;
-  }
-  memset(*endpoint, 0, endpoint_hdr.length);
-
-  _HIP_DEBUG("Allocated %d bytes for endpoint\n", endpoint_hdr.length);
-
-  hip_build_endpoint(*endpoint, &endpoint_hdr, hostname,
-                    rsa_key_rr, rsa_key_rr_len);
-
-  _HIP_HEXDUMP("endpoint contains: ", *endpoint, endpoint_hdr.length);
-
- out_err:
-
-  if (rsa_key_rr)
-    free(rsa_key_rr);
-
-  return err;
-}
+int dsa_to_hip_endpoint(DSA *dsa,
+                        struct endpoint_hip **endpoint,
+                        se_hip_flags_t endpoint_flags,
+                        const char *hostname)
+{
+    int err = 0;
+    unsigned char *dsa_key_rr = NULL;
+    int dsa_key_rr_len;
+    struct endpoint_hip endpoint_hdr;
+
+    _HIP_DEBUG("dsa_to_hip_endpoint called\n");
+
+    dsa_key_rr_len = dsa_to_dns_key_rr(dsa, &dsa_key_rr);
+    if (dsa_key_rr_len <= 0) {
+        HIP_ERROR("dsa_key_rr_len <= 0\n");
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    hip_build_endpoint_hdr(&endpoint_hdr,
+                           hostname,
+                           endpoint_flags,
+                           HIP_HI_DSA,
+                           dsa_key_rr_len);
+
+    *endpoint = malloc(endpoint_hdr.length);
+    if (!(*endpoint)) {
+        err = -ENOMEM;
+        goto out_err;
+    }
+    memset(*endpoint, 0, endpoint_hdr.length);
+
+    _HIP_DEBUG("Allocated %d bytes for endpoint\n", endpoint_hdr.length);
+    hip_build_endpoint(*endpoint,
+                       &endpoint_hdr,
+                       hostname,
+                       dsa_key_rr,
+                       dsa_key_rr_len);
+    _HIP_HEXDUMP("endpoint contains: ", *endpoint, endpoint_hdr.length);
+
+    out_err:
+
+    if (dsa_key_rr) {
+        free(dsa_key_rr);
+    }
+
+    return err;
+}
+
+int rsa_to_hip_endpoint(RSA *rsa,
+                        struct endpoint_hip **endpoint,
+                        se_hip_flags_t endpoint_flags,
+                        const char *hostname)
+{
+    int err = 0;
+    unsigned char *rsa_key_rr = NULL;
+    int rsa_key_rr_len;
+    struct endpoint_hip endpoint_hdr;
+
+    HIP_DEBUG("rsa_to_hip_endpoint called\n");
+
+    rsa_key_rr_len = rsa_to_dns_key_rr(rsa, &rsa_key_rr);
+    if (rsa_key_rr_len <= 0) {
+        HIP_ERROR("rsa_key_rr_len <= 0\n");
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    hip_build_endpoint_hdr(&endpoint_hdr,
+                           hostname,
+                           endpoint_flags,
+                           HIP_HI_RSA,
+                           rsa_key_rr_len);
+
+    *endpoint = malloc(endpoint_hdr.length);
+    if (!(*endpoint)) {
+        err = -ENOMEM;
+        goto out_err;
+    }
+    memset(*endpoint, 0, endpoint_hdr.length);
+
+    _HIP_DEBUG("Allocated %d bytes for endpoint\n", endpoint_hdr.length);
+
+    hip_build_endpoint(*endpoint,
+                       &endpoint_hdr,
+                       hostname,
+                       rsa_key_rr,
+                       rsa_key_rr_len);
+
+    _HIP_HEXDUMP("endpoint contains: ", *endpoint, endpoint_hdr.length);
+
+    out_err:
+
+    if (rsa_key_rr) {
+        free(rsa_key_rr);
+    }
+
+    return err;
+}
+
 #endif
 int alloc_and_set_host_id_param_hdr(struct hip_host_id **host_id,
-                                   unsigned int key_rr_len,
-                                   uint8_t algo,
-                                   const char *hostname)
+                                    unsigned int key_rr_len,
+                                    uint8_t algo,
+                                    const char *hostname)
 {
-  int err = 0;
-  struct hip_host_id host_id_hdr;
-  hip_build_param_host_id_hdr(&host_id_hdr, hostname,
-                             key_rr_len, algo);
-
-  *host_id = HIP_MALLOC(hip_get_param_total_len(&host_id_hdr), GFP_ATOMIC);
-  if (!host_id) {
-    err = -ENOMEM;
-  }
-
-  memcpy(*host_id, &host_id_hdr, sizeof(host_id_hdr));
-
-  return err;
+    int err = 0;
+    struct hip_host_id host_id_hdr;
+    hip_build_param_host_id_hdr(&host_id_hdr, hostname, key_rr_len, algo);
+
+    *host_id = HIP_MALLOC(hip_get_param_total_len(&host_id_hdr), GFP_ATOMIC);
+    if (!host_id) {
+        err = -ENOMEM;
+    }
+
+    memcpy(*host_id, &host_id_hdr, sizeof(host_id_hdr));
+
+    return err;
 }
 
 int alloc_and_build_param_host_id_only(struct hip_host_id **host_id,
-                                      unsigned char *key_rr, int key_rr_len,
-                                      int algo, char *hostname) {
-  int err = 0;
-  HIP_IFEL(alloc_and_set_host_id_param_hdr(host_id, key_rr_len, algo,
-                                          hostname), -1, "alloc\n");
-  hip_build_param_host_id_only(*host_id, key_rr, "hostname");
- out_err:
-  if (err && *host_id) {
-    *host_id = NULL;
-    HIP_FREE(host_id);
-  }
-
-  return err;
+                                       unsigned char *key_rr,
+                                       int key_rr_len,
+                                       int algo,
+                                       char *hostname)
+{
+    int err = 0;
+    HIP_IFEL(alloc_and_set_host_id_param_hdr(host_id,
+                                             key_rr_len,
+                                             algo,
+                                             hostname),
+            -1,
+            "alloc\n");
+
+    hip_build_param_host_id_only(*host_id, key_rr, "hostname");
+
+out_err:
+    if (err && *host_id) {
+        *host_id = NULL;
+        HIP_FREE(host_id);
+    }
+
+    return err;
 }
 
 #ifndef __KERNEL__
 /* Note: public here means that you only have the public key,
-   not the private */
-int hip_any_key_to_hit(void *any_key, unsigned char *any_key_rr, int hit_type,
-                      hip_hit_t *hit, int is_public, int is_dsa) {
-  int err = 0, key_rr_len;
-  unsigned char *key_rr = NULL;
-  char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-  struct hip_host_id_priv *host_id = NULL;
-  struct hip_host_id *host_id_pub = NULL;
-  RSA *rsa_key = (RSA *) any_key;
-  DSA *dsa_key = (DSA *) any_key;
-
-  memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
-  HIP_IFEL(gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1), -1,
-          "gethostname failed\n");
-
-  if (is_dsa) {
-    HIP_IFEL(((key_rr_len = dsa_to_dns_key_rr(dsa_key, &key_rr)) <= 0), -1,
-            "key_rr_len\n");
-    if (is_public) {
-      HIP_IFEL(!(host_id_pub = malloc(sizeof(struct hip_host_id))),
-                                               -ENOMEM, "malloc\n");
-      host_id_pub->hi_length = htons(key_rr_len +
-                               sizeof(struct hip_host_id_key_rdata));
-      memcpy(&host_id_pub->key, key_rr, key_rr_len);
-      HIP_IFEL(hip_dsa_host_id_to_hit(host_id_pub, hit, HIP_HIT_TYPE_HASH100),
-              -1, "conversion from host id to hit failed\n");
-    } else {
-      HIP_IFEL(!(host_id = malloc(sizeof(struct hip_host_id_priv))),
-                                               -ENOMEM, "malloc\n");
-      host_id->hi_length = htons(key_rr_len +
-                               sizeof(struct hip_host_id_key_rdata));
-      memcpy(&host_id->key, key_rr, key_rr_len);
-      HIP_IFEL(hip_private_dsa_host_id_to_hit(host_id, hit,
-                                             HIP_HIT_TYPE_HASH100),
-              -1, "conversion from host id to hit failed\n");
-    }
-  } else /* rsa */ {
-    HIP_IFEL(((key_rr_len = rsa_to_dns_key_rr(rsa_key, &key_rr)) <= 0), -1,
-            "key_rr_len\n");
-    if (is_public) {
-      HIP_IFEL(!(host_id_pub = malloc(sizeof(struct hip_host_id))),
-                                               -ENOMEM, "malloc\n");
-      host_id_pub->hi_length = htons(key_rr_len +
-                               sizeof(struct hip_host_id_key_rdata));
-      memcpy(&host_id_pub->key, key_rr, key_rr_len);
-      HIP_IFEL(hip_rsa_host_id_to_hit(host_id_pub, hit, HIP_HIT_TYPE_HASH100),
-              -1, "conversion from host id to hit failed\n");
-    } else {
-      HIP_IFEL(!(host_id = malloc(sizeof(struct hip_host_id_priv))),
-                                               -ENOMEM, "malloc\n");
-      host_id->hi_length = htons(key_rr_len +
-                               sizeof(struct hip_host_id_key_rdata));
-      memcpy(&host_id->key, key_rr, key_rr_len);
-      HIP_IFEL(hip_private_rsa_host_id_to_hit(host_id, hit,
-                                             HIP_HIT_TYPE_HASH100),
-              -1, "conversion from host id to hit failed\n");
-    }
-  }
-
-   HIP_DEBUG_HIT("hit", hit);
-   HIP_DEBUG("hi is %s %s\n", (is_public ? "public" : "private"),
-            (is_dsa ? "dsa" : "rsa"));
-
- out_err:
-
-  if (key_rr)
-    HIP_FREE(key_rr);
-  if (host_id)
-    HIP_FREE(host_id);
-  if (host_id_pub)
-    HIP_FREE(host_id_pub);
-
-  return err;
-}
-
-int hip_public_rsa_to_hit(RSA *rsa_key, unsigned char *rsa, int type,
-                         struct in6_addr *hit) {
-  return hip_any_key_to_hit(rsa_key, rsa, type, hit, 1, 0);
-}
-
-int hip_private_rsa_to_hit(RSA *rsa_key, unsigned char *rsa, int type,
-                         struct in6_addr *hit) {
-  return hip_any_key_to_hit(rsa_key, rsa, type, hit, 0, 0);
-}
-
-int hip_public_dsa_to_hit(DSA *dsa_key, unsigned char *dsa, int type,
-                         struct in6_addr *hit) {
-  return hip_any_key_to_hit(dsa_key, dsa, type, hit, 1, 1);
-}
-
-int hip_private_dsa_to_hit(DSA *dsa_key, unsigned char *dsa, int type,
-                          struct in6_addr *hit) {
-  return hip_any_key_to_hit(dsa_key, dsa, type, hit, 0, 1);
-}
+ * not the private */
+int hip_any_key_to_hit(void *any_key,
+                       unsigned char *any_key_rr,
+                       int hit_type,
+                       hip_hit_t *hit,
+                       int is_public,
+                       int is_dsa)
+{
+    int err = 0, key_rr_len;
+    unsigned char *key_rr = NULL;
+    char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    struct hip_host_id_priv *host_id = NULL;
+    struct hip_host_id *host_id_pub = NULL;
+    RSA *rsa_key = (RSA *) any_key;
+    DSA *dsa_key = (DSA *) any_key;
+
+    memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
+    HIP_IFEL(gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1), -1,
+            "gethostname failed\n");
+
+    if (is_dsa) {
+        HIP_IFEL(((key_rr_len = dsa_to_dns_key_rr(dsa_key, &key_rr)) <= 0), -1,
+                "key_rr_len\n");
+        if (is_public) {
+            HIP_IFEL(!(host_id_pub = malloc(sizeof(struct hip_host_id))),
+                    -ENOMEM, "malloc\n");
+            host_id_pub->hi_length = htons(key_rr_len
+                    + sizeof(struct hip_host_id_key_rdata));
+            memcpy(&host_id_pub->key, key_rr, key_rr_len);
+            HIP_IFEL(hip_dsa_host_id_to_hit(host_id_pub, hit, 
HIP_HIT_TYPE_HASH100),
+                    -1, "conversion from host id to hit failed\n");
+        } else {
+            HIP_IFEL(!(host_id = malloc(sizeof(struct hip_host_id_priv))),
+                    -ENOMEM,
+                    "malloc\n");
+
+            host_id->hi_length = htons(key_rr_len
+                    + sizeof(struct hip_host_id_key_rdata));
+            memcpy(&host_id->key, key_rr, key_rr_len);
+            HIP_IFEL(hip_private_dsa_host_id_to_hit(host_id, hit,
+                                                    HIP_HIT_TYPE_HASH100),
+                     -1, "conversion from host id to hit failed\n");
+        }
+    } else { /* rsa */
+        HIP_IFEL(((key_rr_len = rsa_to_dns_key_rr(rsa_key, &key_rr)) <= 0), -1,
+                 "key_rr_len\n");
+        if (is_public) {
+            HIP_IFEL(!(host_id_pub = malloc(sizeof(struct hip_host_id))),
+                     -ENOMEM, "malloc\n");
+
+            host_id_pub->hi_length = htons(key_rr_len +
+                                           sizeof(struct 
hip_host_id_key_rdata));
+
+            memcpy(&host_id_pub->key, key_rr, key_rr_len);
+
+            HIP_IFEL(hip_rsa_host_id_to_hit(host_id_pub,
+                                            hit,
+                                            HIP_HIT_TYPE_HASH100),
+                     -1,
+                     "conversion from host id to hit failed\n");
+        } else {
+            HIP_IFEL(!(host_id = malloc(sizeof(struct hip_host_id_priv))),
+                     -ENOMEM,
+                     "malloc\n");
+
+            host_id->hi_length = htons(key_rr_len +
+                                       sizeof(struct hip_host_id_key_rdata));
+            memcpy(&host_id->key, key_rr, key_rr_len);
+
+            HIP_IFEL(hip_private_rsa_host_id_to_hit(host_id,
+                                                    hit,
+                                                    HIP_HIT_TYPE_HASH100),
+                     -1,
+                     "conversion from host id to hit failed\n");
+        }
+    }
+
+    HIP_DEBUG_HIT("hit", hit);
+    HIP_DEBUG("hi is %s %s\n", (is_public ? "public" : "private"),
+              (is_dsa ? "dsa" : "rsa"));
+
+out_err:
+
+    if (key_rr) {
+        HIP_FREE(key_rr);
+    }
+    if (host_id) {
+        HIP_FREE(host_id);
+    }
+    if (host_id_pub) {
+        HIP_FREE(host_id_pub);
+    }
+
+    return err;
+}
+
+int hip_public_rsa_to_hit(RSA *rsa_key,
+                          unsigned char *rsa,
+                          int type,
+                          struct in6_addr *hit)
+{
+    return hip_any_key_to_hit(rsa_key, rsa, type, hit, 1, 0);
+}
+
+int hip_private_rsa_to_hit(RSA *rsa_key,
+                           unsigned char *rsa,
+                           int type,
+                           struct in6_addr *hit)
+{
+    return hip_any_key_to_hit(rsa_key, rsa, type, hit, 0, 0);
+}
+
+int hip_public_dsa_to_hit(DSA *dsa_key,
+                          unsigned char *dsa,
+                          int type,
+                          struct in6_addr *hit)
+{
+    return hip_any_key_to_hit(dsa_key, dsa, type, hit, 1, 1);
+}
+
+int hip_private_dsa_to_hit(DSA *dsa_key,
+                           unsigned char *dsa,
+                           int type,
+                           struct in6_addr *hit)
+{
+    return hip_any_key_to_hit(dsa_key, dsa, type, hit, 0, 1);
+}
+
 #endif
 
 
@@ -4188,30 +4383,31 @@
  *
  * return the amount the locator items(type 1 and 2 are both supproted).
  * */
-int hip_get_locator_addr_item_count(const struct hip_locator *locator) {
-       char *address_pointer =(char*) (locator + 1);
-       int amount = 0;
+int hip_get_locator_addr_item_count(const struct hip_locator *locator)
+{
+    char *address_pointer = (char *) (locator + 1);
+    int amount            = 0;
 
-       for(;address_pointer < ((char*)locator) + 
hip_get_param_contents_len(locator); ) {
-               if (((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type
-                    == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item2);
-                        amount += 1;
-                }
-                else if(((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type
-                        == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                        amount += 1;
-                }
-                else if(((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type
-                        == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                        amount += 1;
-                }
-                else
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-       }
-       return amount;
+    for (; address_pointer < ((char *) locator)
+            + hip_get_param_contents_len(locator);)
+    {
+        if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
+            address_pointer += sizeof(struct hip_locator_info_addr_item2);
+            amount += 1;
+        } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+            amount += 1;
+        } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+            amount += 1;
+        } else {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+        }
+    }
+    return amount;
 }
 
 /**
@@ -4222,23 +4418,27 @@
  * @param item_list      a pointer to the first item in the list
  * @param index     the index of the item in the list
  */
-union hip_locator_info_addr * hip_get_locator_item(void* item_list, int index){
-       int i= 0;
-       struct hip_locator_info_addr_item *temp;
-       char *result ;
-       result = (char*) item_list;
-       
-       
-       for(i=0;i<= index-1;i++){
-               temp = (struct hip_locator_info_addr_item*) result;
-               if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI ||
-                               temp->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_IPV6)
-                       result += sizeof(struct hip_locator_info_addr_item);
-               else
-                       result += sizeof(struct hip_locator_info_addr_item2);
-       }
-       _HIP_DEBUG("*****locator %d has offset :%d \n", index, (char*)result - 
(char*)item_list );
-       return (union hip_locator_info_addr *) result;
+union hip_locator_info_addr *hip_get_locator_item(void *item_list, int index)
+{
+    int i = 0;
+    struct hip_locator_info_addr_item *temp;
+    char *result;
+    result = (char *) item_list;
+
+
+    for (i = 0; i <= index - 1; i++) {
+        temp = (struct hip_locator_info_addr_item *) result;
+        if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI ||
+            temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
+            result += sizeof(struct hip_locator_info_addr_item);
+        } else {
+            result += sizeof(struct hip_locator_info_addr_item2);
+        }
+    }
+    _HIP_DEBUG("*****locator %d has offset :%d \n",
+               index,
+               (char *) result - (char *) item_list);
+    return (union hip_locator_info_addr *) result;
 }
 
 /**
@@ -4250,54 +4450,57 @@
  * @param index     the index of the item in the list
  * @note DO NOT GIVE TOO LARGE INDEX
  */
-struct hip_locator_info_addr_item * hip_get_locator_item_as_one(
-       struct hip_locator_info_addr_item* item_list, int index){
-
-       struct hip_locator_info_addr_item * address_pointer;
-    int i = 0;
-    struct hip_locator_info_addr_item *item = NULL;
+struct hip_locator_info_addr_item *hip_get_locator_item_as_one(struct 
hip_locator_info_addr_item *item_list,
+                                                               int index)
+{
+    struct hip_locator_info_addr_item *address_pointer;
+    int i                                     = 0;
+    struct hip_locator_info_addr_item *item   = NULL;
     struct hip_locator_info_addr_item2 *item2 = NULL;
 
     address_pointer = item_list;
 
     HIP_DEBUG("LOCATOR TYPE %d\n",
-                     ((struct hip_locator_info_addr_item 
*)address_pointer)->locator_type);
+              ((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type);
     if (index ==  0) {
-           if (((struct hip_locator_info_addr_item 
*)address_pointer)->locator_type
-               == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
-                   item2 = (struct hip_locator_info_addr_item2 
*)address_pointer;
-                   HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr 
*)&item2->address);
-           } else {
-                   item = (struct hip_locator_info_addr_item *)address_pointer;
-                   HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr 
*)&item->address);
-           }
-           return address_pointer;
-    }
-
-    for(i = 0; i < index; i++) {
-           if (((struct hip_locator_info_addr_item 
*)address_pointer)->locator_type
-               == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
-                   address_pointer += sizeof(struct 
hip_locator_info_addr_item2);
-                   item2 = (struct hip_locator_info_addr_item2 
*)address_pointer;
-                   HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr 
*)&item2->address);
-           }
-           else if(((struct hip_locator_info_addr_item 
*)address_pointer)->locator_type
-                   == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
-                   address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                   item = (struct hip_locator_info_addr_item *)address_pointer;
-                   HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr 
*)&item->address);
-           }
-           else if(((struct hip_locator_info_addr_item 
*)address_pointer)->locator_type
-                   == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
-                   address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                   item = (struct hip_locator_info_addr_item *)address_pointer;
-                   HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr 
*)&item->address);
-           }
-           else
-                   address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-    }  
+        if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+            == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
+            item2 = (struct hip_locator_info_addr_item2 *) address_pointer;
+            HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr *) &item2->address);
+        } else {
+            item = (struct hip_locator_info_addr_item *) address_pointer;
+            HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr *) &item->address);
+        }
+        return address_pointer;
+    }
+
+    for (i = 0; i < index; i++) {
+        if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+            == HIP_LOCATOR_LOCATOR_TYPE_UDP)
+        {
+            address_pointer += sizeof(struct hip_locator_info_addr_item2);
+            item2            = (struct hip_locator_info_addr_item2 *) 
address_pointer;
+            HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr *) &item2->address);
+
+        } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                   == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI)
+        {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+            item             = (struct hip_locator_info_addr_item *) 
address_pointer;
+            HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr *) &item->address);
+
+        } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                   == HIP_LOCATOR_LOCATOR_TYPE_IPV6)
+        {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+            item             = (struct hip_locator_info_addr_item *) 
address_pointer;
+            HIP_DEBUG_IN6ADDR("LOCATOR", (struct in6_addr *) &item->address);
+        } else {
+            address_pointer += sizeof(struct hip_locator_info_addr_item);
+        }
+    }
     return address_pointer;
-} 
+}
 
 /**
  * retreive a IP address  from a locator item structure
@@ -4305,64 +4508,58 @@
  *
  * @param item      a pointer to the item
  */
-struct in6_addr * hip_get_locator_item_address(void* item){
-
-       struct hip_locator_info_addr_item *temp;
-
-
-       temp = (struct hip_locator_info_addr_item*) item;
-       if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI){
-               return &temp->address;
-       } else  if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_IPV6){
-               return &temp->address;
-       } else {
-               return &((struct hip_locator_info_addr_item2 *)temp)->address;
-       }
-
-}
-
-/**
- * retreive a port from a locator item structure
- *
- *
- * @param item      a pointer to the item
- */
-uint16_t hip_get_locator_item_port(void* item){
-
-       struct hip_locator_info_addr_item *temp;
-
-
-       temp = (struct hip_locator_info_addr_item*) item;
-       if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI){
-               return 0;
-       }
-       else {
-               return ntohs(((struct hip_locator_info_addr_item2 
*)temp)->port);
-       }
-
-}
-
-
-/**
- * retreive a port from a locator item structure
- *
- *
- * @param item      a pointer to the item
- */
-uint32_t hip_get_locator_item_priority(void* item){
-
-       struct hip_locator_info_addr_item *temp;
-
-
-       temp = (struct hip_locator_info_addr_item*) item;
-       if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI){
-               //todo check the constant value
-               return HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI_PRIORITY;
-       }
-       else {
-               return ntohl(((struct hip_locator_info_addr_item2 
*)temp)->priority);
-       }
-
+struct in6_addr *hip_get_locator_item_address(void *item)
+{
+    struct hip_locator_info_addr_item *temp;
+
+
+    temp = (struct hip_locator_info_addr_item *) item;
+    if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+        return &temp->address;
+    } else if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
+        return &temp->address;
+    } else {
+        return &((struct hip_locator_info_addr_item2 *) temp)->address;
+    }
+}
+
+/**
+ * retreive a port from a locator item structure
+ *
+ *
+ * @param item      a pointer to the item
+ */
+uint16_t hip_get_locator_item_port(void *item)
+{
+    struct hip_locator_info_addr_item *temp;
+
+
+    temp = (struct hip_locator_info_addr_item *) item;
+    if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+        return 0;
+    } else {
+        return ntohs(((struct hip_locator_info_addr_item2 *) temp)->port);
+    }
+}
+
+/**
+ * retreive a port from a locator item structure
+ *
+ *
+ * @param item      a pointer to the item
+ */
+uint32_t hip_get_locator_item_priority(void *item)
+{
+    struct hip_locator_info_addr_item *temp;
+
+
+    temp = (struct hip_locator_info_addr_item *) item;
+    if (temp->locator_type == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+        //todo check the constant value
+        return HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI_PRIORITY;
+    } else {
+        return ntohl(((struct hip_locator_info_addr_item2 *) temp)->priority);
+    }
 }
 
 /**
@@ -4378,25 +4575,23 @@
  *             draft, this is now RELAY_TO.
  */
 int hip_build_param_reg_from(struct hip_common *msg,
-                            const in6_addr_t *addr,
-                            const in_port_t port)
+                             const in6_addr_t *addr,
+                             const in_port_t port)
 {
-
-     struct hip_reg_from reg_from;
-     int err = 0;
-
-     hip_set_param_type((struct hip_tlv_common *) &reg_from, 
HIP_PARAM_REG_FROM);
-     ipv6_addr_copy((struct in6_addr *)&reg_from.address, addr);
-     HIP_DEBUG_IN6ADDR("reg_from address is ", &reg_from.address);
-     HIP_DEBUG_IN6ADDR("the given address is ", addr);
-     reg_from.port = htons(port);
-     reg_from.reserved = 0;
-     reg_from.protocol = HIP_NAT_PROTO_UDP;
-     hip_calc_generic_param_len((struct hip_tlv_common *) &reg_from, 
sizeof(reg_from), 0);
-     err = hip_build_param(msg, &reg_from);
-
-     return err;
-
+    struct hip_reg_from reg_from;
+    int err = 0;
+
+    hip_set_param_type((struct hip_tlv_common *) &reg_from, 
HIP_PARAM_REG_FROM);
+    ipv6_addr_copy((struct in6_addr *) &reg_from.address, addr);
+    HIP_DEBUG_IN6ADDR("reg_from address is ", &reg_from.address);
+    HIP_DEBUG_IN6ADDR("the given address is ", addr);
+    reg_from.port     = htons(port);
+    reg_from.reserved = 0;
+    reg_from.protocol = HIP_NAT_PROTO_UDP;
+    hip_calc_generic_param_len((struct hip_tlv_common *) &reg_from, 
sizeof(reg_from), 0);
+    err               = hip_build_param(msg, &reg_from);
+
+    return err;
 }
 
 /**
@@ -4405,19 +4600,21 @@
  * @param msg          a pointer to a HIP packet common header
  * @param port         NAT port number
  * @param param                parameter to create. Currently it is either
- *                     HIP_SET_SRC_NAT_PORT or HIP_SET_DST_NAT_PORT
- * 
+ *          HIP_SET_SRC_NAT_PORT or HIP_SET_DST_NAT_PORT
+ *
  * @return     zero on success, non-zero otherwise.
  */
-int hip_build_param_nat_port(hip_common_t *msg, const in_port_t port, 
hip_tlv_type_t hipparam)
+int hip_build_param_nat_port(hip_common_t *msg,
+                             const in_port_t port,
+                             hip_tlv_type_t hipparam)
 {
-       int err = 0;
-       struct hip_port_info nat_port;
-       
-       hip_set_param_type((struct hip_tlv_common *) &nat_port, hipparam);
-       nat_port.port = port;
-       hip_calc_generic_param_len((struct hip_tlv_common *) &nat_port, 
sizeof(nat_port), 0);
-       err = hip_build_param(msg, &nat_port);
-
-       return err;
+    int err = 0;
+    struct hip_port_info nat_port;
+
+    hip_set_param_type((struct hip_tlv_common *) &nat_port, hipparam);
+    nat_port.port = port;
+    hip_calc_generic_param_len((struct hip_tlv_common *) &nat_port, 
sizeof(nat_port), 0);
+    err           = hip_build_param(msg, &nat_port);
+
+    return err;
 }

=== modified file 'lib/core/builder.c.doxyme'
--- lib/core/builder.c.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/builder.c.doxyme   2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,7 +45,7 @@
 
 
 /**
- * alloc_and_build_param_host_id_only 
+ * alloc_and_build_param_host_id_only
  *
  *
  * @param host_id
@@ -52,36 +53,36 @@
  * @param key_rr_len
  * @param algo
  * @param hostname
- * @return 
+ * @return
  **/
 
 
 /**
- * alloc_and_set_host_id_param_hdr 
+ * alloc_and_set_host_id_param_hdr
  *
  *
  * @param host_id
  * @param key_rr_len
  * @param algo
  * @param hostname
- * @return 
+ * @return
  **/
 
 
 /**
- * dsa_to_hip_endpoint 
+ * dsa_to_hip_endpoint
  *
  *
  * @param dsa
  * @param endpoint
  * @param endpoint_flags
  * @param hostname
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_any_key_to_hit 
+ * hip_any_key_to_hit
  *
  *
  * @param any_key
@@ -90,12 +91,12 @@
  * @param hit
  * @param is_public
  * @param is_dsa
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_endpoint 
+ * hip_build_endpoint
  *
  *
  * @param endpoint
@@ -103,12 +104,12 @@
  * @param hostname
  * @param key_rr
  * @param key_rr_len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_endpoint_hdr 
+ * hip_build_endpoint_hdr
  *
  *
  * @param endpoint_hdr
@@ -116,12 +117,12 @@
  * @param endpoint_flags
  * @param host_id_algo
  * @param rr_data_len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_network_hdr 
+ * hip_build_network_hdr
  *
  *
  * @param msg
@@ -129,42 +130,42 @@
  * @param control
  * @param hit_sender
  * @param hit_receiver
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param 
+ * hip_build_param
  *
  *
  * @param msg
  * @param tlv_common
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_ack 
+ * hip_build_param_ack
  *
  *
  * @param msg
  * @param peer_update_id
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_blind_nonce 
+ * hip_build_param_blind_nonce
  *
  *
  * @param msg
  * @param nonce
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_cert 
+ * hip_build_param_cert
  *
  *
  * @param msg
@@ -174,48 +175,48 @@
  * @param type
  * @param data
  * @param size
- * @return 
- **/
-
-
-/**
- * hip_build_param_cert_spki_info 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_build_param_cert_x509_req 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_build_param_cert_x509_resp 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_build_param_cert_x509_ver 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_build_param_challenge_request 
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_cert_spki_info
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_cert_x509_req
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_cert_x509_resp
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_cert_x509_ver
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_challenge_request
  *
  *
  * @param msg
@@ -223,35 +224,35 @@
  * @param lifetime
  * @param opaque
  * @param opaque_len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_challenge_response 
+ * hip_build_param_challenge_response
  *
  *
  * @param msg
  * @param pz
  * @param val_J
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_contents 
+ * hip_build_param_contents
  *
  *
  * @param msg
  * @param contents
  * @param param_type
  * @param contents_size
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_diffie_hellman_contents 
+ * hip_build_param_diffie_hellman_contents
  *
  *
  * @param msg
@@ -261,12 +262,12 @@
  * @param group_id2
  * @param pubkey2
  * @param pubkey_len2
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_echo 
+ * hip_build_param_echo
  *
  *
  * @param msg
@@ -274,117 +275,117 @@
  * @param len
  * @param sign
  * @param request
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_echo_m 
+ * hip_build_param_echo_m
  *
  *
  * @param msg
  * @param opaque
  * @param len
  * @param request
- * @return 
- **/
-
-
-/**
- * hip_build_param_eid_endpoint 
- *
- *
- * @param msg
- * @param endpoint
- * @return 
- **/
-
-
-/**
- * hip_build_param_eid_endpoint_from_hit 
- *
- *
- * @param msg
- * @param endpoint
- * @return 
- **/
-
-
-/**
- * hip_build_param_eid_endpoint_from_host_id 
- *
- *
- * @param msg
- * @param endpoint
- * @return 
- **/
-
-
-/**
- * hip_build_param_eid_iface 
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_eid_endpoint
+ *
+ *
+ * @param msg
+ * @param endpoint
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_eid_endpoint_from_hit
+ *
+ *
+ * @param msg
+ * @param endpoint
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_eid_endpoint_from_host_id
+ *
+ *
+ * @param msg
+ * @param endpoint
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_eid_iface
  *
  *
  * @param msg
  * @param if_index
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_eid_sockaddr 
+ * hip_build_param_eid_sockaddr
  *
  *
  * @param msg
  * @param sockaddr
  * @param sockaddr_len
- * @return 
- **/
-
-
-/**
- * hip_build_param_encrypted_3des_sha1 
- *
- *
- * @param msg
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_build_param_encrypted_aes_sha1 
- *
- *
- * @param msg
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_build_param_encrypted_null_sha1 
- *
- *
- * @param msg
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_build_param_esp_info 
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_encrypted_3des_sha1
+ *
+ *
+ * @param msg
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_encrypted_aes_sha1
+ *
+ *
+ * @param msg
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_encrypted_null_sha1
+ *
+ *
+ * @param msg
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_esp_info
  *
  *
  * @param msg
  * @param keymat_index
  * @param old_spi
  * @param new_spi
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_esp_prot_anchor 
+ * hip_build_param_esp_prot_anchor
  *
  *
  * @param msg
@@ -393,174 +394,174 @@
  * @param next_anchor
  * @param hash_length
  * @param hash_item_length
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_esp_prot_branch 
+ * hip_build_param_esp_prot_branch
  *
  *
  * @param msg
  * @param anchor_offset
  * @param branch_length
  * @param branch_nodes
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_esp_prot_root 
+ * hip_build_param_esp_prot_root
  *
  *
  * @param msg
  * @param root_length
  * @param root
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_esp_prot_secret 
+ * hip_build_param_esp_prot_secret
  *
  *
  * @param msg
  * @param secret_length
  * @param secret
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_esp_prot_transform 
+ * hip_build_param_esp_prot_transform
  *
  *
  * @param msg
  * @param num_transforms
  * @param transforms
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_from 
+ * hip_build_param_from
  *
  *
  * @param msg
  * @param addr
  * @param not_used
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_heartbeat 
+ * hip_build_param_heartbeat
  *
  *
  * @param msg
  * @param seconds
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hip_hdrr_info 
+ * hip_build_param_hip_hdrr_info
  *
  *
  * @param autogen.sh
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hip_uadb_info 
+ * hip_build_param_hip_uadb_info
  *
  *
  * @param msg
  * @param uadb_info
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hit_to_ip_set 
+ * hip_build_param_hit_to_ip_set
  *
  *
  * @param msg
  * @param name
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hmac 
+ * hip_build_param_hmac
  *
  *
  * @param msg
  * @param key
  * @param param_type
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hmac2_contents 
+ * hip_build_param_hmac2_contents
  *
  *
  * @param msg
  * @param key
  * @param host_id
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_hmac_contents 
+ * hip_build_param_hmac_contents
  *
  *
  * @param msg
  * @param key
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_host_id 
+ * hip_build_param_host_id
  *
  *
  * @param msg
  * @param host_id_hdr
  * @param rr_data
  * @param fqdn
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_host_id_hdr 
+ * hip_build_param_host_id_hdr
  *
  *
  * @param host_id_hdr
  * @param hostname
  * @param rr_data_len
  * @param algorithm
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_host_id_only 
+ * hip_build_param_host_id_only
  *
  *
  * @param host_id
  * @param rr_data
  * @param fqdn
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_keys 
+ * hip_build_param_keys
  *
  *
  * @param msg
@@ -573,12 +574,12 @@
  * @param spi_old
  * @param key_len
  * @param enc
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_keys_hdr 
+ * hip_build_param_keys_hdr
  *
  *
  * @param keys
@@ -591,67 +592,67 @@
  * @param spi_old
  * @param key_len
  * @param enc
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_locator 
+ * hip_build_param_locator
  *
  *
  * @param msg
  * @param addresses
  * @param address_count
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_nat_pacing 
+ * hip_build_param_nat_pacing
  *
  *
  * @param msg
  * @param min_ta
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_nat_port 
+ * hip_build_param_nat_port
  *
  *
  * @param msg
  * @param port
  * @param hipparam
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_nat_transform 
+ * hip_build_param_nat_transform
  *
  *
  * @param msg
  * @param suite
  * @param suite_count
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_notification 
+ * hip_build_param_notification
  *
  *
  * @param msg
  * @param msgtype
  * @param data
  * @param data_len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_opendht_gw_info 
+ * hip_build_param_opendht_gw_info
  *
  *
  * @param msg
@@ -659,22 +660,22 @@
  * @param ttl
  * @param port
  * @param host_name
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_opendht_set 
+ * hip_build_param_opendht_set
  *
  *
  * @param msg
  * @param name
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_puzzle 
+ * hip_build_param_puzzle
  *
  *
  * @param msg
@@ -682,835 +683,834 @@
  * @param lifetime
  * @param opaque
  * @param random_i
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_r1_counter 
+ * hip_build_param_r1_counter
  *
  *
  * @param msg
  * @param generation
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_reg_failed 
+ * hip_build_param_reg_failed
  *
  *
  * @param msg
  * @param failure_type
  * @param type_list
  * @param type_count
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_reg_from 
+ * hip_build_param_reg_from
  *
  *
  * @param msg
  * @param addr
  * @param port
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_reg_info 
+ * hip_build_param_reg_info
  *
  *
  * @param msg
  * @param srv_list
  * @param service_count
- * @return 
- **/
-
-
-/**
- * hip_build_param_reg_request 
- *
- *
- * @param msg
- * @param lifetime
- * @param type_list
- * @param type_count
- * @return 
- **/
-
-
-/**
- * hip_build_param_reg_response 
- *
- *
- * @param msg
- * @param lifetime
- * @param type_list
- * @param type_count
- * @return 
- **/
-
-
-/**
- * hip_build_param_relay_from 
- *
- *
- * @param msg
- * @param addr
- * @param port
- * @return 
- **/
-
-
-/**
- * hip_build_param_relay_to 
- *
- *
- * @param msg
- * @param addr
- * @param port
- * @return 
- **/
-
-
-/**
- * hip_build_param_seq 
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_reg_request
+ *
+ *
+ * @param msg
+ * @param lifetime
+ * @param type_list
+ * @param type_count
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_reg_response
+ *
+ *
+ * @param msg
+ * @param lifetime
+ * @param type_list
+ * @param type_count
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_relay_from
+ *
+ *
+ * @param msg
+ * @param addr
+ * @param port
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_relay_to
+ *
+ *
+ * @param msg
+ * @param addr
+ * @param port
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_seq
  *
  *
  * @param msg
  * @param update_id
- * @return 
- **/
-
-
-/**
- * hip_build_param_signature2_contents 
- *
- *
- * @param msg
- * @param contents
- * @param contents_size
- * @param algorithm
- * @return 
- **/
-
-
-/**
- * hip_build_param_signature_contents 
- *
- *
- * @param msg
- * @param contents
- * @param contents_size
- * @param algorithm
- * @return 
- **/
-
-
-/**
- * hip_build_param_solution 
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_signature2_contents
+ *
+ *
+ * @param msg
+ * @param contents
+ * @param contents_size
+ * @param algorithm
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_signature_contents
+ *
+ *
+ * @param msg
+ * @param contents
+ * @param contents_size
+ * @param algorithm
+ * @return
+ **/
+
+
+/**
+ * hip_build_param_solution
  *
  *
  * @param msg
  * @param pz
  * @param val_J
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_transform 
+ * hip_build_param_transform
  *
  *
  * @param msg
  * @param transform_type
  * @param transform_suite[]
  * @param transform_count
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_transform_order 
+ * hip_build_param_transform_order
  *
  *
  * @param msg
  * @param order
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_unit_test 
+ * hip_build_param_unit_test
  *
  *
  * @param msg
  * @param suiteid
  * @param caseid
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_param_via_rvs 
+ * hip_build_param_via_rvs
  *
  *
  * @param msg
  * @param rvs_addresses[]
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_build_user_hdr 
+ * hip_build_user_hdr
  *
  *
  * @param msg
  * @param base_type
  * @param err_val
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_calc_generic_param_len 
+ * hip_calc_generic_param_len
  *
  *
  * @param tlv_common
  * @param tlv_size
  * @param contents_size
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_calc_hdr_len 
+ * hip_calc_hdr_len
  *
  *
  * @param msg
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_calc_param_len 
+ * hip_calc_param_len
  *
  *
  * @param tlv_common
  * @param contents_size
- * @return 
- **/
-
-
-/**
- * hip_check_network_msg 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_check_network_msg_len 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_check_network_msg_type 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_check_network_param_attributes 
- *
- *
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_check_network_param_type 
- *
- *
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_check_param_contents_len 
- *
- *
- * @param msg
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_check_user_msg_len 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_check_userspace_msg 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_check_userspace_param_type 
- *
- *
- * @param param
- * @return 
- **/
-
-
-/**
- * hip_checksum_packet 
+ * @return
+ **/
+
+
+/**
+ * hip_check_network_msg
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_check_network_msg_len
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_check_network_msg_type
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_check_network_param_attributes
+ *
+ *
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_check_network_param_type
+ *
+ *
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_check_param_contents_len
+ *
+ *
+ * @param msg
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_check_user_msg_len
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_check_userspace_msg
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_check_userspace_param_type
+ *
+ *
+ * @param param
+ * @return
+ **/
+
+
+/**
+ * hip_checksum_packet
  *
  *
  * @param data
  * @param src
  * @param dst
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_convert_msg_total_len_to_bytes 
+ * hip_convert_msg_total_len_to_bytes
  *
  *
  * @param len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_create_msg_pseudo_hmac2 
+ * hip_create_msg_pseudo_hmac2
  *
  *
  * @param msg
  * @param msg_copy
  * @param host_id
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_dh_select_key 
+ * hip_dh_select_key
  *
  *
  * @param dhf
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_dump_msg 
+ * hip_dump_msg
  *
  *
  * @param msg
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_host_id_algo 
+ * hip_get_host_id_algo
  *
  *
  * @param host_id
- * @return 
- **/
-
-
-/**
- * hip_get_lifetime_seconds 
- *
- *
- * @param lifetime
- * @param seconds
- * @return 
- **/
-
-
-/**
- * hip_get_lifetime_value 
- *
- *
- * @param seconds
- * @param lifetime
- * @return 
- **/
-
-
-/**
- * hip_get_locator_addr_item_count 
- *
- *
- * @param locator
- * @return 
- **/
-
-
-/**
- * hip_get_locator_first_addr_item 
- *
- *
- * @param locator
- * @return 
- **/
-
-
-/**
- * hip_get_locator_item 
- *
- *
- * @param item_list
- * @param index
- * @return 
- **/
-
-
-/**
- * hip_get_locator_item_address 
- *
- *
- * @param item
- * @return 
- **/
-
-
-/**
- * hip_get_locator_item_as_one 
- *
- *
- * @param item_list
- * @param index
- * @return 
- **/
-
-
-/**
- * hip_get_locator_item_port 
- *
- *
- * @param item
- * @return 
- **/
-
-
-/**
- * hip_get_locator_item_priority 
- *
- *
- * @param item
- * @return 
- **/
-
-
-/**
- * hip_get_msg_checksum 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_get_msg_err 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_get_msg_response 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_get_msg_total_len 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_get_msg_type 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_get_next_param 
+ * @return
+ **/
+
+
+/**
+ * hip_get_lifetime_seconds
+ *
+ *
+ * @param lifetime
+ * @param seconds
+ * @return
+ **/
+
+
+/**
+ * hip_get_lifetime_value
+ *
+ *
+ * @param seconds
+ * @param lifetime
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_addr_item_count
+ *
+ *
+ * @param locator
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_first_addr_item
+ *
+ *
+ * @param locator
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_item
+ *
+ *
+ * @param item_list
+ * @param index
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_item_address
+ *
+ *
+ * @param item
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_item_as_one
+ *
+ *
+ * @param item_list
+ * @param index
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_item_port
+ *
+ *
+ * @param item
+ * @return
+ **/
+
+
+/**
+ * hip_get_locator_item_priority
+ *
+ *
+ * @param item
+ * @return
+ **/
+
+
+/**
+ * hip_get_msg_checksum
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_get_msg_err
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_get_msg_response
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_get_msg_total_len
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_get_msg_type
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_get_next_param
  *
  *
  * @param msg
  * @param current_param
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_nth_param 
+ * hip_get_nth_param
  *
  *
  * @param msg
  * @param param_type
  * @param n
- * @return 
- **/
-
-
-/**
- * hip_get_param 
- *
- *
- * @param msg
- * @param param_type
- * @return 
- **/
-
-
-/**
- * hip_get_param_contents 
- *
- *
- * @param msg
- * @param param_type
- * @return 
- **/
-
-
-/**
- * hip_get_param_contents_direct 
- *
- *
- * @param tlv_common
- * @return 
- **/
-
-
-/**
- * hip_get_param_contents_len 
- *
- *
- * @param tlv_common
- * @return 
- **/
-
-
-/**
- * hip_get_param_host_id_di_type_len 
+ * @return
+ **/
+
+
+/**
+ * hip_get_param
+ *
+ *
+ * @param msg
+ * @param param_type
+ * @return
+ **/
+
+
+/**
+ * hip_get_param_contents
+ *
+ *
+ * @param msg
+ * @param param_type
+ * @return
+ **/
+
+
+/**
+ * hip_get_param_contents_direct
+ *
+ *
+ * @param tlv_common
+ * @return
+ **/
+
+
+/**
+ * hip_get_param_contents_len
+ *
+ *
+ * @param tlv_common
+ * @return
+ **/
+
+
+/**
+ * hip_get_param_host_id_di_type_len
  *
  *
  * @param host
  * @param libhipandroid
  * @param len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_param_host_id_hostname 
+ * hip_get_param_host_id_hostname
  *
  *
  * @param hostid
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_param_total_len 
+ * hip_get_param_total_len
  *
  *
  * @param tlv_common
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_param_transform_suite_id 
+ * hip_get_param_transform_suite_id
  *
  *
  * @param transform_tlv
  * @param index
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_param_type 
+ * hip_get_param_type
  *
  *
  * @param tlv_common
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_get_transform_max 
+ * hip_get_transform_max
  *
  *
  * @param transform_type
- * @return 
- **/
-
-
-/**
- * hip_get_unit_test_case_param_id 
- *
- *
- * @param test
- * @return 
- **/
-
-
-/**
- * hip_get_unit_test_suite_param_id 
- *
- *
- * @param test
- * @return 
- **/
-
-
-/**
- * hip_host_id_entry_to_endpoint 
+ * @return
+ **/
+
+
+/**
+ * hip_get_unit_test_case_param_id
+ *
+ *
+ * @param test
+ * @return
+ **/
+
+
+/**
+ * hip_get_unit_test_suite_param_id
+ *
+ *
+ * @param test
+ * @return
+ **/
+
+
+/**
+ * hip_host_id_entry_to_endpoint
  *
  *
  * @param entry
  * @param opaq
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_message_type_name 
+ * hip_message_type_name
  *
  *
  * @param msg_type
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_msg_alloc 
+ * hip_msg_alloc
  *
  *
  * @param void
- * @return 
- **/
-
-
-/**
- * hip_msg_free 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_msg_init 
- *
- *
- * @param msg
- * @return 
- **/
-
-
-/**
- * hip_param_type_name 
+ * @return
+ **/
+
+
+/**
+ * hip_msg_free
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_msg_init
+ *
+ *
+ * @param msg
+ * @return
+ **/
+
+
+/**
+ * hip_param_type_name
  *
  *
  * @param param_type
- * @return 
- **/
-
-
-/**
- * hip_private_dsa_to_hit 
- *
- *
- * @param dsa_key
- * @param dsa
- * @param type
- * @param hit
- * @return 
- **/
-
-
-/**
- * hip_private_rsa_to_hit 
- *
- *
- * @param rsa_key
- * @param rsa
- * @param type
- * @param hit
- * @return 
- **/
-
-
-/**
- * hip_public_dsa_to_hit 
- *
- *
- * @param dsa_key
- * @param dsa
- * @param type
- * @param hit
- * @return 
- **/
-
-
-/**
- * hip_public_rsa_to_hit 
- *
- *
- * @param rsa_key
- * @param rsa
- * @param type
- * @param hit
- * @return 
- **/
-
-
-/**
- * hip_set_msg_checksum 
+ * @return
+ **/
+
+
+/**
+ * hip_private_dsa_to_hit
+ *
+ *
+ * @param dsa_key
+ * @param dsa
+ * @param type
+ * @param hit
+ * @return
+ **/
+
+
+/**
+ * hip_private_rsa_to_hit
+ *
+ *
+ * @param rsa_key
+ * @param rsa
+ * @param type
+ * @param hit
+ * @return
+ **/
+
+
+/**
+ * hip_public_dsa_to_hit
+ *
+ *
+ * @param dsa_key
+ * @param dsa
+ * @param type
+ * @param hit
+ * @return
+ **/
+
+
+/**
+ * hip_public_rsa_to_hit
+ *
+ *
+ * @param rsa_key
+ * @param rsa
+ * @param type
+ * @param hit
+ * @return
+ **/
+
+
+/**
+ * hip_set_msg_checksum
  *
  *
  * @param msg
  * @param checksum
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_msg_err 
+ * hip_set_msg_err
  *
  *
  * @param msg
  * @param err
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_msg_response 
+ * hip_set_msg_response
  *
  *
  * @param msg
  * @param on
- * @return 
- **/
-
-
-/**
- * hip_set_msg_total_len 
- *
- *
- * @param msg
- * @param len
- * @return 
- **/
-
-
-/**
- * hip_set_msg_type 
- *
- *
- * @param msg
- * @param type
- * @return 
- **/
-
-
-/**
- * hip_set_param_contents_len 
- *
- *
- * @param tlv_common
- * @param len
- * @return 
- **/
-
-
-/**
- * hip_set_param_type 
- *
- *
- * @param tlv_common
- * @param type
- * @return 
- **/
-
-
-/**
- * hip_verify_network_header 
+ * @return
+ **/
+
+
+/**
+ * hip_set_msg_total_len
+ *
+ *
+ * @param msg
+ * @param len
+ * @return
+ **/
+
+
+/**
+ * hip_set_msg_type
+ *
+ *
+ * @param msg
+ * @param type
+ * @return
+ **/
+
+
+/**
+ * hip_set_param_contents_len
+ *
+ *
+ * @param tlv_common
+ * @param len
+ * @return
+ **/
+
+
+/**
+ * hip_set_param_type
+ *
+ *
+ * @param tlv_common
+ * @param type
+ * @return
+ **/
+
+
+/**
+ * hip_verify_network_header
  *
  *
  * @param hip_common
  * @param src
  * @param dst
  * @param len
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_zero_msg_checksum 
+ * hip_zero_msg_checksum
  *
  *
  * @param msg
- * @return 
+ * @return
  **/
 
 
 /**
- * rsa_to_hip_endpoint 
+ * rsa_to_hip_endpoint
  *
  *
  * @param rsa
  * @param endpoint
  * @param endpoint_flags
  * @param hostname
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/builder.h'
--- lib/core/builder.h  2010-02-08 15:18:06 +0000
+++ lib/core/builder.h  2010-02-10 23:55:24 +0000
@@ -16,7 +16,7 @@
 #endif
 
 #ifdef HAVE_CONFIG_H
-  #include <config.h>
+#include <config.h>
 #endif /* HAVE_CONFIG_H */
 
 #ifdef __KERNEL__
@@ -39,20 +39,32 @@
 int hip_build_netlink_dummy_header(struct hip_common *);
 int hip_build_param_heartbeat(struct hip_common *msg, int seconds);
 int hip_build_param_transform_order(struct hip_common *msg, int order);
-void hip_build_network_hdr(struct hip_common *, uint8_t, uint16_t,
-                           const struct in6_addr *, const struct in6_addr *);
-int hip_host_id_hits(hip_ha_t *entry,struct hip_common *msg);
+void hip_build_network_hdr(struct hip_common *,
+                           uint8_t,
+                           uint16_t,
+                           const struct in6_addr *,
+                           const struct in6_addr *);
+int hip_host_id_hits(hip_ha_t *entry, struct hip_common *msg);
 int hip_build_param_ack(struct hip_common *, uint32_t);
-int hip_build_param_contents(struct hip_common *, const void *, hip_tlv_type_t,
+int hip_build_param_contents(struct hip_common *,
+                             const void *,
+                             hip_tlv_type_t,
                              hip_tlv_type_t);
 int hip_build_param_diffie_hellman_contents(struct hip_common *,
-                                     uint8_t, void *, hip_tlv_len_t,
-                                     uint8_t, void *, hip_tlv_len_t);
+                                            uint8_t,
+                                            void *,
+                                            hip_tlv_len_t,
+                                            uint8_t,
+                                            void *,
+                                            hip_tlv_len_t);
 int hip_build_param_echo(struct hip_common *, void *, int, int, int);
 int hip_build_param_eid_endpoint(struct hip_common *,
                                  const struct endpoint_hip *);
 int hip_build_param_eid_iface(struct hip_common *, hip_eid_iface_type_t);
-int hip_build_param_eid_sockaddr(struct hip_common *, struct sockaddr *, 
size_t);
+int
+        hip_build_param_eid_sockaddr(struct hip_common *,
+                                     struct sockaddr *,
+                                     size_t);
 int hip_build_param_encrypted_3des_sha1(struct hip_common *,
                                         struct hip_tlv_common *);
 int hip_build_param_encrypted_aes_sha1(struct hip_common *,
@@ -60,99 +72,139 @@
 int hip_build_param_encrypted_null_sha1(struct hip_common *,
                                         struct hip_tlv_common *);
 int hip_build_param_esp_info(struct hip_common *, uint16_t, uint32_t, 
uint32_t);
-int hip_build_param_relay_from(struct hip_common *, const struct in6_addr *,
-                             const in_port_t);
-int hip_build_param_from(struct hip_common *, const struct in6_addr *,
+int hip_build_param_relay_from(struct hip_common *,
+                               const struct in6_addr *,
+                               const in_port_t);
+int hip_build_param_from(struct hip_common *,
+                         const struct in6_addr *,
                          const in_port_t);
-int hip_build_param_hmac2_contents(struct hip_common *, struct hip_crypto_key 
*,
+int hip_build_param_hmac2_contents(struct hip_common *,
+                                   struct hip_crypto_key *,
                                    struct hip_host_id *);
-int hip_build_param_hmac_contents(struct hip_common *, const struct 
hip_crypto_key *);
+int hip_build_param_hmac_contents(struct hip_common *,
+                                  const struct hip_crypto_key *);
 int hip_create_msg_pseudo_hmac2(const struct hip_common *msg,
-               struct hip_common *msg_copy,
-               struct hip_host_id *host_id);
-int hip_build_param_hmac(struct hip_common *, const struct hip_crypto_key *,
-                                  hip_tlv_type_t);
-void hip_build_param_host_id_hdr(struct hip_host_id *host_id_hdr, const char 
*hostname,
-                                hip_tlv_len_t rr_data_len, uint8_t algorithm);
-void hip_build_param_host_id_only(struct hip_host_id *host_id, const void 
*rr_data,
-                                   const char *fqdn);
+                                struct hip_common *msg_copy,
+                                struct hip_host_id *host_id);
+int hip_build_param_hmac(struct hip_common *,
+                         const struct hip_crypto_key *,
+                         hip_tlv_type_t);
+void hip_build_param_host_id_hdr(struct hip_host_id *host_id_hdr,
+                                 const char *hostname,
+                                 hip_tlv_len_t rr_data_len,
+                                 uint8_t algorithm);
+void hip_build_param_host_id_only(struct hip_host_id *host_id,
+                                  const void *rr_data,
+                                  const char *fqdn);
 void hip_build_param_host_id_hdr_priv(struct hip_host_id_priv *host_id_hdr,
-                                     const char *hostname,
-                                     hip_tlv_len_t rr_data_len,
-                                     uint8_t algorithm);
-int hip_build_param_hostname(struct hip_common*, const char*);
-int hip_build_param_keys_hdr(struct hip_keys *, uint16_t, uint16_t,
-                             struct in6_addr *, struct in6_addr *,
-                             struct in6_addr *, uint32_t, uint32_t, uint16_t,
+                                      const char *hostname,
+                                      hip_tlv_len_t rr_data_len,
+                                      uint8_t algorithm);
+int hip_build_param_hostname(struct hip_common *, const char *);
+int hip_build_param_keys_hdr(struct hip_keys *,
+                             uint16_t,
+                             uint16_t,
+                             struct in6_addr *,
+                             struct in6_addr *,
+                             struct in6_addr *,
+                             uint32_t,
+                             uint32_t,
+                             uint16_t,
                              struct hip_crypto_key *);
 int hip_build_param_locator(struct hip_common *,
-                            struct hip_locator_info_addr_item *, int);
-int hip_build_param_cert(struct hip_common *, uint8_t, uint8_t, uint8_t,
-                                                       uint8_t, void *, 
size_t);
-int hip_build_param_puzzle(struct hip_common *, uint8_t, uint8_t, uint32_t, 
uint64_t);
+                            struct hip_locator_info_addr_item *,
+                            int);
+int hip_build_param_cert(struct hip_common *,
+                         uint8_t,
+                         uint8_t,
+                         uint8_t,
+                         uint8_t,
+                         void *,
+                         size_t);
+int hip_build_param_puzzle(struct hip_common *,
+                           uint8_t,
+                           uint8_t,
+                           uint32_t,
+                           uint64_t);
 #ifdef CONFIG_HIP_MIDAUTH
-int hip_build_param_challenge_request(struct hip_common *, uint8_t, uint8_t, 
uint8_t *,
-                                     uint8_t);
+int hip_build_param_challenge_request(struct hip_common *,
+                                      uint8_t,
+                                      uint8_t,
+                                      uint8_t *,
+                                      uint8_t);
 #endif
 int hip_build_param_r1_counter(struct hip_common *, uint64_t);
 
 int hip_build_param_seq(struct hip_common *, uint32_t);
-int hip_build_param_signature2_contents(struct hip_common *, const void *,
-                                        hip_tlv_len_t, uint8_t);
-int hip_build_param_signature_contents(struct hip_common *, const void *,
-                                       hip_tlv_len_t, uint8_t);
-int hip_build_param_solution(struct hip_common *, struct hip_puzzle *,
-                             uint64_t);
+int hip_build_param_signature2_contents(struct hip_common *,
+                                        const void *,
+                                        hip_tlv_len_t,
+                                        uint8_t);
+int hip_build_param_signature_contents(struct hip_common *,
+                                       const void *,
+                                       hip_tlv_len_t,
+                                       uint8_t);
+int
+        hip_build_param_solution(struct hip_common *,
+                                 struct hip_puzzle *,
+                                 uint64_t);
 #ifdef CONFIG_HIP_MIDAUTH
-int hip_build_param_challenge_response(struct hip_common *, struct 
hip_challenge_request *,
-                               uint64_t);
+int hip_build_param_challenge_response(struct hip_common *,
+                                       struct hip_challenge_request *,
+                                       uint64_t);
 #endif
 int hip_build_param(struct hip_common *, const void *);
 void hip_set_msg_response(struct hip_common *msg, uint8_t on);
 uint8_t hip_get_msg_response(struct hip_common *msg);
 int hip_build_param_esp_transform(struct hip_common *,
-                              const hip_transform_suite_t[], const uint16_t);
+                                  const hip_transform_suite_t[],
+                                  const uint16_t);
 int hip_build_param_hip_transform(struct hip_common *,
-                              const hip_transform_suite_t[], const uint16_t);
+                                  const hip_transform_suite_t[],
+                                  const uint16_t);
 int hip_build_param_unit_test(struct hip_common *, uint16_t, uint16_t);
 int hip_build_param_via_rvs_nat(struct hip_common *,
-               const struct hip_in6_addr_port[], const int);
+                                const struct hip_in6_addr_port[],
+                                const int);
 int hip_build_param_relay_to(struct hip_common *msg,
-                            const in6_addr_t *rvs_addr,
-                            const in_port_t port);
+                             const in6_addr_t *rvs_addr,
+                             const in_port_t port);
 int hip_build_param_via_rvs(struct hip_common *msg,
-                           const struct in6_addr rvs_addresses[]);
-int hip_build_param_cert_spki_info(struct hip_common * msg,
-                                  struct hip_cert_spki_info * cert_info);
-int hip_build_param_cert_x509_req(struct hip_common *,struct in6_addr *);
+                            const struct in6_addr rvs_addresses[]);
+int hip_build_param_cert_spki_info(struct hip_common *msg,
+                                   struct hip_cert_spki_info *cert_info);
+int hip_build_param_cert_x509_req(struct hip_common *, struct in6_addr *);
 int hip_build_param_cert_x509_resp(struct hip_common *, char *, int);
 int hip_build_param_cert_x509_ver(struct hip_common *, char *, int);
 
 int hip_build_param_opendht_set(struct hip_common *, const char *);
-int hip_build_param_opendht_gw_info(struct hip_common *, struct in6_addr *,
-               uint32_t, uint16_t, char *);
+int hip_build_param_opendht_gw_info(struct hip_common *,
+                                    struct in6_addr *,
+                                    uint32_t,
+                                    uint16_t,
+                                    char *);
 int hip_build_param_hit_to_ip_set(struct hip_common *, const char *);
 int hip_build_user_hdr(struct hip_common *, hip_hdr_type_t, hip_hdr_err_t);
 void hip_calc_hdr_len(struct hip_common *);
 int hip_check_network_msg(const struct hip_common *);
 int hip_verify_network_header(struct hip_common *hip_common,
-                             struct sockaddr *src, struct sockaddr *dst,
-                             int len);
-u16 hip_checksum_packet(char *data, struct sockaddr *src,
-                       struct sockaddr *dst);
+                              struct sockaddr *src,
+                              struct sockaddr *dst,
+                              int len);
+u16 hip_checksum_packet(char *data, struct sockaddr *src, struct sockaddr 
*dst);
 int hip_check_userspace_msg(const struct hip_common *);
 int hip_check_userspace_msg_type(const struct hip_common *);
 void hip_dump_msg(const struct hip_common *);
-struct hip_dh_public_value *hip_dh_select_key(
-       const struct hip_diffie_hellman *);
+struct hip_dh_public_value
+        *hip_dh_select_key(const struct hip_diffie_hellman *);
 uint8_t hip_get_host_id_algo(const struct hip_host_id *);
 int hip_get_locator_addr_item_count(const struct hip_locator *);
-union hip_locator_info_addr * hip_get_locator_item(void* item_list, int index);
+union hip_locator_info_addr *hip_get_locator_item(void *item_list, int index);
 int hip_get_lifetime_value(time_t seconds, uint8_t *lifetime);
 int hip_get_lifetime_seconds(uint8_t lifetime, time_t *seconds);
 int hip_check_network_msg_len(const struct hip_common *msg);
-struct hip_locator_info_addr_item *hip_get_locator_first_addr_item(
-        const struct hip_locator *);
+struct hip_locator_info_addr_item
+        *hip_get_locator_first_addr_item(const struct hip_locator *);
 hip_hdr_err_t hip_get_msg_err(const struct hip_common *);
 uint16_t hip_get_msg_total_len(const struct hip_common *);
 hip_hdr_type_t hip_get_msg_type(const struct hip_common *);
@@ -169,11 +221,11 @@
                                                        const uint16_t);
 hip_tlv_type_t hip_get_param_type(const void *);
 uint16_t hip_get_msg_checksum(struct hip_common *msg);
-char* hip_message_type_name(const uint8_t);
+char *hip_message_type_name(const uint8_t);
 struct hip_common *hip_msg_alloc(void);
 void hip_msg_free(struct hip_common *);
 void hip_msg_init(struct hip_common *);
-char* hip_param_type_name(const hip_tlv_type_t);
+char *hip_param_type_name(const hip_tlv_type_t);
 void hip_set_msg_err(struct hip_common *, hip_hdr_err_t);
 void hip_set_msg_checksum(struct hip_common *msg, u8 checksum);
 void hip_set_msg_total_len(struct hip_common *, uint16_t);
@@ -182,54 +234,81 @@
 void hip_set_param_lsi_value(struct hip_esp_info *, uint32_t);
 void hip_zero_msg_checksum(struct hip_common *);
 #ifndef __KERNEL__
-int rsa_to_hip_endpoint(RSA *rsa, struct endpoint_hip **endpoint,
-                       se_hip_flags_t endpoint_flags, const char *hostname);
-int dsa_to_hip_endpoint(DSA *dsa, struct endpoint_hip **endpoint,
-                       se_hip_flags_t endpoint_flags, const char *hostname);
-int hip_build_param_hip_hdrr_info(struct hip_common * msg,
-                                   struct hip_hdrr_info * hdrr_info);
+int rsa_to_hip_endpoint(RSA *rsa,
+                        struct endpoint_hip **endpoint,
+                        se_hip_flags_t endpoint_flags,
+                        const char *hostname);
+int dsa_to_hip_endpoint(DSA *dsa,
+                        struct endpoint_hip **endpoint,
+                        se_hip_flags_t endpoint_flags,
+                        const char *hostname);
+int hip_build_param_hip_hdrr_info(struct hip_common *msg,
+                                  struct hip_hdrr_info *hdrr_info);
 #endif
 int hip_build_param_hip_uadb_info(struct hip_common *msg,
-                                       struct hip_uadb_info *uadb_info);
+                                  struct hip_uadb_info *uadb_info);
 int hip_build_param_reg_info(hip_common_t *msg,
-                            const void *service_list,
-                            const unsigned int service_count);
-int hip_build_param_reg_request(hip_common_t *msg, const uint8_t lifetime,
-                               const uint8_t *type_list, const int type_count);
-int hip_build_param_reg_response(hip_common_t *msg, const uint8_t lifetime,
-                                const uint8_t *type_list, const int 
type_count);
+                             const void *service_list,
+                             const unsigned int service_count);
+int hip_build_param_reg_request(hip_common_t *msg,
+                                const uint8_t lifetime,
+                                const uint8_t *type_list,
+                                const int type_count);
+int hip_build_param_reg_response(hip_common_t *msg,
+                                 const uint8_t lifetime,
+                                 const uint8_t *type_list,
+                                 const int type_count);
 int hip_build_param_full_relay_hmac_contents(struct hip_common *,
-                                      struct hip_crypto_key *);
+                                             struct hip_crypto_key *);
 
-int hip_public_rsa_to_hit(RSA *rsa_key, unsigned char *rsa, int type,
-                         struct in6_addr *hit);
-int hip_private_rsa_to_hit(RSA *rsa_key, unsigned char *rsa, int type,
-                         struct in6_addr *hit);
-int hip_public_dsa_to_hit(DSA *dsa_key, unsigned char *dsa, int type,
-                         struct in6_addr *hit);
-int hip_private_dsa_to_hit(DSA *dsa_key, unsigned char *dsa, int type,
-                          struct in6_addr *hit);
+int hip_public_rsa_to_hit(RSA *rsa_key,
+                          unsigned char *rsa,
+                          int type,
+                          struct in6_addr *hit);
+int hip_private_rsa_to_hit(RSA *rsa_key,
+                           unsigned char *rsa,
+                           int type,
+                           struct in6_addr *hit);
+int hip_public_dsa_to_hit(DSA *dsa_key,
+                          unsigned char *dsa,
+                          int type,
+                          struct in6_addr *hit);
+int hip_private_dsa_to_hit(DSA *dsa_key,
+                           unsigned char *dsa,
+                           int type,
+                           struct in6_addr *hit);
 int hip_build_param_nat_pacing(struct hip_common *msg, uint32_t min_ta);
-                                 
-int hip_build_param_reg_failed(struct hip_common *msg, uint8_t failure_type,
-                              uint8_t *type_list, int type_count);
-
-int hip_build_param_esp_prot_transform(struct hip_common *msg, int 
num_transforms,
-               uint8_t *transforms);
-int hip_build_param_esp_prot_anchor(struct hip_common *msg, uint8_t transform,
-               unsigned char *active_anchor, unsigned char *next_anchor, int 
hash_length,
-               int hash_item_length);
-int hip_build_param_esp_prot_branch(struct hip_common *msg, int anchor_offset,
-               int branch_length, unsigned char *branch_nodes);
-int hip_build_param_esp_prot_secret(struct hip_common *msg, int secret_length,
-               unsigned char *secret);
-int hip_build_param_esp_prot_root(struct hip_common *msg, uint8_t root_length,
-               unsigned char *root);
+
+int hip_build_param_reg_failed(struct hip_common *msg,
+                               uint8_t failure_type,
+                               uint8_t *type_list,
+                               int type_count);
+
+int hip_build_param_esp_prot_transform(struct hip_common *msg,
+                                       int num_transforms,
+                                       uint8_t *transforms);
+int hip_build_param_esp_prot_anchor(struct hip_common *msg,
+                                    uint8_t transform,
+                                    unsigned char *active_anchor,
+                                    unsigned char *next_anchor,
+                                    int hash_length,
+                                    int hash_item_length);
+int hip_build_param_esp_prot_branch(struct hip_common *msg,
+                                    int anchor_offset,
+                                    int branch_length,
+                                    unsigned char *branch_nodes);
+int hip_build_param_esp_prot_secret(struct hip_common *msg,
+                                    int secret_length,
+                                    unsigned char *secret);
+int hip_build_param_esp_prot_root(struct hip_common *msg,
+                                  uint8_t root_length,
+                                  unsigned char *root);
 int hip_build_param_reg_from(struct hip_common *msg,
-                const in6_addr_t *addr,
-                const in_port_t port);
-int hip_build_param_nat_port(hip_common_t *msg, const in_port_t port, 
-               hip_tlv_type_t hipparam);
-struct in6_addr * hip_get_locator_item_address(void* item);
+                             const in6_addr_t *addr,
+                             const in_port_t port);
+int hip_build_param_nat_port(hip_common_t *msg,
+                             const in_port_t port,
+                             hip_tlv_type_t hipparam);
+struct in6_addr *hip_get_locator_item_address(void *item);
 
 #endif /* BUILDER_H */

=== modified file 'lib/core/builder.h.doxyme'
--- lib/core/builder.h.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/builder.h.doxyme   2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/builder.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/certtools.c'
--- lib/core/certtools.c        2010-02-09 14:08:06 +0000
+++ lib/core/certtools.c        2010-02-10 23:55:24 +0000
@@ -4,10 +4,10 @@
  * @author Samu Varjonen
  */
 #include "certtools.h"
- 
+
 
/*******************************************************************************
- * FUNCTIONS FOR SPKI                                                          
*
- 
*******************************************************************************/
+* FUNCTIONS FOR SPKI                                                          *
+*******************************************************************************/
 
 /**
  * hip_cert_spki_lib_verify - Function that verifies the signature in
@@ -16,344 +16,354 @@
  * @param cert points to hip_cert_spki_info that is going to be verified
  *
  * @return 0 if signature matches, -1 if error or signature did NOT match
- * 
+ *
  * @note see hip_cert_spki_char2certinfo to convert from wire to 
hip_cert_spki_info
  */
-int hip_cert_spki_lib_verify(struct hip_cert_spki_info * cert) {
-       int err = 0, start = 0, stop = 0, evpret = 0, keylen = 0, algo = 0;
-        char buf[200];
-
-        unsigned char sha_digest[21];
-        unsigned char *sha_retval;
-        unsigned char * signature_hash = NULL;
-        unsigned char * signature_hash_b64 = NULL;
-        unsigned char * signature_b64 = NULL;
-
-        unsigned char * signature = NULL;
-
-        /** RSA **/
-        RSA *rsa = NULL;
-        unsigned long e_code;
-        char * e_hex = NULL;
-        unsigned char * modulus_b64 = NULL;
-        unsigned char * modulus = NULL;
-
-        /** DSA **/
-        DSA *dsa = NULL;
-        unsigned char * p_bin = NULL, * q_bin = NULL, * g_bin = NULL, * y_bin 
= NULL;
-        unsigned char * p_b64 = NULL, * q_b64 = NULL, * g_b64 = NULL, * y_b64 
= NULL;
-       DSA_SIG *dsa_sig;
-
-        /* rules for regular expressions */
-
-        /* 
-           Rule to get the info if we are using DSA
-        */
-        char dsa_rule[] = "[d][s][a][-][p][k][c][s][1][-][s][h][a][1]";
-
-        /* 
-           Rule to get the info if we are using RSA
-        */
-        char rsa_rule[] = "[r][s][a][-][p][k][c][s][1][-][s][h][a][1]";
-
-        /* 
-           Rule to get DSA p
-           Look for pattern "(p |" and stop when first "|"  
-           anything in base 64 is accepted inbetween
-        */
-        char p_rule[] = "[(][p][ ][|][[A-Za-z0-9+/()#=-]*[|]";
-
-        /*
-          Rule to get DSA q
-           Look for pattern "(q |" and stop when first "|" 
-           anything in base 64 is accepted inbetween
-        */
-        char q_rule[] = "[(][q][ ][|][[A-Za-z0-9+/()#=-]*[|]";
-
-        /*
-          Rule to get DSA g
-           Look for pattern "(g |" and stop when first "|" 
-           anything in base 64 is accepted inbetween
-        */
-        char g_rule[] = "[(][g][ ][|][[A-Za-z0-9+/()#=-]*[|]";
-
-        /*
-          Rule to get DSA y / pub_key
-          Look for pattern "(y |" and stop when first "|" 
-           anything in base 64 is accepted inbetween
-        */
-        char y_rule[] = "[(][y][ ][|][[A-Za-z0-9+/()#=-]*[|]";
-
-        /* 
-           rule to get the public exponent RSA 
-           Look for the part that says # and after that some hex blob and #
-        */
-        char e_rule[] = "[#][0-9A-Fa-f]*[#]";
-
-        /* 
-           rule to get the public modulus RSA
-           Look for the part that starts with '|' and after that anything
-           that is in base 64 char set and then '|' again
-        */
-        char n_rule[] = "[|][A-Za-z0-9+/()#=-]*[|]";
-
-        /* 
-           rule to get the signature hash 
-           Look for the similar than the n_rule
-        */
-        char h_rule[] = "[|][A-Za-z0-9+/()#=-]*[|]";
-
-        /* 
-           rule to get the signature 
-           Look for part that starts ")|" and base 64 blob after it
-           and stops to '|' char remember to add and subtract 2 from 
-           the indexes below
-        */
-        char s_rule[] = "[)][|][A-Za-z0-9+/()#=-]*[|]";
-
-        _HIP_DEBUG("\n\n** CONTENTS of public key sequence **\n"
-                   "%s\n\n",cert->public_key); 
-
-        /* check the algo DSA or RSA  */
-        HIP_DEBUG("Verifying\nRunning regexps to identify algo\n");
-        start = stop = 0;
-        algo = hip_cert_regex(dsa_rule, cert->public_key, &start, &stop);
-        if (algo != -1) {
-                HIP_DEBUG("Public-key is DSA\n");
-                algo = HIP_HI_DSA;
-                goto algo_check_done;
-        }
-        start = stop = 0;
-        algo = hip_cert_regex(rsa_rule, cert->public_key, &start, &stop);
-        if (algo != -1) { 
-                HIP_DEBUG("Public-key is RSA\n");
-                algo = HIP_HI_RSA;
-                goto algo_check_done;
-        }
-        HIP_DEBUG((1!=1), -1,"Unknown algorithm\n");
-               
- algo_check_done:
-        if (algo == HIP_HI_RSA) {
-
-                /* malloc space for new rsa */
-                rsa = RSA_new();
-                HIP_IFEL(!rsa, -1, "Failed to malloc RSA\n");
-
-                /* extract the public-key from cert to rsa */
-
-                /* public exponent first */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(e_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex (exponent)\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                e_hex = malloc(stop-start);
-                HIP_IFEL((!e_hex), -1, "Malloc for e_hex failed\n");
-                snprintf((char *)e_hex, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("E_HEX %s\n",e_hex);
-                
-                /* public modulus */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(n_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex (modulus)\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                modulus_b64 = malloc(stop-start+1);
-                HIP_IFEL((!modulus_b64), -1, "Malloc for modulus_b64 
failed\n");
-                memset(modulus_b64, 0, (stop-start+1));
-                modulus = malloc(stop-start+1);
-                HIP_IFEL((!modulus), -1, "Malloc for modulus failed\n");
-                memset(modulus, 0, (stop-start+1));
-                snprintf((char *)modulus_b64, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("modulus_b64 %s\n",modulus_b64);
-                
-                /* put the stuff into the RSA struct */
-                BN_hex2bn(&rsa->e, e_hex);
-                evpret = EVP_DecodeBlock(modulus, modulus_b64, 
-                                         strlen((char *)modulus_b64));
-                
-                /* EVP returns a multiple of 3 octets, subtract any extra */
-                keylen = evpret;
-                if (keylen % 4 != 0) {
-                       --keylen;
-                        keylen = keylen - keylen % 2;
-               }
-                _HIP_DEBUG("keylen = %d (%d bits)\n", keylen, keylen * 8);
-                signature = malloc(keylen);
-                HIP_IFEL((!signature), -1, "Malloc for signature failed.\n");
-                rsa->n = BN_bin2bn(modulus, keylen, 0);
-                
-                _HIP_DEBUG("In verification RSA e=%s\n", BN_bn2hex(rsa->e));
-                _HIP_DEBUG("In verification RSA n=%s\n", BN_bn2hex(rsa->n));
-
-        } else if (algo == HIP_HI_DSA) {
-                
-                /* malloc space for new dsa */
-                dsa = DSA_new();
-                HIP_IFEL(!dsa, -1, "Failed to malloc DSA\n");
-                
-                /* Extract public key from the cert */
-                
-                /* dsa->p */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(p_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex dsa->p\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                p_b64 = malloc(stop-start+1);
-                HIP_IFEL((!p_b64), -1, "Malloc for p_b64 failed\n");
-                memset(p_b64, 0, (stop-start+1));
-                p_bin = malloc(stop-start+1);
-                HIP_IFEL((!p_bin), -1, "Malloc for p_bin failed\n");
-                memset(p_bin, 0, (stop-start+1));
-                snprintf((char *)p_b64, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("p_b64 %s\n",p_b64);
-                evpret = EVP_DecodeBlock(p_bin, p_b64, strlen((char *)p_b64));
-
-                /* dsa->q */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(q_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex dsa->q\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                q_b64 = malloc(stop-start+1);
-                HIP_IFEL((!q_b64), -1, "Malloc for q_b64 failed\n");
-                memset(q_b64, 0, (stop-start+1));
-                q_bin = malloc(stop-start+1);
-                HIP_IFEL((!q_bin), -1, "Malloc for q_bin failed\n");
-                memset(q_bin, 0, (stop-start+1));
-                snprintf((char *)q_b64, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("q_b64 %s\n",q_b64);
-                evpret = EVP_DecodeBlock(q_bin, q_b64, strlen((char *)q_b64));
-
-                /* dsa->g */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(g_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex dsa->g\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                g_b64 = malloc(stop-start+1);
-                HIP_IFEL((!g_b64), -1, "Malloc for g_b64 failed\n");
-                memset(g_b64, 0, (stop-start+1));
-                g_bin = malloc(stop-start+1);
-                HIP_IFEL((!g_bin), -1, "Malloc for g_bin failed\n");
-                memset(g_bin, 0, (stop-start+1));
-                snprintf((char *)g_b64, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("g_b64 %s\n",g_b64);
-                evpret = EVP_DecodeBlock(g_bin, g_b64, strlen((char *)g_b64));
-
-                /* dsa->y */
-                start = stop = 0;
-                HIP_IFEL(hip_cert_regex(y_rule, cert->public_key, &start, 
&stop), -1,
-                         "Failed to run hip_cert_regex dsa->y\n");
-                _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-                y_b64 = malloc(stop-start+1);
-                HIP_IFEL((!y_b64), -1, "Malloc for y_b64 failed\n");
-                memset(y_b64, 0, (stop-start+1));
-                y_bin = malloc(stop-start+1);
-                HIP_IFEL((!y_bin), -1, "Malloc for y_bin failed\n");
-                memset(y_bin, 0, (stop-start+1));
-                snprintf((char *)y_b64, (stop-start-1), "%s", 
&cert->public_key[start + 1]);
-                _HIP_DEBUG("y_b64 %s\n",y_b64);
-                evpret = EVP_DecodeBlock(y_bin, y_b64, strlen((char *)y_b64));
-                
-        } else HIP_IFEL((1==0), -1, "Unknown algorithm\n");        
-
-        memset(sha_digest, '\0', sizeof(sha_digest));        
-        /* build sha1 digest that will be signed */
-        HIP_IFEL(!(sha_retval = SHA1((unsigned char *)cert->cert, 
-                                     strlen((char *)cert->cert), sha_digest)),
-                 -1, "SHA1 error when creating digest.\n");        
-        _HIP_HEXDUMP("SHA1 digest of cert sequence ", sha_digest, 20);         
 
-   
-        /* Get the signature hash and compare it to the sha_digest we just 
made */
-        start = stop = 0;
-        HIP_IFEL(hip_cert_regex(h_rule, cert->signature, &start, &stop), -1,
-                 "Failed to run hip_cert_regex (signature hash)\n");
-        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-        signature_hash_b64 = malloc(stop-start+1);
-        HIP_IFEL((!signature_hash_b64), -1, "Failed to malloc 
signature_hash_b64\n");
-        memset(signature_hash_b64, '\0', (stop-start+1));        
-        signature_hash = malloc(stop-start+1);
-        HIP_IFEL((!signature_hash), -1, "Failed to malloc signature_hash\n");
-        snprintf((char *)signature_hash_b64, (stop-start-1), "%s", 
-                 &cert->signature[start + 1]);       
-        _HIP_DEBUG("SIG HASH B64 %s\n", signature_hash_b64);
-        evpret = EVP_DecodeBlock(signature_hash, signature_hash_b64, 
-                                 strlen((char *)signature_hash_b64));
-        HIP_IFEL(memcmp(sha_digest, signature_hash, 20), -1,
-                 "Signature hash did not match of the one made from the"
-                 "cert sequence in the certificate\n");
-
-        /* memset signature and put it into its place */
-        start = stop = 0;
-        HIP_IFEL(hip_cert_regex(s_rule, cert->signature, &start, &stop), -1,
-                 "Failed to run hip_cert_regex (signature)\n");
-        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-        signature_b64 = malloc(stop-start+1);
-        HIP_IFEL((!signature_b64), -1, "Failed to malloc signature_b64\n");
-        memset(signature_b64, '\0', keylen);
-        snprintf((char *)signature_b64, (stop-start-2),"%s", 
&cert->signature[start + 2]);       
-       _HIP_DEBUG("SIG_B64 %s\n", signature_b64);
-        if (algo == HIP_HI_DSA) {
-                signature = malloc(stop-start+1);
-                HIP_IFEL(!signature, -1, "Failed to malloc signature (dsa)\n");
-        }
-        evpret = EVP_DecodeBlock(signature, signature_b64, 
-                                 strlen((char *)signature_b64));
-        _HIP_HEXDUMP("SIG\n", signature, keylen);
-
-        if (algo == HIP_HI_RSA) {
-                /* do the verification */
-                err = RSA_verify(NID_sha1, sha_digest, SHA_DIGEST_LENGTH,
-                                 signature, RSA_size(rsa), rsa);
-                e_code = ERR_get_error();
-                ERR_load_crypto_strings();
-                ERR_error_string(e_code ,buf);
-                
-                _HIP_DEBUG("***********RSA ERROR*************\n");
-                _HIP_DEBUG("RSA_size(rsa) = %d\n",RSA_size(rsa));
-                _HIP_DEBUG("Signature length :%d\n",strlen((char *)signature));
-                _HIP_DEBUG("Error string :%s\n",buf);
-                _HIP_DEBUG("LIB error :%s\n",ERR_lib_error_string(e_code));
-                _HIP_DEBUG("func error :%s\n",ERR_func_error_string(e_code));
-                _HIP_DEBUG("Reason error 
:%s\n",ERR_reason_error_string(e_code));
-                _HIP_DEBUG("***********RSA ERROR*************\n");
-
-                /* RSA_verify returns 1 if success. */
-                cert->success = err == 1 ? 0 : -1;
-                HIP_IFEL((err = err == 1 ? 0 : -1), -1, "RSA_verify error\n");
-
-        } else if (algo == HIP_HI_DSA) {
-
-                /* build the signature structure */
-                dsa_sig = DSA_SIG_new();
-                HIP_IFEL(!dsa_sig, 1, "Failed to allocate DSA_SIG\n");
-                dsa_sig->r = BN_bin2bn(&signature[1], DSA_PRIV, NULL);
-                dsa_sig->s = BN_bin2bn(&signature[1 + DSA_PRIV], DSA_PRIV, 
NULL);
-
-                /* verify the DSA signature */
-                err = DSA_do_verify(sha_digest, SHA_DIGEST_LENGTH, 
-                                    dsa_sig, dsa) == 0 ? 1 : 0;
-
-                /* DSA_do_verify returns 1 if success. */
-                cert->success = err == 1 ? 0 : -1;
-                HIP_IFEL((err = err == 1 ? 0 : -1), -1, "DSA_do_verify 
error\n");
-
-        } else HIP_IFEL((1==0), -1, "Unknown algorithm\n");
+int hip_cert_spki_lib_verify(struct hip_cert_spki_info *cert)
+{
+    int err = 0, start = 0, stop = 0, evpret = 0, keylen = 0, algo = 0;
+    char buf[200];
+
+    unsigned char sha_digest[21];
+    unsigned char *sha_retval;
+    unsigned char *signature_hash     = NULL;
+    unsigned char *signature_hash_b64 = NULL;
+    unsigned char *signature_b64      = NULL;
+
+    unsigned char *signature          = NULL;
+
+    /** RSA **/
+    RSA *rsa                          = NULL;
+    unsigned long e_code;
+    char *e_hex                       = NULL;
+    unsigned char *modulus_b64        = NULL;
+    unsigned char *modulus            = NULL;
+
+    /** DSA **/
+    DSA *dsa                          = NULL;
+    unsigned char *p_bin              = NULL, *q_bin = NULL, *g_bin = NULL, 
*y_bin = NULL;
+    unsigned char *p_b64              = NULL, *q_b64 = NULL, *g_b64 = NULL, 
*y_b64 = NULL;
+    DSA_SIG *dsa_sig;
+
+    /* rules for regular expressions */
+
+    /*
+     * Rule to get the info if we are using DSA
+     */
+    char dsa_rule[] = "[d][s][a][-][p][k][c][s][1][-][s][h][a][1]";
+
+    /*
+     * Rule to get the info if we are using RSA
+     */
+    char rsa_rule[] = "[r][s][a][-][p][k][c][s][1][-][s][h][a][1]";
+
+    /*
+     * Rule to get DSA p
+     * Look for pattern "(p |" and stop when first "|"
+     * anything in base 64 is accepted inbetween
+     */
+    char p_rule[]   = "[(][p][ ][|][[A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * Rule to get DSA q
+     * Look for pattern "(q |" and stop when first "|"
+     * anything in base 64 is accepted inbetween
+     */
+    char q_rule[]   = "[(][q][ ][|][[A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * Rule to get DSA g
+     * Look for pattern "(g |" and stop when first "|"
+     * anything in base 64 is accepted inbetween
+     */
+    char g_rule[]   = "[(][g][ ][|][[A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * Rule to get DSA y / pub_key
+     * Look for pattern "(y |" and stop when first "|"
+     * anything in base 64 is accepted inbetween
+     */
+    char y_rule[]   = "[(][y][ ][|][[A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * rule to get the public exponent RSA
+     * Look for the part that says # and after that some hex blob and #
+     */
+    char e_rule[]   = "[#][0-9A-Fa-f]*[#]";
+
+    /*
+     * rule to get the public modulus RSA
+     * Look for the part that starts with '|' and after that anything
+     * that is in base 64 char set and then '|' again
+     */
+    char n_rule[]   = "[|][A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * rule to get the signature hash
+     * Look for the similar than the n_rule
+     */
+    char h_rule[]   = "[|][A-Za-z0-9+/()#=-]*[|]";
+
+    /*
+     * rule to get the signature
+     * Look for part that starts ")|" and base 64 blob after it
+     * and stops to '|' char remember to add and subtract 2 from
+     * the indexes below
+     */
+    char s_rule[]   = "[)][|][A-Za-z0-9+/()#=-]*[|]";
+
+    _HIP_DEBUG("\n\n** CONTENTS of public key sequence **\n"
+               "%s\n\n", cert->public_key);
+
+    /* check the algo DSA or RSA  */
+    HIP_DEBUG("Verifying\nRunning regexps to identify algo\n");
+    start = stop = 0;
+    algo  = hip_cert_regex(dsa_rule, cert->public_key, &start, &stop);
+    if (algo != -1) {
+        HIP_DEBUG("Public-key is DSA\n");
+        algo = HIP_HI_DSA;
+        goto algo_check_done;
+    }
+    start = stop = 0;
+    algo  = hip_cert_regex(rsa_rule, cert->public_key, &start, &stop);
+    if (algo != -1) {
+        HIP_DEBUG("Public-key is RSA\n");
+        algo = HIP_HI_RSA;
+        goto algo_check_done;
+    }
+    HIP_DEBUG((1 != 1), -1, "Unknown algorithm\n");
+
+algo_check_done:
+    if (algo == HIP_HI_RSA) {
+        /* malloc space for new rsa */
+        rsa = RSA_new();
+        HIP_IFEL(!rsa, -1, "Failed to malloc RSA\n");
+
+        /* extract the public-key from cert to rsa */
+
+        /* public exponent first */
+        start = stop = 0;
+        HIP_IFEL(hip_cert_regex(e_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex (exponent)\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        e_hex = malloc(stop - start);
+        HIP_IFEL((!e_hex), -1, "Malloc for e_hex failed\n");
+        snprintf((char *) e_hex, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("E_HEX %s\n", e_hex);
+
+        /* public modulus */
+        start       = stop = 0;
+        HIP_IFEL(hip_cert_regex(n_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex (modulus)\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        modulus_b64 = malloc(stop - start + 1);
+        HIP_IFEL((!modulus_b64), -1, "Malloc for modulus_b64 failed\n");
+        memset(modulus_b64, 0, (stop - start + 1));
+        modulus     = malloc(stop - start + 1);
+        HIP_IFEL((!modulus), -1, "Malloc for modulus failed\n");
+        memset(modulus, 0, (stop - start + 1));
+        snprintf((char *) modulus_b64, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("modulus_b64 %s\n", modulus_b64);
+
+        /* put the stuff into the RSA struct */
+        BN_hex2bn(&rsa->e, e_hex);
+        evpret = EVP_DecodeBlock(modulus, modulus_b64,
+                                 strlen((char *) modulus_b64));
+
+        /* EVP returns a multiple of 3 octets, subtract any extra */
+        keylen = evpret;
+        if (keylen % 4 != 0) {
+            --keylen;
+            keylen = keylen - keylen % 2;
+        }
+        _HIP_DEBUG("keylen = %d (%d bits)\n", keylen, keylen * 8);
+        signature = malloc(keylen);
+        HIP_IFEL((!signature), -1, "Malloc for signature failed.\n");
+        rsa->n    = BN_bin2bn(modulus, keylen, 0);
+
+        _HIP_DEBUG("In verification RSA e=%s\n", BN_bn2hex(rsa->e));
+        _HIP_DEBUG("In verification RSA n=%s\n", BN_bn2hex(rsa->n));
+    } else if (algo == HIP_HI_DSA) {
+        /* malloc space for new dsa */
+        dsa = DSA_new();
+        HIP_IFEL(!dsa, -1, "Failed to malloc DSA\n");
+
+        /* Extract public key from the cert */
+
+        /* dsa->p */
+        start = stop = 0;
+        HIP_IFEL(hip_cert_regex(p_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex dsa->p\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        p_b64 = malloc(stop - start + 1);
+        HIP_IFEL((!p_b64), -1, "Malloc for p_b64 failed\n");
+        memset(p_b64, 0, (stop - start + 1));
+        p_bin = malloc(stop - start + 1);
+        HIP_IFEL((!p_bin), -1, "Malloc for p_bin failed\n");
+        memset(p_bin, 0, (stop - start + 1));
+        snprintf((char *) p_b64, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("p_b64 %s\n", p_b64);
+        evpret = EVP_DecodeBlock(p_bin, p_b64, strlen((char *) p_b64));
+
+        /* dsa->q */
+        start  = stop = 0;
+        HIP_IFEL(hip_cert_regex(q_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex dsa->q\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        q_b64  = malloc(stop - start + 1);
+        HIP_IFEL((!q_b64), -1, "Malloc for q_b64 failed\n");
+        memset(q_b64, 0, (stop - start + 1));
+        q_bin  = malloc(stop - start + 1);
+        HIP_IFEL((!q_bin), -1, "Malloc for q_bin failed\n");
+        memset(q_bin, 0, (stop - start + 1));
+        snprintf((char *) q_b64, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("q_b64 %s\n", q_b64);
+        evpret = EVP_DecodeBlock(q_bin, q_b64, strlen((char *) q_b64));
+
+        /* dsa->g */
+        start  = stop = 0;
+        HIP_IFEL(hip_cert_regex(g_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex dsa->g\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        g_b64  = malloc(stop - start + 1);
+        HIP_IFEL((!g_b64), -1, "Malloc for g_b64 failed\n");
+        memset(g_b64, 0, (stop - start + 1));
+        g_bin  = malloc(stop - start + 1);
+        HIP_IFEL((!g_bin), -1, "Malloc for g_bin failed\n");
+        memset(g_bin, 0, (stop - start + 1));
+        snprintf((char *) g_b64, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("g_b64 %s\n", g_b64);
+        evpret = EVP_DecodeBlock(g_bin, g_b64, strlen((char *) g_b64));
+
+        /* dsa->y */
+        start  = stop = 0;
+        HIP_IFEL(hip_cert_regex(y_rule, cert->public_key, &start, &stop), -1,
+                 "Failed to run hip_cert_regex dsa->y\n");
+        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+        y_b64  = malloc(stop - start + 1);
+        HIP_IFEL((!y_b64), -1, "Malloc for y_b64 failed\n");
+        memset(y_b64, 0, (stop - start + 1));
+        y_bin  = malloc(stop - start + 1);
+        HIP_IFEL((!y_bin), -1, "Malloc for y_bin failed\n");
+        memset(y_bin, 0, (stop - start + 1));
+        snprintf((char *) y_b64, (stop - start - 1), "%s", 
&cert->public_key[start + 1]);
+        _HIP_DEBUG("y_b64 %s\n", y_b64);
+        evpret = EVP_DecodeBlock(y_bin, y_b64, strlen((char *) y_b64));
+    } else {HIP_IFEL((1 == 0), -1, "Unknown algorithm\n");
+    }
+
+    memset(sha_digest, '\0', sizeof(sha_digest));
+    /* build sha1 digest that will be signed */
+    HIP_IFEL(!(sha_retval = SHA1((unsigned char *) cert->cert,
+                                 strlen((char *) cert->cert), sha_digest)),
+             -1, "SHA1 error when creating digest.\n");
+    _HIP_HEXDUMP("SHA1 digest of cert sequence ", sha_digest, 20);
+
+    /* Get the signature hash and compare it to the sha_digest we just made */
+    start              = stop = 0;
+    HIP_IFEL(hip_cert_regex(h_rule, cert->signature, &start, &stop), -1,
+             "Failed to run hip_cert_regex (signature hash)\n");
+    _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+    signature_hash_b64 = malloc(stop - start + 1);
+    HIP_IFEL((!signature_hash_b64), -1, "Failed to malloc 
signature_hash_b64\n");
+    memset(signature_hash_b64, '\0', (stop - start + 1));
+    signature_hash     = malloc(stop - start + 1);
+    HIP_IFEL((!signature_hash), -1, "Failed to malloc signature_hash\n");
+    snprintf((char *) signature_hash_b64, (stop - start - 1), "%s",
+             &cert->signature[start + 1]);
+    _HIP_DEBUG("SIG HASH B64 %s\n", signature_hash_b64);
+    evpret = EVP_DecodeBlock(signature_hash, signature_hash_b64,
+                             strlen((char *) signature_hash_b64));
+    HIP_IFEL(memcmp(sha_digest, signature_hash, 20), -1,
+             "Signature hash did not match of the one made from the"
+             "cert sequence in the certificate\n");
+
+    /* memset signature and put it into its place */
+    start         = stop = 0;
+    HIP_IFEL(hip_cert_regex(s_rule, cert->signature, &start, &stop), -1,
+             "Failed to run hip_cert_regex (signature)\n");
+    _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+    signature_b64 = malloc(stop - start + 1);
+    HIP_IFEL((!signature_b64), -1, "Failed to malloc signature_b64\n");
+    memset(signature_b64, '\0', keylen);
+    snprintf((char *) signature_b64, (stop - start - 2), "%s", 
&cert->signature[start + 2]);
+    _HIP_DEBUG("SIG_B64 %s\n", signature_b64);
+    if (algo == HIP_HI_DSA) {
+        signature = malloc(stop - start + 1);
+        HIP_IFEL(!signature, -1, "Failed to malloc signature (dsa)\n");
+    }
+    evpret = EVP_DecodeBlock(signature, signature_b64,
+                             strlen((char *) signature_b64));
+    _HIP_HEXDUMP("SIG\n", signature, keylen);
+
+    if (algo == HIP_HI_RSA) {
+        /* do the verification */
+        err    = RSA_verify(NID_sha1, sha_digest, SHA_DIGEST_LENGTH,
+                            signature, RSA_size(rsa), rsa);
+        e_code = ERR_get_error();
+        ERR_load_crypto_strings();
+        ERR_error_string(e_code, buf);
+
+        _HIP_DEBUG("***********RSA ERROR*************\n");
+        _HIP_DEBUG("RSA_size(rsa) = %d\n", RSA_size(rsa));
+        _HIP_DEBUG("Signature length :%d\n", strlen((char *) signature));
+        _HIP_DEBUG("Error string :%s\n", buf);
+        _HIP_DEBUG("LIB error :%s\n", ERR_lib_error_string(e_code));
+        _HIP_DEBUG("func error :%s\n", ERR_func_error_string(e_code));
+        _HIP_DEBUG("Reason error :%s\n", ERR_reason_error_string(e_code));
+        _HIP_DEBUG("***********RSA ERROR*************\n");
+
+        /* RSA_verify returns 1 if success. */
+        cert->success = err == 1 ? 0 : -1;
+        HIP_IFEL((err = err == 1 ? 0 : -1), -1, "RSA_verify error\n");
+    } else if (algo == HIP_HI_DSA) {
+        /* build the signature structure */
+        dsa_sig       = DSA_SIG_new();
+        HIP_IFEL(!dsa_sig, 1, "Failed to allocate DSA_SIG\n");
+        dsa_sig->r    = BN_bin2bn(&signature[1], DSA_PRIV, NULL);
+        dsa_sig->s    = BN_bin2bn(&signature[1 + DSA_PRIV], DSA_PRIV, NULL);
+
+        /* verify the DSA signature */
+        err           = DSA_do_verify(sha_digest, SHA_DIGEST_LENGTH,
+                                      dsa_sig, dsa) == 0 ? 1 : 0;
+
+        /* DSA_do_verify returns 1 if success. */
+        cert->success = err == 1 ? 0 : -1;
+        HIP_IFEL((err = err == 1 ? 0 : -1), -1, "DSA_do_verify error\n");
+    } else {HIP_IFEL((1 == 0), -1, "Unknown algorithm\n");
+    }
 
 out_err:
-        if (signature_hash_b64) free(signature_hash_b64);
-        if (signature_hash) free(signature_hash);
-        if (modulus_b64) free(modulus_b64);
-        if (modulus) free(modulus);
-        if (rsa) RSA_free(rsa);
-       if (e_hex) free(e_hex);
-        if (dsa) DSA_free(dsa);
-       return (err);
+    if (signature_hash_b64) {
+        free(signature_hash_b64);
+    }
+    if (signature_hash) {
+        free(signature_hash);
+    }
+    if (modulus_b64) {
+        free(modulus_b64);
+    }
+    if (modulus) {
+        free(modulus);
+    }
+    if (rsa) {
+        RSA_free(rsa);
+    }
+    if (e_hex) {
+        free(e_hex);
+    }
+    if (dsa) {
+        DSA_free(dsa);
+    }
+    return err;
 }
 
-/**  
- * hip_cert_spki_create_cert - Function to build the create minimal SPKI cert  
+/**
+ * hip_cert_spki_create_cert - Function to build the create minimal SPKI cert
  *
- * @param content holds the struct hip_cert_spki_info containing 
- *                the minimal needed information for cert object, 
- *                also contains the char table where the cert object 
+ * @param content holds the struct hip_cert_spki_info containing
+ *                the minimal needed information for cert object,
+ *                also contains the char table where the cert object
  *                is to be stored
  * @param issuer_type With HIP its HIT
  * @param issuer HIT in representation encoding 2001:001...
@@ -364,149 +374,169 @@
  *
  * @return 0 if ok -1 if error
  */
-int hip_cert_spki_create_cert(struct hip_cert_spki_info * content,
-                              char * issuer_type, struct in6_addr * issuer,
-                              char * subject_type, struct in6_addr * subject,
-                              time_t * not_before, time_t * not_after) {
-       int err = 0;
-        char * tmp_issuer  = NULL;
-        char * tmp_subject = NULL;
-        char * tmp_before  = NULL;
-        char * tmp_after   = NULL;
-        struct tm *ts      = NULL;
-        char buf_before[80];
-        char buf_after[80];
-        char present_issuer[41];
-        char present_subject[41];
-        struct hip_common * msg = NULL;
-        struct hip_cert_spki_info * returned = NULL;
-
-        /* Malloc needed */
-        tmp_issuer = malloc(128);
-        if (!tmp_issuer) goto out_err; /* Why does this return 0? */
-        tmp_subject = malloc(128);
-        if (!tmp_subject) goto out_err;
-        tmp_before = malloc(128);
-        if (!tmp_before) goto out_err;
-        tmp_after = malloc(128);
-        if (!tmp_after) goto out_err;
-        HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, 
-                 "Malloc for msg failed\n");   
-
-        /* Memset everything */
-        HIP_IFEL(!memset(buf_before, '\0', sizeof(buf_before)), -1,
-                 "Failed to memset memory for tmp buffers variables\n");
-        HIP_IFEL(!memset(buf_after, '\0', sizeof(buf_after)), -1,
-                 "Failed to memset memory for tmp buffers variables\n");
-        HIP_IFEL(!memset(tmp_issuer, '\0', sizeof(tmp_issuer)), -1,
-                 "Failed to memset memory for tmp variables\n");
-        HIP_IFEL(!memset(tmp_subject, '\0', sizeof(tmp_subject)), -1,
-                 "Failed to memset memory for tmp variables\n");
-        HIP_IFEL(!memset(tmp_before, '\0', sizeof(tmp_before)), -1,
-                 "Failed to memset memory for tmp variables\n");
-        HIP_IFEL(!memset(tmp_after, '\0', sizeof(tmp_after)), -1,
-                 "Failed to memset memory for tmp variables\n");
-        HIP_IFEL(!memset(present_issuer, '\0', sizeof(present_issuer)), -1,
-                 "Failed to memset memory for tmp variables\n");
-        HIP_IFEL(!memset(present_subject, '\0', sizeof(present_subject)), -1,
-                 "Failed to memset memory for tmp variables\n");
-
-        /* Make needed transforms to the date */
-        _HIP_DEBUG("not_before %d not_after %d\n",*not_before,*not_after);
-        /*  Format and print the time, "yyyy-mm-dd hh:mm:ss"
-           (not-after "1998-04-15_00:00:00") */
-        ts = localtime(not_before);
-        strftime(buf_before, sizeof(buf_before), "%Y-%m-%d_%H:%M:%S", ts);
-        ts = localtime(not_after);
-        strftime(buf_after, sizeof(buf_after), "%Y-%m-%d_%H:%M:%S", ts);
-        _HIP_DEBUG("Not before %s\n", buf_before);
-        _HIP_DEBUG("Not after %s\n", buf_after);
-
-        sprintf(tmp_before, "(not-before \"%s\")", buf_before);
-        sprintf(tmp_after, "(not-after \"%s\")", buf_after);
-        
-        ipv6_addr_copy(&content->issuer_hit, issuer);
-        hip_in6_ntop(issuer, present_issuer);        
-        hip_in6_ntop(subject, present_subject);
-
-        sprintf(tmp_issuer, "(hash %s %s)", issuer_type, present_issuer);
-        sprintf(tmp_subject, "(hash %s %s)", subject_type, present_subject);
-
-        /* Create the cert sequence */        
-        HIP_IFEL(hip_cert_spki_build_cert(content), -1, 
-                 "hip_cert_spki_build_cert failed\n");
-
-        HIP_IFEL(hip_cert_spki_inject(content, "cert", tmp_after), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-        HIP_IFEL(hip_cert_spki_inject(content, "cert", tmp_before), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-        HIP_IFEL(hip_cert_spki_inject(content, "cert", "(subject )"), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-        HIP_IFEL(hip_cert_spki_inject(content, "subject", tmp_subject), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-        HIP_IFEL(hip_cert_spki_inject(content, "cert", "(issuer )"), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-        HIP_IFEL(hip_cert_spki_inject(content, "issuer", tmp_issuer), -1, 
-                 "hip_cert_spki_inject failed to inject\n");
-
-        /* Create the signature and the public-key sequences */
-
-        /* Send the daemon the struct hip_cert_spki_header 
-           containing the cert sequence in content->cert. 
-           As a result you should get the struct back with 
-           public-key and signature fields filled */
-
-        /* build the msg to be sent to the daemon */
-       hip_msg_init(msg);         
-        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_SPKI_SIGN, 0), -1, 
-                 "Failed to build user header\n");
-        HIP_IFEL(hip_build_param_cert_spki_info(msg, content), -1,
-                 "Failed to build cert_info\n");
-        /* send and wait */
-        HIP_DEBUG("Sending request to sign SPKI cert sequence to "
-                  "daemon and waiting for answer\n");  
-        hip_send_recv_daemon_info(msg, 0, 0);
-        
-        /* get the struct from the message sent back by the daemon */
-       _HIP_DUMP_MSG(msg);
-        HIP_IFEL(!(returned = hip_get_param(msg, HIP_PARAM_CERT_SPKI_INFO)), 
-                 -1, "No hip_cert_spki_info struct found from daemons msg\n");
-
-       _HIP_DEBUG("PUBLIC-KEY\n%s\nCERT\n%s\nSIGNATURE\n%s\n", 
returned->public_key,
-                 returned->cert, returned->signature);
-        memcpy(content, returned, sizeof(struct hip_cert_spki_info));
+int hip_cert_spki_create_cert(struct hip_cert_spki_info *content,
+                              char *issuer_type, struct in6_addr *issuer,
+                              char *subject_type, struct in6_addr *subject,
+                              time_t *not_before, time_t *not_after)
+{
+    int err           = 0;
+    char *tmp_issuer  = NULL;
+    char *tmp_subject = NULL;
+    char *tmp_before  = NULL;
+    char *tmp_after   = NULL;
+    struct tm *ts     = NULL;
+    char buf_before[80];
+    char buf_after[80];
+    char present_issuer[41];
+    char present_subject[41];
+    struct hip_common *msg              = NULL;
+    struct hip_cert_spki_info *returned = NULL;
+
+    /* Malloc needed */
+    tmp_issuer  = malloc(128);
+    if (!tmp_issuer) {
+        goto out_err;                  /* Why does this return 0? */
+    }
+    tmp_subject = malloc(128);
+    if (!tmp_subject) {
+        goto out_err;
+    }
+    tmp_before  = malloc(128);
+    if (!tmp_before) {
+        goto out_err;
+    }
+    tmp_after   = malloc(128);
+    if (!tmp_after) {
+        goto out_err;
+    }
+    HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1,
+             "Malloc for msg failed\n");
+
+    /* Memset everything */
+    HIP_IFEL(!memset(buf_before, '\0', sizeof(buf_before)), -1,
+             "Failed to memset memory for tmp buffers variables\n");
+    HIP_IFEL(!memset(buf_after, '\0', sizeof(buf_after)), -1,
+             "Failed to memset memory for tmp buffers variables\n");
+    HIP_IFEL(!memset(tmp_issuer, '\0', sizeof(tmp_issuer)), -1,
+             "Failed to memset memory for tmp variables\n");
+    HIP_IFEL(!memset(tmp_subject, '\0', sizeof(tmp_subject)), -1,
+             "Failed to memset memory for tmp variables\n");
+    HIP_IFEL(!memset(tmp_before, '\0', sizeof(tmp_before)), -1,
+             "Failed to memset memory for tmp variables\n");
+    HIP_IFEL(!memset(tmp_after, '\0', sizeof(tmp_after)), -1,
+             "Failed to memset memory for tmp variables\n");
+    HIP_IFEL(!memset(present_issuer, '\0', sizeof(present_issuer)), -1,
+             "Failed to memset memory for tmp variables\n");
+    HIP_IFEL(!memset(present_subject, '\0', sizeof(present_subject)), -1,
+             "Failed to memset memory for tmp variables\n");
+
+    /* Make needed transforms to the date */
+    _HIP_DEBUG("not_before %d not_after %d\n", *not_before, *not_after);
+    /*  Format and print the time, "yyyy-mm-dd hh:mm:ss"
+     * (not-after "1998-04-15_00:00:00") */
+    ts = localtime(not_before);
+    strftime(buf_before, sizeof(buf_before), "%Y-%m-%d_%H:%M:%S", ts);
+    ts = localtime(not_after);
+    strftime(buf_after, sizeof(buf_after), "%Y-%m-%d_%H:%M:%S", ts);
+    _HIP_DEBUG("Not before %s\n", buf_before);
+    _HIP_DEBUG("Not after %s\n", buf_after);
+
+    sprintf(tmp_before, "(not-before \"%s\")", buf_before);
+    sprintf(tmp_after, "(not-after \"%s\")", buf_after);
+
+    ipv6_addr_copy(&content->issuer_hit, issuer);
+    hip_in6_ntop(issuer, present_issuer);
+    hip_in6_ntop(subject, present_subject);
+
+    sprintf(tmp_issuer, "(hash %s %s)", issuer_type, present_issuer);
+    sprintf(tmp_subject, "(hash %s %s)", subject_type, present_subject);
+
+    /* Create the cert sequence */
+    HIP_IFEL(hip_cert_spki_build_cert(content), -1,
+             "hip_cert_spki_build_cert failed\n");
+
+    HIP_IFEL(hip_cert_spki_inject(content, "cert", tmp_after), -1,
+             "hip_cert_spki_inject failed to inject\n");
+    HIP_IFEL(hip_cert_spki_inject(content, "cert", tmp_before), -1,
+             "hip_cert_spki_inject failed to inject\n");
+    HIP_IFEL(hip_cert_spki_inject(content, "cert", "(subject )"), -1,
+             "hip_cert_spki_inject failed to inject\n");
+    HIP_IFEL(hip_cert_spki_inject(content, "subject", tmp_subject), -1,
+             "hip_cert_spki_inject failed to inject\n");
+    HIP_IFEL(hip_cert_spki_inject(content, "cert", "(issuer )"), -1,
+             "hip_cert_spki_inject failed to inject\n");
+    HIP_IFEL(hip_cert_spki_inject(content, "issuer", tmp_issuer), -1,
+             "hip_cert_spki_inject failed to inject\n");
+
+    /* Create the signature and the public-key sequences */
+
+    /* Send the daemon the struct hip_cert_spki_header
+     * containing the cert sequence in content->cert.
+     * As a result you should get the struct back with
+     * public-key and signature fields filled */
+
+    /* build the msg to be sent to the daemon */
+    hip_msg_init(msg);
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_SPKI_SIGN, 0), -1,
+             "Failed to build user header\n");
+    HIP_IFEL(hip_build_param_cert_spki_info(msg, content), -1,
+             "Failed to build cert_info\n");
+    /* send and wait */
+    HIP_DEBUG("Sending request to sign SPKI cert sequence to "
+              "daemon and waiting for answer\n");
+    hip_send_recv_daemon_info(msg, 0, 0);
+
+    /* get the struct from the message sent back by the daemon */
+    _HIP_DUMP_MSG(msg);
+    HIP_IFEL(!(returned = hip_get_param(msg, HIP_PARAM_CERT_SPKI_INFO)),
+             -1, "No hip_cert_spki_info struct found from daemons msg\n");
+
+    _HIP_DEBUG("PUBLIC-KEY\n%s\nCERT\n%s\nSIGNATURE\n%s\n", 
returned->public_key,
+               returned->cert, returned->signature);
+    memcpy(content, returned, sizeof(struct hip_cert_spki_info));
 
 out_err:
-        /* free everything malloced */
-        if (tmp_before) free(tmp_before);
-        if (tmp_after) free(tmp_after);
-        if (tmp_issuer) free(tmp_issuer);
-        if (tmp_subject) free(tmp_subject);
-        if (msg) free(msg);
-       return (err);
-} 
- 
+    /* free everything malloced */
+    if (tmp_before) {
+        free(tmp_before);
+    }
+    if (tmp_after) {
+        free(tmp_after);
+    }
+    if (tmp_issuer) {
+        free(tmp_issuer);
+    }
+    if (tmp_subject) {
+        free(tmp_subject);
+    }
+    if (msg) {
+        free(msg);
+    }
+    return err;
+}
+
 /**
  * hip_cert_spki_build_cert - Function to build the basic cert object
  * of SPKI clears public-key object and signature in
- * hip_cert_spki_header 
- * 
+ * hip_cert_spki_header
+ *
  * @param minimal_content holds the struct hip_cert_spki_header
- *                        containing the minimal needed information for 
+ *                        containing the minimal needed information for
  *                        cert object, also contains the char table where
  *                        the cert object is to be stored
  *
  * @return 0 if ok -1 if error
  */
-int hip_cert_spki_build_cert(struct hip_cert_spki_info * minimal_content) {
-       int err = 0;
-       char needed[] = "(cert )";
-       memset(minimal_content->public_key, '\0', 
sizeof(minimal_content->public_key));
-       memset(minimal_content->cert, '\0', sizeof(minimal_content->cert));
-       memset(minimal_content->signature, '\0', 
sizeof(minimal_content->signature));
-        sprintf(minimal_content->cert, "%s", needed);
+int hip_cert_spki_build_cert(struct hip_cert_spki_info *minimal_content)
+{
+    int err       = 0;
+    char needed[] = "(cert )";
+    memset(minimal_content->public_key, '\0', 
sizeof(minimal_content->public_key));
+    memset(minimal_content->cert, '\0', sizeof(minimal_content->cert));
+    memset(minimal_content->signature, '\0', 
sizeof(minimal_content->signature));
+    sprintf(minimal_content->cert, "%s", needed);
 
-       return (err);
+    return err;
 }
 
 /**
@@ -514,46 +544,49 @@
  *
  * @param to hip_cert_spki_info containing the char table where to insert
  * @param after is a char pointer for the regcomp after which the inject 
happens
- * @param what is char pointer of what to 
+ * @param what is char pointer of what to
  *
  * @return 0 if ok and negative if error. -1 returned for example when after 
is NOT found
  */
-int hip_cert_spki_inject(struct hip_cert_spki_info * to, 
-                         char * after, char * what) {
-       int err = 0, status = 0;
-        regex_t re;
-        regmatch_t pm[1];
-        char * tmp_cert;        
+int hip_cert_spki_inject(struct hip_cert_spki_info *to,
+                         char *after, char *what)
+{
+    int err = 0, status = 0;
+    regex_t re;
+    regmatch_t pm[1];
+    char *tmp_cert;
 
-        _HIP_DEBUG("Before inject:\n%s\n",to->cert);
-        _HIP_DEBUG("Inserting \"%s\" after \"%s\"\n", what, after);       
-        tmp_cert = malloc(strlen(to->cert) + strlen(what) + 1);
-        if (!tmp_cert) return(-1);
-        HIP_IFEL(!memset(tmp_cert, 0, sizeof(tmp_cert)), -1,
-                 "Failed to memset temporary workspace\n");        
-        /* Compiling the regular expression */
-        HIP_IFEL(regcomp(&re, after, REG_EXTENDED), -1, 
-                 "Compilation of the regular expression failed\n");       
-        /* Running the regular expression */
-        HIP_IFEL((status = regexec(&re, to->cert, 1, pm, 0)), -1,
-                 "Handling of regular expression failed\n");
-        _HIP_DEBUG("Found \"%s\" at %d and it ends at %d\n",
-                  after, pm[0].rm_so, pm[0].rm_eo);
-        /* Using tmp char table to do the inject (remember the terminators)
-           first the beginning */
-        snprintf(tmp_cert, pm[0].rm_eo + 2, "%s", to->cert);
-        /* Then the middle part to be injected */
-        snprintf(&tmp_cert[pm[0].rm_eo + 1], strlen(what) + 1, "%s", what);
-        /* then glue back the rest of the original at the end */
-        snprintf(&tmp_cert[(pm[0].rm_eo + strlen(what) + 1)], 
-                (strlen(to->cert) - pm[0].rm_eo), "%s", &to->cert[pm[0].rm_eo 
+ 1]);
-        /* move tmp to the result */
-        sprintf(to->cert, "%s", tmp_cert);
-        _HIP_DEBUG("After inject:\n%s\n",to->cert);
+    _HIP_DEBUG("Before inject:\n%s\n", to->cert);
+    _HIP_DEBUG("Inserting \"%s\" after \"%s\"\n", what, after);
+    tmp_cert = malloc(strlen(to->cert) + strlen(what) + 1);
+    if (!tmp_cert) {
+        return -1;
+    }
+    HIP_IFEL(!memset(tmp_cert, 0, sizeof(tmp_cert)), -1,
+             "Failed to memset temporary workspace\n");
+    /* Compiling the regular expression */
+    HIP_IFEL(regcomp(&re, after, REG_EXTENDED), -1,
+             "Compilation of the regular expression failed\n");
+    /* Running the regular expression */
+    HIP_IFEL((status = regexec(&re, to->cert, 1, pm, 0)), -1,
+             "Handling of regular expression failed\n");
+    _HIP_DEBUG("Found \"%s\" at %d and it ends at %d\n",
+               after, pm[0].rm_so, pm[0].rm_eo);
+    /* Using tmp char table to do the inject (remember the terminators)
+     * first the beginning */
+    snprintf(tmp_cert, pm[0].rm_eo + 2, "%s", to->cert);
+    /* Then the middle part to be injected */
+    snprintf(&tmp_cert[pm[0].rm_eo + 1], strlen(what) + 1, "%s", what);
+    /* then glue back the rest of the original at the end */
+    snprintf(&tmp_cert[(pm[0].rm_eo + strlen(what) + 1)],
+             (strlen(to->cert) - pm[0].rm_eo), "%s", &to->cert[pm[0].rm_eo + 
1]);
+    /* move tmp to the result */
+    sprintf(to->cert, "%s", tmp_cert);
+    _HIP_DEBUG("After inject:\n%s\n", to->cert);
 out_err:
-        free(tmp_cert);
-       regfree(&re);
-       return (err);
+    free(tmp_cert);
+    regfree(&re);
+    return err;
 }
 
 /**
@@ -563,56 +596,57 @@
  * @param from char pointer to the whole certificate
  * @param to hip_cert_spki_info containing the char table where to insert
  *
- * @return 0 if ok and negative if error. 
+ * @return 0 if ok and negative if error.
  */
-int hip_cert_spki_char2certinfo(char * from, struct hip_cert_spki_info * to) {
-        int err = 0, start = 0, stop = 0;
-        /* 
-           p_rule looks for string "(public_key " after which there can be
-           pretty much anything until string "|)))" is encountered.
-           This is the public-key sequence.
-        */
-        char p_rule[] = "[(]public_key [ A-Za-z0-9+|/()#=-]*[|][)][)][)]";
-        /* 
-           c_rule looks for string "(cert " after which there can be
-           pretty much anything until string '"))' is encountered.
-           This is the cert sequence.
-        */ 
-        char c_rule[] = "[(]cert [ A-Za-z0-9+|/():=_\"-]*[\"][)][)]"; //\" is 
one char  
-        /* 
-           s_rule looks for string "(signature " after which there can be
-           pretty much anything until string "|))" is encountered.
-           This is the signature sequence.
-        */
-        char s_rule[] = "[(]signature [ A-Za-z0-9+/|()=]*[|][)][)]";
-        
-        _HIP_DEBUG("FROM %s\n", from);
-
-        /* Look for the public key */ 
-        HIP_IFEL(hip_cert_regex(p_rule, from , &start, &stop), -1,
-                 "Failed to run hip_cert_regex (public-key)\n");
-        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-        snprintf(to->public_key, (stop-start) + 1,"%s", &from[start]);
-
-        /* Look for the cert sequence */
-        start = stop = 0;
-        HIP_IFEL(hip_cert_regex(c_rule, from, &start, &stop), -1,
-                 "Failed to run hip_cert_regex (cert)\n");
-        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-        snprintf(to->cert, (stop-start) + 1,"%s", &from[start]);        
-
-        /* look for the signature sequence */
-        start = stop = 0;
-        HIP_IFEL(hip_cert_regex(s_rule, from, &start, &stop), -1,
-                 "Failed to run hip_cert_regex (signature)\n");
-        _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
-        snprintf(to->signature, (stop-start) + 1,"%s", &from[start]);
-        
-        _HIP_DEBUG("PK %s\nCert %s\nSign %s\n",
-                  to->public_key, to->cert, to->signature);
-
- out_err:
-        return(err);
+int hip_cert_spki_char2certinfo(char *from, struct hip_cert_spki_info *to)
+{
+    int err       = 0, start = 0, stop = 0;
+    /*
+     * p_rule looks for string "(public_key " after which there can be
+     * pretty much anything until string "|)))" is encountered.
+     * This is the public-key sequence.
+     */
+    char p_rule[] = "[(]public_key [ A-Za-z0-9+|/()#=-]*[|][)][)][)]";
+    /*
+     * c_rule looks for string "(cert " after which there can be
+     * pretty much anything until string '"))' is encountered.
+     * This is the cert sequence.
+     */
+    char c_rule[] = "[(]cert [ A-Za-z0-9+|/():=_\"-]*[\"][)][)]";     //\" is 
one char
+    /*
+     * s_rule looks for string "(signature " after which there can be
+     * pretty much anything until string "|))" is encountered.
+     * This is the signature sequence.
+     */
+    char s_rule[] = "[(]signature [ A-Za-z0-9+/|()=]*[|][)][)]";
+
+    _HIP_DEBUG("FROM %s\n", from);
+
+    /* Look for the public key */
+    HIP_IFEL(hip_cert_regex(p_rule, from, &start, &stop), -1,
+             "Failed to run hip_cert_regex (public-key)\n");
+    _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+    snprintf(to->public_key, (stop - start) + 1, "%s", &from[start]);
+
+    /* Look for the cert sequence */
+    start = stop = 0;
+    HIP_IFEL(hip_cert_regex(c_rule, from, &start, &stop), -1,
+             "Failed to run hip_cert_regex (cert)\n");
+    _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+    snprintf(to->cert, (stop - start) + 1, "%s", &from[start]);
+
+    /* look for the signature sequence */
+    start = stop = 0;
+    HIP_IFEL(hip_cert_regex(s_rule, from, &start, &stop), -1,
+             "Failed to run hip_cert_regex (signature)\n");
+    _HIP_DEBUG("REGEX results from %d to %d\n", start, stop);
+    snprintf(to->signature, (stop - start) + 1, "%s", &from[start]);
+
+    _HIP_DEBUG("PK %s\nCert %s\nSign %s\n",
+               to->public_key, to->cert, to->signature);
+
+out_err:
+    return err;
 }
 
 /**
@@ -621,43 +655,46 @@
  *
  * @param to_verification is the cert to be verified
  *
- * @return 0 if ok and negative if error or unsuccesfull. 
+ * @return 0 if ok and negative if error or unsuccesfull.
  *
  * @note use hip_cert_spki_char2certinfo to build the hip_cert_spki_info
  */
-int hip_cert_spki_send_to_verification(struct hip_cert_spki_info * 
to_verification) {
-        int err = 0;
-        struct hip_common * msg;
-        struct hip_cert_spki_info * returned;
-
-        HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, 
-                 "Malloc for msg failed\n");   
-        hip_msg_init(msg);
-        /* build the msg to be sent to the daemon */         
-        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_SPKI_VERIFY, 0), -1, 
-                 "Failed to build user header\n");
-        HIP_IFEL(hip_build_param_cert_spki_info(msg, to_verification), -1,
-                 "Failed to build cert_info\n");
-
-        /* send and wait */
-        HIP_DEBUG("Sending request to verify SPKI cert to "
-                  "daemon and waiting for answer\n");  
-        hip_send_recv_daemon_info(msg, 0, 0);
-        
-        HIP_IFEL(!(returned = hip_get_param(msg, HIP_PARAM_CERT_SPKI_INFO)), 
-                 -1, "No hip_cert_spki_info struct found from daemons msg\n");
-         
-       _HIP_DEBUG("Success = %d (should be 0 if OK\n", returned->success);
-        memcpy(to_verification, returned, sizeof(struct hip_cert_spki_info));
-
- out_err:
-        if (msg) free(msg);
-        return (err);
+int hip_cert_spki_send_to_verification(struct hip_cert_spki_info 
*to_verification)
+{
+    int err = 0;
+    struct hip_common *msg;
+    struct hip_cert_spki_info *returned;
+
+    HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1,
+             "Malloc for msg failed\n");
+    hip_msg_init(msg);
+    /* build the msg to be sent to the daemon */
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_SPKI_VERIFY, 0), -1,
+             "Failed to build user header\n");
+    HIP_IFEL(hip_build_param_cert_spki_info(msg, to_verification), -1,
+             "Failed to build cert_info\n");
+
+    /* send and wait */
+    HIP_DEBUG("Sending request to verify SPKI cert to "
+              "daemon and waiting for answer\n");
+    hip_send_recv_daemon_info(msg, 0, 0);
+
+    HIP_IFEL(!(returned = hip_get_param(msg, HIP_PARAM_CERT_SPKI_INFO)),
+             -1, "No hip_cert_spki_info struct found from daemons msg\n");
+
+    _HIP_DEBUG("Success = %d (should be 0 if OK\n", returned->success);
+    memcpy(to_verification, returned, sizeof(struct hip_cert_spki_info));
+
+out_err:
+    if (msg) {
+        free(msg);
+    }
+    return err;
 }
 
-/*******************************************************************************
- * FUNCTIONS FOR x509v3                                                        
*
- 
*******************************************************************************/
+/******************************************************************************
+ * FUNCTIONS FOR x509v3                                                       *
+ 
******************************************************************************/
 
 /**
  * hip_cert_x509v3_request_certificate - Function that requests for a
@@ -665,43 +702,46 @@
  *
  * @param subject is the subjects HIT
  *
- * @param cert is pointer to a buffer to which this function writes the 
completed cert 
+ * @param cert is pointer to a buffer to which this function writes the 
completed cert
  *
  * @return positive on success negative otherwise
- * 
+ *
  * @note The certificate is given in DER encoding
- */ 
-int hip_cert_x509v3_request_certificate(struct in6_addr * subject, 
-                                        unsigned char * certificate) {
-        int err = 0;
-        struct hip_common * msg;
-        struct hip_cert_x509_resp * p;
-        
-        HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, 
-                 "Malloc for msg failed\n");   
-       hip_msg_init(msg);
-        /* build the msg to be sent to the daemon */
-         
-        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_X509V3_SIGN, 0), -1, 
-                 "Failed to build user header\n");
-        HIP_IFEL(hip_build_param_cert_x509_req(msg, subject), -1,
-                 "Failed to build cert_info\n");
-        /* send and wait */
-        HIP_DEBUG("Sending request to sign x509 cert to "
-                  "daemon and waiting for answer\n");  
-        hip_send_recv_daemon_info(msg, 0, 0);
-        /* get the struct from the message sent back by the daemon */
-        HIP_IFEL(!(p = hip_get_param(msg, HIP_PARAM_CERT_X509_RESP)), -1,
-                 "No name x509 struct found\n");
-        _HIP_HEXDUMP("DER:\n", p->der, p->der_len);
-        _HIP_DEBUG("DER length %d\n", p->der_len);
-        memcpy(certificate, p->der, p->der_len);
-        err = p->der_len;
-       _HIP_DUMP_MSG(msg);
-
- out_err:
-        if (msg) free(msg);
-        return(err);
+ */
+int hip_cert_x509v3_request_certificate(struct in6_addr *subject,
+                                        unsigned char *certificate)
+{
+    int err = 0;
+    struct hip_common *msg;
+    struct hip_cert_x509_resp *p;
+
+    HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1,
+             "Malloc for msg failed\n");
+    hip_msg_init(msg);
+    /* build the msg to be sent to the daemon */
+
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_X509V3_SIGN, 0), -1,
+             "Failed to build user header\n");
+    HIP_IFEL(hip_build_param_cert_x509_req(msg, subject), -1,
+             "Failed to build cert_info\n");
+    /* send and wait */
+    HIP_DEBUG("Sending request to sign x509 cert to "
+              "daemon and waiting for answer\n");
+    hip_send_recv_daemon_info(msg, 0, 0);
+    /* get the struct from the message sent back by the daemon */
+    HIP_IFEL(!(p = hip_get_param(msg, HIP_PARAM_CERT_X509_RESP)), -1,
+             "No name x509 struct found\n");
+    _HIP_HEXDUMP("DER:\n", p->der, p->der_len);
+    _HIP_DEBUG("DER length %d\n", p->der_len);
+    memcpy(certificate, p->der, p->der_len);
+    err = p->der_len;
+    _HIP_DUMP_MSG(msg);
+
+out_err:
+    if (msg) {
+        free(msg);
+    }
+    return err;
 }
 
 /**
@@ -714,47 +754,52 @@
  * @return 0 on success negative otherwise
  *
  * @note give the certificate in PEM encoding
- */ 
-int hip_cert_x509v3_request_verification(unsigned char * certificate, int len) 
{
-        int err = 0;
-        struct hip_common * msg;
-        struct hip_cert_x509_resp * received;
-        
-        HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, 
-                 "Malloc for msg failed\n");   
-        hip_msg_init(msg);
-
-        _HIP_HEXDUMP("DER DUMP:\n", certificate, len);
-        _HIP_DEBUG("DER LEN %d\n", len);
-        
-        /* build the msg to be sent to the daemon */
-        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_X509V3_VERIFY, 0), -1, 
-                 "Failed to build user header\n");
-        HIP_IFEL(hip_build_param_cert_x509_ver(msg, (char *)certificate, len), 
-1, 
-                 "Failed to build cert_info\n");         
-
-        /* send and wait */
-        HIP_DEBUG("Sending request to verify x509  cert to "
-                  "daemon and waiting for answer\n");
-        _HIP_DUMP_MSG(msg);    
-        hip_send_recv_daemon_info(msg, 0, 0);
-
-        /* get the struct from the message sent back by the daemon */
-        HIP_IFEL(!(received = hip_get_param(msg, HIP_PARAM_CERT_X509_RESP)), 
-1,
-                 "No x509 struct found\n");
-        err = hip_get_msg_err(msg); 
-        if (err == 0) HIP_DEBUG("Verified successfully\n");
-        else HIP_DEBUG("Verification failed\n");
-       _HIP_DUMP_MSG(msg);
-
- out_err:
-        if (msg) free(msg);
-        return(err);
+ */
+int hip_cert_x509v3_request_verification(unsigned char *certificate, int len)
+{
+    int err = 0;
+    struct hip_common *msg;
+    struct hip_cert_x509_resp *received;
+
+    HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1,
+             "Malloc for msg failed\n");
+    hip_msg_init(msg);
+
+    _HIP_HEXDUMP("DER DUMP:\n", certificate, len);
+    _HIP_DEBUG("DER LEN %d\n", len);
+
+    /* build the msg to be sent to the daemon */
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_CERT_X509V3_VERIFY, 0), -1,
+             "Failed to build user header\n");
+    HIP_IFEL(hip_build_param_cert_x509_ver(msg, (char *) certificate, len), -1,
+             "Failed to build cert_info\n");
+
+    /* send and wait */
+    HIP_DEBUG("Sending request to verify x509  cert to "
+              "daemon and waiting for answer\n");
+    _HIP_DUMP_MSG(msg);
+    hip_send_recv_daemon_info(msg, 0, 0);
+
+    /* get the struct from the message sent back by the daemon */
+    HIP_IFEL(!(received = hip_get_param(msg, HIP_PARAM_CERT_X509_RESP)), -1,
+             "No x509 struct found\n");
+    err = hip_get_msg_err(msg);
+    if (err == 0) {
+        HIP_DEBUG("Verified successfully\n");
+    } else {      HIP_DEBUG("Verification failed\n");
+    }
+    _HIP_DUMP_MSG(msg);
+
+out_err:
+    if (msg) {
+        free(msg);
+    }
+    return err;
 }
 
 
/*******************************************************************************
- * UTILITARY FUNCTIONS                                                         
*
- 
*******************************************************************************/
+* UTILITARY FUNCTIONS                                                         *
+*******************************************************************************/
 
 
 /**
@@ -765,18 +810,21 @@
  *
  * @return * X509 or on error NULL is returned
  */
-X509 * hip_cert_der_to_x509(const unsigned char * der, int length) {
-        int err = 0;
-        X509 * cert = NULL;
-
-        _HIP_HEXDUMP("DER:\n", der, length);
-        _HIP_DEBUG("DER length %d\n", length);
-
-        HIP_IFEL(((cert = d2i_X509(NULL, (BROKEN_SSL_CONST unsigned 
char**)&der , length)) == NULL), -1,
-                 "Failed to convert cert from DER to internal format\n");
- out_err:
-       if (err == -1) return NULL;
-        return cert;
+X509 *hip_cert_der_to_x509(const unsigned char *der, int length)
+{
+    int err    = 0;
+    X509 *cert = NULL;
+
+    _HIP_HEXDUMP("DER:\n", der, length);
+    _HIP_DEBUG("DER length %d\n", length);
+
+    HIP_IFEL(((cert = d2i_X509(NULL, (BROKEN_SSL_CONST unsigned char **) &der, 
length)) == NULL), -1,
+             "Failed to convert cert from DER to internal format\n");
+out_err:
+    if (err == -1) {
+        return NULL;
+    }
+    return cert;
 }
 
 /**
@@ -786,64 +834,70 @@
  *
  * @return *X509 or on error NULL is returned
  */
-X509 * hip_cert_pem_to_x509(char * pem) {
-        int err = 0;
-        BIO *out = NULL; 
-        X509 * cert = NULL;
-
-        _HIP_DEBUG("PEM:\n%s\nLength of PEM %d\n", pem, strlen(pem));        
-        out = BIO_new_mem_buf(pem, -1);      
-        HIP_IFEL((NULL == (cert = PEM_read_bio_X509(out, NULL, 0, NULL))), -1,
-                 "Cert variable is NULL\n");
- out_err:
-
-        if (out) 
-       { 
-               err = BIO_flush(out); 
-               err = 0; /* We are not interested in the return value here */
-       }
-       if (err == -1) return NULL;
-        return cert;
+X509 *hip_cert_pem_to_x509(char *pem)
+{
+    int err    = 0;
+    BIO *out   = NULL;
+    X509 *cert = NULL;
+
+    _HIP_DEBUG("PEM:\n%s\nLength of PEM %d\n", pem, strlen(pem));
+    out = BIO_new_mem_buf(pem, -1);
+    HIP_IFEL((NULL == (cert = PEM_read_bio_X509(out, NULL, 0, NULL))), -1,
+             "Cert variable is NULL\n");
+out_err:
+
+    if (out) {
+        err = BIO_flush(out);
+        err = 0;         /* We are not interested in the return value here */
+    }
+    if (err == -1) {
+        return NULL;
+    }
+    return cert;
 }
- 
+
 /**
  * hip_cert_read_conf_section - Function that reads configuration
  * section from HIP_CERT_CONF_PATH,
  *
  * @param section_name a char pointer pointing to the name of the section to 
be retrieved
- * @param conf pointer to CONF struct that will point to the default 
configuration 
- *
- * @return STACK_OF(CONF_VALUE) pointer if ok and NULL if error or 
unsuccesfull. 
- *
- * @note Remember to open the conf first with hip_cert_open_conf and after 
done close 
+ * @param conf pointer to CONF struct that will point to the default 
configuration
+ *
+ * @return STACK_OF(CONF_VALUE) pointer if ok and NULL if error or 
unsuccesfull.
+ *
+ * @note Remember to open the conf first with hip_cert_open_conf and after 
done close
  *       the conf with the hip_cert_free_conf
- * 
+ *
  */
-STACK_OF(CONF_VALUE) * hip_cert_read_conf_section(char * section_name, CONF * 
conf) {
-       long err = 0;
-       int i; 
-       STACK_OF(CONF_VALUE) * sec = NULL;
-       CONF_VALUE *item;
-       
-       _HIP_DEBUG("Started to read cert configuration file\n");
-
-       /* XXTODO conf is opened and reopened here why -Samu */
-       conf = NCONF_new(NCONF_default());
-       HIP_IFEL(!NCONF_load(conf, HIP_CERT_CONF_PATH, &err),
-                -1, "Error opening the configuration file");
-
-       HIP_IFEL(!(sec = NCONF_get_section(conf, section_name)), -1,
-                "Section %s was not in the configuration (%s)\n", 
-                 section_name,HIP_CERT_CONF_PATH);
-
-       for (i = 0; i < sk_CONF_VALUE_num(sec); i++) {
-               item = (void*)sk_CONF_VALUE_value(sec, i);
-               _HIP_DEBUG("Sec: %s, Key; %s, Val %s\n", 
-                         item->section, item->name, item->value);
-       }
+STACK_OF(CONF_VALUE) * hip_cert_read_conf_section(char *section_name,
+                                                  CONF * conf)
+{
+    long err = 0;
+    int i;
+    STACK_OF(CONF_VALUE) * sec = NULL;
+    CONF_VALUE *item;
+
+    _HIP_DEBUG("Started to read cert configuration file\n");
+
+    /* XXTODO conf is opened and reopened here why -Samu */
+    conf = NCONF_new(NCONF_default());
+    HIP_IFEL(!NCONF_load(conf, HIP_CERT_CONF_PATH, &err),
+             -1, "Error opening the configuration file");
+
+    HIP_IFEL(!(sec = NCONF_get_section(conf, section_name)), -1,
+             "Section %s was not in the configuration (%s)\n",
+             section_name, HIP_CERT_CONF_PATH);
+
+    for (i = 0; i < sk_CONF_VALUE_num(sec); i++) {
+        item = (void *) sk_CONF_VALUE_value(sec, i);
+        _HIP_DEBUG("Sec: %s, Key; %s, Val %s\n",
+                   item->section, item->name, item->value);
+    }
 out_err:
-       if (err == -1) return NULL;
-       return sec;
+    if (err == -1) {
+        return NULL;
+    }
+    return sec;
 }
 
 /**
@@ -851,31 +905,37 @@
  *
  * @param void
  *
- * @return CONF pointer if ok and NULL if error or unsuccesfull. 
+ * @return CONF pointer if ok and NULL if error or unsuccesfull.
  */
-CONF * hip_cert_open_conf(void) {
-       long err = 0;
-       CONF *conf = NULL;
-       
-       _HIP_DEBUG("Started to read cert configuration file\n");
-
-       conf = NCONF_new(NCONF_default());
-       HIP_IFEL(!NCONF_load(conf, HIP_CERT_CONF_PATH, &err),
-                -1, "Error opening the configuration file");
+CONF *hip_cert_open_conf(void)
+{
+    long err   = 0;
+    CONF *conf = NULL;
+
+    _HIP_DEBUG("Started to read cert configuration file\n");
+
+    conf = NCONF_new(NCONF_default());
+    HIP_IFEL(!NCONF_load(conf, HIP_CERT_CONF_PATH, &err),
+             -1, "Error opening the configuration file");
 out_err:
-       if (err == -1) return NULL;
-       return conf;
+    if (err == -1) {
+        return NULL;
+    }
+    return conf;
 }
 
 /**
  * hip_cert_free_conf - Function that frees the memory of a allocated 
configuration
  *
- * @param CONF pointer to the to be freed configuration 
+ * @param CONF pointer to the to be freed configuration
  *
- * @return void 
+ * @return void
  */
-void hip_cert_free_conf(CONF * conf) {
-       if (conf) NCONF_free(conf);
+void hip_cert_free_conf(CONF *conf)
+{
+    if (conf) {
+        NCONF_free(conf);
+    }
 }
 
 /**
@@ -886,43 +946,43 @@
  * @param start will store the start point of the found substr
  * @param stop will store the end point of the found substr
  *
- * @return 0 if ok and negative if error. 
- * 
+ * @return 0 if ok and negative if error.
+ *
  * @note Be carefull with the what so you get what you want :)
  */
-int hip_cert_regex(char * what, char * from, int * start, int * stop) {
-        int err = 0, status = 0;
-        regex_t re;
-        regmatch_t answer[1];
-       
-       *start = *stop = 0;
-                
-        /* Compiling the regular expression */
-        HIP_IFEL(regcomp(&re, what, REG_EXTENDED), -1, 
-                 "Compilation of the regular expression failed\n");       
-        /* Running the regular expression */
-        // TODO this might need to be an error!?
-       // this needs to be separated to found, not found, and error -Samu
-        if ((status = regexec(&re, from, 1, answer, 0)))
-               {
-               _HIP_DEBUG("No match for regexp or failed to run it\n");
-               err = -1;
-               goto out_err;
-               }
-
-        _HIP_DEBUG("Found \"%s\" at %d and it ends at %d\n",
-                  what, answer[0].rm_so, answer[0].rm_eo); 
-
-        *start = answer[0].rm_so;
-        *stop = answer[0].rm_eo;
-
-        /* Just for debugging do NOT leave these 2 lines uncommented */
-        /*
-       int i = 0;
-        for (i = answer[0].rm_so; i < answer[0].rm_eo; i++) HIP_DEBUG("%c", 
from[i]);
-        HIP_DEBUG("\n");
-        */
- out_err:
-       regfree(&re);
-        return (err);
+int hip_cert_regex(char *what, char *from, int *start, int *stop)
+{
+    int err = 0, status = 0;
+    regex_t re;
+    regmatch_t answer[1];
+
+    *start = *stop = 0;
+
+    /* Compiling the regular expression */
+    HIP_IFEL(regcomp(&re, what, REG_EXTENDED), -1,
+             "Compilation of the regular expression failed\n");
+    /* Running the regular expression */
+    // TODO this might need to be an error!?
+    // this needs to be separated to found, not found, and error -Samu
+    if ((status = regexec(&re, from, 1, answer, 0))) {
+        _HIP_DEBUG("No match for regexp or failed to run it\n");
+        err = -1;
+        goto out_err;
+    }
+
+    _HIP_DEBUG("Found \"%s\" at %d and it ends at %d\n",
+               what, answer[0].rm_so, answer[0].rm_eo);
+
+    *start = answer[0].rm_so;
+    *stop  = answer[0].rm_eo;
+
+    /* Just for debugging do NOT leave these 2 lines uncommented */
+    /*
+     * int i = 0;
+     * for (i = answer[0].rm_so; i < answer[0].rm_eo; i++) HIP_DEBUG("%c", 
from[i]);
+     * HIP_DEBUG("\n");
+     */
+out_err:
+    regfree(&re);
+    return err;
 }

=== modified file 'lib/core/certtools.c.doxyme'
--- lib/core/certtools.c.doxyme 2010-01-19 09:28:42 +0000
+++ lib/core/certtools.c.doxyme 2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,118 +45,117 @@
 
 
 /**
- * hip_cert_der_to_x509 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_free_conf 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_open_conf 
+ * hip_cert_der_to_x509
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_free_conf
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_open_conf
  *
  *
  * @param void
- * @return 
- **/
-
-
-/**
- * hip_cert_pem_to_x509 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_regex 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_build_cert 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_char2certinfo 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_create_cert 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_inject 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_lib_verify 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_spki_send_to_verification 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_x509v3_request_certificate 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_cert_x509v3_request_verification 
- *
- *
- * @param autogen.sh
- * @return 
- **/
-
+ * @return
+ **/
+
+
+/**
+ * hip_cert_pem_to_x509
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_regex
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_build_cert
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_char2certinfo
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_create_cert
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_inject
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_lib_verify
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_spki_send_to_verification
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_x509v3_request_certificate
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/
+
+
+/**
+ * hip_cert_x509v3_request_verification
+ *
+ *
+ * @param autogen.sh
+ * @return
+ **/

=== modified file 'lib/core/certtools.h'
--- lib/core/certtools.h        2010-01-19 09:28:42 +0000
+++ lib/core/certtools.h        2010-02-10 23:55:24 +0000
@@ -3,7 +3,7 @@
 
 /** @file
  * A header file for certtools.c
- * 
+ *
  * Certificate building, parseing and verification functions.
  *
  * @author Samu Varjonen
@@ -32,7 +32,7 @@
 #include "hashtable.h"
 
 /** Defines **/
-#define HIP_CERT_CONF_PATH HIPL_SYSCONFDIR"hip_cert.cnf"
+#define HIP_CERT_CONF_PATH HIPL_SYSCONFDIR "hip_cert.cnf"
 
 /* Needed if the configuration file for certs did not exist  */
 #define HIP_CERT_INIT_DAYS 10
@@ -41,14 +41,14 @@
 
 /** Struct used to deliver the minimal needed information to build SPKI cert 
**/
 struct hip_cert_spki_info {
-       hip_tlv_type_t    type;
-       hip_tlv_len_t     length;
-       char public_key[768];
-       char cert[224];
-       char signature[768];
-        struct in6_addr issuer_hit;
-        /* 0 if succesfully verified otherwise negative */
-        uint32_t success;
+    hip_tlv_type_t  type;
+    hip_tlv_len_t   length;
+    char            public_key[768];
+    char            cert[224];
+    char            signature[768];
+    struct in6_addr issuer_hit;
+    /* 0 if succesfully verified otherwise negative */
+    uint32_t        success;
 };
 
 /** SPKI cert related functions **/
@@ -60,18 +60,18 @@
 int hip_cert_spki_build_cert(struct hip_cert_spki_info *);
 int hip_cert_spki_inject(struct hip_cert_spki_info *, char *, char *);
 int hip_cert_spki_construct_keys(HIP_HASHTABLE *, hip_hit_t *, RSA *);
-int hip_cert_spki_char2certinfo(char *,struct hip_cert_spki_info *); 
+int hip_cert_spki_char2certinfo(char *, struct hip_cert_spki_info *);
 int hip_cert_spki_send_to_verification(struct hip_cert_spki_info *);
 
 /** x509v3 cert related functions **/
 int hip_cert_x509v3_request_certificate(struct in6_addr *, unsigned char *);
 int hip_cert_x509v3_request_verification(unsigned char *, int);
- 
+
 /** Utilitary functions **/
-X509 * hip_cert_der_to_x509(const unsigned char *, int);
-X509 * hip_cert_pem_to_x509(char *);
+X509 *hip_cert_der_to_x509(const unsigned char *, int);
+X509 *hip_cert_pem_to_x509(char *);
 STACK_OF(CONF_VALUE) * hip_cert_read_conf_section(char *, CONF *);
-CONF * hip_cert_open_conf(void); 
+CONF *hip_cert_open_conf(void);
 void hip_cert_free_conf(CONF *);
 int hip_cert_regex(char *, char *, int *, int *);
 

=== modified file 'lib/core/certtools.h.doxyme'
--- lib/core/certtools.h.doxyme 2010-01-19 09:28:42 +0000
+++ lib/core/certtools.h.doxyme 2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/certtools.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/common_defines.h'
--- lib/core/common_defines.h   2010-01-19 09:28:42 +0000
+++ lib/core/common_defines.h   2010-02-10 23:55:24 +0000
@@ -10,37 +10,37 @@
 #include <stdint.h>
 
 /* maximum packet size of a packet to be sent on the wire */
-#define MAX_PACKET_SIZE                1500
+#define MAX_PACKET_SIZE         1500
 
 /* see bug id 595
  *
  * @note if you want to make this smaller, you have to change also
  *       /proc/sys/net/ipv6/conf/default/mtu, but it will have a
  *       negative impact on non-HIP IPv6 connectivity. */
-#define MIN_HIP_MTU                    1280
+#define MIN_HIP_MTU             1280
 
 /* change this when support for a cipher with bigger block size is added */
-#define CIPHER_BLOCK_SIZE      AES_BLOCK_SIZE
+#define CIPHER_BLOCK_SIZE       AES_BLOCK_SIZE
 
 /* IP version translation from IPv4 to IPv6 takes another 20 bytes */
-#define IPV4_TO_IPV6           (sizeof(struct ip6_hdr) - sizeof(struct ip))
+#define IPV4_TO_IPV6            (sizeof(struct ip6_hdr) - sizeof(struct ip))
 
 /* max. ESP padding as defined in RFC ???
  *
  * @note this allows to hide the actual payload length */
-#define MAX_ESP_PADDING                255
+#define MAX_ESP_PADDING         255
 /* this is the the max. ESP padding as needed by the cipher
  *
  * @note calculated as max. block-size - 1 */
-#define CIPHER_ESP_PADDING     CIPHER_BLOCK_SIZE - 1
+#define CIPHER_ESP_PADDING      CIPHER_BLOCK_SIZE - 1
 /* in the max packet size case we don't want to use any padding
  * -> the payload should fill the whole last block */
-#define NO_ESP_PADDING         0
+#define NO_ESP_PADDING          0
 /* if we do IP version translation from IPv4 to IPv6 we get another 
IPV4_TO_IPV6
  * bytes. Consider this in the last block. */
-#define OPTIMAL_ESP_PADDING    CIPHER_BLOCK_SIZE - (IPV4_TO_IPV6 % 
CIPHER_BLOCK_SIZE)
+#define OPTIMAL_ESP_PADDING CIPHER_BLOCK_SIZE - (IPV4_TO_IPV6 % 
CIPHER_BLOCK_SIZE)
 /* change this if you want to use another padding */
-#define ESP_PADDING                    OPTIMAL_ESP_PADDING
+#define ESP_PADDING             OPTIMAL_ESP_PADDING
 
 /* overhead added by encapsulating the application packet in
  * an ESP packet
@@ -50,29 +50,27 @@
  * @note additional space for possible IP4 -> IPv6 conversion, UDP 
encapsulation,
  *       ESP header, max. initialization vector for a cipher, max. allowed 
padding,
  *       ESP tail, ESP authentication part */
-#define BEET_OVERHEAD          IPV4_TO_IPV6 \
-                                                       + sizeof(struct udphdr) 
+ sizeof(struct hip_esp) \
-                                                       + AES_BLOCK_SIZE + 
ESP_PADDING \
-                                                       + sizeof(struct 
hip_esp_tail) + EVP_MAX_MD_SIZE
+#define BEET_OVERHEAD           IPV4_TO_IPV6 \
+    + sizeof(struct udphdr) + sizeof(struct hip_esp) \
+    + AES_BLOCK_SIZE + ESP_PADDING \
+    + sizeof(struct hip_esp_tail) + EVP_MAX_MD_SIZE
 /* maximum allowed packet size coming from the application */
 
-#define HIP_MTU                                MAX_PACKET_SIZE - 
(BEET_OVERHEAD)
+#define HIP_MTU                 MAX_PACKET_SIZE - (BEET_OVERHEAD)
 
-#define HIP_HIT_DEV_MTU                HIP_MTU >= MIN_HIP_MTU ? HIP_MTU : 
MIN_HIP_MTU
+#define HIP_HIT_DEV_MTU         HIP_MTU >= MIN_HIP_MTU ? HIP_MTU : MIN_HIP_MTU
 
 
 /*********** ESP structures *************/
 
-struct hip_esp
-{
-       uint32_t esp_spi;
-       uint32_t esp_seq;
+struct hip_esp {
+    uint32_t esp_spi;
+    uint32_t esp_seq;
 } __attribute__ ((packed));
 
-struct hip_esp_tail
-{
-       uint8_t esp_padlen;
-       uint8_t esp_next;
+struct hip_esp_tail {
+    uint8_t esp_padlen;
+    uint8_t esp_next;
 } __attribute__ ((packed));
 
 #endif /* COMMON_DEFINES_H_ */

=== modified file 'lib/core/common_defines.h.doxyme'
--- lib/core/common_defines.h.doxyme    2010-01-19 09:28:42 +0000
+++ lib/core/common_defines.h.doxyme    2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/common_defines.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/debug.c'
--- lib/core/debug.c    2010-02-08 15:18:06 +0000
+++ lib/core/debug.c    2010-02-10 23:55:24 +0000
@@ -15,7 +15,7 @@
  * PERROR("socket");
  * HEXDUMP("foobar", data, len);
  *</pre>
- * 
+ *
  * Adjusting of log types and format dynamically. (there really should not be a
  * reason to call these in the code, because default settings should be
  * reasonable)
@@ -24,7 +24,7 @@
  * hip_set_logtype(LOGTYPE_STDERR); // set logging output to stderr
  * hip_set_logfmt(LOGFMT_SHORT);    // set short logging format
  *</pre>
- * 
+ *
  * @todo debug messages should not be compiled at all in a production release
  * @todo set_log{type|format}(XX_DEFAULT)
  * @todo locking (is it really needed?)
@@ -53,8 +53,8 @@
 
 /* must be in the same order as enum debug_level (straight mapping) */
 const int debug2syslog_map[] = { LOG_ALERT,
-                                LOG_ERR,
-                                LOG_INFO,
+                                 LOG_ERR,
+                                 LOG_INFO,
                                  LOG_DEBUG };
 
 /* must be in the same order as enum debug_level (straight mapping) */
@@ -66,137 +66,145 @@
  * here and it should not be used.
  */
 #ifdef CONFIG_HIP_DEBUG
-static enum logtype_t logtype = LOGTYPE_STDERR;
+static enum logtype_t logtype   = LOGTYPE_STDERR;
 #else
-static enum logtype_t logtype = LOGTYPE_SYSLOG;
+static enum logtype_t logtype   = LOGTYPE_SYSLOG;
 #endif /* CONFIG_HIP_DEBUG */
 
 #ifdef HIP_LOGFMT_LONG
-static enum logfmt_t logfmt = LOGFMT_LONG;
+static enum logfmt_t logfmt     = LOGFMT_LONG;
 #else
-static enum logfmt_t logfmt = LOGFMT_SHORT;
+static enum logfmt_t logfmt     = LOGFMT_SHORT;
 #endif /* HIP_LONGFMT */
 
 static enum logdebug_t logdebug = LOGDEBUG_ALL;
 
 /**
  * @brief Sets logging to stderr or syslog.
- * 
- * Defines where HIP daemon DEBUG, INFO, ERROR etc. messages are printed. 
- * 
+ *
+ * Defines where HIP daemon DEBUG, INFO, ERROR etc. messages are printed.
+ *
  * @param new_logtype the type of logging output, either LOGTYPE_STDERR or
  *                    LOGTYPE_SYSLOG
  */
-void hip_set_logtype(int new_logtype) {
-  logtype = new_logtype;
+void hip_set_logtype(int new_logtype)
+{
+    logtype = new_logtype;
 }
 
 /**
  * @brief Sets the formatting of log output.
  *
- * Defines whether the messages should include file name and line number or 
not. 
- * 
+ * Defines whether the messages should include file name and line number or 
not.
+ *
  * @param new_logfmt the format of the log output, either LOGFMT_SHORT or
  *                    LOGFMT_LONG
  */
-void hip_set_logfmt(int new_logfmt) {
-  logfmt = new_logfmt;
+void hip_set_logfmt(int new_logfmt)
+{
+    logfmt = new_logfmt;
 }
 
 /**
  * @brief Selects what logging messages to display.
- * 
+ *
  * @param new_logdebug either LOGDEBUG_ALL, LOGDEBUG_MEDIUM or LOGDEBUG_NONE
  * @return             always zero.
  */
-int hip_set_logdebug(int new_logdebug) {
-  logdebug = new_logdebug;
-  return 0;
+int hip_set_logdebug(int new_logdebug)
+{
+    logdebug = new_logdebug;
+    return 0;
 }
 
-
 /**
- * hip_set_auto_logdebug - The libraries read from hipd configuration file 
what 
+ * hip_set_auto_logdebug - The libraries read from hipd configuration file what
  *                          logging messages to display
  * @param name   pointer that contains the name of the hipd configuration file.
  * @return       zero on success, or negative error value on error.
  *
  */
-int hip_set_auto_logdebug(const char *cfile){
-       int err = 0, i, len;
-       FILE *hip_config = NULL; 
-
-       List list;
-       char *c, line[128], *fname, *args[64], *comment;
-
-       if (!strcmp(cfile, "default"))
-               fname = HIPL_CONFIG_FILE;
-       else
-         fname = (char *) cfile;
-
-       HIP_IFEL(!(hip_config = fopen(fname, "r")), -1, 
-                "Error: can't open config file %s.\n", fname);
-
-       while(err == 0 && fgets(line, sizeof(line), hip_config) != NULL) {
-
-               /* Remove whitespace */
-               c = line;
-               while (*c == ' ' || *c == '\t')
-                       c++;
-
-               /* Line is a comment or empty */
-               if (c[0] =='#' || c[0] =='\n' || c[0] == '\0')
-                       continue;
-
-               /* If line is not a "debug" command, skip it */
-               if (strncmp(c, "debug", 5))
-                       continue;
-
-               /* Terminate before (the first) trailing comment */
-               comment = strchr(c, '#');
-               if (comment)
-                       *comment = '\0';
-
-               /* replace \n with \0  */
-               c[strlen(c) - 1] = '\0';
-
-               /* split the line into an array of strings and feed it
-                  recursively to hipconf */
-               initlist(&list);
-               extractsubstrings(c, &list);
-               len = length(&list);
-               for(i = 0; i < len; i++) {
-                       /* the list is backwards ordered */
-                       args[len - i - 1] = getitem(&list, i);
-               }
-
-               if(len != 2)
-                 HIP_IFEL(1, -EINVAL, "Wrong amount of arguments. 
Usage:\ndebug all|medium|none\n");
-
-               if (!strcmp("all", args[1])) {
-                 HIP_IFEL(hip_set_logdebug(LOGDEBUG_ALL), -1, "Error setting 
the debug parameter.");
-                 HIP_INFO("Displaying all debugging messages\n");
-               } else if (!strcmp("medium", args[1])) {
-                 HIP_IFEL(hip_set_logdebug(LOGDEBUG_MEDIUM), -1, "Error 
setting the debug parameter.");
-                 HIP_INFO("Displaying ERROR and INFO debugging messages\n");
-               } else if (!strcmp("none", args[1])) {
-                 HIP_IFEL(hip_set_logdebug(LOGDEBUG_NONE), -1, "Error setting 
the debug parameter.");
-                 HIP_INFO("Displaying no debugging messages\n");
-               } else
-                 HIP_IFEL(1, -EINVAL, "Unknown argument\n");
-
-               destroy(&list);
-       }
-
- out_err:
-       if (hip_config)
-               fclose(hip_config);
-
-       return err;
-
+int hip_set_auto_logdebug(const char *cfile)
+{
+    int err          = 0, i, len;
+    FILE *hip_config = NULL;
+
+    List list;
+    char *c, line[128], *fname, *args[64], *comment;
+
+    if (!strcmp(cfile, "default")) {
+        fname = HIPL_CONFIG_FILE;
+    } else {
+        fname = (char *) cfile;
+    }
+
+    HIP_IFEL(!(hip_config = fopen(fname, "r")), -1,
+             "Error: can't open config file %s.\n", fname);
+
+    while (err == 0 && fgets(line, sizeof(line), hip_config) != NULL) {
+        /* Remove whitespace */
+        c = line;
+        while (*c == ' ' || *c == '\t') {
+            c++;
+        }
+
+        /* Line is a comment or empty */
+        if (c[0] == '#' || c[0] == '\n' || c[0] == '\0') {
+            continue;
+        }
+
+        /* If line is not a "debug" command, skip it */
+        if (strncmp(c, "debug", 5)) {
+            continue;
+        }
+
+        /* Terminate before (the first) trailing comment */
+        comment = strchr(c, '#');
+        if (comment) {
+            *comment = '\0';
+        }
+
+        /* replace \n with \0  */
+        c[strlen(c) - 1] = '\0';
+
+        /* split the line into an array of strings and feed it
+         * recursively to hipconf */
+        initlist(&list);
+        extractsubstrings(c, &list);
+        len = length(&list);
+        for (i = 0; i < len; i++) {
+            /* the list is backwards ordered */
+            args[len - i - 1] = getitem(&list, i);
+        }
+
+        if (len != 2) {
+            HIP_IFEL(1, -EINVAL, "Wrong amount of arguments. Usage:\ndebug 
all|medium|none\n");
+        }
+
+        if (!strcmp("all", args[1])) {
+            HIP_IFEL(hip_set_logdebug(LOGDEBUG_ALL), -1, "Error setting the 
debug parameter.");
+            HIP_INFO("Displaying all debugging messages\n");
+        } else if (!strcmp("medium", args[1])) {
+            HIP_IFEL(hip_set_logdebug(LOGDEBUG_MEDIUM), -1, "Error setting the 
debug parameter.");
+            HIP_INFO("Displaying ERROR and INFO debugging messages\n");
+        } else if (!strcmp("none", args[1])) {
+            HIP_IFEL(hip_set_logdebug(LOGDEBUG_NONE), -1, "Error setting the 
debug parameter.");
+            HIP_INFO("Displaying no debugging messages\n");
+        } else {
+            HIP_IFEL(1, -EINVAL, "Unknown argument\n");
+        }
+
+        destroy(&list);
+    }
+
+out_err:
+    if (hip_config) {
+        fclose(hip_config);
+    }
+
+    return err;
 }
 
-
 /**
  * hip_handle_log_error - handle errors generated by log handling
  * @param logtype the type of the log that generated the error (LOGTYPE_STDERR 
or
@@ -206,14 +214,15 @@
  * be to e.g. exit).
  *
  */
-void hip_handle_log_error(int logtype) {
-  fprintf(stderr, "log (type=%d) failed, ignoring\n", logtype);
+void hip_handle_log_error(int logtype)
+{
+    fprintf(stderr, "log (type=%d) failed, ignoring\n", logtype);
 }
 
 /**
  * hip_vlog - "multiplexer" for correctly outputting all debug messages
  * @param debug_level the urgency of the message (DEBUG_LEVEL_XX)
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param fmt the output format of the debug message as in printf(3)
@@ -223,73 +232,81 @@
  * debugging functions.
  */
 void hip_vlog(int debug_level, const char *file, const int line,
-             const char *function, const char *fmt, va_list args) {
-  char syslog_msg[DEBUG_MSG_MAX_LEN] = "";
-  int syslog_level = debug2syslog_map[debug_level];
-  char prefix[DEBUG_PREFIX_MAX] = "\0";
-  int printed = 0;
+              const char *function, const char *fmt, va_list args)
+{
+    char syslog_msg[DEBUG_MSG_MAX_LEN] = "";
+    int syslog_level                   = debug2syslog_map[debug_level];
+    char prefix[DEBUG_PREFIX_MAX]      = "\0";
+    int printed                        = 0;
 
-  if (logfmt == LOGFMT_LONG) {
-    /* note: printed is not absolutely necessary to check in this case;
-       worst case is that filename or line number could be shortened */
-    printed = snprintf(prefix, DEBUG_PREFIX_MAX, "%s(%s:%d@%s)",
-                      debug_prefix[debug_level], file, line, function);
-  } else {
-    /* LOGFMT_SHORT: no prefix */
-  }
-    
-  switch(logtype) {
-  case LOGTYPE_NOLOG:
-    break;
-  case LOGTYPE_STDERR:
-    if (strlen(prefix) > 0) {
-      printed = fprintf(stderr, "%s: ", prefix);
-      if (printed < 0)
-       goto err;
+    if (logfmt == LOGFMT_LONG) {
+        /* note: printed is not absolutely necessary to check in this case;
+         * worst case is that filename or line number could be shortened */
+        printed = snprintf(prefix, DEBUG_PREFIX_MAX, "%s(%s:%d@%s)",
+                           debug_prefix[debug_level], file, line, function);
     } else {
-      /* LOGFMT_SHORT: no prefix */
-    }
-
-    printed = vfprintf(stderr, fmt, args);
-    if (printed < 0)
-      goto err;
-    break;
-  case LOGTYPE_SYSLOG:
-    openlog(NULL, SYSLOG_OPT, SYSLOG_FACILITY);
-    printed = vsnprintf(syslog_msg, DEBUG_MSG_MAX_LEN, fmt, args);
-    syslog(syslog_level|SYSLOG_FACILITY, "%s %s", prefix, syslog_msg);
-    /* the result of vsnprintf depends on glibc version; handle them both
-       (note about barriers: printed has \0 excluded,
-       DEBUG_MSG_MAX_LEN has \0 included) */
-    if (printed < 0 || printed > DEBUG_MSG_MAX_LEN - 1) {
-      syslog(syslog_level|SYSLOG_FACILITY,
-            "%s", "previous msg was truncated!!!");
-    }
-    closelog();
-    break;
-  default:
-    printed = fprintf(stderr, "hip_vlog(): undefined logtype: %d", logtype);
-    exit(1);
-  }
-
-  /* logging was succesful */
-  return;
-
- err:
-  hip_handle_log_error(logtype);
-
+        /* LOGFMT_SHORT: no prefix */
+    }
+
+    switch (logtype) {
+    case LOGTYPE_NOLOG:
+        break;
+    case LOGTYPE_STDERR:
+        if (strlen(prefix) > 0) {
+            printed = fprintf(stderr, "%s: ", prefix);
+            if (printed < 0) {
+                goto err;
+            }
+        } else {
+            /* LOGFMT_SHORT: no prefix */
+        }
+
+        printed = vfprintf(stderr, fmt, args);
+        if (printed < 0) {
+            goto err;
+        }
+        break;
+    case LOGTYPE_SYSLOG:
+        openlog(NULL, SYSLOG_OPT, SYSLOG_FACILITY);
+        printed = vsnprintf(syslog_msg, DEBUG_MSG_MAX_LEN, fmt, args);
+        syslog(syslog_level | SYSLOG_FACILITY, "%s %s", prefix, syslog_msg);
+        /* the result of vsnprintf depends on glibc version; handle them both
+         * (note about barriers: printed has \0 excluded,
+         * DEBUG_MSG_MAX_LEN has \0 included) */
+        if (printed < 0 || printed > DEBUG_MSG_MAX_LEN - 1) {
+            syslog(syslog_level | SYSLOG_FACILITY,
+                   "%s", "previous msg was truncated!!!");
+        }
+        closelog();
+        break;
+    default:
+        printed = fprintf(stderr, "hip_vlog(): undefined logtype: %d", 
logtype);
+        exit(1);
+    }
+
+    /* logging was succesful */
+    return;
+
+err:
+    hip_handle_log_error(logtype);
 }
 
-void hip_print_str(int debug_level, const char *file, int line, const char 
*function, const char *fmt, ...)
+void hip_print_str(int debug_level,
+                   const char *file,
+                   int line,
+                   const char *function,
+                   const char *fmt,
+                   ...)
 {
-       va_list args;
-       va_start(args, fmt);
-       if ((debug_level == DEBUG_LEVEL_INFO && logdebug != LOGDEBUG_NONE) ||
-           (debug_level == DEBUG_LEVEL_DEBUG && logdebug == LOGDEBUG_ALL) ||
-           (debug_level == DEBUG_LEVEL_ERROR && logdebug != LOGDEBUG_NONE) ||
-           (debug_level == DEBUG_LEVEL_DIE))
-         hip_vlog(debug_level, file, line, function, fmt, args);
-       va_end(args);
+    va_list args;
+    va_start(args, fmt);
+    if ((debug_level == DEBUG_LEVEL_INFO && logdebug != LOGDEBUG_NONE) ||
+        (debug_level == DEBUG_LEVEL_DEBUG && logdebug == LOGDEBUG_ALL) ||
+        (debug_level == DEBUG_LEVEL_ERROR && logdebug != LOGDEBUG_NONE) ||
+        (debug_level == DEBUG_LEVEL_DIE)) {
+        hip_vlog(debug_level, file, line, function, fmt, args);
+    }
+    va_end(args);
 }
 
 /**
@@ -300,7 +317,7 @@
  *                than the current debug level.
  * @param debug_group the debug group which has to be matched
  * @param debug_level the debug level of the debug output
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param fmt the output format of the debug message as in printf(3)
@@ -310,21 +327,22 @@
  * use the HIP_DEBUG_GL macro instead.
  */
 void hip_debug_gl(int debug_group, int debug_level,
-            const char *file, int line,
-            const char *function, const char *fmt, ...) {
-       if(debug_level <= HIP_DEBUG_LEVEL && 
-       (HIP_DEBUG_GROUP == HIP_DEBUG_GROUP_ALL ||
-        debug_group == HIP_DEBUG_GROUP) && logdebug == LOGDEBUG_ALL) {
-               va_list args;
-               va_start(args, fmt);
-               hip_vlog(DEBUG_LEVEL_DEBUG, file, line, function, fmt, args);
-               va_end(args);
-       }
+                  const char *file, int line,
+                  const char *function, const char *fmt, ...)
+{
+    if (debug_level <= HIP_DEBUG_LEVEL &&
+        (HIP_DEBUG_GROUP == HIP_DEBUG_GROUP_ALL ||
+         debug_group == HIP_DEBUG_GROUP) && logdebug == LOGDEBUG_ALL) {
+        va_list args;
+        va_start(args, fmt);
+        hip_vlog(DEBUG_LEVEL_DEBUG, file, line, function, fmt, args);
+        va_end(args);
+    }
 }
 
 /**
  * hip_die - output a fatal error and exit
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param fmt the output format of the debug message as in printf(3)
@@ -334,18 +352,18 @@
  * use the HIP_DIE macro instead.
  */
 void hip_die(const char *file, int line, const char *function,
-            const char *fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  hip_print_str(DEBUG_LEVEL_DIE, file, line, function, fmt, args);
-  va_end(args);
-  exit(1);
+             const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    hip_print_str(DEBUG_LEVEL_DIE, file, line, function, fmt, args);
+    va_end(args);
+    exit(1);
 }
 
-
 /**
  * hip_error - output an error message (high level)
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param fmt the output format of the debug message as in printf(3)
@@ -355,18 +373,19 @@
  * use the HIP_ERROR macro instead.
  */
 void hip_error(const char *file, int line, const char *function,
-              const char *fmt, ...) {
-  if ( logdebug != LOGDEBUG_NONE ){
-       va_list args;
-       va_start(args, fmt);
-       hip_vlog(DEBUG_LEVEL_ERROR, file, line, function, fmt, args);
-       va_end(args);
-  }
+               const char *fmt, ...)
+{
+    if (logdebug != LOGDEBUG_NONE) {
+        va_list args;
+        va_start(args, fmt);
+        hip_vlog(DEBUG_LEVEL_ERROR, file, line, function, fmt, args);
+        va_end(args);
+    }
 }
 
 /**
  * hip_perror_wrapper - a wrapper for perror(3) style calls
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param s the string as in perror(3)
@@ -376,16 +395,17 @@
  * debug module, use the HIP_PERROR macro instead.
  */
 void hip_perror_wrapper(const char *file, int line, const char *function,
-                       const char *s) {
-       hip_error(file, line, function, "%s%s\n", s, strerror(errno));
+                        const char *s)
+{
+    hip_error(file, line, function, "%s%s\n", s, strerror(errno));
 }
 
 /**
  * Prints a hexdump starting from address @c str of length @c len. Do not call
  * this function from the outside of the debug module, use the HIP_HEXDUMP 
macro
  * instead.
- * 
- * @param file     the file from where the debug call was made        
+ *
+ * @param file     the file from where the debug call was made
  * @param line     the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param prefix   the prefix string will printed before the hexdump
@@ -393,185 +413,186 @@
  * @param len      the length of the data to be hexdumped
  */
 void hip_hexdump(const char *file, int line, const char *function,
-                const char *prefix, const void *str, int len) {
-  int hexdump_max_size = 0;
-  int hexdump_count = 0;
-  char *hexdump = NULL;
-  int hexdump_written = 0;
-  int hexdump_index = 0;
-  int char_index = 0;
-
-  hexdump_max_size = len * 2 + 1;
-  hexdump_count = hexdump_max_size;
-
-  hexdump = (char *) calloc(hexdump_max_size, sizeof(char));
-  if (hexdump == NULL) {
-    HIP_DIE("hexdump memory allocation failed\n");
-  }
-  if(len == 0){
-         /* Removed this error message to keep hexdump quiet in 
-            HIP_DUMP_MSG for zero length padding. Lauri 22.09.2006 */
-         //HIP_ERROR("hexdump length was 0\n");  
-  }else{
-       do {
-       /* note: if you change the printing format, adjust also hexdump_count! 
*/
-       hexdump_written = snprintf((char *) (hexdump + hexdump_index),
-                               hexdump_count, "%02x",
-                       (unsigned char)(*(((unsigned char *)str) + 
char_index)));
-       if (hexdump_written < 0 || hexdump_written > hexdump_max_size - 1) {
-       free(hexdump);
-       HIP_DIE("hexdump msg too long(%d)", hexdump_written);
-       } else {
-       hexdump_count -= hexdump_written;
-       HIP_ASSERT(hexdump_count >=0);
-       hexdump_index += hexdump_written;
-       HIP_ASSERT(hexdump_index + hexdump_count == hexdump_max_size);
-       }
-       char_index++;
-       } while(char_index < len);
-       
-       hip_print_str(DEBUG_LEVEL_DEBUG, file, line, function, "%s0x%s\n", 
prefix, hexdump);
-  }
-
-  free(hexdump);
-
+                 const char *prefix, const void *str, int len)
+{
+    int hexdump_max_size = 0;
+    int hexdump_count    = 0;
+    char *hexdump        = NULL;
+    int hexdump_written  = 0;
+    int hexdump_index    = 0;
+    int char_index       = 0;
+
+    hexdump_max_size = len * 2 + 1;
+    hexdump_count    = hexdump_max_size;
+
+    hexdump          = (char *) calloc(hexdump_max_size, sizeof(char));
+    if (hexdump == NULL) {
+        HIP_DIE("hexdump memory allocation failed\n");
+    }
+    if (len == 0) {
+        /* Removed this error message to keep hexdump quiet in
+         * HIP_DUMP_MSG for zero length padding. Lauri 22.09.2006 */
+        //HIP_ERROR("hexdump length was 0\n");
+    } else {
+        do {
+            /* note: if you change the printing format, adjust also 
hexdump_count! */
+            hexdump_written
+                    = snprintf((char *) (hexdump + hexdump_index),
+                               hexdump_count,
+                               "%02x",
+                               (unsigned char) (*(((unsigned char *) str)
+                                       + char_index)));
+            if (hexdump_written < 0 || hexdump_written > hexdump_max_size - 1) 
{
+                free(hexdump);
+                HIP_DIE("hexdump msg too long(%d)", hexdump_written);
+            } else {
+                hexdump_count -= hexdump_written;
+                HIP_ASSERT(hexdump_count >= 0);
+                hexdump_index += hexdump_written;
+                HIP_ASSERT(hexdump_index + hexdump_count == hexdump_max_size);
+            }
+            char_index++;
+        } while (char_index < len);
+
+        hip_print_str(DEBUG_LEVEL_DEBUG, file, line, function, "%s0x%s\n", 
prefix, hexdump);
+    }
+
+    free(hexdump);
 }
 
-
 /**
  * Example of the output:
  * 13 88 94 64 0d b9 89 ff f3 cc 4c a1 80 11 05 94 ...d......L.....
  * 6c 3c 00 00 01 01 08 0a 00 10 a2 58 00 0f 98 30 l<.........X....
  */
 int hip_hexdump_parsed(const char *file, int line, const char *function,
-                const char *prefix, const void *str, int len) 
+                       const char *prefix, const void *str, int len)
 {
-       int hexdump_total_size = 0;
-       int hexdump_count = 0;
-       int hexdump_written = 0;
-       int hexdump_index = 0;
-       int char_index = 0;
-       char *hexdump = NULL;
-       
-       int bytes_per_line = 16;
-       char space = ' ';
-       char nonascii = '.';
-       char * asciidump = NULL;
-       int lines = 0;
-       int line_index = 0;
-       
-       int pad_length = 0;
-       int pad_start_position = 0;
-
-       // Count lines
-       if (len % 16 == 0)
-               lines = (int) len / 16;
-       else 
-               lines = (int) len / 16 + 1;     
-       
-       hexdump_total_size = lines * 4 * bytes_per_line + 1; // one byte 
requires 4 bytes in the output (two for hex, one for ascii and one space)
-       pad_start_position = len * 3 + ((lines - 1) * bytes_per_line) + 1;
-       hexdump_count = hexdump_total_size;
-       pad_length = (hexdump_total_size - bytes_per_line) - pad_start_position;
-
-       hexdump = (char *) calloc(hexdump_total_size, sizeof(char));
-       asciidump = (char *) calloc((bytes_per_line + 2), sizeof(char));
-
-       _HIP_DEBUG("hexdump_total_size: %d, pad_start_position: %d, pad_length: 
%d\n", 
-               hexdump_total_size, pad_start_position, pad_length);
-       if (hexdump == NULL || asciidump == NULL) {
-       HIP_DIE("memory allocation failed\n");
-       }
-       
-       if(len > 0) {
-               while(char_index < len) {
-                       
-                       // Write the character in hex
-                       hexdump_written = snprintf((char *) (hexdump + 
hexdump_index),
-                               hexdump_count, "%02x", (unsigned 
char)(*(((unsigned char *)str) + char_index)));
-                       if (hexdump_written < 0 || hexdump_written > 
hexdump_total_size - 1) {
-                               free(hexdump);
-                               HIP_DIE("hexdump msg too long(%d)", 
hexdump_written);
-                       } 
-                       char written = (unsigned char)(*(((unsigned char *)str) 
+ char_index));
-                       
-                       // Write space between          
-                       hexdump_index += hexdump_written;
-                       hexdump_count -= hexdump_written;
-                       hexdump_written = snprintf((char *) (hexdump + 
hexdump_index),
-                                       hexdump_count, "%c", space);
-                       if (hexdump_written < 0 || hexdump_written > 
hexdump_total_size - 1) {
-                               free(hexdump);
-                               free(asciidump);
-                               HIP_DIE("hexdump msg too long(%d)", 
hexdump_written);
-                       }
-                       hexdump_count -= hexdump_written;
-                       HIP_ASSERT(hexdump_count >=0);
-                       hexdump_index += hexdump_written;
-                       HIP_ASSERT(hexdump_index + hexdump_count == 
hexdump_total_size);
-                       
-                       // Wite the character in ascii to asciidump line        
-                       if (written > 32 && written < 127)
-                               memset(asciidump + line_index, written, 1);
-                       else    
-                               memset(asciidump + line_index, nonascii, 1);
-                       line_index++;
-                       /* If line is full or input is all read, copy data to 
hexdump */
-                       if (line_index >= 16 || (char_index + 1) == len) {
-                               // Add padding
-                               _HIP_DEBUG("Line ready\n");
-                               if ((char_index + 1) == len && pad_length > 0
-                                       && ((hexdump_index + line_index + 
pad_length) < hexdump_total_size)) 
-                               {
-                                       char * padding = (char *) 
calloc(pad_length + 1, sizeof(char));
-                                       _HIP_DEBUG("Creating padding for the 
last line... \n");
-                                       _HIP_DEBUG("hexdump_index: %d, 
line_index: %d\n", hexdump_index, line_index);
-                                       memset(padding, ' ', pad_length);
-                                       memset(padding + pad_length, '\0', 1);
-                                       hexdump_written = snprintf((char *) 
(hexdump + hexdump_index), 
-                                               hexdump_count, "%s", padding);
-                                       if (hexdump_written < 0 || 
hexdump_written > hexdump_total_size - 1) {
-                                               free(hexdump);
-                                               free(asciidump);
-                                               free(padding);
-                                               HIP_DIE("hexdump msg too 
long(%d)", hexdump_written);
-                                       }
-                                       hexdump_index += hexdump_written;
-                                       hexdump_count -= hexdump_written;
-                                       free(padding);
-                               }
-                               memset(asciidump + line_index, '\n', 1);
-                               memset(asciidump + line_index + 1, '\0', 1);
-                               hexdump_written = snprintf((char *) (hexdump + 
hexdump_index), 
-                                       hexdump_count, "%s", asciidump);
-                               if (hexdump_written < 0 || hexdump_written > 
hexdump_total_size - 1) {
-                                       free(hexdump);
-                                       free(asciidump);
-                                       HIP_DIE("hexdump msg too long(%d)", 
hexdump_written);
-                               }
-                               hexdump_index += hexdump_written;
-                               hexdump_count -= hexdump_written;
-                               line_index = 0;
-                               memset(asciidump, 0, bytes_per_line + 2);
-                       }
-                       char_index++;
-               } 
-               hip_print_str(DEBUG_LEVEL_DEBUG, file, line, function, 
"%s%s\n", prefix, hexdump);
-       }
-       else {
-         HIP_ERROR("hexdump length was 0\n");  
-       }
-       
-       free(hexdump);
-       free(asciidump);
-
-       return 0;
+    int hexdump_total_size = 0;
+    int hexdump_count      = 0;
+    int hexdump_written    = 0;
+    int hexdump_index      = 0;
+    int char_index         = 0;
+    char *hexdump          = NULL;
+
+    int bytes_per_line     = 16;
+    char space             = ' ';
+    char nonascii          = '.';
+    char *asciidump        = NULL;
+    int lines              = 0;
+    int line_index         = 0;
+
+    int pad_length         = 0;
+    int pad_start_position = 0;
+
+    // Count lines
+    if (len % 16 == 0) {
+        lines = (int) len / 16;
+    } else {
+        lines = (int) len / 16 + 1;
+    }
+
+    // one byte requires 4 bytes in the output (two for hex, one for ascii and 
one space)
+    hexdump_total_size = lines * 4 * bytes_per_line + 1;
+    pad_start_position = len * 3 + ((lines - 1) * bytes_per_line) + 1;
+    hexdump_count      = hexdump_total_size;
+    pad_length         = (hexdump_total_size - bytes_per_line) - 
pad_start_position;
+
+    hexdump            = (char *) calloc(hexdump_total_size, sizeof(char));
+    asciidump          = (char *) calloc((bytes_per_line + 2), sizeof(char));
+
+    _HIP_DEBUG("hexdump_total_size: %d, pad_start_position: %d, pad_length: 
%d\n",
+               hexdump_total_size, pad_start_position, pad_length);
+    if (hexdump == NULL || asciidump == NULL) {
+        HIP_DIE("memory allocation failed\n");
+    }
+
+    if (len > 0) {
+        while (char_index < len) {
+            // Write the character in hex
+            hexdump_written = snprintf((char *) (hexdump + hexdump_index),
+                                       hexdump_count, "%02x", (unsigned char) 
(*(((unsigned char *) str) + char_index)));
+            if (hexdump_written < 0 || hexdump_written > hexdump_total_size - 
1) {
+                free(hexdump);
+                HIP_DIE("hexdump msg too long(%d)", hexdump_written);
+            }
+            char written = (unsigned char) (*(((unsigned char *) str) + 
char_index));
+
+            // Write space between
+            hexdump_index  += hexdump_written;
+            hexdump_count  -= hexdump_written;
+            hexdump_written = snprintf((char *) (hexdump + hexdump_index),
+                                       hexdump_count, "%c", space);
+            if (hexdump_written < 0 || hexdump_written > hexdump_total_size - 
1) {
+                free(hexdump);
+                free(asciidump);
+                HIP_DIE("hexdump msg too long(%d)", hexdump_written);
+            }
+            hexdump_count -= hexdump_written;
+            HIP_ASSERT(hexdump_count >= 0);
+            hexdump_index += hexdump_written;
+            HIP_ASSERT(hexdump_index + hexdump_count == hexdump_total_size);
+
+            // Wite the character in ascii to asciidump line
+            if (written > 32 && written < 127) {
+                memset(asciidump + line_index, written, 1);
+            } else {
+                memset(asciidump + line_index, nonascii, 1);
+            }
+            line_index++;
+            /* If line is full or input is all read, copy data to hexdump */
+            if (line_index >= 16 || (char_index + 1) == len) {
+                // Add padding
+                _HIP_DEBUG("Line ready\n");
+                if ((char_index + 1) == len && pad_length > 0
+                    && ((hexdump_index + line_index + pad_length) < 
hexdump_total_size)) {
+                    char *padding = (char *) calloc(pad_length + 1, 
sizeof(char));
+                    _HIP_DEBUG("Creating padding for the last line... \n");
+                    _HIP_DEBUG("hexdump_index: %d, line_index: %d\n", 
hexdump_index, line_index);
+                    memset(padding, ' ', pad_length);
+                    memset(padding + pad_length, '\0', 1);
+                    hexdump_written = snprintf((char *) (hexdump + 
hexdump_index),
+                                               hexdump_count, "%s", padding);
+                    if (hexdump_written < 0 || hexdump_written > 
hexdump_total_size - 1) {
+                        free(hexdump);
+                        free(asciidump);
+                        free(padding);
+                        HIP_DIE("hexdump msg too long(%d)", hexdump_written);
+                    }
+                    hexdump_index += hexdump_written;
+                    hexdump_count -= hexdump_written;
+                    free(padding);
+                }
+                memset(asciidump + line_index, '\n', 1);
+                memset(asciidump + line_index + 1, '\0', 1);
+                hexdump_written = snprintf((char *) (hexdump + hexdump_index),
+                                           hexdump_count, "%s", asciidump);
+                if (hexdump_written < 0 || hexdump_written > 
hexdump_total_size - 1) {
+                    free(hexdump);
+                    free(asciidump);
+                    HIP_DIE("hexdump msg too long(%d)", hexdump_written);
+                }
+                hexdump_index += hexdump_written;
+                hexdump_count -= hexdump_written;
+                line_index     = 0;
+                memset(asciidump, 0, bytes_per_line + 2);
+            }
+            char_index++;
+        }
+        hip_print_str(DEBUG_LEVEL_DEBUG, file, line, function, "%s%s\n", 
prefix, hexdump);
+    } else {
+        HIP_ERROR("hexdump length was 0\n");
+    }
+
+    free(hexdump);
+    free(asciidump);
+
+    return 0;
 }
 
-
 /**
  * hip_print_sockaddr - print a socket address structure
- * @param file the file from where the debug call was made        
+ * @param file the file from where the debug call was made
  * @param line the line of the debug call in the source file
  * @param function the name of function where the debug call is located
  * @param prefix the prefix string will printed before the sockaddr
@@ -580,146 +601,148 @@
  *
  * Do not call this function from the outside of the debug module, use the
  * HIP_DEBUG_SOCKADDR macro instead. Currently this function supports
- * only INET and INET6 addresses. 
+ * only INET and INET6 addresses.
  */
 void hip_print_sockaddr(const char *file, int line, const char *function,
-                       const char *prefix,
-                       const struct sockaddr *sockaddr) {
-      char *default_str = "<unknown>";
-      int maxlen;
-      void *addr;
-      int family = sockaddr->sa_family;
-      char addr_str[INET6_ADDRSTRLEN+1];
-      
-      switch (family) {
-      case AF_INET:
-       maxlen = INET_ADDRSTRLEN;
-       addr = &(((struct sockaddr_in *) sockaddr)->sin_addr);
-       break;
-      case AF_INET6:
-       maxlen = INET6_ADDRSTRLEN;
-       addr = &(((struct sockaddr_in6 *) sockaddr)->sin6_addr);
-       break;
-      default:
-       maxlen = 0;
-      }
-      
-      if (maxlen == 0) {
-       memcpy(addr_str, default_str, strlen(default_str) + 1);
-      } else {
-       if (!inet_ntop(family, addr, addr_str, maxlen)) {
-         HIP_ERROR("inet_ntop");
-         return;
-       }
-      }
-      if (prefix)
-       HIP_DEBUG("%s: %s\n", prefix, addr_str);
-      else
-       HIP_DEBUG("%s\n", addr_str);
+                        const char *prefix,
+                        const struct sockaddr *sockaddr)
+{
+    char *default_str = "<unknown>";
+    int maxlen;
+    void *addr;
+    int family        = sockaddr->sa_family;
+    char addr_str[INET6_ADDRSTRLEN + 1];
+
+    switch (family) {
+    case AF_INET:
+        maxlen = INET_ADDRSTRLEN;
+        addr   = &(((struct sockaddr_in *) sockaddr)->sin_addr);
+        break;
+    case AF_INET6:
+        maxlen = INET6_ADDRSTRLEN;
+        addr   = &(((struct sockaddr_in6 *) sockaddr)->sin6_addr);
+        break;
+    default:
+        maxlen = 0;
+    }
+
+    if (maxlen == 0) {
+        memcpy(addr_str, default_str, strlen(default_str) + 1);
+    } else {
+        if (!inet_ntop(family, addr, addr_str, maxlen)) {
+            HIP_ERROR("inet_ntop");
+            return;
+        }
+    }
+    if (prefix) {
+        HIP_DEBUG("%s: %s\n", prefix, addr_str);
+    } else {
+        HIP_DEBUG("%s\n", addr_str);
+    }
 }
 
 void hip_print_lsi(int debug_level, const char *file, int line, const char 
*function,
-                  const char *str, const struct in_addr *lsi)
+                   const char *str, const struct in_addr *lsi)
 {
-       char dst[INET_ADDRSTRLEN];
-       inet_ntop(AF_INET, lsi, dst, sizeof(dst));
-       hip_print_str(debug_level, file, line, function, "%s: %s\n", str, dst);
+    char dst[INET_ADDRSTRLEN];
+    inet_ntop(AF_INET, lsi, dst, sizeof(dst));
+    hip_print_str(debug_level, file, line, function, "%s: %s\n", str, dst);
 }
+
 /**
  * hip_print_hit - print a HIT
  * @param str string to be printed before the HIT
  * @param hit the HIT to be printed
  */
 void hip_print_hit(int debug_level, const char *file, int line, const char 
*function,
-                  const char *str, const struct in6_addr *hit)
+                   const char *str, const struct in6_addr *hit)
 {
-       if(hit == NULL) {
-               HIP_DEBUG("%s: NULL\n", str);
-               return;
-       }
-       else {
-               char dst[INET6_ADDRSTRLEN];
-               
-               if (IN6_IS_ADDR_V4MAPPED(hit)) {
-                       struct in_addr in_addr;
-                       IPV6_TO_IPV4_MAP(hit, &in_addr);
-                       hip_print_lsi(debug_level, file, line, function, str, 
&in_addr);
-               } else {
-                       hip_in6_ntop(hit, dst);
-                       hip_print_str(debug_level, file, line, function, "%s: 
%s\n", str, dst);
-               }
-               return;
-       }
+    if (hit == NULL) {
+        HIP_DEBUG("%s: NULL\n", str);
+        return;
+    } else {
+        char dst[INET6_ADDRSTRLEN];
+
+        if (IN6_IS_ADDR_V4MAPPED(hit)) {
+            struct in_addr in_addr;
+            IPV6_TO_IPV4_MAP(hit, &in_addr);
+            hip_print_lsi(debug_level, file, line, function, str, &in_addr);
+        } else {
+            hip_in6_ntop(hit, dst);
+            hip_print_str(debug_level, file, line, function, "%s: %s\n", str, 
dst);
+        }
+        return;
+    }
 }
 
 /* THIS ONE WORKS -SAMU */
-void hip_print_locator_addresses(struct hip_common * in_msg) {
+void hip_print_locator_addresses(struct hip_common *in_msg)
+{
     struct hip_locator *locator;
-    struct hip_locator_info_addr_item *item = NULL;
+    struct hip_locator_info_addr_item *item   = NULL;
     struct hip_locator_info_addr_item2 *item2 = NULL;
-    char *address_pointer; 
-       
+    char *address_pointer;
+
     _HIP_DUMP_MSG(in_msg);
 
-    locator = hip_get_param((struct hip_common *)in_msg,
+    locator = hip_get_param((struct hip_common *) in_msg,
                             HIP_PARAM_LOCATOR);
-    if (locator) {     
-       address_pointer =(char*) (locator + 1);
-       
-       for(;address_pointer < ((char*)locator) + 
hip_get_param_contents_len(locator); ) {
-               if (((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type 
-                    == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
-                       item2 = (struct hip_locator_info_addr_item2 
*)address_pointer;
-                       HIP_DEBUG_HIT("LOCATOR", (struct in6_addr 
*)&item2->address);
-                       HIP_DEBUG("Locator address offset is %d\n", 
address_pointer - (char*) (locator + 1));
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item2);
-                }
-                else if(((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type 
-                        == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
-                       item = (struct hip_locator_info_addr_item 
*)address_pointer;
-                       HIP_DEBUG_HIT("LOCATOR", (struct in6_addr 
*)&item->address);
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                } 
-                else if(((struct 
hip_locator_info_addr_item*)address_pointer)->locator_type 
-                        == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
-                       item = (struct hip_locator_info_addr_item 
*)address_pointer;
-                       HIP_DEBUG_HIT("LOCATOR", (struct in6_addr 
*)&item->address);
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-                } 
-                else
-                        address_pointer += sizeof(struct 
hip_locator_info_addr_item);
-       }       
+    if (locator) {
+        address_pointer = (char *) (locator + 1);
+
+        for (; address_pointer < ((char *) locator) + 
hip_get_param_contents_len(locator); ) {
+            if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                == HIP_LOCATOR_LOCATOR_TYPE_UDP) {
+                item2            = (struct hip_locator_info_addr_item2 *) 
address_pointer;
+                HIP_DEBUG_HIT("LOCATOR", (struct in6_addr *) &item2->address);
+                HIP_DEBUG("Locator address offset is %d\n", address_pointer - 
(char *) (locator + 1));
+                address_pointer += sizeof(struct hip_locator_info_addr_item2);
+            } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                       == HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+                item             = (struct hip_locator_info_addr_item *) 
address_pointer;
+                HIP_DEBUG_HIT("LOCATOR", (struct in6_addr *) &item->address);
+                address_pointer += sizeof(struct hip_locator_info_addr_item);
+            } else if (((struct hip_locator_info_addr_item *) 
address_pointer)->locator_type
+                       == HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
+                item             = (struct hip_locator_info_addr_item *) 
address_pointer;
+                HIP_DEBUG_HIT("LOCATOR", (struct in6_addr *) &item->address);
+                address_pointer += sizeof(struct hip_locator_info_addr_item);
+            } else {
+                address_pointer += sizeof(struct hip_locator_info_addr_item);
+            }
+        }
     }
 }
 
 void hip_print_peer_addresses_to_be_added(hip_ha_t *entry)
 {
-       hip_list_t *item = NULL, *tmp = NULL;
-       struct hip_peer_addr_list_item *addr;
-       int i = 0;
-
-       HIP_DEBUG("All the addresses in the peer_addr_list_to_be_added 
list:\n");
-       if (entry->peer_addr_list_to_be_added == NULL)
-               return;
-
-        list_for_each_safe(item, tmp, entry->peer_addr_list_to_be_added, i)
-        {
-               addr = (struct hip_peer_addr_list_item *)list_entry(item);
-               HIP_DEBUG_HIT("Peer address", &addr->address);
-       }
+    hip_list_t *item = NULL, *tmp = NULL;
+    struct hip_peer_addr_list_item *addr;
+    int i            = 0;
+
+    HIP_DEBUG("All the addresses in the peer_addr_list_to_be_added list:\n");
+    if (entry->peer_addr_list_to_be_added == NULL) {
+        return;
+    }
+
+    list_for_each_safe(item, tmp, entry->peer_addr_list_to_be_added, i)
+    {
+        addr = (struct hip_peer_addr_list_item *) list_entry(item);
+        HIP_DEBUG_HIT("Peer address", &addr->address);
+    }
 }
 
 void hip_print_addresses_to_send_update_request(hip_ha_t *ha)
 {
-       hip_list_t *item = NULL, *tmp = NULL;
-       struct in6_addr *address;
-       int i = 0;
+    hip_list_t *item = NULL, *tmp = NULL;
+    struct in6_addr *address;
+    int i            = 0;
 
-       HIP_DEBUG("Addresses to send update:\n");
-        list_for_each_safe(item, tmp, ha->addresses_to_send_echo_request, i) {
-               address = (struct in6_addr *)list_entry(item);
-                HIP_DEBUG_IN6ADDR("", address);
-       }
+    HIP_DEBUG("Addresses to send update:\n");
+    list_for_each_safe(item, tmp, ha->addresses_to_send_echo_request, i) {
+        address = (struct in6_addr *) list_entry(item);
+        HIP_DEBUG_IN6ADDR("", address);
+    }
 }
 
 //add  by santtu
@@ -729,59 +752,53 @@
  * @param hit the HIT to be printed
  */
 void hip_print_locator(int debug_level, const char *file, int line, const char 
*function,
-                  const char *str, const struct hip_locator *locator)
+                       const char *str, const struct hip_locator *locator)
 {
-
 /* XXTRASHXX Totally useless does anything but what it is supposed to do -SAMU 
*/
 
-       int n_addrs = 0, i = 0;
-       struct hip_locator_info_addr_item *first_address_item = NULL, 
-               *locator_address_item = NULL;
-       struct hip_locator_info_addr_item2 * locator_address_item2 = NULL;
-          /* locator = hip_get_param((struct hip_common *)in_msg,
-       HIP_PARAM_LOCATOR);*/
-       if (locator) {
-               HIP_DEBUG("%s: \n", str);
-       
-       n_addrs = hip_get_locator_addr_item_count(locator);
-       HIP_DEBUG("there are  %d locator items \n", n_addrs);
-       first_address_item = hip_get_locator_first_addr_item(locator);
-                      
-       for (i = 0; i < n_addrs; i++) {
-               locator_address_item = (struct hip_locator_info_addr_item *) 
-                       hip_get_locator_item(first_address_item, i);
-           _HIP_HEXDUMP("LOC HEX", &locator_address_item[i],
-                                  sizeof(struct hip_locator_info_addr_item));
-       HIP_DEBUG("locator items index %d, type is %d \n", i,
-                 locator_address_item->locator_type );
-       if (locator_address_item->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
-           
-               HIP_INFO_HIT("locator",
-                     (struct in6_addr *)&locator_address_item->address);
-               _HIP_HEXDUMP("Should be in6_addr", 
-                        &locator_address_item[i].address,
-                        sizeof(struct in6_addr));
-           
-       }
-       if (locator_address_item->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
-               
-                       HIP_INFO_HIT("LOCATOR from ESP SPI(type 1)",
-                        (struct in6_addr *)&locator_address_item->address);
-                       _HIP_HEXDUMP("Should be in6_addr", 
-                                   &locator_address_item[i].address,
-                                   sizeof(struct in6_addr));
-                      
-                  }
-       if (locator_address_item->locator_type == HIP_LOCATOR_LOCATOR_TYPE_UDP) 
{
-               locator_address_item2 = (struct hip_locator_info_addr_item2 *) 
locator_address_item;
-                       HIP_INFO_HIT("LOCATOR from UDP",
-                      (struct in6_addr *)&locator_address_item2->address);
-                       HIP_DEBUG("LOCATOR port for UDP: %d\n",  
ntohs(locator_address_item2->port));
-                       _HIP_HEXDUMP("Should be in6_addr", 
-                                         &locator_address_item[i].address,
-                                         sizeof(struct in6_addr));
-                            
-                        }
-           }
-       }
+    int n_addrs                                               = 0, i = 0;
+    struct hip_locator_info_addr_item *first_address_item     = NULL,
+    *locator_address_item                                     = NULL;
+    struct hip_locator_info_addr_item2 *locator_address_item2 = NULL;
+    /* locator = hip_get_param((struct hip_common *)in_msg,
+     * HIP_PARAM_LOCATOR);*/
+    if (locator) {
+        HIP_DEBUG("%s: \n", str);
+
+        n_addrs            = hip_get_locator_addr_item_count(locator);
+        HIP_DEBUG("there are  %d locator items \n", n_addrs);
+        first_address_item = hip_get_locator_first_addr_item(locator);
+
+        for (i = 0; i < n_addrs; i++) {
+            locator_address_item = (struct hip_locator_info_addr_item *)
+                                   hip_get_locator_item(first_address_item, i);
+            _HIP_HEXDUMP("LOC HEX", &locator_address_item[i],
+                         sizeof(struct hip_locator_info_addr_item));
+            HIP_DEBUG("locator items index %d, type is %d \n", i,
+                      locator_address_item->locator_type );
+            if (locator_address_item->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_IPV6) {
+                HIP_INFO_HIT("locator",
+                             (struct in6_addr *) 
&locator_address_item->address);
+                _HIP_HEXDUMP("Should be in6_addr",
+                             &locator_address_item[i].address,
+                             sizeof(struct in6_addr));
+            }
+            if (locator_address_item->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_ESP_SPI) {
+                HIP_INFO_HIT("LOCATOR from ESP SPI(type 1)",
+                             (struct in6_addr *) 
&locator_address_item->address);
+                _HIP_HEXDUMP("Should be in6_addr",
+                             &locator_address_item[i].address,
+                             sizeof(struct in6_addr));
+            }
+            if (locator_address_item->locator_type == 
HIP_LOCATOR_LOCATOR_TYPE_UDP) {
+                locator_address_item2 = (struct hip_locator_info_addr_item2 *) 
locator_address_item;
+                HIP_INFO_HIT("LOCATOR from UDP",
+                             (struct in6_addr *) 
&locator_address_item2->address);
+                HIP_DEBUG("LOCATOR port for UDP: %d\n",  
ntohs(locator_address_item2->port));
+                _HIP_HEXDUMP("Should be in6_addr",
+                             &locator_address_item[i].address,
+                             sizeof(struct in6_addr));
+            }
+        }
+    }
 }

=== modified file 'lib/core/debug.c.doxyme'
--- lib/core/debug.c.doxyme     2010-01-19 09:28:42 +0000
+++ lib/core/debug.c.doxyme     2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,7 +45,7 @@
 
 
 /**
- * hip_debug_gl 
+ * hip_debug_gl
  *
  *
  * @param debug_group
@@ -54,96 +55,96 @@
  * @param function
  * @param fmt
  * @param ...
- * @return 
- **/
-
-
-/**
- * hip_die 
- *
- *
- * @param file
- * @param line
- * @param function
- * @param fmt
- * @param ...
- * @return 
- **/
-
-
-/**
- * hip_error 
- *
- *
- * @param file
- * @param line
- * @param function
- * @param fmt
- * @param ...
- * @return 
- **/
-
-
-/**
- * hip_handle_log_error 
+ * @return
+ **/
+
+
+/**
+ * hip_die
+ *
+ *
+ * @param file
+ * @param line
+ * @param function
+ * @param fmt
+ * @param ...
+ * @return
+ **/
+
+
+/**
+ * hip_error
+ *
+ *
+ * @param file
+ * @param line
+ * @param function
+ * @param fmt
+ * @param ...
+ * @return
+ **/
+
+
+/**
+ * hip_handle_log_error
  *
  *
  * @param logtype
- * @return 
- **/
-
-
-/**
- * hip_hexdump 
- *
- *
- * @param file
- * @param line
- * @param function
- * @param prefix
- * @param str
- * @param len
- * @return 
- **/
-
-
-/**
- * hip_hexdump_parsed 
- *
- *
- * @param file
- * @param line
- * @param function
- * @param prefix
- * @param str
- * @param len
- * @return 
- **/
-
-
-/**
- * hip_perror_wrapper 
+ * @return
+ **/
+
+
+/**
+ * hip_hexdump
+ *
+ *
+ * @param file
+ * @param line
+ * @param function
+ * @param prefix
+ * @param str
+ * @param len
+ * @return
+ **/
+
+
+/**
+ * hip_hexdump_parsed
+ *
+ *
+ * @param file
+ * @param line
+ * @param function
+ * @param prefix
+ * @param str
+ * @param len
+ * @return
+ **/
+
+
+/**
+ * hip_perror_wrapper
  *
  *
  * @param file
  * @param line
  * @param function
  * @param tools
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_addresses_to_send_update_request 
+ * hip_print_addresses_to_send_update_request
  *
  *
  * @param ha
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_hit 
+ * hip_print_hit
  *
  *
  * @param debug_level
@@ -152,12 +153,12 @@
  * @param function
  * @param str
  * @param hit
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_locator 
+ * hip_print_locator
  *
  *
  * @param debug_level
@@ -166,21 +167,21 @@
  * @param function
  * @param str
  * @param locator
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_locator_addresses 
+ * hip_print_locator_addresses
  *
  *
  * @param autogen.sh
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_lsi 
+ * hip_print_lsi
  *
  *
  * @param debug_level
@@ -189,21 +190,21 @@
  * @param function
  * @param str
  * @param lsi
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_peer_addresses_to_be_added 
+ * hip_print_peer_addresses_to_be_added
  *
  *
  * @param entry
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_sockaddr 
+ * hip_print_sockaddr
  *
  *
  * @param file
@@ -211,12 +212,12 @@
  * @param function
  * @param prefix
  * @param sockaddr
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_print_str 
+ * hip_print_str
  *
  *
  * @param debug_level
@@ -225,48 +226,48 @@
  * @param function
  * @param fmt
  * @param ...
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_auto_logdebug 
+ * hip_set_auto_logdebug
  *
  *
  * @param cfile
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_logdebug 
+ * hip_set_logdebug
  *
  *
  * @param new_logdebug
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_logfmt 
+ * hip_set_logfmt
  *
  *
  * @param new_logfmt
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_set_logtype 
+ * hip_set_logtype
  *
  *
  * @param new_logtype
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_vlog 
+ * hip_vlog
  *
  *
  * @param debug_level
@@ -275,6 +276,5 @@
  * @param function
  * @param fmt
  * @param args
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/debug.h'
--- lib/core/debug.h    2010-02-08 15:18:06 +0000
+++ lib/core/debug.h    2010-02-10 23:55:24 +0000
@@ -21,7 +21,7 @@
 #define DEBUG_PREFIX_MAX  64
 
 /* stderror: includes prefix, separator, msg and \0
-   syslog:   includes msg and \0 */
+ * syslog:   includes msg and \0 */
 #define DEBUG_MSG_MAX_LEN     1024
 
 #define SYSLOG_OPT        (LOG_PID)
@@ -37,7 +37,7 @@
 #define HIP_ERROR(...) hip_print_str(DEBUG_LEVEL_ERROR, __FILE__, __LINE__, 
__FUNCTION__, __VA_ARGS__)
 #define HIP_DIE(...)   hip_die(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
 #define HIP_PERROR(s) hip_perror_wrapper(__FILE__, __LINE__, __FUNCTION__, s)
-#define HIP_ASSERT(s) { if (!(s)) HIP_DIE("assertion failed\n"); }
+#define HIP_ASSERT(s) { if (!(s)) {HIP_DIE("assertion failed\n"); }}
 /** @} */
 
 /**
@@ -47,60 +47,60 @@
 #ifdef CONFIG_HIP_DEBUG
 #define HIP_DEBUG(...) hip_print_str(DEBUG_LEVEL_DEBUG, __FILE__, __LINE__, 
__FUNCTION__, __VA_ARGS__)
 #define HIP_HEXDUMP(prefix, str, len) \
-            hip_hexdump(__FILE__, __LINE__, __FUNCTION__, prefix, str, len)
+    hip_hexdump(__FILE__, __LINE__, __FUNCTION__, prefix, str, len)
 #define HIP_DUMP_PACKET(prefix, str, len) \
-            hip_hexdump_parsed(__FILE__, __LINE__, __FUNCTION__, prefix, str, 
len)
+    hip_hexdump_parsed(__FILE__, __LINE__, __FUNCTION__, prefix, str, len)
 #define HIP_DEBUG_SOCKADDR(prefix, sockaddr) \
- hip_print_sockaddr(__FILE__, __LINE__, __FUNCTION__, prefix, sockaddr)
+    hip_print_sockaddr(__FILE__, __LINE__, __FUNCTION__, prefix, sockaddr)
 #define HIP_DUMP_MSG(msg) { hip_print_str(DEBUG_LEVEL_DEBUG, __FILE__, 
__LINE__, __FUNCTION__, " dump: \n"); hip_dump_msg(msg); }
 #define HIP_DEBUG_GL(debug_group, debug_level, ...) \
-       hip_debug_gl( debug_group, debug_level, __FILE__, __LINE__, 
__FUNCTION__, __VA_ARGS__)
+    hip_debug_gl( debug_group, debug_level, __FILE__, __LINE__, __FUNCTION__, 
__VA_ARGS__)
 
 #else
-#define HIP_DEBUG(...) do {} while(0)
-#define HIP_HEXDUMP(prefix, str, len) do {} while(0)
-#define HIP_DUMP_PACKET(prefix, str, len) do {} while(0)
-#define HIP_DEBUG_SOCKADDR(prefix, sockaddr) do {} while(0)
-#define HIP_DUMP_MSG(msg) do {} while(0)
-#define HIP_DEBUG_GL(debug_group, debug_level, ...) do {} while(0)
+#define HIP_DEBUG(...) do {} while (0)
+#define HIP_HEXDUMP(prefix, str, len) do {} while (0)
+#define HIP_DUMP_PACKET(prefix, str, len) do {} while (0)
+#define HIP_DEBUG_SOCKADDR(prefix, sockaddr) do {} while (0)
+#define HIP_DUMP_MSG(msg) do {} while (0)
+#define HIP_DEBUG_GL(debug_group, debug_level, ...) do {} while (0)
 #endif
 
 #ifdef CONFIG_HIP_DEMO
 #define HIP_DEMO(...) printf(__VA_ARGS__);
 #else
-#define HIP_DEMO(...) do{} while(0)
+#define HIP_DEMO(...) do {} while (0)
 #endif
 
 /** @} */
 
 /* Debug groups define groups of debug messages which belong to the
-   same logical part of hip. Debug messages can be enabled or disabled more
-   finegrained by only printing messages which belong to a debug group */
-# define HIP_DEBUG_GROUP_ALL           770
-# define HIP_DEBUG_GROUP_DEFAULT       771
-# define HIP_DEBUG_GROUP_ADAPT         772
-# define HIP_DEBUG_GROUP_INIT          773
-# define HIP_DEBUG_GROUP_MSG           774
+ * same logical part of hip. Debug messages can be enabled or disabled more
+ * finegrained by only printing messages which belong to a debug group */
+# define HIP_DEBUG_GROUP_ALL            770
+# define HIP_DEBUG_GROUP_DEFAULT        771
+# define HIP_DEBUG_GROUP_ADAPT          772
+# define HIP_DEBUG_GROUP_INIT           773
+# define HIP_DEBUG_GROUP_MSG            774
 
 /* Current debug group */
 # define HIP_DEBUG_GROUP HIP_DEBUG_GROUP_INIT
 
 /* Debug messages are divided into several levels. Severe errors
-   or abnormal conditions are the lowest level. Higher levels are
-   considered as less severe or less important. The highest level means
-   every debug message which matches the current switch is printed.
-   The highest debug level number must be assigned to HIP_DEBUG_ALL*/
-# define HIP_DEBUG_LEVEL_ERRORS                0
-# define HIP_DEBUG_LEVEL_IMPORTANT     10
-# define HIP_DEBUG_LEVEL_INFORMATIVE   20
-# define HIP_DEBUG_LEVEL_DEFAULT       30
-# define HIP_DEBUG_LEVEL_ALL           40
+ * or abnormal conditions are the lowest level. Higher levels are
+ * considered as less severe or less important. The highest level means
+ * every debug message which matches the current switch is printed.
+ * The highest debug level number must be assigned to HIP_DEBUG_ALL*/
+# define HIP_DEBUG_LEVEL_ERRORS         0
+# define HIP_DEBUG_LEVEL_IMPORTANT      10
+# define HIP_DEBUG_LEVEL_INFORMATIVE    20
+# define HIP_DEBUG_LEVEL_DEFAULT        30
+# define HIP_DEBUG_LEVEL_ALL            40
 
 # define HIP_DEBUG_LEVEL HIP_DEBUG_LEVEL_ALL
 
 /* differentiate between die(), error() and debug() error levels */
 enum debug_level { DEBUG_LEVEL_DIE, DEBUG_LEVEL_ERROR, DEBUG_LEVEL_INFO,
-                  DEBUG_LEVEL_DEBUG, DEBUG_LEVEL_MAX };
+                   DEBUG_LEVEL_DEBUG, DEBUG_LEVEL_MAX };
 
 #define HIP_INFO_HIT(str, hit)  hip_print_hit(DEBUG_LEVEL_INFO, __FILE__, 
__LINE__, __FUNCTION__, str, hit)
 #define HIP_INFO_IN6ADDR(str, in6) hip_print_hit(DEBUG_LEVEL_INFO, __FILE__, 
__LINE__, __FUNCTION__, str, in6)
@@ -113,19 +113,19 @@
 #define HIP_DEBUG_INADDR(str, in)  hip_print_lsi(DEBUG_LEVEL_DEBUG, __FILE__, 
__LINE__, __FUNCTION__, str, in)
 
 /* these are used for disabling a debugging command temporarily */
-#define _HIP_DEBUG(...) do {} while(0)
-#define _HIP_INFO(...) do {} while(0)
-#define _HIP_ERROR(...) do {} while(0)
-#define _HIP_DIE(...) do {} while(0)
-#define _HIP_HEXDUMP(prefix, str, len) do {} while(0)
-#define _HIP_DUMP_MSG(msg) do {} while(0)
-#define _HIP_PERROR(s) do {} while(0)
-#define _HIP_ASSERT(s) do {} while(0)
-#define _HIP_DEBUG_HIT(str, hit) do {} while(0)
-#define _HIP_DEBUG_IN6ADDR(str, hit) do {} while(0)
-#define _HIP_DEBUG_LSI(str, lsi) do {} while(0)
-#define _HIP_DEBUG_INADDR(str, in) do {} while(0)
-#define _HIP_DEBUG_SOCKADDR(a,b ) do {} while(0)
+#define _HIP_DEBUG(...) do {} while (0)
+#define _HIP_INFO(...) do {} while (0)
+#define _HIP_ERROR(...) do {} while (0)
+#define _HIP_DIE(...) do {} while (0)
+#define _HIP_HEXDUMP(prefix, str, len) do {} while (0)
+#define _HIP_DUMP_MSG(msg) do {} while (0)
+#define _HIP_PERROR(s) do {} while (0)
+#define _HIP_ASSERT(s) do {} while (0)
+#define _HIP_DEBUG_HIT(str, hit) do {} while (0)
+#define _HIP_DEBUG_IN6ADDR(str, hit) do {} while (0)
+#define _HIP_DEBUG_LSI(str, lsi) do {} while (0)
+#define _HIP_DEBUG_INADDR(str, in) do {} while (0)
+#define _HIP_DEBUG_SOCKADDR(a, b ) do {} while (0)
 
 enum logtype_t { LOGTYPE_NOLOG, LOGTYPE_SYSLOG, LOGTYPE_STDERR };
 enum logfmt_t { LOGFMT_SHORT, LOGFMT_LONG };
@@ -137,29 +137,75 @@
 int hip_set_auto_logdebug(const char *cfile);
 
 /* Don't use the functions below directly; use the corresponding macros
-   instead */
+ * instead */
 void hip_handle_log_error(int logtype);
-void hip_vlog(int debug_level, const char *file, int line,
-             const char *function, const char *fmt, va_list args);
-void hip_info(const char *file, int line, const char *function,
-             const char *fmt, ...);
-void hip_die(const char *file, int line, const char *function,
-            const char *fmt, ...);
-void hip_error(const char *file, int line, const char *function,
-              const char *fmt, ...);
-void hip_perror_wrapper(const char *file, int line, const char *function,
-                       const char *s);
-void hip_hexdump(const char *file, int line, const char *function,
-                const char *prefix, const void *str, int len);
-void hip_print_packet(const char *file, int line, const char *function,
-                const char *prefix, const void *str, int len);
-void hip_print_sockaddr(const char *file, int line, const char *function,
-                       const char *prefix,
-                       const struct sockaddr *sockaddr);
-void hip_print_hit(int debug_level, const char *file, int line, const char 
*function, const char *str, const struct in6_addr *hit);
-void hip_print_str(int debug_level, const char *file, int line, const char 
*function, const char *fmt, ...);
-void hip_debug_gl(int debug_group, int debug_level, const char *file, int 
line, const char *function, const char *fmt, ...);
-void hip_print_lsi(int debug_level, const char *file, int line, const char 
*function, const char *str, const struct in_addr *lsi);
+void hip_vlog(int debug_level,
+              const char *file,
+              int line,
+              const char *function,
+              const char *fmt,
+              va_list args);
+void hip_info(const char *file,
+              int line,
+              const char *function,
+              const char *fmt,
+              ...);
+void hip_die(const char *file,
+             int line,
+             const char *function,
+             const char *fmt,
+             ...);
+void hip_error(const char *file,
+               int line,
+               const char *function,
+               const char *fmt,
+               ...);
+void hip_perror_wrapper(const char *file,
+                        int line,
+                        const char *function,
+                        const char *s);
+void hip_hexdump(const char *file,
+                 int line,
+                 const char *function,
+                 const char *prefix,
+                 const void *str,
+                 int len);
+void hip_print_packet(const char *file,
+                      int line,
+                      const char *function,
+                      const char *prefix,
+                      const void *str,
+                      int len);
+void hip_print_sockaddr(const char *file,
+                        int line,
+                        const char *function,
+                        const char *prefix,
+                        const struct sockaddr *sockaddr);
+void hip_print_hit(int debug_level,
+                   const char *file,
+                   int line,
+                   const char *function,
+                   const char *str,
+                   const struct in6_addr *hit);
+void hip_print_str(int debug_level,
+                   const char *file,
+                   int line,
+                   const char *function,
+                   const char *fmt,
+                   ...);
+void hip_debug_gl(int debug_group,
+                  int debug_level,
+                  const char *file,
+                  int line,
+                  const char *function,
+                  const char *fmt,
+                  ...);
+void hip_print_lsi(int debug_level,
+                   const char *file,
+                   int line,
+                   const char *function,
+                   const char *str,
+                   const struct in_addr *lsi);
 
 
 /**
@@ -192,8 +238,12 @@
 void hip_print_locator_addresses(struct hip_common *);
 void hip_print_peer_addresses_to_be_added(hip_ha_t *);
 void hip_print_peer_addresses(hip_ha_t *);
-void hip_print_locator(int debug_level, const char *file, int line,
-       const char *function, const char *str, const struct hip_locator 
*locator);
+void hip_print_locator(int debug_level,
+                       const char *file,
+                       int line,
+                       const char *function,
+                       const char *str,
+                       const struct hip_locator *locator);
 void hip_print_addresses_to_send_update_request(hip_ha_t *);
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -206,27 +256,28 @@
  */
 static inline const char *hip_state_str(unsigned int state)
 {
-       const char *str = "UNKNOWN";
-        static const char *states[] =
-               {
-                       "NONE",          // 0
-                       "UNASSOCIATED",  // 1
-                       "I1-SENT",       // 2
-                       "I2-SENT",       // 3
-                       "R2-SENT",       // 4
-                       "ESTABLISHED",   // 5
-                       "UNKNOWN",       // 6 is not currently used.
-                       "FAILED",        // 7
-                       "CLOSING",       // 8
-                       "CLOSED",        // 9
-                       "FILTERING"      // 10
-               };
-        if (state < ARRAY_SIZE(states))
-               str = states[state];
-        else
-               HIP_ERROR("invalid state %u\n", state);
+    const char *str             = "UNKNOWN";
+    static const char *states[] =
+    {
+        "NONE",                          // 0
+        "UNASSOCIATED",                  // 1
+        "I1-SENT",                       // 2
+        "I2-SENT",                       // 3
+        "R2-SENT",                       // 4
+        "ESTABLISHED",                   // 5
+        "UNKNOWN",                       // 6 is not currently used.
+        "FAILED",                        // 7
+        "CLOSING",                       // 8
+        "CLOSED",                        // 9
+        "FILTERING"                      // 10
+    };
+    if (state < ARRAY_SIZE(states)) {
+        str = states[state];
+    } else {
+        HIP_ERROR("invalid state %u\n", state);
+    }
 
-        return str;
+    return str;
 }
 
 #endif /* DEBUG_H */

=== modified file 'lib/core/debug.h.doxyme'
--- lib/core/debug.h.doxyme     2010-01-19 09:28:42 +0000
+++ lib/core/debug.h.doxyme     2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/debug.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/esp_prot_common.c'
--- lib/core/esp_prot_common.c  2010-01-19 09:28:42 +0000
+++ lib/core/esp_prot_common.c  2010-02-10 23:55:24 +0000
@@ -24,25 +24,24 @@
  * @param      transform the ESP protection extension transform to be checked
  * @return     index in the preferred_transforms array, -1 if no match found
  */
-int esp_prot_check_transform(const int num_transforms, const uint8_t 
*preferred_transforms,
-               const uint8_t transform)
+int esp_prot_check_transform(const int num_transforms,
+                             const uint8_t *preferred_transforms,
+                             const uint8_t transform)
 {
-       int err = -1, i;
-
-       // check if local preferred transforms contain passed transform
-       for (i = 0; i < num_transforms; i++)
-       {
-               if (preferred_transforms[i] == transform)
-               {
-                       HIP_DEBUG("transform found in preferred transforms\n");
-
-                       err = i;
-                       goto out_err;
-               }
-       }
-
-       HIP_DEBUG("transform NOT found in local preferred transforms\n");
-
-  out_err:
-       return err;
+    int err = -1, i;
+
+    // check if local preferred transforms contain passed transform
+    for (i = 0; i < num_transforms; i++) {
+        if (preferred_transforms[i] == transform) {
+            HIP_DEBUG("transform found in preferred transforms\n");
+
+            err = i;
+            goto out_err;
+        }
+    }
+
+    HIP_DEBUG("transform NOT found in local preferred transforms\n");
+
+out_err:
+    return err;
 }

=== modified file 'lib/core/esp_prot_common.h'
--- lib/core/esp_prot_common.h  2010-01-19 09:28:42 +0000
+++ lib/core/esp_prot_common.h  2010-02-10 23:55:24 +0000
@@ -19,22 +19,23 @@
 #include <inttypes.h>
 
 /* the maximum numbers for arrays used for the different modes */
-#define MAX_NUM_TRANSFORMS                                     10
-#define MAX_NUM_PARALLEL_HCHAINS                       10
-#define HCSTORE_MAX_HCHAINS_PER_ITEM           100
-#define MAX_HTREE_DEPTH                                                20
-#define MAX_RING_BUFFER_SIZE                           128
+#define MAX_NUM_TRANSFORMS                      10
+#define MAX_NUM_PARALLEL_HCHAINS                10
+#define HCSTORE_MAX_HCHAINS_PER_ITEM            100
+#define MAX_HTREE_DEPTH                         20
+#define MAX_RING_BUFFER_SIZE                    128
 
 /* this is a special purpose transform representing no hash token to be used */
-#define ESP_PROT_TFM_UNUSED                                    0
-#define ESP_PROT_TFM_PLAIN                                     1
-#define ESP_PROT_TFM_PARALLEL                          2
-#define ESP_PROT_TFM_CUMULATIVE                                3
-#define ESP_PROT_TFM_PARA_CUMUL                                4
-#define ESP_PROT_TFM_TREE                                      5
-#define ESP_PROT_TFM_TREE_CHAIN                                6
+#define ESP_PROT_TFM_UNUSED                     0
+#define ESP_PROT_TFM_PLAIN                      1
+#define ESP_PROT_TFM_PARALLEL                   2
+#define ESP_PROT_TFM_CUMULATIVE                 3
+#define ESP_PROT_TFM_PARA_CUMUL                 4
+#define ESP_PROT_TFM_TREE                       5
+#define ESP_PROT_TFM_TREE_CHAIN                 6
 
-int esp_prot_check_transform(const int num_transforms, const uint8_t 
*preferred_transforms,
-               const uint8_t transform);
+int esp_prot_check_transform(const int num_transforms,
+                             const uint8_t *preferred_transforms,
+                             const uint8_t transform);
 
 #endif /*EXT_ESP_PROT_COMMON_H_*/

=== modified file 'lib/core/getendpointinfo.c'
--- lib/core/getendpointinfo.c  2010-02-08 15:18:06 +0000
+++ lib/core/getendpointinfo.c  2010-02-10 23:55:24 +0000
@@ -51,374 +51,383 @@
 
 // needed due to missing system inlcude for openWRT
 #ifndef HOST_NAME_MAX
-#define HOST_NAME_MAX          64
+#define HOST_NAME_MAX           64
 #endif
 
 int convert_port_string_to_number(const char *servname, in_port_t *port)
 {
-  int err = 0;
-  struct servent *servent;
-  long int strtol_port;
+    int err = 0;
+    struct servent *servent;
+    long int strtol_port;
 
-  servent = getservbyname(servname, NULL);
-  if (servent) {
-    *port = ntohs(servent->s_port);
-  } else {
-    /* Try strtol if getservbyname fails, e.g. if the servname is "12345". */
-    strtol_port = strtol(servname, NULL, 0);
-    if (strtol_port == LONG_MIN || strtol_port == LONG_MAX ||
-       strtol_port <= 0) {
-      HIP_PERROR("strtol failed:");
-      err = EEI_NONAME;
-      goto out_err;
+    servent = getservbyname(servname, NULL);
+    if (servent) {
+        *port = ntohs(servent->s_port);
+    } else {
+        /* Try strtol if getservbyname fails, e.g. if the servname is "12345". 
*/
+        strtol_port = strtol(servname, NULL, 0);
+        if (strtol_port == LONG_MIN || strtol_port == LONG_MAX ||
+            strtol_port <= 0) {
+            HIP_PERROR("strtol failed:");
+            err = EEI_NONAME;
+            goto out_err;
+        }
+        *port = strtol_port;
     }
-    *port = strtol_port;
-  }
-
- out_err:
-
-  endservent();
-
-  return err;
-
+
+out_err:
+
+    endservent();
+
+    return err;
 }
+
 #if 0
-char* hip_in6_ntop(const struct in6_addr *in6, char *buf)
+char *hip_in6_ntop(const struct in6_addr *in6, char *buf)
 {
-        if (!buf)
-                return NULL;
-        sprintf(buf,
-                "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
-                ntohs(in6->s6_addr16[0]), ntohs(in6->s6_addr16[1]),
-                ntohs(in6->s6_addr16[2]), ntohs(in6->s6_addr16[3]),
-                ntohs(in6->s6_addr16[4]), ntohs(in6->s6_addr16[5]),
-                ntohs(in6->s6_addr16[6]), ntohs(in6->s6_addr16[7]));
-        return buf;
+    if (!buf) {
+        return NULL;
+    }
+    sprintf(buf,
+            "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
+            ntohs(in6->s6_addr16[0]), ntohs(in6->s6_addr16[1]),
+            ntohs(in6->s6_addr16[2]), ntohs(in6->s6_addr16[3]),
+            ntohs(in6->s6_addr16[4]), ntohs(in6->s6_addr16[5]),
+            ntohs(in6->s6_addr16[6]), ntohs(in6->s6_addr16[7]));
+    return buf;
 }
+
 #endif
 
 int setmyeid(struct sockaddr_eid *my_eid,
-            const char *servname,
-            const struct endpoint *endpoint,
-            const struct if_nameindex *ifaces)
+             const char *servname,
+             const struct endpoint *endpoint,
+             const struct if_nameindex *ifaces)
 {
-  int err = 0;
-  struct hip_common *msg = NULL;
-  struct if_nameindex *iface;
-  struct hip_sockaddr_eid *sa_eid;
-  struct endpoint_hip *ep_hip = (struct endpoint_hip *) endpoint;
-  in_port_t port;
-  int socket_fd = 0;
-  unsigned int len = 0;
-
-  if (ep_hip->family != PF_HIP) {
-    HIP_ERROR("Only HIP endpoints are supported\n");
-    err = EAI_FAMILY;
-    goto out_err;
-  }
-
-  _HIP_HEXDUMP("host_id in endpoint: ", &ep_hip->id.host_id,
-             hip_get_param_total_len(&ep_hip->id.host_id));
-
-  msg = hip_msg_alloc();
-  if (!msg) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if (servname == NULL || strlen(servname) == 0) {
-    port = 0; /* Ephemeral port */
-    goto skip_port_conversion;
-  }
-
-  err = convert_port_string_to_number(servname, &port);
-  if (err) {
-    HIP_ERROR("Port conversion failed (%d)\n", err);
-    goto out_err;
-  }
-
- skip_port_conversion:
-
-  /* Handler emphemeral port number */
-  if (port == 0) {
-    while (port < 1024) /* XX FIXME: CHECK UPPER BOUNDARY */
-          port = rand();
-  }
-
-  HIP_DEBUG("port=%d\n", port);
-
-  hip_build_user_hdr(msg, SO_HIP_SET_MY_EID, 0);
-
-  err = hip_build_param_eid_endpoint(msg, ep_hip);
-  if (err) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if(hip_host_id_contains_private_key((struct hip_host_id 
*)&ep_hip->id.host_id)){
-
-    HIP_DEBUG("Private key found from hip_host_id\n");
-
-    err = hip_private_host_id_to_hit(&ep_hip->id.host_id, &ep_hip->id.hit,
-                                    HIP_HIT_TYPE_HASH100);
-    if (err) {
-      HIP_ERROR("Failed to calculate HIT from private HI.");
-      goto out_err;
-    }
-  }
-  /* Only public key*/
-  else {
-
-     HIP_DEBUG("Public key found from hip_host_id\n");
-
-    /*Generate HIT from the public HI */
-    err = hip_host_id_to_hit((struct hip_host_id *)&ep_hip->id.host_id, 
&ep_hip->id.hit,
-                            HIP_HIT_TYPE_HASH100);
-
-    if (err) {
-      HIP_ERROR("Failed to calculate HIT from public key.");
-      goto out_err;
-    }
-  }
-
-  HIP_DEBUG_HIT("Calculated HIT from hip_host_id", &ep_hip->id.hit);
-
-  err = hip_build_param_contents(msg, (void *) &ep_hip->id.hit, HIP_PARAM_HIT,
-                                      sizeof(struct in6_addr));
-  if (err) {
-    HIP_ERROR("Build param hit failed: %s\n", strerror(err));
-    goto out_err;
-  }
-
-  /*Currently ifaces is NULL, so this for loop is skipped*/
-  for(iface = (struct if_nameindex *) ifaces;
-      iface && iface->if_index != 0; iface++) {
-    err = hip_build_param_eid_iface(msg, iface->if_index);
-    if (err) {
-      err = EEI_MEMORY;
-      goto out_err;
-    }
-  }
+    int err                     = 0;
+    struct hip_common *msg      = NULL;
+    struct if_nameindex *iface;
+    struct hip_sockaddr_eid *sa_eid;
+    struct endpoint_hip *ep_hip = (struct endpoint_hip *) endpoint;
+    in_port_t port;
+    int socket_fd               = 0;
+    unsigned int len            = 0;
+
+    if (ep_hip->family != PF_HIP) {
+        HIP_ERROR("Only HIP endpoints are supported\n");
+        err = EAI_FAMILY;
+        goto out_err;
+    }
+
+    _HIP_HEXDUMP("host_id in endpoint: ", &ep_hip->id.host_id,
+                 hip_get_param_total_len(&ep_hip->id.host_id));
+
+    msg = hip_msg_alloc();
+    if (!msg) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (servname == NULL || strlen(servname) == 0) {
+        port = 0; /* Ephemeral port */
+        goto skip_port_conversion;
+    }
+
+    err = convert_port_string_to_number(servname, &port);
+    if (err) {
+        HIP_ERROR("Port conversion failed (%d)\n", err);
+        goto out_err;
+    }
+
+skip_port_conversion:
+
+    /* Handler emphemeral port number */
+    if (port == 0) {
+        while (port < 1024) { /* XX FIXME: CHECK UPPER BOUNDARY */
+            port = rand();
+        }
+    }
+
+    HIP_DEBUG("port=%d\n", port);
+
+    hip_build_user_hdr(msg, SO_HIP_SET_MY_EID, 0);
+
+    err = hip_build_param_eid_endpoint(msg, ep_hip);
+    if (err) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (hip_host_id_contains_private_key((struct hip_host_id *) 
&ep_hip->id.host_id)) {
+        HIP_DEBUG("Private key found from hip_host_id\n");
+
+        err = hip_private_host_id_to_hit(&ep_hip->id.host_id, &ep_hip->id.hit,
+                                         HIP_HIT_TYPE_HASH100);
+        if (err) {
+            HIP_ERROR("Failed to calculate HIT from private HI.");
+            goto out_err;
+        }
+    }
+    /* Only public key*/
+    else {
+        HIP_DEBUG("Public key found from hip_host_id\n");
+
+        /*Generate HIT from the public HI */
+        err = hip_host_id_to_hit((struct hip_host_id *) &ep_hip->id.host_id, 
&ep_hip->id.hit,
+                                 HIP_HIT_TYPE_HASH100);
+
+        if (err) {
+            HIP_ERROR("Failed to calculate HIT from public key.");
+            goto out_err;
+        }
+    }
+
+    HIP_DEBUG_HIT("Calculated HIT from hip_host_id", &ep_hip->id.hit);
+
+    err = hip_build_param_contents(msg, (void *) &ep_hip->id.hit, 
HIP_PARAM_HIT,
+                                   sizeof(struct in6_addr));
+    if (err) {
+        HIP_ERROR("Build param hit failed: %s\n", strerror(err));
+        goto out_err;
+    }
+
+    /*Currently ifaces is NULL, so this for loop is skipped*/
+    for (iface = (struct if_nameindex *) ifaces;
+         iface && iface->if_index != 0; iface++) {
+        err = hip_build_param_eid_iface(msg, iface->if_index);
+        if (err) {
+            err = EEI_MEMORY;
+            goto out_err;
+        }
+    }
 
 #if 0 //hip_recv_daemon_info returns currently -1, temporary solution is shown 
below.
-  err = hip_recv_daemon_info(msg, 0);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Failed to recv msg\n");
-    goto out_err;
-  }
+    err = hip_recv_daemon_info(msg, 0);
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Failed to recv msg\n");
+        goto out_err;
+    }
 #endif
 
-  /*Laura*********************/
-  //hip_send_daemon_info(msg_HIT); // for app. specified HIs
-  _HIP_DEBUG("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n calling socket..\n\n\n");
-  socket_fd = socket(PF_HIP, SOCK_STREAM, 0);
-  if(socket_fd == -1){
-    HIP_ERROR("Couldn't create socket\n");
-    err = -1;
-    goto out_err;
-  }
-  _HIP_DEBUG("\n\n\n\n\n\n\n\n\n\n great no error..\n\n\n");
-
-  len = hip_get_msg_total_len(msg);
-  err = getsockopt(socket_fd, IPPROTO_HIP, SO_HIP_SOCKET_OPT, (void *)msg, 
&len);
-
-  if (err) {
-    HIP_ERROR("getsockopt failed\n");
-    goto out_err;
-  }
-
-  /***************************/
-  /* getsockopt wrote the corresponding EID into the message, use it */
-
-  err = hip_get_msg_err(msg);
-  if (err) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  sa_eid = hip_get_param_contents(msg, HIP_PARAM_EID_SOCKADDR);
-  if (!sa_eid) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  memcpy(my_eid, sa_eid, sizeof(struct sockaddr_eid));
-
-  /* Fill the port number also because the HIP module did not fill it */
-  my_eid->eid_port = htons(port);
-
-  HIP_DEBUG("eid val=%d, port=%d\n", htons(my_eid->eid_val),
-           htons(my_eid->eid_port));
-
-  HIP_DEBUG("\n");
-
- out_err:
-
-  if (msg)
-    hip_msg_free(msg);
-
-  return err;
+    /*Laura*********************/
+    //hip_send_daemon_info(msg_HIT); // for app. specified HIs
+    _HIP_DEBUG("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n calling socket..\n\n\n");
+    socket_fd = socket(PF_HIP, SOCK_STREAM, 0);
+    if (socket_fd == -1) {
+        HIP_ERROR("Couldn't create socket\n");
+        err = -1;
+        goto out_err;
+    }
+    _HIP_DEBUG("\n\n\n\n\n\n\n\n\n\n great no error..\n\n\n");
+
+    len = hip_get_msg_total_len(msg);
+    err = getsockopt(socket_fd, IPPROTO_HIP, SO_HIP_SOCKET_OPT, (void *) msg, 
&len);
+
+    if (err) {
+        HIP_ERROR("getsockopt failed\n");
+        goto out_err;
+    }
+
+    /***************************/
+    /* getsockopt wrote the corresponding EID into the message, use it */
+
+    err = hip_get_msg_err(msg);
+    if (err) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    sa_eid = hip_get_param_contents(msg, HIP_PARAM_EID_SOCKADDR);
+    if (!sa_eid) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    memcpy(my_eid, sa_eid, sizeof(struct sockaddr_eid));
+
+    /* Fill the port number also because the HIP module did not fill it */
+    my_eid->eid_port = htons(port);
+
+    HIP_DEBUG("eid val=%d, port=%d\n", htons(my_eid->eid_val),
+              htons(my_eid->eid_port));
+
+    HIP_DEBUG("\n");
+
+out_err:
+
+    if (msg) {
+        hip_msg_free(msg);
+    }
+
+    return err;
 }
 
 int setpeereid(struct sockaddr_eid *peer_eid,
-              const char *servname,
-              const struct endpoint *endpoint,
-              const struct addrinfo *addrinfo)
+               const char *servname,
+               const struct endpoint *endpoint,
+               const struct addrinfo *addrinfo)
 {
-  int err = 0;
-  struct hip_common *msg = NULL, *msg_mapping;
-  struct addrinfo *addr;
-  struct sockaddr_eid *sa_eid;
-  in_port_t port = 0;
-  struct endpoint_hip *ep_hip = (struct endpoint_hip *) endpoint;
-  int socket_fd = 0;
-  unsigned int msg_len = 0;
-
-  HIP_DEBUG("\n");
-
-  if (endpoint->family != PF_HIP) {
-    HIP_ERROR("Only HIP endpoints are supported\n");
-    err = EAI_FAMILY;
-    goto out_err;
-  }
+    int err                     = 0;
+    struct hip_common *msg      = NULL, *msg_mapping;
+    struct addrinfo *addr;
+    struct sockaddr_eid *sa_eid;
+    in_port_t port              = 0;
+    struct endpoint_hip *ep_hip = (struct endpoint_hip *) endpoint;
+    int socket_fd               = 0;
+    unsigned int msg_len        = 0;
+
+    HIP_DEBUG("\n");
+
+    if (endpoint->family != PF_HIP) {
+        HIP_ERROR("Only HIP endpoints are supported\n");
+        err = EAI_FAMILY;
+        goto out_err;
+    }
 
 #ifdef CONFIG_HIP_DEBUG
-  {
-
-    if (ep_hip->flags & HIP_ENDPOINT_FLAG_HIT) {
-      _HIP_HEXDUMP("setpeereid hit: ", &ep_hip->id.hit,
-                 sizeof(struct in6_addr));
-    } else {
-      _HIP_HEXDUMP("setpeereid hi: ", &ep_hip->id.host_id,
-                 hip_get_param_total_len(&ep_hip->id.host_id));
+    {
+        if (ep_hip->flags & HIP_ENDPOINT_FLAG_HIT) {
+            _HIP_HEXDUMP("setpeereid hit: ", &ep_hip->id.hit,
+                         sizeof(struct in6_addr));
+        } else {
+            _HIP_HEXDUMP("setpeereid hi: ", &ep_hip->id.host_id,
+                         hip_get_param_total_len(&ep_hip->id.host_id));
+        }
     }
-  }
 #endif
 
-  msg = hip_msg_alloc();
-  if (!msg) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if (servname != NULL) {
-    err = convert_port_string_to_number(servname, &port);
+    msg = hip_msg_alloc();
+    if (!msg) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (servname != NULL) {
+        err = convert_port_string_to_number(servname, &port);
+        if (err) {
+            HIP_ERROR("Port conversion failed (%d)\n", err);
+            goto out_err;
+        }
+    }
+
+    HIP_DEBUG("port=%d\n", port);
+
+    hip_build_user_hdr(msg, SO_HIP_SET_PEER_EID, 0);
+
+    err = hip_build_param_eid_endpoint(msg, (struct endpoint_hip *) endpoint);
     if (err) {
-      HIP_ERROR("Port conversion failed (%d)\n", err);
-      goto out_err;
+        err = EEI_MEMORY;
+        goto out_err;
     }
-  }
-
-  HIP_DEBUG("port=%d\n", port);
-
-  hip_build_user_hdr(msg, SO_HIP_SET_PEER_EID, 0);
-
-  err = hip_build_param_eid_endpoint(msg, (struct endpoint_hip *) endpoint);
-  if (err) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
 
 
 #if 0 //hip_recv_daemon_info returns currently -1, temporary solution is shown 
below.
-  err = hip_recv_daemon_info(msg, 0);
-  if (err) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
+    err = hip_recv_daemon_info(msg, 0);
+    if (err) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
 #endif
 
-  /*Revove this part after hip_recv_daemon has beem implemented (2.3.2006 
Laura)*/
-
-  /* Send HIT-IP mapping to the daemon.********************************/
-
-  msg_mapping = hip_msg_alloc();
-  if (!msg_mapping) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  /* Is it possible that there are several public HITs for the peer 
(/etc/hip/hosts)?
-   * Do we send all possible mappings to the daemon?
-  */
-  for(addr = (struct addrinfo *) addrinfo; addr; addr = addr->ai_next) {
-    struct sockaddr_in6 *sock_addr_ipv6;
-    struct in6_addr ipv6_addr;
-
-    if(addr->ai_family != AF_INET6)
-      continue;
-
-    sock_addr_ipv6 = (struct sockaddr_in6 *)addrinfo->ai_addr;
-    ipv6_addr = sock_addr_ipv6->sin6_addr;
-
-    HIP_DEBUG("Adding HIP-IP mapping: ");
-    HIP_DEBUG_IN6ADDR("HIT", (struct in6_addr *) &ep_hip->id.hit);
-    HIP_DEBUG_IN6ADDR("IP", &ipv6_addr);
-
-    hip_msg_init(msg_mapping);
-    hip_build_user_hdr(msg_mapping, SO_HIP_ADD_PEER_MAP_HIT_IP, 0);
-    err = hip_build_param_contents(msg_mapping, (void *) &ep_hip->id.hit, 
HIP_PARAM_HIT,
-                                  sizeof(struct in6_addr));
-
-    if (err) {
-      HIP_ERROR("build param hit failed: %s\n", strerror(err));
-      goto out_err;
-    }
-
-    err = hip_build_param_contents(msg_mapping, (void *) &ipv6_addr, 
HIP_PARAM_IPV6_ADDR,
-                                  sizeof(struct in6_addr));
-
-    if (err) {
-      HIP_ERROR("build param ipv6 failed: %s\n", strerror(err));
-      goto out_err;
-    }
-
-    hip_send_recv_daemon_info(msg_mapping, 0, 0);
-  }
-  free(msg_mapping);
-
-  /**************************************/
-
-
-  /* Type of the socket? Does it matter?*/
-  socket_fd = socket(PF_HIP, SOCK_STREAM, 0);
-  if(socket_fd == -1){
-    HIP_ERROR("Couldn't create socket\n");
-    err = -1;
-    goto out_err;
-  }
-
-  msg_len = hip_get_msg_total_len(msg);
-  err = getsockopt(socket_fd, IPPROTO_HIP, SO_HIP_SOCKET_OPT, (void *)msg, 
&msg_len);
-  if(err) {
-    HIP_ERROR("getsockopt failed\n");
+    /*Revove this part after hip_recv_daemon has beem implemented (2.3.2006 
Laura)*/
+
+    /* Send HIT-IP mapping to the daemon.********************************/
+
+    msg_mapping = hip_msg_alloc();
+    if (!msg_mapping) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    /* Is it possible that there are several public HITs for the peer 
(/etc/hip/hosts)?
+     * Do we send all possible mappings to the daemon?
+     */
+    for (addr = (struct addrinfo *) addrinfo; addr; addr = addr->ai_next) {
+        struct sockaddr_in6 *sock_addr_ipv6;
+        struct in6_addr ipv6_addr;
+
+        if (addr->ai_family != AF_INET6) {
+            continue;
+        }
+
+        sock_addr_ipv6 = (struct sockaddr_in6 *) addrinfo->ai_addr;
+        ipv6_addr      = sock_addr_ipv6->sin6_addr;
+
+        HIP_DEBUG("Adding HIP-IP mapping: ");
+        HIP_DEBUG_IN6ADDR("HIT", (struct in6_addr *) &ep_hip->id.hit);
+        HIP_DEBUG_IN6ADDR("IP", &ipv6_addr);
+
+        hip_msg_init(msg_mapping);
+        hip_build_user_hdr(msg_mapping, SO_HIP_ADD_PEER_MAP_HIT_IP, 0);
+        err = hip_build_param_contents(msg_mapping, (void *) &ep_hip->id.hit, 
HIP_PARAM_HIT,
+                                       sizeof(struct in6_addr));
+
+        if (err) {
+            HIP_ERROR("build param hit failed: %s\n", strerror(err));
+            goto out_err;
+        }
+
+        err = hip_build_param_contents(msg_mapping,
+                                       (void *) &ipv6_addr,
+                                       HIP_PARAM_IPV6_ADDR,
+                                       sizeof(struct in6_addr));
+
+        if (err) {
+            HIP_ERROR("build param ipv6 failed: %s\n", strerror(err));
+            goto out_err;
+        }
+
+        hip_send_recv_daemon_info(msg_mapping, 0, 0);
+    }
+    free(msg_mapping);
+
+    /**************************************/
+
+
+    /* Type of the socket? Does it matter?*/
+    socket_fd = socket(PF_HIP, SOCK_STREAM, 0);
+    if (socket_fd == -1) {
+        HIP_ERROR("Couldn't create socket\n");
+        err = -1;
+        goto out_err;
+    }
+
+    msg_len = hip_get_msg_total_len(msg);
+    err = getsockopt(socket_fd,
+                     IPPROTO_HIP,
+                     SO_HIP_SOCKET_OPT,
+                     (void *) msg,
+                     &msg_len);
+    if (err) {
+        HIP_ERROR("getsockopt failed\n");
+        close(socket_fd);
+        goto out_err;
+    }
+
     close(socket_fd);
-    goto out_err;
-  }
-
-  close(socket_fd);
-  /***************************************************************************/
-
-  /* The HIP module wrote the eid into the msg. Let's use it. */
-
-  sa_eid = hip_get_param_contents(msg, HIP_PARAM_EID_SOCKADDR);
-  if (!sa_eid) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  memcpy(peer_eid, sa_eid, sizeof(struct sockaddr_eid));
-
-  /* Fill the port number also because the HIP module did not fill it */
-  peer_eid->eid_port = htons(port);
-
- out_err:
-
-  if (msg)
-    hip_msg_free(msg);
-
-  return err;
+    
/***************************************************************************/
+
+    /* The HIP module wrote the eid into the msg. Let's use it. */
+
+    sa_eid = hip_get_param_contents(msg, HIP_PARAM_EID_SOCKADDR);
+    if (!sa_eid) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    memcpy(peer_eid, sa_eid, sizeof(struct sockaddr_eid));
+
+    /* Fill the port number also because the HIP module did not fill it */
+    peer_eid->eid_port = htons(port);
+
+out_err:
+
+    if (msg) {
+        hip_msg_free(msg);
+    }
+
+    return err;
 }
 
 /*
@@ -428,100 +437,105 @@
  * Are application specified identities always anonymous?
  */
 int load_hip_endpoint_pem(const char *filename,
-                         struct endpoint **endpoint)
+                          struct endpoint **endpoint)
 {
-  int err = 0, algo = 0;
-  char first_key_line[30];
-  DSA *dsa = NULL;
-  RSA *rsa = NULL;
-  FILE* fp;
-
-  *endpoint = NULL;
-
-  /* check the algorithm from PEM format private key */
-  fp = fopen(filename, "rb");
-  if (!fp) {
-    HIP_ERROR("Couldn't open key file %s for reading\n", filename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-  else
-    HIP_DEBUG("open key file %s for reading\n", filename);
-  if( fgets(first_key_line,30,fp) != NULL ) {
-       HIP_ERROR("Cannot read from key file %s\n, filename");
-       }
-  //read first line.
-  _HIP_DEBUG("1st key line: %s", first_key_line);
-  fclose(fp);
-
-  if(findsubstring(first_key_line, "RSA"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(first_key_line, "DSA"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",filename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  if(algo == HIP_HI_RSA)
-    err = load_rsa_private_key(filename, &rsa);
-  else
-    err = load_dsa_private_key(filename, &dsa);
-  if (err) {
-    HIP_ERROR("Failed to load private key %s (%d)\n",filename, err);
-    goto out_err;
-  }
-
-  // XX FIX: host_id_hdr->rdata.flags = htons(0x0200); /* key is for a host */
-  if(algo == HIP_HI_RSA)
-    err = rsa_to_hip_endpoint(rsa, (struct endpoint_hip **) endpoint,
-                             HIP_ENDPOINT_FLAG_ANON, "");
-  else
-    err = dsa_to_hip_endpoint(dsa, (struct endpoint_hip **) endpoint,
-                             HIP_ENDPOINT_FLAG_ANON, "");
-  if (err) {
-    HIP_ERROR("Failed to convert private key to HIP endpoint (%d)\n", err);
-    goto out_err;
-  }
-
- out_err:
-
-  if (dsa)
-    DSA_free(dsa);
-  if (rsa)
-    RSA_free(rsa);
-  if (err && *endpoint)
-    free(*endpoint);
-
-  return err;
+    int err  = 0, algo = 0;
+    char first_key_line[30];
+    DSA *dsa = NULL;
+    RSA *rsa = NULL;
+    FILE *fp;
+
+    *endpoint = NULL;
+
+    /* check the algorithm from PEM format private key */
+    fp        = fopen(filename, "rb");
+    if (!fp) {
+        HIP_ERROR("Couldn't open key file %s for reading\n", filename);
+        err = -ENOMEM;
+        goto out_err;
+    } else {
+        HIP_DEBUG("open key file %s for reading\n", filename);
+    }
+    if (fgets(first_key_line, 30, fp) != NULL) {
+        HIP_ERROR("Cannot read from key file %s\n, filename");
+    }
+    //read first line.
+    _HIP_DEBUG("1st key line: %s", first_key_line);
+    fclose(fp);
+
+    if (findsubstring(first_key_line, "RSA")) {
+        algo = HIP_HI_RSA;
+    } else if (findsubstring(first_key_line, "DSA")) {
+        algo = HIP_HI_DSA;
+    } else {
+        HIP_ERROR("Wrong kind of key file: %s\n", filename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    if (algo == HIP_HI_RSA) {
+        err = load_rsa_private_key(filename, &rsa);
+    } else {
+        err = load_dsa_private_key(filename, &dsa);
+    }
+    if (err) {
+        HIP_ERROR("Failed to load private key %s (%d)\n", filename, err);
+        goto out_err;
+    }
+
+    // XX FIX: host_id_hdr->rdata.flags = htons(0x0200); /* key is for a host 
*/
+    if (algo == HIP_HI_RSA) {
+        err = rsa_to_hip_endpoint(rsa, (struct endpoint_hip **) endpoint,
+                                  HIP_ENDPOINT_FLAG_ANON, "");
+    } else {
+        err = dsa_to_hip_endpoint(dsa, (struct endpoint_hip **) endpoint,
+                                  HIP_ENDPOINT_FLAG_ANON, "");
+    }
+    if (err) {
+        HIP_ERROR("Failed to convert private key to HIP endpoint (%d)\n", err);
+        goto out_err;
+    }
+
+out_err:
+
+    if (dsa) {
+        DSA_free(dsa);
+    }
+    if (rsa) {
+        RSA_free(rsa);
+    }
+    if (err && *endpoint) {
+        free(*endpoint);
+    }
+
+    return err;
 }
 
 void free_endpointinfo(struct addrinfo *res)
 {
-  struct addrinfo *tmp;
-
-  HIP_DEBUG("\n");
-
-  while(res) {
-
-    if (res->ai_addr)
-      free(res->ai_addr);
-
-    if (res->ai_canonname)
-      free(res->ai_canonname);
-
-    HIP_DEBUG("Freeing res\n");
-
-    /* Save the next pointer from the data structure before the data
-       structure is freed. */
-    tmp = res;
-    res = tmp->ai_next;
-
-    /* The outermost data structure must be freed last. */
-    free(tmp);
-  }
-
+    struct addrinfo *tmp;
+
+    HIP_DEBUG("\n");
+
+    while (res) {
+        if (res->ai_addr) {
+            free(res->ai_addr);
+        }
+
+        if (res->ai_canonname) {
+            free(res->ai_canonname);
+        }
+
+        HIP_DEBUG("Freeing res\n");
+
+        /* Save the next pointer from the data structure before the data
+         * structure is freed. */
+        tmp = res;
+        res = tmp->ai_next;
+
+        /* The outermost data structure must be freed last. */
+        free(tmp);
+    }
 }
 
 /**
@@ -548,204 +562,214 @@
  * @return zero on success, or negative error value on failure
  */
 int get_localhost_endpointinfo(const char *basename,
-                              const char *servname,
-                              struct addrinfo *hints,
-                              struct addrinfo **res)
+                               const char *servname,
+                               struct addrinfo *hints,
+                               struct addrinfo **res)
 {
-  int err = 0, algo = 0;
-  DSA *dsa = NULL;
-  RSA *rsa = NULL;
-  struct endpoint_hip *endpoint_hip = NULL;
-  char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-  struct if_nameindex *ifaces = NULL;
-  FILE* fp;
-  const char *pub_suffix = "_pub";
-
-  *res = NULL;
-
-  _HIP_DEBUG("glhepi\n");
-  HIP_ASSERT(hints);
-
-  // XX TODO: check flags?
-  memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
-  err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
-  if (err) {
-    HIP_ERROR("gethostname failed (%d)\n", err);
-    err = EEI_NONAME;
-    goto out_err;
-  }
-
-  /* select between anonymous/public HI based on the file name */
-  if(!findsubstring(basename, pub_suffix))
-    hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
-
-  /* System specific HIs should be added into the kernel with the
-     HIP_HI_REUSE_ANY flag set. We set the flag
-     (specific for setmyeid) 'wrongly' here
-     because this way we make the HIs readable by all processes.
-     This function calls setmyeid() internally.. */
-  hints->ai_flags |= HIP_HI_REUSE_ANY;
-
-  /*Support for HITs (14.3.06 Laura)*/
-  hints->ai_flags |= HIP_ENDPOINT_FLAG_HIT;
-
-  /* check the algorithm from PEM format key */
-  fp = fopen(basename, "rb");
-  if (!fp) {
-    HIP_ERROR("Couldn't open key file %s for reading\n", basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  /*Laura 10.4.
-  fgets(first_key_line,30,fp);  //read first line.
-  HIP_DEBUG("1st key line: %s",first_key_line);
-  fclose(fp);
-
-  if(findsubstring(first_key_line, "RSA"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(first_key_line, "DSA"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-  }*/
-
-  HIP_DEBUG("Debug1\n");
-
-
-  if(findsubstring(basename, "rsa"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(basename, "dsa"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-    }
-
-  HIP_DEBUG("Debug2: basename %s\n", basename);
-
-  /* Only private keys are handled. */
-  if(algo == HIP_HI_RSA)
-    err = load_rsa_public_key(basename, &rsa);
-  //err = load_rsa_private_key(basename, &rsa);
-  else
-    err = load_dsa_public_key(basename, &dsa);
+    int err                           = 0, algo = 0;
+    DSA *dsa                          = NULL;
+    RSA *rsa                          = NULL;
+    struct endpoint_hip *endpoint_hip = NULL;
+    char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    struct if_nameindex *ifaces       = NULL;
+    FILE *fp;
+    const char *pub_suffix            = "_pub";
+
+    *res = NULL;
+
+    _HIP_DEBUG("glhepi\n");
+    HIP_ASSERT(hints);
+
+    // XX TODO: check flags?
+    memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
+    err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
+    if (err) {
+        HIP_ERROR("gethostname failed (%d)\n", err);
+        err = EEI_NONAME;
+        goto out_err;
+    }
+
+    /* select between anonymous/public HI based on the file name */
+    if (!findsubstring(basename, pub_suffix)) {
+        hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
+    }
+
+    /* System specific HIs should be added into the kernel with the
+     * HIP_HI_REUSE_ANY flag set. We set the flag
+     * (specific for setmyeid) 'wrongly' here
+     * because this way we make the HIs readable by all processes.
+     * This function calls setmyeid() internally.. */
+    hints->ai_flags |= HIP_HI_REUSE_ANY;
+
+    /*Support for HITs (14.3.06 Laura)*/
+    hints->ai_flags |= HIP_ENDPOINT_FLAG_HIT;
+
+    /* check the algorithm from PEM format key */
+    fp               = fopen(basename, "rb");
+    if (!fp) {
+        HIP_ERROR("Couldn't open key file %s for reading\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    /*Laura 10.4.
+     * fgets(first_key_line,30,fp);  //read first line.
+     * HIP_DEBUG("1st key line: %s",first_key_line);
+     * fclose(fp);
+     *
+     * if(findsubstring(first_key_line, "RSA"))
+     * algo = HIP_HI_RSA;
+     * else if(findsubstring(first_key_line, "DSA"))
+     * algo = HIP_HI_DSA;
+     * else {
+     * HIP_ERROR("Wrong kind of key file: %s\n",basename);
+     * err = -ENOMEM;
+     * goto out_err;
+     * }*/
+
+    HIP_DEBUG("Debug1\n");
+
+
+    if (findsubstring(basename, "rsa")) {
+        algo = HIP_HI_RSA;
+    } else if (findsubstring(basename, "dsa")) {
+        algo = HIP_HI_DSA;
+    } else {
+        HIP_ERROR("Wrong kind of key file: %s\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    HIP_DEBUG("Debug2: basename %s\n", basename);
+
+    /* Only private keys are handled. */
+    if (algo == HIP_HI_RSA) {
+        err = load_rsa_public_key(basename, &rsa);
+    }
+    //err = load_rsa_private_key(basename, &rsa);
+    else {
+        err = load_dsa_public_key(basename, &dsa);
+    }
     //err = load_dsa_private_key(basename, &dsa);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Loading of private key %s failed\n", basename);
-    goto out_err;
-  }
-
-  HIP_DEBUG("Debug3\n");
-
-  if(algo == HIP_HI_RSA)
-    err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, hostname);
-  else
-    err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, hostname);
-  if (err) {
-    HIP_ERROR("Failed to allocate and build endpoint.\n");
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  HIP_DEBUG("Debug4\n");
-
-  _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
-              hip_get_param_total_len(&endpoint_hip->id.host_id));
-
-  _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Loading of private key %s failed\n", basename);
+        goto out_err;
+    }
+
+    HIP_DEBUG("Debug3\n");
+
+    if (algo == HIP_HI_RSA) {
+        err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    } else {
+        err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    }
+    if (err) {
+        HIP_ERROR("Failed to allocate and build endpoint.\n");
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    HIP_DEBUG("Debug4\n");
+
+    _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
+                 hip_get_param_total_len(&endpoint_hip->id.host_id));
+
+    _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
 
 #if 0 /* XX FIXME */
-  ifaces = if_nameindex();
-  if (ifaces == NULL || (ifaces->if_index == 0)) {
-    HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
-    err = 1;
-    goto out_err;
-  }
+    ifaces = if_nameindex();
+    if (ifaces == NULL || (ifaces->if_index == 0)) {
+        HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
+        err = 1;
+        goto out_err;
+    }
 #endif
 
-  *res = calloc(1, sizeof(struct addrinfo));
-  if (!*res) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
-  if (!(*res)->ai_addr) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    int len = strlen(hostname) + 1;
-    if (len > 1) {
-      (*res)->ai_canonname = malloc(len);
-      if (!((*res)->ai_canonname)) {
-       err = EEI_MEMORY;
-       goto out_err;
-      }
-      memcpy((*res)->ai_canonname, hostname, len);
-    }
-  }
+    *res = calloc(1, sizeof(struct addrinfo));
+    if (!*res) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
+    if (!(*res)->ai_addr) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        int len = strlen(hostname) + 1;
+        if (len > 1) {
+            (*res)->ai_canonname = malloc(len);
+            if (!((*res)->ai_canonname)) {
+                err = EEI_MEMORY;
+                goto out_err;
+            }
+            memcpy((*res)->ai_canonname, hostname, len);
+        }
+    }
 
 //  err = setmyeid(((struct sockaddr_eid *) (*res)->ai_addr), servname,
 //              (struct endpoint *) endpoint_hip, ifaces);
-  if (err) {
-    HIP_ERROR("Failed to set up my EID (%d)\n", err);
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
+    if (err) {
+        HIP_ERROR("Failed to set up my EID (%d)\n", err);
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
 
 #ifdef CONFIG_HIP_DEBUG
-  {
-    struct sockaddr_eid *eid = (struct sockaddr_eid *) (*res)->ai_addr;
-    HIP_DEBUG("eid family=%d value=%d\n", eid->eid_family,
-             ntohs(eid->eid_val));
-  }
+    {
+        struct sockaddr_eid *eid = (struct sockaddr_eid *) (*res)->ai_addr;
+        HIP_DEBUG("eid family=%d value=%d\n", eid->eid_family,
+                  ntohs(eid->eid_val));
+    }
 #endif
 
-  (*res)->ai_flags = 0; /* FIXME: what about anonymous identities? */
-  (*res)->ai_family = PF_HIP;
-  (*res)->ai_socktype = hints->ai_socktype;
-  (*res)->ai_protocol = hints->ai_protocol;
-  (*res)->ai_addrlen = sizeof(struct sockaddr_eid);
-  /* ai_addr has already been set */
-  /* canonname has already been set */
-  (*res)->ai_next = NULL; /* only one local HI currently supported */
-
- out_err:
-
-  if (rsa)
-    RSA_free(rsa);
-
- if (dsa)
-    DSA_free(dsa);
-
-  if (endpoint_hip)
-    free(endpoint_hip);
-
-  if (ifaces)
-    if_freenameindex(ifaces);
-
-  /* Free allocated memory on error. Nullify the result in case the
-     caller tries to deallocate the result twice with free_endpointinfo. */
-  if (err) {
-    if (*res) {
-      if ((*res)->ai_addr)
-       free((*res)->ai_addr);
-      if ((*res)->ai_canonname)
-       free((*res)->ai_canonname);
-
-      free(*res);
-      *res = NULL;
-    }
-  }
-
-  return err;
+    (*res)->ai_flags    = 0; /* FIXME: what about anonymous identities? */
+    (*res)->ai_family   = PF_HIP;
+    (*res)->ai_socktype = hints->ai_socktype;
+    (*res)->ai_protocol = hints->ai_protocol;
+    (*res)->ai_addrlen  = sizeof(struct sockaddr_eid);
+    /* ai_addr has already been set */
+    /* canonname has already been set */
+    (*res)->ai_next     = NULL; /* only one local HI currently supported */
+
+out_err:
+
+    if (rsa) {
+        RSA_free(rsa);
+    }
+
+    if (dsa) {
+        DSA_free(dsa);
+    }
+
+    if (endpoint_hip) {
+        free(endpoint_hip);
+    }
+
+    if (ifaces) {
+        if_freenameindex(ifaces);
+    }
+
+    /* Free allocated memory on error. Nullify the result in case the
+     * caller tries to deallocate the result twice with free_endpointinfo. */
+    if (err) {
+        if (*res) {
+            if ((*res)->ai_addr) {
+                free((*res)->ai_addr);
+            }
+            if ((*res)->ai_canonname) {
+                free((*res)->ai_canonname);
+            }
+
+            free(*res);
+            *res = NULL;
+        }
+    }
+
+    return err;
 }
 
 /**
@@ -763,307 +787,317 @@
  * @todo: this function is outdated; query for SO_HIP_GET_HA_INFO instead
  *
  */
-int get_hipd_peer_list(const char *nodename, const char *servname,
-                        const struct addrinfo *hints,
-                        struct addrinfo **res, int alt_flag)
+int get_hipd_peer_list(const char *nodename,
+                       const char *servname,
+                       const struct addrinfo *hints,
+                       struct addrinfo **res,
+                       int alt_flag)
 {
-  int err = 0;
-  struct hip_common *msg = NULL;
-  unsigned int *count, *acount;
-  struct hip_host_id *host_id;
-  hip_hit_t *hit;
-  struct in6_addr *addr;
-  int i, j;
-  struct addrinfo *einfo = NULL;
-  char *fqdn_str;
-  int nodename_str_len = 0;
-  int fqdn_str_len = 0;
-  struct addrinfo *previous_einfo = NULL;
-  /* Only HITs are supported, so endpoint_hip is statically allocated */
-  struct endpoint_hip endpoint_hip;
-  struct addrinfo ai_hints, *ai_tail, *ai_res = NULL;
-  char hit_str[46];
-
-  if (!alt_flag)
-    *res = NULL; /* The NULL value is used in the loop below. */
-
-  HIP_DEBUG("\n");
-  HIP_ASSERT(hints);
-
-  if (nodename != NULL)
-    nodename_str_len = strlen(nodename);
-
-  memset(&ai_hints, 0, sizeof(struct addrinfo));
-  /* ai_hints.ai_flags = hints->ai_flags; */
-  /* Family should be AF_ANY but currently the HIP module supports only IPv6.
-     In any case, the family cannot be copied directly from hints, because
-     it contains PF_HIP. */
-  ai_hints.ai_family = AF_INET6;
-  ai_hints.ai_socktype = hints->ai_socktype;
-  ai_hints.ai_protocol = hints->ai_protocol;
-
-  /* The getaddrinfo is called only once and the results are copied in each
-     element of the endpointinfo linked lists. */
-  err = getaddrinfo(NULL, servname, &ai_hints, &ai_res);
-  if (err) {
-    HIP_ERROR("getaddrinfo failed: %s", gai_strerror(err));
-    goto out_err;
-  }
-
-  /* Call the kernel to get the list of known peer addresses */
-  msg = hip_msg_alloc();
-  if (!msg) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  /* Build the message header */
-  err = hip_build_user_hdr(msg, SO_HIP_GET_PEER_LIST, 0);
-  if (err) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  /* Call the kernel */
-  err = hip_send_recv_daemon_info(msg, 0, 0);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Failed to recv msg\n");
-    goto out_err;
-  }
-
-  /* getsockopt wrote the peer list into the message, now process it
-   * Format is:
-     <unsigned integer> - Number of entries
-     [<host id> - Host identifier
-      <hit> - HIT
-      <unsigned integer> - Number of addresses
-      [<ipv6 address> - IPv6 address
-       ...]
-     ...]
-  */
-  err = hip_get_msg_err(msg);
-  if (err) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  /* Get count of entries in peer list */
-  count = hip_get_param_contents(msg, HIP_PARAM_UINT);
-  if (!count) {
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  for (i = 0; i < *count; i++) {
-    /* Get the next peer HOST ID */
-    host_id = hip_get_param(msg, HIP_PARAM_HOST_ID);
-    if (!host_id) {
-      HIP_ERROR("no host identity pubkey in response\n");
-      err = EEI_SYSTEM;
-      goto out_err;
-    }
-
-    /* Extract the peer hostname, and determine its length */
-    fqdn_str = hip_get_param_host_id_hostname(host_id);
-    fqdn_str_len = strlen(fqdn_str);
-
-    /* Get the peer HIT */
-    hit = (hip_hit_t *) hip_get_param_contents(msg, HIP_PARAM_HIT);
-    if (!hit) {
-      HIP_ERROR("no hit in response\n");
-      err = EEI_SYSTEM;
-      goto out_err;
-    }
-
-    /* Get the number of addresses */
-    acount = hip_get_param_contents(msg, HIP_PARAM_UINT);
-    if (!acount) {
-      err = EEI_SYSTEM;
-      goto out_err;
-    }
-
-    /* Parse the hit into text form for comparison below */
-    hip_in6_ntop((const struct in6_addr *)&hit, hit_str);
-
-    /* Check if the nodename or the endpoint in the hints matches the
-       scanned entries. */
-    if (nodename_str_len && (fqdn_str_len == nodename_str_len) &&
-       (strcmp(fqdn_str, nodename) == 0)) {
-      /* XX FIX: foobar should match to foobar.org, depending on resolv.conf */
-      HIP_DEBUG("Nodename match\n");
-    } else if(hints->ai_addrlen && hints->ai_addr &&
-             (strlen(hit_str) == hints->ai_addrlen) &&
-             (strcmp(hit_str, (char *) hints->ai_addr) == 0)) {
-      HIP_DEBUG("Endpoint match\n");
-    } else if (!nodename_str_len) {
-      HIP_DEBUG("Null nodename, returning as matched\n");
-    } else {
-      /* Not matched, so skip the addresses in the kernel response */
-      for (j = 0; j < *acount; j++) {
-       addr = (struct in6_addr *)hip_get_param_contents(msg,
-                                                        HIP_PARAM_IPV6_ADDR);
-       if (!addr) {
-         HIP_ERROR("no ip addr in response\n");
-         err = EEI_SYSTEM;
-         goto out_err;
-       }
-      }
-      continue;
-    }
-
-    /* Allocate a new endpointinfo */
-    einfo = calloc(1, sizeof(struct addrinfo));
-    if (!einfo) {
-      err = EEI_MEMORY;
-      goto out_err;
-    }
-
-    /* Allocate a new endpoint */
-    einfo->ai_addr = calloc(1, sizeof(struct sockaddr_eid));
-    if (!einfo->ai_addr) {
-      err = EEI_MEMORY;
-      goto out_err;
-    }
-
-    /* Copy the name if the flag is set */
-    if (hints->ai_flags & AI_CANONNAME) {
-      einfo->ai_canonname = malloc(fqdn_str_len + 1);
-      if (!(einfo->ai_canonname)) {
-       err = EEI_MEMORY;
-       goto out_err;
-      }
-      HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
-      strcpy(einfo->ai_canonname, fqdn_str);
-      /* XX FIX: we should append the domain name if it does not exist */
-    }
-
-    _HIP_DEBUG("*** %p %p\n", einfo, previous_einfo);
-
-    HIP_ASSERT(einfo); /* Assertion 1 */
-
-    /* Allocate and fill the HI. Note that here we are assuming that the
-       endpoint is really a HIT. The following assertion checks that we are
-       dealing with a HIT. Change the memory allocations and other code when
-       HIs are really supported. */
-
-    memset(&endpoint_hip, 0, sizeof(struct endpoint_hip));
-    endpoint_hip.family = PF_HIP;
-
-    /* Only HITs are supported, so endpoint_hip is not dynamically allocated
-       and sizeof(endpoint_hip) is enough */
-    endpoint_hip.length = sizeof(struct endpoint_hip);
-    endpoint_hip.flags = HIP_ENDPOINT_FLAG_HIT;
-    memcpy(&endpoint_hip.id.hit, hit, sizeof(struct in6_addr));
-
-    _HIP_HEXDUMP("peer HIT: ", &endpoint_hip.id.hit, sizeof(struct in6_addr));
-
-    HIP_ASSERT(einfo && einfo->ai_addr); /* Assertion 2 */
-
-    /* Now replace the addresses that we got from getaddrinfo in the ai_res
-       structure, with the entries from the kernel. If there are not enough
-       entries already present, allocate and fill new ones */
-    ai_tail = ai_res;
-    for (j = 0; j < *acount; j++, ai_tail = ai_tail->ai_next) {
-      addr = (struct in6_addr *) hip_get_param_contents(msg,
-                                                       HIP_PARAM_IPV6_ADDR);
-      if (!addr) {
-       HIP_ERROR("no ip addr in response\n");
-       err = EEI_SYSTEM;
-       goto out_err;
-      }
-
-      /* Should we always include our entries, even if there are none? */
-      if (!ai_res) continue;
-
-      if (!ai_tail) {
-       /* We ran out of entries, so copy the first one so we get the
-          flags and other info*/
-       ai_tail = malloc(sizeof(struct addrinfo));
-       memcpy(ai_tail, ai_res, sizeof(struct addrinfo));
-       ai_tail->ai_addr = malloc(sizeof(struct sockaddr_in6));
-       memcpy(ai_tail->ai_addr, ai_res->ai_addr,sizeof(struct sockaddr_in6));
-       ai_tail->ai_canonname = malloc(strlen(ai_res->ai_canonname)+1);
-       strcpy(ai_tail->ai_canonname, ai_res->ai_canonname);
-      }
-
-      /* Now, save the address from the kernel */
-      memcpy(&(((struct sockaddr_in6 *)ai_tail->ai_addr)->sin6_addr), addr,
-              sizeof(struct in6_addr));
-    }
-
-    /* Call the kernel for the peer eid */
-    err = setpeereid((struct sockaddr_eid *) einfo->ai_addr, servname,
-                    (struct endpoint *) &endpoint_hip, ai_res);
-    if (err) {
-      HIP_ERROR("association failed (%d): %s\n", err);
-      goto out_err;
-    }
-
-    /* Fill the rest of the fields in the einfo */
-    einfo->ai_flags = hints->ai_flags;
-    einfo->ai_family = PF_HIP;
-    einfo->ai_socktype = hints->ai_socktype;
-    einfo->ai_protocol = hints->ai_protocol;
-    einfo->ai_addrlen = sizeof(struct sockaddr_eid);
-
-    /* The einfo structure has been filled now. Now, append it to the linked
-       list. */
-
-    /* Set res point to the first memory allocation, so that the starting
-       point of the linked list will not be forgotten. The res will be set
-       only once because on the next iteration of the loop it will non-null. */
-    if (!*res)
-      *res = einfo;
-
-    HIP_ASSERT(einfo && einfo->ai_addr && *res); /* 3 */
-
-    /* Link the previous endpoint info structure to this new one. */
-    if (previous_einfo) {
-      previous_einfo->ai_next = einfo;
-    }
-
-    /* Store a pointer to this einfo so that we can link this einfo to the
-       following einfo on the next iteration. */
-    previous_einfo = einfo;
-
-    HIP_ASSERT(einfo && einfo->ai_addr && *res &&
-              previous_einfo == einfo); /* 4 */
-  }
-
-  HIP_DEBUG("Kernel list scanning ended\n");
-
- out_err:
-
-  if (ai_res)
-    freeaddrinfo(ai_res);
-
-  if (msg)
-    hip_msg_free(msg);
-
-  /* Free all of the reserved memory on error */
-  if (err) {
-    /* Assertions 1, 2 and 3: einfo has not been linked to *res and
-       it has to be freed separately. In English: free only einfo
-       if it has not been linked into the *res list */
-    if (einfo && previous_einfo != einfo) {
-      if (einfo->ai_addr)
-       free(einfo->ai_addr);
-      if (einfo->ai_canonname)
-       free(einfo->ai_canonname);
-      free(einfo);
-    }
-
-    /* Assertion 4: einfo has been linked into the *res. Free all of the
-     *res list elements (einfo does not need be freed separately). */
-    if (*res) {
-      free_endpointinfo(*res);
-      /* In case the caller of tries to free the res again */
-      *res = NULL;
-    }
-  }
-
-  return err;
+    int err                = 0;
+    struct hip_common *msg = NULL;
+    unsigned int *count, *acount;
+    struct hip_host_id *host_id;
+    hip_hit_t *hit;
+    struct in6_addr *addr;
+    int i, j;
+    struct addrinfo *einfo          = NULL;
+    char *fqdn_str;
+    int nodename_str_len            = 0;
+    int fqdn_str_len                = 0;
+    struct addrinfo *previous_einfo = NULL;
+    /* Only HITs are supported, so endpoint_hip is statically allocated */
+    struct endpoint_hip endpoint_hip;
+    struct addrinfo ai_hints, *ai_tail, *ai_res = NULL;
+    char hit_str[46];
+
+    if (!alt_flag) {
+        *res = NULL; /* The NULL value is used in the loop below. */
+    }
+    HIP_DEBUG("\n");
+    HIP_ASSERT(hints);
+
+    if (nodename != NULL) {
+        nodename_str_len = strlen(nodename);
+    }
+
+    memset(&ai_hints, 0, sizeof(struct addrinfo));
+    /* ai_hints.ai_flags = hints->ai_flags; */
+    /* Family should be AF_ANY but currently the HIP module supports only IPv6.
+     * In any case, the family cannot be copied directly from hints, because
+     * it contains PF_HIP. */
+    ai_hints.ai_family   = AF_INET6;
+    ai_hints.ai_socktype = hints->ai_socktype;
+    ai_hints.ai_protocol = hints->ai_protocol;
+
+    /* The getaddrinfo is called only once and the results are copied in each
+     * element of the endpointinfo linked lists. */
+    err                  = getaddrinfo(NULL, servname, &ai_hints, &ai_res);
+    if (err) {
+        HIP_ERROR("getaddrinfo failed: %s", gai_strerror(err));
+        goto out_err;
+    }
+
+    /* Call the kernel to get the list of known peer addresses */
+    msg = hip_msg_alloc();
+    if (!msg) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    /* Build the message header */
+    err = hip_build_user_hdr(msg, SO_HIP_GET_PEER_LIST, 0);
+    if (err) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    /* Call the kernel */
+    err = hip_send_recv_daemon_info(msg, 0, 0);
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Failed to recv msg\n");
+        goto out_err;
+    }
+
+    /* getsockopt wrote the peer list into the message, now process it
+     * Format is:
+     * <unsigned integer> - Number of entries
+     * [<host id> - Host identifier
+     *  <hit> - HIT
+     *  <unsigned integer> - Number of addresses
+     *  [<ipv6 address> - IPv6 address
+     *   ...]
+     * ...]
+     */
+    err = hip_get_msg_err(msg);
+    if (err) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    /* Get count of entries in peer list */
+    count = hip_get_param_contents(msg, HIP_PARAM_UINT);
+    if (!count) {
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    for (i = 0; i < *count; i++) {
+        /* Get the next peer HOST ID */
+        host_id = hip_get_param(msg, HIP_PARAM_HOST_ID);
+        if (!host_id) {
+            HIP_ERROR("no host identity pubkey in response\n");
+            err = EEI_SYSTEM;
+            goto out_err;
+        }
+
+        /* Extract the peer hostname, and determine its length */
+        fqdn_str     = hip_get_param_host_id_hostname(host_id);
+        fqdn_str_len = strlen(fqdn_str);
+
+        /* Get the peer HIT */
+        hit          = (hip_hit_t *) hip_get_param_contents(msg, 
HIP_PARAM_HIT);
+        if (!hit) {
+            HIP_ERROR("no hit in response\n");
+            err = EEI_SYSTEM;
+            goto out_err;
+        }
+
+        /* Get the number of addresses */
+        acount = hip_get_param_contents(msg, HIP_PARAM_UINT);
+        if (!acount) {
+            err = EEI_SYSTEM;
+            goto out_err;
+        }
+
+        /* Parse the hit into text form for comparison below */
+        hip_in6_ntop((const struct in6_addr *) &hit, hit_str);
+
+        /* Check if the nodename or the endpoint in the hints matches the
+         * scanned entries. */
+        if (nodename_str_len && (fqdn_str_len == nodename_str_len) &&
+            (strcmp(fqdn_str, nodename) == 0)) {
+            /* XX FIX: foobar should match to foobar.org, depending on 
resolv.conf */
+            HIP_DEBUG("Nodename match\n");
+        } else if (hints->ai_addrlen && hints->ai_addr &&
+                   (strlen(hit_str) == hints->ai_addrlen) &&
+                   (strcmp(hit_str, (char *) hints->ai_addr) == 0)) {
+            HIP_DEBUG("Endpoint match\n");
+        } else if (!nodename_str_len) {
+            HIP_DEBUG("Null nodename, returning as matched\n");
+        } else {
+            /* Not matched, so skip the addresses in the kernel response */
+            for (j = 0; j < *acount; j++) {
+                addr = (struct in6_addr *) hip_get_param_contents(msg,
+                                                                  
HIP_PARAM_IPV6_ADDR);
+                if (!addr) {
+                    HIP_ERROR("no ip addr in response\n");
+                    err = EEI_SYSTEM;
+                    goto out_err;
+                }
+            }
+            continue;
+        }
+
+        /* Allocate a new endpointinfo */
+        einfo = calloc(1, sizeof(struct addrinfo));
+        if (!einfo) {
+            err = EEI_MEMORY;
+            goto out_err;
+        }
+
+        /* Allocate a new endpoint */
+        einfo->ai_addr = calloc(1, sizeof(struct sockaddr_eid));
+        if (!einfo->ai_addr) {
+            err = EEI_MEMORY;
+            goto out_err;
+        }
+
+        /* Copy the name if the flag is set */
+        if (hints->ai_flags & AI_CANONNAME) {
+            einfo->ai_canonname = malloc(fqdn_str_len + 1);
+            if (!(einfo->ai_canonname)) {
+                err = EEI_MEMORY;
+                goto out_err;
+            }
+            HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
+            strcpy(einfo->ai_canonname, fqdn_str);
+            /* XX FIX: we should append the domain name if it does not exist */
+        }
+
+        _HIP_DEBUG("*** %p %p\n", einfo, previous_einfo);
+
+        HIP_ASSERT(einfo); /* Assertion 1 */
+
+        /* Allocate and fill the HI. Note that here we are assuming that the
+         * endpoint is really a HIT. The following assertion checks that we are
+         * dealing with a HIT. Change the memory allocations and other code 
when
+         * HIs are really supported. */
+
+        memset(&endpoint_hip, 0, sizeof(struct endpoint_hip));
+        endpoint_hip.family = PF_HIP;
+
+        /* Only HITs are supported, so endpoint_hip is not dynamically 
allocated
+         * and sizeof(endpoint_hip) is enough */
+        endpoint_hip.length = sizeof(struct endpoint_hip);
+        endpoint_hip.flags  = HIP_ENDPOINT_FLAG_HIT;
+        memcpy(&endpoint_hip.id.hit, hit, sizeof(struct in6_addr));
+
+        _HIP_HEXDUMP("peer HIT: ", &endpoint_hip.id.hit, sizeof(struct 
in6_addr));
+
+        HIP_ASSERT(einfo && einfo->ai_addr); /* Assertion 2 */
+
+        /* Now replace the addresses that we got from getaddrinfo in the ai_res
+         * structure, with the entries from the kernel. If there are not enough
+         * entries already present, allocate and fill new ones */
+        ai_tail = ai_res;
+        for (j = 0; j < *acount; j++, ai_tail = ai_tail->ai_next) {
+            addr = (struct in6_addr *) hip_get_param_contents(msg,
+                                                              
HIP_PARAM_IPV6_ADDR);
+            if (!addr) {
+                HIP_ERROR("no ip addr in response\n");
+                err = EEI_SYSTEM;
+                goto out_err;
+            }
+
+            /* Should we always include our entries, even if there are none? */
+            if (!ai_res) {
+                continue;
+            }
+
+            if (!ai_tail) {
+                /* We ran out of entries, so copy the first one so we get the
+                 * flags and other info*/
+                ai_tail               = malloc(sizeof(struct addrinfo));
+                memcpy(ai_tail, ai_res, sizeof(struct addrinfo));
+                ai_tail->ai_addr      = malloc(sizeof(struct sockaddr_in6));
+                memcpy(ai_tail->ai_addr, ai_res->ai_addr, sizeof(struct 
sockaddr_in6));
+                ai_tail->ai_canonname = malloc(strlen(ai_res->ai_canonname) + 
1);
+                strcpy(ai_tail->ai_canonname, ai_res->ai_canonname);
+            }
+
+            /* Now, save the address from the kernel */
+            memcpy(&(((struct sockaddr_in6 *) ai_tail->ai_addr)->sin6_addr), 
addr,
+                   sizeof(struct in6_addr));
+        }
+
+        /* Call the kernel for the peer eid */
+        err = setpeereid((struct sockaddr_eid *) einfo->ai_addr, servname,
+                         (struct endpoint *) &endpoint_hip, ai_res);
+        if (err) {
+            HIP_ERROR("association failed (%d): %s\n", err);
+            goto out_err;
+        }
+
+        /* Fill the rest of the fields in the einfo */
+        einfo->ai_flags    = hints->ai_flags;
+        einfo->ai_family   = PF_HIP;
+        einfo->ai_socktype = hints->ai_socktype;
+        einfo->ai_protocol = hints->ai_protocol;
+        einfo->ai_addrlen  = sizeof(struct sockaddr_eid);
+
+        /* The einfo structure has been filled now. Now, append it to the 
linked
+         * list. */
+
+        /* Set res point to the first memory allocation, so that the starting
+         * point of the linked list will not be forgotten. The res will be set
+         * only once because on the next iteration of the loop it will 
non-null. */
+        if (!*res) {
+            *res = einfo;
+        }
+
+        HIP_ASSERT(einfo && einfo->ai_addr && *res); /* 3 */
+
+        /* Link the previous endpoint info structure to this new one. */
+        if (previous_einfo) {
+            previous_einfo->ai_next = einfo;
+        }
+
+        /* Store a pointer to this einfo so that we can link this einfo to the
+         * following einfo on the next iteration. */
+        previous_einfo = einfo;
+
+        HIP_ASSERT(einfo && einfo->ai_addr && *res &&
+                   previous_einfo == einfo); /* 4 */
+    }
+
+    HIP_DEBUG("Kernel list scanning ended\n");
+
+out_err:
+
+    if (ai_res) {
+        freeaddrinfo(ai_res);
+    }
+
+    if (msg) {
+        hip_msg_free(msg);
+    }
+
+    /* Free all of the reserved memory on error */
+    if (err) {
+        /* Assertions 1, 2 and 3: einfo has not been linked to *res and
+         * it has to be freed separately. In English: free only einfo
+         * if it has not been linked into the *res list */
+        if (einfo && previous_einfo != einfo) {
+            if (einfo->ai_addr) {
+                free(einfo->ai_addr);
+            }
+            if (einfo->ai_canonname) {
+                free(einfo->ai_canonname);
+            }
+            free(einfo);
+        }
+
+        /* Assertion 4: einfo has been linked into the *res. Free all of the
+         *res list elements (einfo does not need be freed separately). */
+        if (*res) {
+            free_endpointinfo(*res);
+            /* In case the caller of tries to free the res again */
+            *res = NULL;
+        }
+    }
+
+    return err;
 }
 
 /**
@@ -1080,736 +1114,754 @@
  *
  */
 int get_peer_endpointinfo(const char *hostsfile,
-                         const char *nodename,
-                         const char *servname,
-                         const struct addrinfo *hints,
-                         struct addrinfo **res)
+                          const char *nodename,
+                          const char *servname,
+                          const struct addrinfo *hints,
+                          struct addrinfo **res)
 {
-  int err = 0, match_found = 0;
-  unsigned int fqdn_str_len = 0;
-  FILE *hosts = NULL;
-  char fqdn_str[HOST_NAME_MAX];
-  struct addrinfo *einfo = NULL;
-  struct addrinfo ai_hints, *ai_res = NULL;
-  struct addrinfo *previous_einfo = NULL;
-  /* Only HITs are supported, so endpoint_hip is statically allocated */
-  struct endpoint_hip endpoint_hip;
-  struct in6_addr hit;
-  List mylist;
-
-  *res = NULL; /* The NULL value is used in the loop below. */
-
-  HIP_DEBUG("\n");
-
-  HIP_ASSERT(nodename);
-  HIP_ASSERT(hints);
-
-  hosts = fopen(hostsfile, "r");
-  if (!hosts) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Failed to open %s\n", hostsfile);
-    goto out_err;
-  }
-
-  memset(&ai_hints, 0, sizeof(struct addrinfo));
-  ai_hints.ai_flags = hints->ai_flags;
-  /* Family should be AF_ANY but currently the HIP module supports only IPv6.
-     In any case, the family cannot be copied directly from hints, because
-     it contains PF_HIP. */
-  ai_hints.ai_family = AF_INET6;
-  ai_hints.ai_socktype = hints->ai_socktype;
-  ai_hints.ai_protocol = hints->ai_protocol;
-
-  /* The getaddrinfo is called only once and the results are copied in each
-     element of the endpointinfo linked lists. */
-  err = getaddrinfo(nodename, servname, &ai_hints, &ai_res);
-  if (err) {
-    HIP_ERROR("getaddrinfo failed: %s\n", gai_strerror(err));
-    goto fallback;
-  }
-
-  /*! \todo check and handle flags here */
-
-  HIP_ASSERT(!*res); /* Pre-loop invariable */
-
-  //HIP_IFEL(err, -1, "Failed to map id to hostname\n");
-
-  memset(fqdn_str, 0, sizeof(fqdn_str));
-  if (inet_pton(AF_INET6, nodename, &hit) > 0) {
-    _HIP_DEBUG("Nodename is numerical address\n");
-    err = (hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
-                                      hip_map_first_id_to_hostname_from_hosts,
-                                      &hit, fqdn_str) &&
-               hip_for_each_hosts_file_line(HOSTS_FILE,
-                                      hip_map_first_id_to_hostname_from_hosts,
-                                      &hit, fqdn_str));
-  } else {
-    strncpy(fqdn_str, nodename, HOST_NAME_MAX);
-  }
-  fqdn_str_len = strlen(fqdn_str);
-
-  if (!err && (!hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
-                                  hip_map_first_hostname_to_hit_from_hosts,
-                                  fqdn_str, &hit) ||
-               !hip_for_each_hosts_file_line(HOSTS_FILE,
-                                  hip_map_first_hostname_to_hit_from_hosts,
-                                  fqdn_str, &hit)))
-    /* create endpointinfo structure for every HIT */
-    {
-      einfo = calloc(1, sizeof(struct addrinfo));
-
-      HIP_IFE(!einfo, EEI_MEMORY);
-      
-      einfo->ai_addr = calloc(1, sizeof(struct sockaddr_eid));
-      HIP_IFE(!einfo->ai_addr, EEI_MEMORY);
-
-      if (hints->ai_flags & AI_CANONNAME) {
-       einfo->ai_canonname = malloc(fqdn_str_len + 1);
-       HIP_IFE(!einfo->ai_canonname, EEI_MEMORY);
-       HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
-       strcpy(einfo->ai_canonname, fqdn_str);
-       /* XX FIX: we should append the domain name if it does not exist */
-      }
-
-      _HIP_DEBUG("*** %p %p\n", einfo, previous_einfo);
-
-      HIP_ASSERT(einfo); /* Assertion 1 */
-
-      /* Allocate and fill the HI. Note that here we are assuming that the
-        endpoint is really a HIT. The following assertion checks that we are
-        dealing with a HIT. Change the memory allocations and other code when
-        HIs are really supported. */
-      //THIS ISN'T TRUE ALWAYS: _HIP_ASSERT(hi_str_len == 4 * 8 + 7 * 1);
-
-      memset(&endpoint_hip, 0, sizeof(struct endpoint_hip));
-      endpoint_hip.family = PF_HIP;
-
-      /* Only HITs are supported, so endpoint_hip is not dynamically allocated
-        and sizeof(endpoint_hip) is enough */
-      endpoint_hip.length = sizeof(struct endpoint_hip);
-      endpoint_hip.flags = HIP_ENDPOINT_FLAG_HIT;
-
-      ipv6_addr_copy(&endpoint_hip.id.hit, &hit);
-
-      HIP_ASSERT(einfo && einfo->ai_addr); /* Assertion 2 */
-
-      err = setpeereid((struct sockaddr_eid *) einfo->ai_addr, servname,
-                      (struct endpoint *) &endpoint_hip, ai_res);
-      if (err) {
-       HIP_ERROR("association failed (%d): %s\n", err);
-       goto out_err;
-      }
-
-      /* Fill the rest of the fields in the einfo */
-      einfo->ai_flags = hints->ai_flags;
-      einfo->ai_family = PF_HIP;
-      einfo->ai_socktype = hints->ai_socktype;
-      einfo->ai_protocol = hints->ai_protocol;
-      einfo->ai_addrlen = sizeof(struct sockaddr_eid);
-
-      /* The einfo structure has been filled now. Now, append it to the linked
-        list. */
-
-      /* Set res point to the first memory allocation, so that the starting
-        point of the linked list will not be forgotten. The res will be set
-        only once because on the next iteration of the loop it will non-null.
-      */
-      if (!*res)
-       *res = einfo;
-
-      HIP_ASSERT(einfo && einfo->ai_addr && *res); /* 3 */
-
-      /* Link the previous endpoint info structure to this new one. */
-      if (previous_einfo) {
-       previous_einfo->ai_next = einfo;
-      }
-
-      /* Store a pointer to this einfo so that we can link this einfo to the
-        following einfo on the next iteration. */
-      previous_einfo = einfo;
-
-      HIP_ASSERT(einfo && einfo->ai_addr && *res &&
-                previous_einfo == einfo); /* 4 */
-      destroy(&mylist);
-  }
-
-  _HIP_DEBUG("Scanning ended\n");
-
-
- fallback:
+    int err                         = 0, match_found = 0;
+    unsigned int fqdn_str_len       = 0;
+    FILE *hosts                     = NULL;
+    char fqdn_str[HOST_NAME_MAX];
+    struct addrinfo *einfo          = NULL;
+    struct addrinfo ai_hints, *ai_res = NULL;
+    struct addrinfo *previous_einfo = NULL;
+    /* Only HITs are supported, so endpoint_hip is statically allocated */
+    struct endpoint_hip endpoint_hip;
+    struct in6_addr hit;
+    List mylist;
+
+    *res = NULL; /* The NULL value is used in the loop below. */
+
+    HIP_DEBUG("\n");
+
+    HIP_ASSERT(nodename);
+    HIP_ASSERT(hints);
+
+    hosts = fopen(hostsfile, "r");
+    if (!hosts) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Failed to open %s\n", hostsfile);
+        goto out_err;
+    }
+
+    memset(&ai_hints, 0, sizeof(struct addrinfo));
+    ai_hints.ai_flags    = hints->ai_flags;
+    /* Family should be AF_ANY but currently the HIP module supports only IPv6.
+     * In any case, the family cannot be copied directly from hints, because
+     * it contains PF_HIP. */
+    ai_hints.ai_family   = AF_INET6;
+    ai_hints.ai_socktype = hints->ai_socktype;
+    ai_hints.ai_protocol = hints->ai_protocol;
+
+    /* The getaddrinfo is called only once and the results are copied in each
+     * element of the endpointinfo linked lists. */
+    err                  = getaddrinfo(nodename, servname, &ai_hints, &ai_res);
+    if (err) {
+        HIP_ERROR("getaddrinfo failed: %s\n", gai_strerror(err));
+        goto fallback;
+    }
+
+    /*! \todo check and handle flags here */
+
+    HIP_ASSERT(!*res); /* Pre-loop invariable */
+
+    //HIP_IFEL(err, -1, "Failed to map id to hostname\n");
+
+    memset(fqdn_str, 0, sizeof(fqdn_str));
+    if (inet_pton(AF_INET6, nodename, &hit) > 0) {
+        _HIP_DEBUG("Nodename is numerical address\n");
+        err = (hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
+                                            
hip_map_first_id_to_hostname_from_hosts,
+                                            &hit, fqdn_str) &&
+               hip_for_each_hosts_file_line(HOSTS_FILE,
+                                            
hip_map_first_id_to_hostname_from_hosts,
+                                            &hit, fqdn_str));
+    } else {
+        strncpy(fqdn_str, nodename, HOST_NAME_MAX);
+    }
+    fqdn_str_len = strlen(fqdn_str);
+
+    if (!err && (!hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
+                                               
hip_map_first_hostname_to_hit_from_hosts,
+                                               fqdn_str, &hit) ||
+                 !hip_for_each_hosts_file_line(HOSTS_FILE,
+                                               
hip_map_first_hostname_to_hit_from_hosts,
+                                               fqdn_str, &hit))) {
+        /* create endpointinfo structure for every HIT */
+        einfo          = calloc(1, sizeof(struct addrinfo));
+
+        HIP_IFE(!einfo, EEI_MEMORY);
+
+        einfo->ai_addr = calloc(1, sizeof(struct sockaddr_eid));
+        HIP_IFE(!einfo->ai_addr, EEI_MEMORY);
+
+        if (hints->ai_flags & AI_CANONNAME) {
+            einfo->ai_canonname = malloc(fqdn_str_len + 1);
+            HIP_IFE(!einfo->ai_canonname, EEI_MEMORY);
+            HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
+            strcpy(einfo->ai_canonname, fqdn_str);
+            /* XX FIX: we should append the domain name if it does not exist */
+        }
+
+        _HIP_DEBUG("*** %p %p\n", einfo, previous_einfo);
+
+        HIP_ASSERT(einfo); /* Assertion 1 */
+
+        /* Allocate and fill the HI. Note that here we are assuming that the
+         * endpoint is really a HIT. The following assertion checks that we are
+         * dealing with a HIT. Change the memory allocations and other code 
when
+         * HIs are really supported. */
+        //THIS ISN'T TRUE ALWAYS: _HIP_ASSERT(hi_str_len == 4 * 8 + 7 * 1);
+
+        memset(&endpoint_hip, 0, sizeof(struct endpoint_hip));
+        endpoint_hip.family = PF_HIP;
+
+        /* Only HITs are supported, so endpoint_hip is not dynamically 
allocated
+         * and sizeof(endpoint_hip) is enough */
+        endpoint_hip.length = sizeof(struct endpoint_hip);
+        endpoint_hip.flags  = HIP_ENDPOINT_FLAG_HIT;
+
+        ipv6_addr_copy(&endpoint_hip.id.hit, &hit);
+
+        HIP_ASSERT(einfo && einfo->ai_addr); /* Assertion 2 */
+
+        err = setpeereid((struct sockaddr_eid *) einfo->ai_addr, servname,
+                         (struct endpoint *) &endpoint_hip, ai_res);
+        if (err) {
+            HIP_ERROR("association failed (%d): %s\n", err);
+            goto out_err;
+        }
+
+        /* Fill the rest of the fields in the einfo */
+        einfo->ai_flags    = hints->ai_flags;
+        einfo->ai_family   = PF_HIP;
+        einfo->ai_socktype = hints->ai_socktype;
+        einfo->ai_protocol = hints->ai_protocol;
+        einfo->ai_addrlen  = sizeof(struct sockaddr_eid);
+
+        /* The einfo structure has been filled now. Now, append it to the 
linked
+         * list. */
+
+        /* Set res point to the first memory allocation, so that the starting
+         * point of the linked list will not be forgotten. The res will be set
+         * only once because on the next iteration of the loop it will 
non-null.
+         */
+        if (!*res) {
+            *res = einfo;
+        }
+
+        HIP_ASSERT(einfo && einfo->ai_addr && *res); /* 3 */
+
+        /* Link the previous endpoint info structure to this new one. */
+        if (previous_einfo) {
+            previous_einfo->ai_next = einfo;
+        }
+
+        /* Store a pointer to this einfo so that we can link this einfo to the
+         * following einfo on the next iteration. */
+        previous_einfo = einfo;
+
+        HIP_ASSERT(einfo && einfo->ai_addr && *res &&
+                   previous_einfo == einfo); /* 4 */
+        destroy(&mylist);
+    }
+
+    _HIP_DEBUG("Scanning ended\n");
+
+
+fallback:
 
 #if 0 /* XX FIXME: the function below does not work */
-  /* If no entries are found, fallback on the kernel's list */
-  if (!*res) {
-    HIP_DEBUG("No entries found, querying hipd for entries\n");
-    err = get_hipd_peer_list(nodename, servname, hints, res, 1);
+    /* If no entries are found, fallback on the kernel's list */
+    if (!*res) {
+        HIP_DEBUG("No entries found, querying hipd for entries\n");
+        err = get_hipd_peer_list(nodename, servname, hints, res, 1);
+        if (err) {
+            HIP_ERROR("Failed to get kernel peer list (%d)\n", err);
+            goto out_err;
+        }
+        HIP_DEBUG("Done with hipd entries\n");
+        if (*res) {
+            match_found = 1;
+        }
+    }
+#endif
+
+    HIP_ASSERT(err == 0);
+
+    if (!match_found) {
+        err = EEI_NONAME;
+    }
+
+out_err:
+
+    if (ai_res) {
+        freeaddrinfo(ai_res);
+    }
+
+    if (hosts) {
+        fclose(hosts);
+    }
+
+    /* Free all of the reserved memory on error */
     if (err) {
-      HIP_ERROR("Failed to get kernel peer list (%d)\n", err);
-      goto out_err;
-    }
-    HIP_DEBUG("Done with hipd entries\n");
-    if (*res) {
-      match_found = 1;
-    }
-  }
-#endif
-
-  HIP_ASSERT(err == 0);
-
-  if (!match_found) {
-    err = EEI_NONAME;
-  }
-
- out_err:
-
-  if (ai_res)
-    freeaddrinfo(ai_res);
-
-  if (hosts)
-    fclose(hosts);
-
-  /* Free all of the reserved memory on error */
-  if (err) {
-    /* Assertions 1, 2 and 3: einfo has not been linked to *res and
-       it has to be freed separately. In English: free only einfo
-       if it has not been linked into the *res list */
-    if (einfo && previous_einfo != einfo) {
-      if (einfo->ai_addr)
-       free(einfo->ai_addr);
-      if (einfo->ai_canonname)
-       free(einfo->ai_canonname);
-      free(einfo);
-    }
-
-    /* Assertion 4: einfo has been linked into the *res. Free all of the
-     *res list elements (einfo does not need be freed separately). */
-    if (*res) {
-      free_endpointinfo(*res);
-      /* In case the caller of tries to free the res again */
-      *res = NULL;
-    }
-  }
-  return err;
+        /* Assertions 1, 2 and 3: einfo has not been linked to *res and
+         * it has to be freed separately. In English: free only einfo
+         * if it has not been linked into the *res list */
+        if (einfo && previous_einfo != einfo) {
+            if (einfo->ai_addr) {
+                free(einfo->ai_addr);
+            }
+            if (einfo->ai_canonname) {
+                free(einfo->ai_canonname);
+            }
+            free(einfo);
+        }
+
+        /* Assertion 4: einfo has been linked into the *res. Free all of the
+         *res list elements (einfo does not need be freed separately). */
+        if (*res) {
+            free_endpointinfo(*res);
+            /* In case the caller of tries to free the res again */
+            *res = NULL;
+        }
+    }
+    return err;
 }
 
 int getendpointinfo(const char *nodename, const char *servname,
-                   const struct addrinfo *hints,
-                   struct addrinfo **res)
+                    const struct addrinfo *hints,
+                    struct addrinfo **res)
 {
-  int err = 0;
-  struct addrinfo modified_hints;
-  struct addrinfo *first, *current, *new;
-  char *filenamebase = NULL;
-  int filenamebase_len, ret, i;
-  List list;
-
-  initlist(&list);
-
-  /* Only HIP is currently supported */
-  if (hints && hints->ai_family != PF_HIP) {
-    err = -EAI_FAMILY;
-    HIP_ERROR("Only HIP is currently supported\n");
-    goto err_out;
-  }
-  /* XX:TODO Check flag values from hints!!!
-   E.g. EI_HI_ANY* should cause the resolver to output only a single socket
-   address containing an ED that would be received using the corresponding
-   HIP_HI_*ANY macro. EI_ANON flag causes the resolver to return only local
-   anonymous ids.
-  */
-
-  if (hints) {
-    memcpy(&modified_hints, hints, sizeof(struct addrinfo));
-  } else {
-    /* No hints given, assign default hints */
-    memset(&modified_hints, 0, sizeof(struct addrinfo));
-    modified_hints.ai_family = PF_HIP;
-  }
-  /* getaddrinfo has been modified to support the legacy HIP API and this
-     ensures that the legacy API does not do anything funny */
-  modified_hints.ai_flags |= AI_HIP_NATIVE;
-
-  /* Note about the hints: the hints is overloaded with AI_XX and EI_XX flags.
-     We make the (concious and lazy) decision not to separate them into
-     different flags and assume that both getendpointinfo and getaddrinfo
-     can survive the overloaded flags. The AI_XX and EI_XX in netdb.h have
-     distinct values, so this should be ok. */
+    int err            = 0;
+    struct addrinfo modified_hints;
+    struct addrinfo *first, *current, *new;
+    char *filenamebase = NULL;
+    int filenamebase_len, ret, i;
+    List list;
+
+    initlist(&list);
+
+    /* Only HIP is currently supported */
+    if (hints && hints->ai_family != PF_HIP) {
+        err = -EAI_FAMILY;
+        HIP_ERROR("Only HIP is currently supported\n");
+        goto err_out;
+    }
+    /* XX:TODO Check flag values from hints!!!
+     * E.g. EI_HI_ANY* should cause the resolver to output only a single socket
+     * address containing an ED that would be received using the corresponding
+     * HIP_HI_*ANY macro. EI_ANON flag causes the resolver to return only local
+     * anonymous ids.
+     */
+
+    if (hints) {
+        memcpy(&modified_hints, hints, sizeof(struct addrinfo));
+    } else {
+        /* No hints given, assign default hints */
+        memset(&modified_hints, 0, sizeof(struct addrinfo));
+        modified_hints.ai_family = PF_HIP;
+    }
+    /* getaddrinfo has been modified to support the legacy HIP API and this
+     * ensures that the legacy API does not do anything funny */
+    modified_hints.ai_flags |= AI_HIP_NATIVE;
+
+    /* Note about the hints: the hints is overloaded with AI_XX and EI_XX 
flags.
+     * We make the (concious and lazy) decision not to separate them into
+     * different flags and assume that both getendpointinfo and getaddrinfo
+     * can survive the overloaded flags. The AI_XX and EI_XX in netdb.h have
+     * distinct values, so this should be ok. */
 
 #if 0 /* the function below should be reimplemented */
-  /* Check for kernel list request */
-  if (modified_hints.ai_flags & AI_KERNEL_LIST) {
-    err = get_hipd_peer_list(nodename, servname, &modified_hints, res, 0);
-    goto err_out;
-  }
+    /* Check for kernel list request */
+    if (modified_hints.ai_flags & AI_KERNEL_LIST) {
+        err = get_hipd_peer_list(nodename, servname, &modified_hints, res, 0);
+        goto err_out;
+    }
 #endif
 
-  if (nodename == NULL) {
-    *res = calloc(1, sizeof(struct addrinfo));
-    if (!*res) {
-      err = EEI_MEMORY;
-      goto err_out;
-    }
-
-    /*DEFAULT_CONFIG_DIR = /etc/hip/*/
-    findkeyfiles(DEFAULT_CONFIG_DIR, &list);
-
-    /* allocate the first endpointinfo
-       and then link the others to it */
-
-    filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
-      strlen(getitem(&list,0)) + 1;
-
-    filenamebase = malloc(filenamebase_len);
-    if (!filenamebase) {
-      HIP_ERROR("Couldn't allocate file name\n");
-      err = -ENOMEM;
-      goto err_out;
-    }
-    ret = snprintf(filenamebase, filenamebase_len, "%s/%s",
-                  DEFAULT_CONFIG_DIR,
-                  getitem(&list,0));
-    if (ret <= 0) {
-      err = -EINVAL;
-      goto err_out;
-    }
-    err = get_localhost_endpointinfo(filenamebase, servname,
-                                    &modified_hints, &first);
-
-    free(filenamebase);
-    current = first;
-
-    for(i=1; i<length(&list); i++) {
-      _HIP_DEBUG ("%s\n", getitem(&list,i));
-
-      filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
-       strlen(getitem(&list,i)) + 1;
-
-      filenamebase = malloc(filenamebase_len);
-      if (!filenamebase) {
-       HIP_ERROR("Couldn't allocate file name\n");
-       err = -ENOMEM;
-       goto err_out;
-      }
-
-      ret = snprintf(filenamebase, filenamebase_len, "%s/%s",
-                    DEFAULT_CONFIG_DIR,
-                    getitem(&list,i));
-      if (ret <= 0) {
-       err = -EINVAL;
-       goto err_out;
-      }
-
-      err = get_localhost_endpointinfo(filenamebase, servname,
-                                      &modified_hints, &new);
-      if (err) {
-       HIP_ERROR("get_localhost_endpointinfo() failed\n");
-       goto err_out;
-      }
-
-      current->ai_next = new;
-      current = new;
-
-    }
-
-    *res = first;
-
-  } else {
+    if (nodename == NULL) {
+        *res = calloc(1, sizeof(struct addrinfo));
+        if (!*res) {
+            err = EEI_MEMORY;
+            goto err_out;
+        }
+
+        /*DEFAULT_CONFIG_DIR = /etc/hip/*/
+        findkeyfiles(DEFAULT_CONFIG_DIR, &list);
+
+        /* allocate the first endpointinfo
+         * and then link the others to it */
+
+        filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
+                           strlen(getitem(&list, 0)) + 1;
+
+        filenamebase     = malloc(filenamebase_len);
+        if (!filenamebase) {
+            HIP_ERROR("Couldn't allocate file name\n");
+            err = -ENOMEM;
+            goto err_out;
+        }
+        ret = snprintf(filenamebase, filenamebase_len, "%s/%s",
+                       DEFAULT_CONFIG_DIR,
+                       getitem(&list, 0));
+        if (ret <= 0) {
+            err = -EINVAL;
+            goto err_out;
+        }
+        err     = get_localhost_endpointinfo(filenamebase, servname,
+                                             &modified_hints, &first);
+
+        free(filenamebase);
+        current = first;
+
+        for (i = 1; i < length(&list); i++) {
+            _HIP_DEBUG("%s\n", getitem(&list, i));
+
+            filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
+                               strlen(getitem(&list, i)) + 1;
+
+            filenamebase     = malloc(filenamebase_len);
+            if (!filenamebase) {
+                HIP_ERROR("Couldn't allocate file name\n");
+                err = -ENOMEM;
+                goto err_out;
+            }
+
+            ret = snprintf(filenamebase, filenamebase_len, "%s/%s",
+                           DEFAULT_CONFIG_DIR,
+                           getitem(&list, i));
+            if (ret <= 0) {
+                err = -EINVAL;
+                goto err_out;
+            }
+
+            err = get_localhost_endpointinfo(filenamebase, servname,
+                                             &modified_hints, &new);
+            if (err) {
+                HIP_ERROR("get_localhost_endpointinfo() failed\n");
+                goto err_out;
+            }
+
+            current->ai_next = new;
+            current          = new;
+        }
+
+        *res = first;
+    } else {
 #ifdef CONFIG_HIP_AGENT
-    /* Communicate the name and port output to the agent
-       synchronously with netlink. First send the name + port
-       and then wait for answer (select). The agent filters
-       or modifies the list. The agent implements get_peer_endpointinfo
-       with some filtering. */
+        /* Communicate the name and port output to the agent
+         * synchronously with netlink. First send the name + port
+         * and then wait for answer (select). The agent filters
+         * or modifies the list. The agent implements get_peer_endpointinfo
+         * with some filtering. */
 #endif /* add #elseif */
 
-      err = (get_peer_endpointinfo(HIPL_HOSTS_FILE, nodename, servname,
-                                               &modified_hints, res)  &&
-               get_peer_endpointinfo(HOSTS_FILE, nodename, servname,
-                                               &modified_hints, res));
-  }
-
- err_out:
-
-  if(filenamebase)
-    free(filenamebase);
-  if(length(&list)>0)
-    destroy(&list);
-
-  return err;
+        err = (get_peer_endpointinfo(HIPL_HOSTS_FILE, nodename, servname,
+                                     &modified_hints, res)  &&
+               get_peer_endpointinfo(HOSTS_FILE, nodename, servname,
+                                     &modified_hints, res));
+    }
+
+err_out:
+
+    if (filenamebase) {
+        free(filenamebase);
+    }
+    if (length(&list) > 0) {
+        destroy(&list);
+    }
+
+    return err;
 }
 
 const char *gepi_strerror(int errcode)
 {
-  return "HIP native resolver failed"; /* XX FIXME */
+    return "HIP native resolver failed"; /* XX FIXME */
 }
 
-
 int get_localhost_endpoint_no_setmyeid(const char *basename,
-                                      const char *servname,
-                                      struct addrinfo *hints,
-                                      struct addrinfo **res,
-                                      struct hip_lhi *lhi)
+                                       const char *servname,
+                                       struct addrinfo *hints,
+                                       struct addrinfo **res,
+                                       struct hip_lhi *lhi)
 {
-  int err = 0, algo = 0;
-  DSA *dsa = NULL;
-  RSA *rsa = NULL;
-  unsigned char *key_rr = NULL;
-  int key_rr_len = 0;
-  struct endpoint_hip *endpoint_hip = NULL;
-  char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-  struct if_nameindex *ifaces = NULL;
-  const char *pub_suffix = "_pub";
-
-  *res = NULL;
-
-  _HIP_DEBUG("get_localhost_endpoint()\n");
-  HIP_ASSERT(hints);
-
-  // XX TODO: check flags?
-  memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
-  err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
-  if (err) {
-    HIP_ERROR("gethostname failed (%d)\n", err);
-    err = EEI_NONAME;
-    goto out_err;
-  }
-
-  /* System specific HIs should be added into the kernel with the
-     HIP_HI_REUSE_ANY flag set, because this way we make the HIs
-     readable by all processes. This function calls setmyeid() internally.. */
-  hints->ai_flags |= HIP_HI_REUSE_ANY;
-
-  /* select between anonymous/public HI based on the file name */
-  if(!findsubstring(basename, pub_suffix)) {
-         hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
-         HIP_DEBUG("Anonymous HI\n");
-  } else {
-         HIP_DEBUG("Published HI\n");
-  }
-
-  if(findsubstring(basename, "rsa"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(basename, "dsa"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  if(algo == HIP_HI_RSA)
-    //modified according Laura's suggestion
-    //    err = load_rsa_private_key(basename, &rsa);
-    err = load_rsa_public_key(basename, &rsa);
-  else
-    //err = load_dsa_private_key(basename, &dsa);
-    err = load_dsa_public_key(basename, &dsa);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Loading of private key %s failed\n", basename);
-    goto out_err;
-  }
-
-  if(algo == HIP_HI_RSA)
-    err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, hostname);
-  else
-    err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, hostname);
-  if (err) {
-    HIP_ERROR("Failed to allocate and build endpoint.\n");
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
-             hip_get_param_total_len(&endpoint_hip->id.host_id));
-
-  _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
-
-  if(algo == HIP_HI_RSA) {
-    key_rr_len = rsa_to_dns_key_rr(rsa, &key_rr);
-    if (key_rr_len <= 0) {
-      HIP_ERROR("rsa_key_rr_len <= 0\n");
-      err = -EFAULT;
-      goto out_err;
-    }
-    //    err = hip_private_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
-    err = hip_public_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH100, &lhi->hit);
-    if (err) {
-      HIP_ERROR("Conversion from RSA to HIT failed\n");
-      goto out_err;
-    }
-    _HIP_HEXDUMP("Calculated RSA HIT: ", &lhi->hit,
-                sizeof(struct in6_addr));
-  } else {
-    key_rr_len = dsa_to_dns_key_rr(dsa, &key_rr);
-    if (key_rr_len <= 0) {
-      HIP_ERROR("dsa_key_rr_len <= 0\n");
-      err = -EFAULT;
-      goto out_err;
-    }
-    //err = hip_private_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
-    err = hip_public_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH100, &lhi->hit);
-    if (err) {
-      HIP_ERROR("Conversion from DSA to HIT failed\n");
-      goto out_err;
-    }
-    _HIP_HEXDUMP("Calculated DSA HIT: ", &lhi->hit,
-               sizeof(struct in6_addr));
-  }
+    int err                           = 0, algo = 0;
+    DSA *dsa                          = NULL;
+    RSA *rsa                          = NULL;
+    unsigned char *key_rr             = NULL;
+    int key_rr_len                    = 0;
+    struct endpoint_hip *endpoint_hip = NULL;
+    char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    struct if_nameindex *ifaces       = NULL;
+    const char *pub_suffix            = "_pub";
+
+    *res = NULL;
+
+    _HIP_DEBUG("get_localhost_endpoint()\n");
+    HIP_ASSERT(hints);
+
+    // XX TODO: check flags?
+    memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
+    err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
+    if (err) {
+        HIP_ERROR("gethostname failed (%d)\n", err);
+        err = EEI_NONAME;
+        goto out_err;
+    }
+
+    /* System specific HIs should be added into the kernel with the
+     * HIP_HI_REUSE_ANY flag set, because this way we make the HIs
+     * readable by all processes. This function calls setmyeid() internally.. 
*/
+    hints->ai_flags |= HIP_HI_REUSE_ANY;
+
+    /* select between anonymous/public HI based on the file name */
+    if (!findsubstring(basename, pub_suffix)) {
+        hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
+        HIP_DEBUG("Anonymous HI\n");
+    } else {
+        HIP_DEBUG("Published HI\n");
+    }
+
+    if (findsubstring(basename, "rsa")) {
+        algo = HIP_HI_RSA;
+    } else if (findsubstring(basename, "dsa")) {
+        algo = HIP_HI_DSA;
+    } else {
+        HIP_ERROR("Wrong kind of key file: %s\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    if (algo == HIP_HI_RSA) {
+        //modified according Laura's suggestion
+        //    err = load_rsa_private_key(basename, &rsa);
+        err = load_rsa_public_key(basename, &rsa);
+    } else {
+        //err = load_dsa_private_key(basename, &dsa);
+        err = load_dsa_public_key(basename, &dsa);
+    }
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Loading of private key %s failed\n", basename);
+        goto out_err;
+    }
+
+    if (algo == HIP_HI_RSA) {
+        err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    } else {
+        err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    }
+    if (err) {
+        HIP_ERROR("Failed to allocate and build endpoint.\n");
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
+                 hip_get_param_total_len(&endpoint_hip->id.host_id));
+
+    _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
+
+    if (algo == HIP_HI_RSA) {
+        key_rr_len = rsa_to_dns_key_rr(rsa, &key_rr);
+        if (key_rr_len <= 0) {
+            HIP_ERROR("rsa_key_rr_len <= 0\n");
+            err = -EFAULT;
+            goto out_err;
+        }
+        //    err = hip_private_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
+        err = hip_public_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH100, 
&lhi->hit);
+        if (err) {
+            HIP_ERROR("Conversion from RSA to HIT failed\n");
+            goto out_err;
+        }
+        _HIP_HEXDUMP("Calculated RSA HIT: ", &lhi->hit,
+                     sizeof(struct in6_addr));
+    } else {
+        key_rr_len = dsa_to_dns_key_rr(dsa, &key_rr);
+        if (key_rr_len <= 0) {
+            HIP_ERROR("dsa_key_rr_len <= 0\n");
+            err = -EFAULT;
+            goto out_err;
+        }
+        //err = hip_private_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
+        err = hip_public_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH100, 
&lhi->hit);
+        if (err) {
+            HIP_ERROR("Conversion from DSA to HIT failed\n");
+            goto out_err;
+        }
+        _HIP_HEXDUMP("Calculated DSA HIT: ", &lhi->hit,
+                     sizeof(struct in6_addr));
+    }
 
 #if 0 /* XX FIXME */
-  ifaces = if_nameindex();
-  if (ifaces == NULL || (ifaces->if_index == 0)) {
-    HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
-    err = 1;
-    goto out_err;
-  }
+    ifaces = if_nameindex();
+    if (ifaces == NULL || (ifaces->if_index == 0)) {
+        HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
+        err = 1;
+        goto out_err;
+    }
 #endif
 
-  *res = calloc(1, sizeof(struct addrinfo));
-  if (!*res) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
-  if (!(*res)->ai_addr) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    int len = strlen(hostname) + 1;
-    if (len > 1) {
-      (*res)->ai_canonname = malloc(len);
-      if (!((*res)->ai_canonname)) {
-       err = EEI_MEMORY;
-       goto out_err;
-      }
-      memcpy((*res)->ai_canonname, hostname, len);
-    }
-  }
-
- out_err:
-
-  if (rsa)
-    RSA_free(rsa);
-
-  if (dsa)
-    DSA_free(dsa);
-
-  if (endpoint_hip)
-    free(endpoint_hip);
-
-  if (ifaces)
-    if_freenameindex(ifaces);
-
-  if (key_rr)
-    free(key_rr);
-
-  return err;
+    *res = calloc(1, sizeof(struct addrinfo));
+    if (!*res) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
+    if (!(*res)->ai_addr) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        int len = strlen(hostname) + 1;
+        if (len > 1) {
+            (*res)->ai_canonname = malloc(len);
+            if (!((*res)->ai_canonname)) {
+                err = EEI_MEMORY;
+                goto out_err;
+            }
+            memcpy((*res)->ai_canonname, hostname, len);
+        }
+    }
+
+out_err:
+
+    if (rsa) {
+        RSA_free(rsa);
+    }
+
+    if (dsa) {
+        DSA_free(dsa);
+    }
+
+    if (endpoint_hip) {
+        free(endpoint_hip);
+    }
+
+    if (ifaces) {
+        if_freenameindex(ifaces);
+    }
+
+    if (key_rr) {
+        free(key_rr);
+    }
+
+    return err;
 }
 
 int get_localhost_endpoint(const char *basename,
-                           const char *servname,
-                           struct addrinfo *hints,
-                           struct addrinfo **res,
-                           struct hip_lhi *lhi)
+                           const char *servname,
+                           struct addrinfo *hints,
+                           struct addrinfo **res,
+                           struct hip_lhi *lhi)
 {
-  int err = 0, algo = 0;
-  DSA *dsa = NULL;
-  RSA *rsa = NULL;
-  unsigned char *key_rr = NULL;
-  int key_rr_len = 0;
-  struct endpoint_hip *endpoint_hip = NULL;
-  char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-  struct if_nameindex *ifaces = NULL;
-  const char *pub_suffix = "_pub";
-
-  *res = NULL;
-
-  _HIP_DEBUG("get_localhost_endpoint()\n");
-  HIP_ASSERT(hints);
-
-  // XX TODO: check flags?
-  memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
-  err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
-  if (err) {
-    HIP_ERROR("gethostname failed (%d)\n", err);
-    err = EEI_NONAME;
-    goto out_err;
-  }
-
-  /* System specific HIs should be added into the kernel with the
-     HIP_HI_REUSE_ANY flag set, because this way we make the HIs
-     readable by all processes. This function calls setmyeid() internally.. */
-  hints->ai_flags |= HIP_HI_REUSE_ANY;
-
-  /* select between anonymous/public HI based on the file name */
-  if(!findsubstring(basename, pub_suffix))
-    hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
-
-  /* check the algorithm from PEM format key */
-  /* Bing, replace the following code:
-  fp = fopen(basename, "rb");
-  if (!fp) {
-    HIP_ERROR("Couldn't open key file %s for reading\n", basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-  fgets(first_key_line,30,fp);  //read first line.
-  _HIP_DEBUG("1st key line: %s",first_key_line);
-  fclose(fp);
-
-  if(findsubstring(first_key_line, "RSA"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(first_key_line, "DSA"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-  */
-  /*Bing, the following code is used instead of the above code*/
-  if(findsubstring(basename, "rsa"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(basename, "dsa"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Wrong kind of key file: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  if(algo == HIP_HI_RSA)
-    //modified according Laura's suggestion
-    //    err = load_rsa_private_key(basename, &rsa);
-    err = load_rsa_public_key(basename, &rsa);
-  else
-    //err = load_dsa_private_key(basename, &dsa);
-    err = load_dsa_public_key(basename, &dsa);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Loading of private key %s failed\n", basename);
-    goto out_err;
-  }
-
-  if(algo == HIP_HI_RSA)
-    err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, hostname);
-  else
-    err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, hostname);
-  if (err) {
-    HIP_ERROR("Failed to allocate and build endpoint.\n");
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
-             hip_get_param_total_len(&endpoint_hip->id.host_id));
-
-
-  _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
-
-  if(algo == HIP_HI_RSA) {
-    key_rr_len = rsa_to_dns_key_rr(rsa, &key_rr);
-    if (key_rr_len <= 0) {
-      HIP_ERROR("rsa_key_rr_len <= 0\n");
-      err = -EFAULT;
-      goto out_err;
-    }
-    //    err = hip_private_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
-    err = hip_public_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH100, &lhi->hit);
-    if (err) {
-      HIP_ERROR("Conversion from RSA to HIT failed\n");
-      goto out_err;
-    }
-    _HIP_HEXDUMP("Calculated RSA HIT: ", &lhi->hit,
-               sizeof(struct in6_addr));
-  } else {
-    key_rr_len = dsa_to_dns_key_rr(dsa, &key_rr);
-    if (key_rr_len <= 0) {
-      HIP_ERROR("dsa_key_rr_len <= 0\n");
-      err = -EFAULT;
-      goto out_err;
-    }
-    //err = hip_private_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
-    err = hip_public_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH100, &lhi->hit);
-    if (err) {
-      HIP_ERROR("Conversion from DSA to HIT failed\n");
-      goto out_err;
-    }
-    _HIP_HEXDUMP("Calculated DSA HIT: ", &lhi->hit,
-               sizeof(struct in6_addr));
-  }
+    int err                           = 0, algo = 0;
+    DSA *dsa                          = NULL;
+    RSA *rsa                          = NULL;
+    unsigned char *key_rr             = NULL;
+    int key_rr_len                    = 0;
+    struct endpoint_hip *endpoint_hip = NULL;
+    char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    struct if_nameindex *ifaces       = NULL;
+    const char *pub_suffix            = "_pub";
+
+    *res = NULL;
+
+    _HIP_DEBUG("get_localhost_endpoint()\n");
+    HIP_ASSERT(hints);
+
+    // XX TODO: check flags?
+    memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
+    err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
+    if (err) {
+        HIP_ERROR("gethostname failed (%d)\n", err);
+        err = EEI_NONAME;
+        goto out_err;
+    }
+
+    /* System specific HIs should be added into the kernel with the
+     * HIP_HI_REUSE_ANY flag set, because this way we make the HIs
+     * readable by all processes. This function calls setmyeid() internally.. 
*/
+    hints->ai_flags |= HIP_HI_REUSE_ANY;
+
+    /* select between anonymous/public HI based on the file name */
+    if (!findsubstring(basename, pub_suffix)) {
+        hints->ai_flags |= HIP_ENDPOINT_FLAG_ANON;
+    }
+
+    /* check the algorithm from PEM format key */
+    /* Bing, replace the following code:
+     * fp = fopen(basename, "rb");
+     * if (!fp) {
+     * HIP_ERROR("Couldn't open key file %s for reading\n", basename);
+     * err = -ENOMEM;
+     * goto out_err;
+     * }
+     * fgets(first_key_line,30,fp);  //read first line.
+     * _HIP_DEBUG("1st key line: %s",first_key_line);
+     * fclose(fp);
+     *
+     * if(findsubstring(first_key_line, "RSA"))
+     * algo = HIP_HI_RSA;
+     * else if(findsubstring(first_key_line, "DSA"))
+     * algo = HIP_HI_DSA;
+     * else {
+     * HIP_ERROR("Wrong kind of key file: %s\n",basename);
+     * err = -ENOMEM;
+     * goto out_err;
+     * }
+     */
+    /*Bing, the following code is used instead of the above code*/
+    if (findsubstring(basename, "rsa")) {
+        algo = HIP_HI_RSA;
+    } else if (findsubstring(basename, "dsa")) {
+        algo = HIP_HI_DSA;
+    } else {
+        HIP_ERROR("Wrong kind of key file: %s\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    if (algo == HIP_HI_RSA) {
+        //modified according Laura's suggestion
+        //    err = load_rsa_private_key(basename, &rsa);
+        err = load_rsa_public_key(basename, &rsa);
+    } else {
+        //err = load_dsa_private_key(basename, &dsa);
+        err = load_dsa_public_key(basename, &dsa);
+    }
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Loading of private key %s failed\n", basename);
+        goto out_err;
+    }
+
+    if (algo == HIP_HI_RSA) {
+        err = rsa_to_hip_endpoint(rsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    } else {
+        err = dsa_to_hip_endpoint(dsa, &endpoint_hip, hints->ai_flags, 
hostname);
+    }
+    if (err) {
+        HIP_ERROR("Failed to allocate and build endpoint.\n");
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    _HIP_HEXDUMP("host identity in endpoint: ", &endpoint_hip->id.host_id,
+                 hip_get_param_total_len(&endpoint_hip->id.host_id));
+
+
+    _HIP_HEXDUMP("hip endpoint: ", endpoint_hip, endpoint_hip->length);
+
+    if (algo == HIP_HI_RSA) {
+        key_rr_len = rsa_to_dns_key_rr(rsa, &key_rr);
+        if (key_rr_len <= 0) {
+            HIP_ERROR("rsa_key_rr_len <= 0\n");
+            err = -EFAULT;
+            goto out_err;
+        }
+        //    err = hip_private_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
+        err = hip_public_rsa_to_hit(rsa, key_rr, HIP_HIT_TYPE_HASH100, 
&lhi->hit);
+        if (err) {
+            HIP_ERROR("Conversion from RSA to HIT failed\n");
+            goto out_err;
+        }
+        _HIP_HEXDUMP("Calculated RSA HIT: ", &lhi->hit,
+                     sizeof(struct in6_addr));
+    } else {
+        key_rr_len = dsa_to_dns_key_rr(dsa, &key_rr);
+        if (key_rr_len <= 0) {
+            HIP_ERROR("dsa_key_rr_len <= 0\n");
+            err = -EFAULT;
+            goto out_err;
+        }
+        //err = hip_private_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH120, 
&lhi->hit);
+        err = hip_public_dsa_to_hit(dsa, key_rr, HIP_HIT_TYPE_HASH100, 
&lhi->hit);
+        if (err) {
+            HIP_ERROR("Conversion from DSA to HIT failed\n");
+            goto out_err;
+        }
+        _HIP_HEXDUMP("Calculated DSA HIT: ", &lhi->hit,
+                     sizeof(struct in6_addr));
+    }
 
 #if 0 /* XX FIXME */
-  ifaces = if_nameindex();
-  if (ifaces == NULL || (ifaces->if_index == 0)) {
-    HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
-    err = 1;
-    goto out_err;
-  }
+    ifaces = if_nameindex();
+    if (ifaces == NULL || (ifaces->if_index == 0)) {
+        HIP_ERROR("%s\n", (ifaces == NULL) ? "Iface error" : "No ifaces.");
+        err = 1;
+        goto out_err;
+    }
 #endif
 
-  *res = calloc(1, sizeof(struct addrinfo));
-  if (!*res) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
-  if (!(*res)->ai_addr) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    int len = strlen(hostname) + 1;
-    if (len > 1) {
-      (*res)->ai_canonname = malloc(len);
-      if (!((*res)->ai_canonname)) {
-       err = EEI_MEMORY;
-       goto out_err;
-      }
-      memcpy((*res)->ai_canonname, hostname, len);
-    }
-  }
-
-  err = setmyeid(((struct sockaddr_eid *) (*res)->ai_addr), servname,
-                (struct endpoint *) endpoint_hip, ifaces);
-  if (err) {
-    HIP_ERROR("Failed to set up my EID (%d)\n", err);
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
+    *res = calloc(1, sizeof(struct addrinfo));
+    if (!*res) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    (*res)->ai_addr = malloc(sizeof(struct sockaddr_eid));
+    if (!(*res)->ai_addr) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        int len = strlen(hostname) + 1;
+        if (len > 1) {
+            (*res)->ai_canonname = malloc(len);
+            if (!((*res)->ai_canonname)) {
+                err = EEI_MEMORY;
+                goto out_err;
+            }
+            memcpy((*res)->ai_canonname, hostname, len);
+        }
+    }
+
+    err = setmyeid(((struct sockaddr_eid *) (*res)->ai_addr), servname,
+                   (struct endpoint *) endpoint_hip, ifaces);
+    if (err) {
+        HIP_ERROR("Failed to set up my EID (%d)\n", err);
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
 
 #ifdef CONFIG_HIP_DEBUG
-  {
-    //struct sockaddr_eid *eid = (struct sockaddr_eid *) (*res)->ai_addr;
-    _HIP_DEBUG("eid family=%d value=%d\n", eid->eid_family,
-              ntohs(eid->eid_val));
-  }
+    {
+        //struct sockaddr_eid *eid = (struct sockaddr_eid *) (*res)->ai_addr;
+        _HIP_DEBUG("eid family=%d value=%d\n", eid->eid_family,
+                   ntohs(eid->eid_val));
+    }
 #endif
 
- out_err:
-
-  if (rsa)
-    RSA_free(rsa);
-
-  if (dsa)
-    DSA_free(dsa);
-
-  if (endpoint_hip)
-    free(endpoint_hip);
-
-  if (ifaces)
-    if_freenameindex(ifaces);
-
-  if (key_rr)
-    free(key_rr);
-
-  return err;
+out_err:
+
+    if (rsa) {
+        RSA_free(rsa);
+    }
+
+    if (dsa) {
+        DSA_free(dsa);
+    }
+
+    if (endpoint_hip) {
+        free(endpoint_hip);
+    }
+
+    if (ifaces) {
+        if_freenameindex(ifaces);
+    }
+
+    if (key_rr) {
+        free(key_rr);
+    }
+
+    return err;
 }
 
 /**
@@ -1824,371 +1876,376 @@
  * @todo: rewrite the function to actually return a list
  *
  */
-int get_local_hits(const char *servname, struct gaih_addrtuple **adr) {
-  int err = 0, i;
-  struct hip_lhi hit;
-  char *filenamebase = NULL;
-  int filenamebase_len, ret;
-  struct addrinfo modified_hints;
-  struct addrinfo *new = NULL;
-  //struct hip_common *msg;
-  //struct in6_addr *hiphit;
-  //struct hip_tlv_common *det;
-  List list;
-
-  _HIP_DEBUG("\n");
-
-  /* assign default hints */
-  memset(&modified_hints, 0, sizeof(struct addrinfo));
-  modified_hints.ai_family = PF_HIP;
-
-  initlist(&list);
-  /* find key files from /etc/hosts */
-  /* or */
-  /* find key files from /etc/hip */
-  findkeyfiles(DEFAULT_CONFIG_DIR, &list);
-  _HIP_DEBUG("LEN:%d\n",length(&list));
-
-  //hip_build_user_hdr(&msg,HIP_PARAM_IPV6_ADDR, sizeof(struct addrinfo));
-  for(i=0; i<length(&list); i++) {
-
-       _HIP_DEBUG("%s\n",getitem(&list,i));
-       filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
-       strlen(getitem(&list,i)) + 1;
-
-    filenamebase = malloc(filenamebase_len);
-    HIP_IFEL(!filenamebase, -ENOMEM, "Couldn't allocate file name\n");
-
-    ret = snprintf(filenamebase, filenamebase_len, "%s/%s",
-                  DEFAULT_CONFIG_DIR,
-                  getitem(&list,i));
-    HIP_IFE(ret <= 0, -EINVAL);
-
-    //    get_localhost_endpoint(filenamebase, servname,
-    //            &modified_hints, &new, &hit);
-    get_localhost_endpoint_no_setmyeid(filenamebase, servname,
-                                      &modified_hints, &new, &hit);
-
-    _HIP_DEBUG_HIT("Got HIT: ", &hit.hit);
-
-    if (*adr == NULL) {
-      *adr = malloc(sizeof(struct gaih_addrtuple));
-      (*adr)->scopeid = 0;
-    }
-    (*adr)->next = NULL;
-    (*adr)->family = AF_INET6;
-    memcpy((*adr)->addr, &hit.hit, sizeof(struct in6_addr));
-    adr = &((*adr)->next); // for opp mode -miika
-
-    free(filenamebase);
-    free(new->ai_canonname);
-    free(new->ai_addr);
-    free(new);
-  }
-
-  filenamebase = NULL;
-  //new = NULL;
-
- out_err:
-  if(filenamebase)
-    free(filenamebase);
-  //if(new)
+int get_local_hits(const char *servname, struct gaih_addrtuple **adr)
+{
+    int err              = 0, i;
+    struct hip_lhi hit;
+    char *filenamebase   = NULL;
+    int filenamebase_len, ret;
+    struct addrinfo modified_hints;
+    struct addrinfo *new = NULL;
+    //struct hip_common *msg;
+    //struct in6_addr *hiphit;
+    //struct hip_tlv_common *det;
+    List list;
+
+    _HIP_DEBUG("\n");
+
+    /* assign default hints */
+    memset(&modified_hints, 0, sizeof(struct addrinfo));
+    modified_hints.ai_family = PF_HIP;
+
+    initlist(&list);
+    /* find key files from /etc/hosts */
+    /* or */
+    /* find key files from /etc/hip */
+    findkeyfiles(DEFAULT_CONFIG_DIR, &list);
+    _HIP_DEBUG("LEN:%d\n", length(&list));
+
+    //hip_build_user_hdr(&msg,HIP_PARAM_IPV6_ADDR, sizeof(struct addrinfo));
+    for (i = 0; i < length(&list); i++) {
+        _HIP_DEBUG("%s\n", getitem(&list, i));
+        filenamebase_len = strlen(DEFAULT_CONFIG_DIR) + 1 +
+                           strlen(getitem(&list, i)) + 1;
+
+        filenamebase     = malloc(filenamebase_len);
+        HIP_IFEL(!filenamebase, -ENOMEM, "Couldn't allocate file name\n");
+
+        ret              = snprintf(filenamebase, filenamebase_len, "%s/%s",
+                                    DEFAULT_CONFIG_DIR,
+                                    getitem(&list, i));
+        HIP_IFE(ret <= 0, -EINVAL);
+
+        //    get_localhost_endpoint(filenamebase, servname,
+        //                &modified_hints, &new, &hit);
+        get_localhost_endpoint_no_setmyeid(filenamebase, servname,
+                                           &modified_hints, &new, &hit);
+
+        _HIP_DEBUG_HIT("Got HIT: ", &hit.hit);
+
+        if (*adr == NULL) {
+            *adr            = malloc(sizeof(struct gaih_addrtuple));
+            (*adr)->scopeid = 0;
+        }
+        (*adr)->next   = NULL;
+        (*adr)->family = AF_INET6;
+        memcpy((*adr)->addr, &hit.hit, sizeof(struct in6_addr));
+        adr            = &((*adr)->next); // for opp mode -miika
+
+        free(filenamebase);
+        free(new->ai_canonname);
+        free(new->ai_addr);
+        free(new);
+    }
+
+    filenamebase = NULL;
+    //new = NULL;
+
+out_err:
+    if (filenamebase) {
+        free(filenamebase);
+    }
+    //if(new)
     //free(new);
-  if(list.head)
-    destroy(&list);
-
-  return err;
-
+    if (list.head) {
+        destroy(&list);
+    }
+
+    return err;
 }
 
 int get_peer_addrinfo_hit(const char *hostsfile,
-                         const char *nodename,
-                         const char *servname,
-                         const struct addrinfo *hints,
-                         struct addrinfo **res)
+                          const char *nodename,
+                          const char *servname,
+                          const struct addrinfo *hints,
+                          struct addrinfo **res)
 {
-  int err = 0;
-  unsigned int fqdn_str_len = 0;
-  char fqdn_str[HOST_NAME_MAX];
-  struct in6_addr hit;
-  struct sockaddr_hip *addr;
-
-  HIP_DEBUG("Called, nodename: %s\n", nodename);
-  *res = NULL;
-  memset(fqdn_str, 0, sizeof(fqdn_str));
-
-  if (inet_pton(AF_INET6, nodename, &hit) > 0) {
-    HIP_DEBUG("Nodename is numerical address\n");
-    if (hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
-               hip_map_first_id_to_hostname_from_hosts, &hit, fqdn_str))
-    {
-       hip_for_each_hosts_file_line(HOSTS_FILE,
-               hip_map_first_id_to_hostname_from_hosts, &hit, fqdn_str);
-    }
-  } else {
-    strncpy(fqdn_str, nodename, HOST_NAME_MAX);
-
-    HIP_IFEL(hip_for_each_hosts_file_line(hostsfile,
-               hip_map_first_hostname_to_hit_from_hosts, fqdn_str, &hit), -1,
-               "Couldn't map nodename to HIT\n");
-  }
-
-  fqdn_str_len = strlen(fqdn_str);
-
-  (*res) = calloc(1, sizeof(struct addrinfo));
-  HIP_IFE(!(*res), EEI_MEMORY);
-  (*res)->ai_addr = calloc(1, sizeof(struct sockaddr_hip));
-  HIP_IFE(!(*res)->ai_addr, EEI_MEMORY);
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    (*res)->ai_canonname = malloc(fqdn_str_len + 1);
-    HIP_IFE(!(*res)->ai_canonname, EEI_MEMORY);
-    HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
-    strcpy((*res)->ai_canonname, fqdn_str);
-    /* XX FIX: we should append the domain name if it does not exist */
-  }
-
-  addr = (struct sockaddr_hip *)(*res)->ai_addr;
-  memcpy(&addr->ship_hit, &hit, sizeof(hit));
-
-  (*res)->ai_flags = hints->ai_flags;
-  (*res)->ai_family = PF_HIP;
-  (*res)->ai_socktype = hints->ai_socktype;
-  (*res)->ai_protocol = hints->ai_protocol;
-  (*res)->ai_addrlen = sizeof(struct sockaddr_hip);
-
- out_err:
-
-  if (err && *res) {
-      if((*res)->ai_addr)
-        free((*res)->ai_addr);
-      if((*res)->ai_canonname)
-       free((*res)->ai_canonname);
-      free(*res);
-      *res = NULL;
-  }
-
-  return err;
+    int err                   = 0;
+    unsigned int fqdn_str_len = 0;
+    char fqdn_str[HOST_NAME_MAX];
+    struct in6_addr hit;
+    struct sockaddr_hip *addr;
+
+    HIP_DEBUG("Called, nodename: %s\n", nodename);
+    *res = NULL;
+    memset(fqdn_str, 0, sizeof(fqdn_str));
+
+    if (inet_pton(AF_INET6, nodename, &hit) > 0) {
+        HIP_DEBUG("Nodename is numerical address\n");
+        if (hip_for_each_hosts_file_line(HIPL_HOSTS_FILE,
+                                         
hip_map_first_id_to_hostname_from_hosts, &hit, fqdn_str)) {
+            hip_for_each_hosts_file_line(HOSTS_FILE,
+                                         
hip_map_first_id_to_hostname_from_hosts, &hit, fqdn_str);
+        }
+    } else {
+        strncpy(fqdn_str, nodename, HOST_NAME_MAX);
+
+        HIP_IFEL(hip_for_each_hosts_file_line(hostsfile,
+                                              
hip_map_first_hostname_to_hit_from_hosts, fqdn_str, &hit), -1,
+                 "Couldn't map nodename to HIT\n");
+    }
+
+    fqdn_str_len    = strlen(fqdn_str);
+
+    (*res)          = calloc(1, sizeof(struct addrinfo));
+    HIP_IFE(!(*res), EEI_MEMORY);
+    (*res)->ai_addr = calloc(1, sizeof(struct sockaddr_hip));
+    HIP_IFE(!(*res)->ai_addr, EEI_MEMORY);
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        (*res)->ai_canonname = malloc(fqdn_str_len + 1);
+        HIP_IFE(!(*res)->ai_canonname, EEI_MEMORY);
+        HIP_ASSERT(strlen(fqdn_str) == fqdn_str_len);
+        strcpy((*res)->ai_canonname, fqdn_str);
+        /* XX FIX: we should append the domain name if it does not exist */
+    }
+
+    addr                = (struct sockaddr_hip *) (*res)->ai_addr;
+    memcpy(&addr->ship_hit, &hit, sizeof(hit));
+
+    (*res)->ai_flags    = hints->ai_flags;
+    (*res)->ai_family   = PF_HIP;
+    (*res)->ai_socktype = hints->ai_socktype;
+    (*res)->ai_protocol = hints->ai_protocol;
+    (*res)->ai_addrlen  = sizeof(struct sockaddr_hip);
+
+out_err:
+
+    if (err && *res) {
+        if ((*res)->ai_addr) {
+            free((*res)->ai_addr);
+        }
+        if ((*res)->ai_canonname) {
+            free((*res)->ai_canonname);
+        }
+        free(*res);
+        *res = NULL;
+    }
+
+    return err;
 }
 
 /* getendpointfo() modified for sockaddr_hip instead of sockaddr_eid */
 
 int get_hit_addrinfo(const char *nodename, const char *servname,
-                   const struct addrinfo *hints,
-                   struct addrinfo **res)
+                     const struct addrinfo *hints,
+                     struct addrinfo **res)
 {
-  int err = 0;
-  struct addrinfo modified_hints;
-  struct addrinfo *current = NULL;
-
-  struct sockaddr_hip *sock_hip;
-  struct hip_tlv_common *current_param = NULL;
-  hip_tlv_type_t param_type = 0;
-  struct hip_hit_info *info = NULL;
-  struct hip_common *msg;
-
-  *res = NULL;
-
-  if (hints) {
-    memcpy(&modified_hints, hints, sizeof(struct addrinfo));
-  } else {
-    memset(&modified_hints, 0, sizeof(struct addrinfo));
-    modified_hints.ai_family = PF_HIP;
-  }
-
-  if (!nodename) { /* Query local hits from daemon */
-
-    HIP_IFE(!(msg = hip_msg_alloc()), -ENOMEM);
-    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HITS, 0), -1,
-                       "Failed to build message to daemon\n");
-    HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, 
-                       "Failed to receive message from daemon\n");
-
-    while((current_param = hip_get_next_param(msg, current_param)) != NULL) {
-      param_type = hip_get_param_type(current_param);
-      if (param_type == HIP_PARAM_HIT_INFO){
-       if(!current) {
-         *res = calloc(1, sizeof(struct addrinfo));
-         HIP_IFE(!*res, -ENOMEM);
-         current = *res;
-       } else {
-         current->ai_next = calloc(1, sizeof(struct addrinfo));
-         HIP_IFE(!current->ai_next, -ENOMEM);
-         current = current->ai_next;
-       }
-
-       sock_hip = calloc(1, sizeof(struct sockaddr_hip));
-       HIP_IFE(!sock_hip, -ENOMEM);
-       info = (struct hip_hit_info *)
-                               hip_get_param_contents_direct(current_param);
-       memcpy(&sock_hip->ship_hit , &info->lhi.hit, sizeof(struct in6_addr));
-
-       current->ai_addr = (struct sockaddr *)sock_hip;
-       current->ai_family = PF_HIP;
-       current->ai_socktype = hints->ai_socktype;
-       current->ai_protocol = hints->ai_protocol;
-       current->ai_addrlen = sizeof(struct sockaddr_hip);
-       }
-  }
-
-  } else if (!strcmp(nodename, "0.0.0.0")) {
-
-    (*res) = calloc(1, sizeof(struct addrinfo));
-    (*res)->ai_addr = calloc(1, sizeof(struct sockaddr_hip));
-    (*res)->ai_family = PF_HIP;
-    (*res)->ai_socktype = hints->ai_socktype;
-    (*res)->ai_protocol = hints->ai_protocol;
-    (*res)->ai_addrlen = sizeof(struct sockaddr_hip);
-
-  } else {
-
-    err = (get_peer_addrinfo_hit(HIPL_HOSTS_FILE, nodename, servname,
-                               &modified_hints, res) &&
-               get_peer_addrinfo_hit(HOSTS_FILE, nodename, servname,
-                               &modified_hints, res));
-  }
- out_err:
-
-  return err;
+    int err                              = 0;
+    struct addrinfo modified_hints;
+    struct addrinfo *current             = NULL;
+
+    struct sockaddr_hip *sock_hip;
+    struct hip_tlv_common *current_param = NULL;
+    hip_tlv_type_t param_type            = 0;
+    struct hip_hit_info *info            = NULL;
+    struct hip_common *msg;
+
+    *res = NULL;
+
+    if (hints) {
+        memcpy(&modified_hints, hints, sizeof(struct addrinfo));
+    } else {
+        memset(&modified_hints, 0, sizeof(struct addrinfo));
+        modified_hints.ai_family = PF_HIP;
+    }
+
+    if (!nodename) { /* Query local hits from daemon */
+        HIP_IFE(!(msg = hip_msg_alloc()), -ENOMEM);
+        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HITS, 0), -1,
+                 "Failed to build message to daemon\n");
+        HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1,
+                 "Failed to receive message from daemon\n");
+
+        while ((current_param = hip_get_next_param(msg, current_param)) != 
NULL) {
+            param_type = hip_get_param_type(current_param);
+            if (param_type == HIP_PARAM_HIT_INFO) {
+                if (!current) {
+                    *res    = calloc(1, sizeof(struct addrinfo));
+                    HIP_IFE(!*res, -ENOMEM);
+                    current = *res;
+                } else {
+                    current->ai_next = calloc(1, sizeof(struct addrinfo));
+                    HIP_IFE(!current->ai_next, -ENOMEM);
+                    current          = current->ai_next;
+                }
+
+                sock_hip             = calloc(1, sizeof(struct sockaddr_hip));
+                HIP_IFE(!sock_hip, -ENOMEM);
+                info                 = (struct hip_hit_info *)
+                                       
hip_get_param_contents_direct(current_param);
+                memcpy(&sock_hip->ship_hit, &info->lhi.hit, sizeof(struct 
in6_addr));
+
+                current->ai_addr     = (struct sockaddr *) sock_hip;
+                current->ai_family   = PF_HIP;
+                current->ai_socktype = hints->ai_socktype;
+                current->ai_protocol = hints->ai_protocol;
+                current->ai_addrlen  = sizeof(struct sockaddr_hip);
+            }
+        }
+    } else if (!strcmp(nodename, "0.0.0.0")) {
+        (*res)              = calloc(1, sizeof(struct addrinfo));
+        (*res)->ai_addr     = calloc(1, sizeof(struct sockaddr_hip));
+        (*res)->ai_family   = PF_HIP;
+        (*res)->ai_socktype = hints->ai_socktype;
+        (*res)->ai_protocol = hints->ai_protocol;
+        (*res)->ai_addrlen  = sizeof(struct sockaddr_hip);
+    } else {
+        err = (get_peer_addrinfo_hit(HIPL_HOSTS_FILE, nodename, servname,
+                                     &modified_hints, res) &&
+               get_peer_addrinfo_hit(HOSTS_FILE, nodename, servname,
+                                     &modified_hints, res));
+    }
+out_err:
+
+    return err;
 }
 
-
 int get_addrinfo_from_key(const char *basename,
-                              const char *servname,
-                              struct addrinfo *hints,
-                              struct addrinfo **res)
+                          const char *servname,
+                          struct addrinfo *hints,
+                          struct addrinfo **res)
 {
-  int err = 0, algo = 0, anon = 0;
-  DSA *dsa = NULL;
-  RSA *rsa = NULL;
-  char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-  FILE* fp;
-  struct sockaddr_hip *sock_hip;
-
-  *res = NULL;
-
-  HIP_ASSERT(hints);
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
-    err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
-    if (err) {
-      HIP_ERROR("gethostname failed (%d)\n", err);
-      err = EEI_NONAME;
-      goto out_err;
-    }
-  }
-
-  if(!findsubstring(basename, DEFAULT_PUB_HI_FILE_NAME_SUFFIX))
-    anon = HIP_ENDPOINT_FLAG_ANON;
-
-  fp = fopen(basename, "rb");
-  if (!fp) {
-    HIP_ERROR("Couldn't open key file %s for reading\n", basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  if(findsubstring(basename, "rsa"))
-    algo = HIP_HI_RSA;
-  else if(findsubstring(basename, "dsa"))
-    algo = HIP_HI_DSA;
-  else {
-    HIP_ERROR("Key file not RSA or DSA: %s\n",basename);
-    err = -ENOMEM;
-    goto out_err;
-  }
-
-  HIP_DEBUG("basename %s\n", basename);
-
-  if(algo == HIP_HI_RSA)
-    err = load_rsa_public_key(basename, &rsa);
-  else
-    err = load_dsa_public_key(basename, &dsa);
-  if (err) {
-    err = EEI_SYSTEM;
-    HIP_ERROR("Loading of key %s failed\n", basename);
-    goto out_err;
-  }
-
-  *res = calloc(1, sizeof(struct addrinfo));
-  if (!*res) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  (*res)->ai_addr = malloc(sizeof(struct sockaddr_hip));
-  if (!(*res)->ai_addr) {
-    err = EEI_MEMORY;
-    goto out_err;
-  }
-
-  sock_hip = (struct sockaddr_hip *)(*res)->ai_addr;
-  if (algo == HIP_HI_RSA)
-    err = hip_public_rsa_to_hit(rsa, NULL, anon, &sock_hip->ship_hit);
-  else
-    err = hip_public_dsa_to_hit(dsa, NULL, anon, &sock_hip->ship_hit);
-
-  if (err) {
-    HIP_ERROR("Failed to get HIT from key.\n");
-    err = EEI_SYSTEM;
-    goto out_err;
-  }
-
-  if (hints->ai_flags & AI_CANONNAME) {
-    int len = strlen(hostname) + 1;
-    if (len > 1) {
-      (*res)->ai_canonname = malloc(len);
-      if (!((*res)->ai_canonname)) {
-       err = EEI_MEMORY;
-       goto out_err;
-      }
-      memcpy((*res)->ai_canonname, hostname, len);
-    }
-  }
-
-  (*res)->ai_flags = 0;
-  (*res)->ai_family = PF_HIP;
-  (*res)->ai_socktype = hints->ai_socktype;
-  (*res)->ai_protocol = hints->ai_protocol;
-  (*res)->ai_addrlen = sizeof(struct sockaddr_hip);
-  /* ai_addr, ai_canonname already set */
-
- out_err:
-
-  if (rsa)
-    RSA_free(rsa);
-  if (dsa)
-    DSA_free(dsa);
-
-  if (err && *res) {
-    if ((*res)->ai_addr)
-      free((*res)->ai_addr);
-    if ((*res)->ai_canonname)
-      free((*res)->ai_canonname);
-    free(*res);
+    int err  = 0, algo = 0, anon = 0;
+    DSA *dsa = NULL;
+    RSA *rsa = NULL;
+    char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    FILE *fp;
+    struct sockaddr_hip *sock_hip;
+
     *res = NULL;
-  }
-  
-  return err;
+
+    HIP_ASSERT(hints);
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        memset(hostname, 0, HIP_HOST_ID_HOSTNAME_LEN_MAX);
+        err = gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
+        if (err) {
+            HIP_ERROR("gethostname failed (%d)\n", err);
+            err = EEI_NONAME;
+            goto out_err;
+        }
+    }
+
+    if (!findsubstring(basename, DEFAULT_PUB_HI_FILE_NAME_SUFFIX)) {
+        anon = HIP_ENDPOINT_FLAG_ANON;
+    }
+
+    fp = fopen(basename, "rb");
+    if (!fp) {
+        HIP_ERROR("Couldn't open key file %s for reading\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    if (findsubstring(basename, "rsa")) {
+        algo = HIP_HI_RSA;
+    } else if (findsubstring(basename, "dsa")) {
+        algo = HIP_HI_DSA;
+    } else {
+        HIP_ERROR("Key file not RSA or DSA: %s\n", basename);
+        err = -ENOMEM;
+        goto out_err;
+    }
+
+    HIP_DEBUG("basename %s\n", basename);
+
+    if (algo == HIP_HI_RSA) {
+        err = load_rsa_public_key(basename, &rsa);
+    } else {
+        err = load_dsa_public_key(basename, &dsa);
+    }
+    if (err) {
+        err = EEI_SYSTEM;
+        HIP_ERROR("Loading of key %s failed\n", basename);
+        goto out_err;
+    }
+
+    *res = calloc(1, sizeof(struct addrinfo));
+    if (!*res) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    (*res)->ai_addr = malloc(sizeof(struct sockaddr_hip));
+    if (!(*res)->ai_addr) {
+        err = EEI_MEMORY;
+        goto out_err;
+    }
+
+    sock_hip = (struct sockaddr_hip *) (*res)->ai_addr;
+    if (algo == HIP_HI_RSA) {
+        err = hip_public_rsa_to_hit(rsa, NULL, anon, &sock_hip->ship_hit);
+    } else {
+        err = hip_public_dsa_to_hit(dsa, NULL, anon, &sock_hip->ship_hit);
+    }
+
+    if (err) {
+        HIP_ERROR("Failed to get HIT from key.\n");
+        err = EEI_SYSTEM;
+        goto out_err;
+    }
+
+    if (hints->ai_flags & AI_CANONNAME) {
+        int len = strlen(hostname) + 1;
+        if (len > 1) {
+            (*res)->ai_canonname = malloc(len);
+            if (!((*res)->ai_canonname)) {
+                err = EEI_MEMORY;
+                goto out_err;
+            }
+            memcpy((*res)->ai_canonname, hostname, len);
+        }
+    }
+
+    (*res)->ai_flags    = 0;
+    (*res)->ai_family   = PF_HIP;
+    (*res)->ai_socktype = hints->ai_socktype;
+    (*res)->ai_protocol = hints->ai_protocol;
+    (*res)->ai_addrlen  = sizeof(struct sockaddr_hip);
+    /* ai_addr, ai_canonname already set */
+
+out_err:
+
+    if (rsa) {
+        RSA_free(rsa);
+    }
+    if (dsa) {
+        DSA_free(dsa);
+    }
+
+    if (err && *res) {
+        if ((*res)->ai_addr) {
+            free((*res)->ai_addr);
+        }
+        if ((*res)->ai_canonname) {
+            free((*res)->ai_canonname);
+        }
+        free(*res);
+        *res = NULL;
+    }
+
+    return err;
 }
 
 int get_sockaddr_hip_from_key(const char *filename, struct sockaddr_hip **hit)
 {
-  int err = 0;
-  struct addrinfo hints;
-  struct addrinfo *res = NULL;
-
-  memset(&hints, 0, sizeof(hints));
-
-  err = get_addrinfo_from_key(filename, NULL, &hints, &res);
-  if (err)
-    goto out_err;
-
-  *hit = (struct sockaddr_hip *)res->ai_addr;
-
- out_err:
-  if (res)
-    free(res);
-  return err;
+    int err              = 0;
+    struct addrinfo hints;
+    struct addrinfo *res = NULL;
+
+    memset(&hints, 0, sizeof(hints));
+
+    err  = get_addrinfo_from_key(filename, NULL, &hints, &res);
+    if (err) {
+        goto out_err;
+    }
+
+    *hit = (struct sockaddr_hip *) res->ai_addr;
+
+out_err:
+    if (res) {
+        free(res);
+    }
+    return err;
 }

=== modified file 'lib/core/getendpointinfo.c.doxyme'
--- lib/core/getendpointinfo.c.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/getendpointinfo.c.doxyme   2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,47 +45,47 @@
 
 
 /**
- * convert_port_string_to_number 
+ * convert_port_string_to_number
  *
  *
  * @param servname
  * @param port
- * @return 
+ * @return
  **/
 
 
 /**
- * free_endpointinfo 
+ * free_endpointinfo
  *
  *
  * @param res
- * @return 
+ * @return
  **/
 
 
 /**
- * gepi_strerror 
+ * gepi_strerror
  *
  *
  * @param errcode
- * @return 
+ * @return
  **/
 
 
 /**
- * get_addrinfo_from_key 
+ * get_addrinfo_from_key
  *
  *
  * @param basename
  * @param servname
  * @param hints
  * @param res
- * @return 
+ * @return
  **/
 
 
 /**
- * get_hipd_peer_list 
+ * get_hipd_peer_list
  *
  *
  * @param nodename
@@ -92,148 +93,147 @@
  * @param hints
  * @param res
  * @param alt_flag
- * @return 
+ * @return
  **/
 
 
 /**
- * get_hit_addrinfo 
+ * get_hit_addrinfo
  *
  *
  * @param nodename
  * @param servname
  * @param hints
  * @param res
- * @return 
+ * @return
  **/
 
 
 /**
- * get_local_hits 
+ * get_local_hits
  *
  *
  * @param servname
  * @param adr
- * @return 
- **/
-
-
-/**
- * get_localhost_endpoint 
- *
- *
- * @param basename
- * @param servname
- * @param hints
- * @param res
- * @param lhi
- * @return 
- **/
-
-
-/**
- * get_localhost_endpoint_no_setmyeid 
- *
- *
- * @param basename
- * @param servname
- * @param hints
- * @param res
- * @param lhi
- * @return 
- **/
-
-
-/**
- * get_localhost_endpointinfo 
- *
- *
- * @param basename
- * @param servname
- * @param hints
- * @param res
- * @return 
- **/
-
-
-/**
- * get_peer_addrinfo_hit 
- *
- *
- * @param hostsfile
- * @param nodename
- * @param servname
- * @param hints
- * @param res
- * @return 
- **/
-
-
-/**
- * get_peer_endpointinfo 
- *
- *
- * @param hostsfile
- * @param nodename
- * @param servname
- * @param hints
- * @param res
- * @return 
- **/
-
-
-/**
- * get_sockaddr_hip_from_key 
+ * @return
+ **/
+
+
+/**
+ * get_localhost_endpoint
+ *
+ *
+ * @param basename
+ * @param servname
+ * @param hints
+ * @param res
+ * @param lhi
+ * @return
+ **/
+
+
+/**
+ * get_localhost_endpoint_no_setmyeid
+ *
+ *
+ * @param basename
+ * @param servname
+ * @param hints
+ * @param res
+ * @param lhi
+ * @return
+ **/
+
+
+/**
+ * get_localhost_endpointinfo
+ *
+ *
+ * @param basename
+ * @param servname
+ * @param hints
+ * @param res
+ * @return
+ **/
+
+
+/**
+ * get_peer_addrinfo_hit
+ *
+ *
+ * @param hostsfile
+ * @param nodename
+ * @param servname
+ * @param hints
+ * @param res
+ * @return
+ **/
+
+
+/**
+ * get_peer_endpointinfo
+ *
+ *
+ * @param hostsfile
+ * @param nodename
+ * @param servname
+ * @param hints
+ * @param res
+ * @return
+ **/
+
+
+/**
+ * get_sockaddr_hip_from_key
  *
  *
  * @param filename
  * @param hit
- * @return 
+ * @return
  **/
 
 
 /**
- * getendpointinfo 
+ * getendpointinfo
  *
  *
  * @param nodename
  * @param servname
  * @param hints
  * @param res
- * @return 
+ * @return
  **/
 
 
 /**
- * load_hip_endpoint_pem 
+ * load_hip_endpoint_pem
  *
  *
  * @param filename
  * @param endpoint
- * @return 
+ * @return
  **/
 
 
 /**
- * setmyeid 
+ * setmyeid
  *
  *
  * @param my_eid
  * @param servname
  * @param endpoint
  * @param ifaces
- * @return 
+ * @return
  **/
 
 
 /**
- * setpeereid 
+ * setpeereid
  *
  *
  * @param peer_eid
  * @param servname
  * @param endpoint
  * @param addrinfo
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/getendpointinfo.h'
--- lib/core/getendpointinfo.h  2010-01-19 11:26:32 +0000
+++ lib/core/getendpointinfo.h  2010-02-10 23:55:24 +0000
@@ -11,70 +11,70 @@
 #include "lib/tool/lutil.h"
 
 
-# define AI_HIP                0x0800  /* Return only HIT addresses */
-# define AI_HIP_NATIVE 0x1000  /* For getaddrinfo internal use only  */
-# define AI_RENDEZVOUS XX_FIX_ME /* The address belongs to rendezvous */
-# define AI_KERNEL_LIST 0x2000 /* Return the list of kernel addresses */
-# define AI_CHK_KERNEL 0x4000  /* Check kernel list of addresses  */
-# define AI_NODHT              0x8000  /* Check kernel list of addresses  */
+# define AI_HIP         0x0800  /* Return only HIT addresses */
+# define AI_HIP_NATIVE  0x1000  /* For getaddrinfo internal use only  */
+# define AI_RENDEZVOUS  XX_FIX_ME /* The address belongs to rendezvous */
+# define AI_KERNEL_LIST 0x2000  /* Return the list of kernel addresses */
+# define AI_CHK_KERNEL  0x4000  /* Check kernel list of addresses  */
+# define AI_NODHT               0x8000  /* Check kernel list of addresses  */
 
 /* XX TODO: begin these flags from where the AI_XX ends */
-# define EI_PASSIVE            0x0001  /* Socket address is intended for 
`bind'.  */
-# define EI_CANONNAME  0x0002  /* Request for canonical name.  */
-# define EI_ANON               XX_FIX_ME /* Return only anonymous endpoints */
-# define EI_NOLOCATORS XX_FIX_ME /* Do not resolve IP addresses */
-# define EI_FALLBACK   XX_FIX_ME /* Fall back to plain TCP/IP is ok */
+# define EI_PASSIVE             0x0001  /* Socket address is intended for 
`bind'.  */
+# define EI_CANONNAME   0x0002  /* Request for canonical name. */
+# define EI_ANON                XX_FIX_ME /* Return only anonymous endpoints */
+# define EI_NOLOCATORS  XX_FIX_ME /* Do not resolve IP addresses */
+# define EI_FALLBACK    XX_FIX_ME /* Fall back to plain TCP/IP is ok */
 
 /* Error values for `getendpointinfo' function */
 
 /* XX TODO: Are these really needed (they are the same with getaddrinfo)? */
 
 /* # define EEI_BADFLAGS         -1    /\* Invalid value for `ai_flags' field. 
 *\/ */
-# define EEI_NONAME      -2    /* NAME or SERVICE is unknown.  */
-# define EEI_AGAIN       -3    /* Temporary failure in name resolution.  */
-# define EEI_FAIL        -4    /* Non-recoverable failure in name res.  */
-# define EEI_NODATA      -5    /* No address associated with NAME.      */
-# define EEI_FAMILY      -6    /* `ai_family' not supported.  */
-# define EEI_SOCKTYPE    -7    /* `ai_socktype' not supported.  */
-# define EEI_SERVICE     -8    /* SERVICE not supported for `ai_socktype'.     
 */
-# define EEI_ADDRFAMILY          -9    /* Address family for NAME not 
supported.  */
-# define EEI_MEMORY      -10   /* Memory allocation failure.  */
-# define EEI_SYSTEM      -11   /* System error returned in `errno'.  */
+# define EEI_NONAME       -2    /* NAME or SERVICE is unknown. */
+# define EEI_AGAIN        -3    /* Temporary failure in name resolution.  */
+# define EEI_FAIL         -4    /* Non-recoverable failure in name res.        
 */
+# define EEI_NODATA       -5    /* No address associated with NAME.     */
+# define EEI_FAMILY       -6    /* `ai_family' not supported.  */
+# define EEI_SOCKTYPE     -7    /* `ai_socktype' not supported.         */
+# define EEI_SERVICE      -8    /* SERVICE not supported for `ai_socktype'.    
 */
+# define EEI_ADDRFAMILY   -9    /* Address family for NAME not supported.  */
+# define EEI_MEMORY       -10   /* Memory allocation failure.  */
+# define EEI_SYSTEM       -11   /* System error returned in `errno'.  */
 /* # ifdef __USE_GNU */
-#  define EEI_INPROGRESS  -100 /* Processing request in progress.      */
-#  define EEI_CANCELED   -101  /* Request canceled.  */
-#  define EEI_NOTCANCELED -102 /* Request not canceled.  */
-#  define EEI_ALLDONE    -103  /* All requests done.  */
-#  define EEI_INTR       -104  /* Interrupted by a signal.      */
+#  define EEI_INPROGRESS  -100  /* Processing request in progress.     */
+#  define EEI_CANCELED    -101  /* Request canceled.  */
+#  define EEI_NOTCANCELED -102  /* Request not canceled.  */
+#  define EEI_ALLDONE     -103  /* All requests done.  */
+#  define EEI_INTR        -104  /* Interrupted by a signal.     */
 /* # endif */
 
 /* The terminating \0 is excluded from STR_MAX */
-#define GEPI_HI_STR_MAX                  "46"  /* Max number of chars in HI 
string       */
-#define GEPI_HI_STR_VAL_MAX            46
-#define GEPI_FQDN_STR_MAX         "255" /* Max number of chars in FQDN string 
*/
-#define GEPI_FQDN_STR_VAL_MAX  255
+#define GEPI_HI_STR_MAX           "46"  /* Max number of chars in HI string    
  */
+#define GEPI_HI_STR_VAL_MAX             46
+#define GEPI_FQDN_STR_MAX          "255" /* Max number of chars in FQDN string 
*/
+#define GEPI_FQDN_STR_VAL_MAX   255
 
 // TODO PF_MAX ??
-#define PF_HIP                 32              /* Host Identity Protocol */
+#define PF_HIP                  32              /* Host Identity Protocol */
 
 int load_hip_endpoint_pem(const char *filename,
-                         struct endpoint **endpoint);
+                          struct endpoint **endpoint);
 
 int setmyeid(struct sockaddr_eid *my_eid,
-            const char *servname,
-            const struct endpoint *endpoint,
-            const struct if_nameindex *ifaces);
+             const char *servname,
+             const struct endpoint *endpoint,
+             const struct if_nameindex *ifaces);
 
 const char *gepi_strerror(int errcode);
 
 /* Translate the name of a service name to a set of identifiers and locators.*/
-extern int getendpointinfo (const char *,
-                           const char *,
-                           const struct addrinfo *,
-                           struct addrinfo **);
+extern int getendpointinfo(const char *,
+                           const char *,
+                           const struct addrinfo *,
+                           struct addrinfo **);
 
 /* Free `endpointinfo' structure ei including associated storage.  */
-extern void free_endpointinfo (struct addrinfo *);
+extern void free_endpointinfo(struct addrinfo *);
 
 int get_local_hits(const char *servname, struct gaih_addrtuple **adr);
 

=== modified file 'lib/core/getendpointinfo.h.doxyme'
--- lib/core/getendpointinfo.h.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/getendpointinfo.h.doxyme   2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/getendpointinfo.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/hashchain.c'
--- lib/core/hashchain.c        2010-01-19 09:28:42 +0000
+++ lib/core/hashchain.c        2010-02-10 23:55:24 +0000
@@ -21,7 +21,7 @@
 #include "ife.h"
 
 /* these are not needed and therefore not implemented
-   right now but they should be used where necessary */
+ * right now but they should be used where necessary */
 #define HCHAIN_LOCK(lock_id)
 #define HCHAIN_UNLOCK(lock_id)
 
@@ -29,45 +29,37 @@
  *
  * @param      hash_chain the hash chain to be printed
  */
-void hchain_print(const hash_chain_t * hash_chain)
+void hchain_print(const hash_chain_t *hash_chain)
 {
-       int i;
-
-       if (hash_chain)
-       {
-               HIP_DEBUG("Hash chain: %p\n", hash_chain);
-
-               if(hash_chain->current_index < hash_chain->hchain_length)
-               {
-                       HIP_HEXDUMP("currrent element: ", 
hchain_element_by_index(hash_chain, hash_chain->current_index),
-                                       hash_chain->hash_length);
-               } else
-               {
-                       HIP_DEBUG(" -- hash chain not in use -- \n");
-               }
-
-               HIP_DEBUG("Remaining elements: %d\n", 
hchain_get_num_remaining(hash_chain));
-               HIP_DEBUG(" - Contents:\n");
-
-               for (i = 0;     i < hash_chain->hchain_length; i++)
-               {
-                       if (i < hash_chain->current_index)
-                       {
-                               HIP_DEBUG("(+) element %i:\n", i + 1);
-
-                       } else
-                       {
-                               HIP_DEBUG("(-) element %i:\n", i + 1);
-                       }
-
-                       HIP_HEXDUMP("\t", hchain_element_by_index(hash_chain, 
i),
-                                       hash_chain->hash_length);
-               }
-
-       } else
-       {
-               HIP_DEBUG("Given hash chain was NULL!\n");
-       }
+    int i;
+
+    if (hash_chain) {
+        HIP_DEBUG("Hash chain: %p\n", hash_chain);
+
+        if (hash_chain->current_index < hash_chain->hchain_length) {
+            HIP_HEXDUMP("currrent element: ",
+                        hchain_element_by_index(hash_chain, 
hash_chain->current_index),
+                        hash_chain->hash_length);
+        } else {
+            HIP_DEBUG(" -- hash chain not in use -- \n");
+        }
+
+        HIP_DEBUG("Remaining elements: %d\n", 
hchain_get_num_remaining(hash_chain));
+        HIP_DEBUG(" - Contents:\n");
+
+        for (i = 0; i < hash_chain->hchain_length; i++) {
+            if (i < hash_chain->current_index) {
+                HIP_DEBUG("(+) element %i:\n", i + 1);
+            } else {
+                HIP_DEBUG("(-) element %i:\n", i + 1);
+            }
+
+            HIP_HEXDUMP("\t", hchain_element_by_index(hash_chain, i),
+                        hash_chain->hash_length);
+        }
+    } else {
+        HIP_DEBUG("Given hash chain was NULL!\n");
+    }
 }
 
 /** checks if a hash is verifiable by a hash chain
@@ -81,59 +73,61 @@
  * @param      secret_length length og the secret
  * @return     hash distance if the hash authentication was successful, 0 
otherwise
  */
-int hchain_verify(const unsigned char * current_hash, const unsigned char * 
last_hash,
-               const hash_function_t hash_function, const int hash_length, 
const int tolerance,
-               const unsigned char *secret, const int secret_length)
+int hchain_verify(const unsigned char *current_hash,
+                  const unsigned char *last_hash,
+                  const hash_function_t hash_function,
+                  const int hash_length,
+                  const int tolerance,
+                  const unsigned char *secret,
+                  const int secret_length)
 {
-       /* stores intermediate hash results and allow to concat
-        * with a secret at each step */
-       unsigned char buffer[MAX_HASH_LENGTH + secret_length];
-       int err = 0, i;
-
-       HIP_ASSERT(current_hash != NULL && last_hash != NULL);
-       HIP_ASSERT(hash_function != NULL);
-       HIP_ASSERT(hash_length > 0 && tolerance >= 0);
-
-       // init buffer with the hash we want to verify
-       memcpy(buffer, current_hash, hash_length);
-
-       if (secret && secret_length > 0)
-       {
-               HIP_HEXDUMP("secret: ", secret, secret_length);
-       }
-
-       _HIP_HEXDUMP("comparing given hash: ", buffer, hash_length);
-       _HIP_DEBUG("\t<->\n");
-       _HIP_HEXDUMP("last known hash: ", last_hash, hash_length);
-
-       for(i = 1; i <= tolerance; i++)
-       {
-               _HIP_DEBUG("Calculating round %i:\n", i);
-
-               // add the secret
-               if (secret != NULL && secret_length > 0)
-                       memcpy(&buffer[hash_length], secret, secret_length);
-
-               hash_function(buffer, hash_length + secret_length, buffer);
-
-               _HIP_HEXDUMP("comparing buffer: ", buffer, hash_length);
-               _HIP_DEBUG("\t<->\n");
-               _HIP_HEXDUMP("last known hash: ", last_hash, hash_length);
-
-               // compare the elements
-               if(!(memcmp(buffer, last_hash, hash_length)))
-               {
-                       HIP_DEBUG("hash verfied\n");
-
-                       err = i;
-                       goto out_err;
-               }
-       }
-
-       HIP_DEBUG("no matches found within tolerance: %i!\n", tolerance);
-
-  out_err:
-       return err;
+    /* stores intermediate hash results and allow to concat
+     * with a secret at each step */
+    unsigned char buffer[MAX_HASH_LENGTH + secret_length];
+    int err = 0, i;
+
+    HIP_ASSERT(current_hash != NULL && last_hash != NULL);
+    HIP_ASSERT(hash_function != NULL);
+    HIP_ASSERT(hash_length > 0 && tolerance >= 0);
+
+    // init buffer with the hash we want to verify
+    memcpy(buffer, current_hash, hash_length);
+
+    if (secret && secret_length > 0) {
+        HIP_HEXDUMP("secret: ", secret, secret_length);
+    }
+
+    _HIP_HEXDUMP("comparing given hash: ", buffer, hash_length);
+    _HIP_DEBUG("\t<->\n");
+    _HIP_HEXDUMP("last known hash: ", last_hash, hash_length);
+
+    for (i = 1; i <= tolerance; i++) {
+        _HIP_DEBUG("Calculating round %i:\n", i);
+
+        // add the secret
+        if (secret != NULL && secret_length > 0) {
+            memcpy(&buffer[hash_length], secret, secret_length);
+        }
+
+        hash_function(buffer, hash_length + secret_length, buffer);
+
+        _HIP_HEXDUMP("comparing buffer: ", buffer, hash_length);
+        _HIP_DEBUG("\t<->\n");
+        _HIP_HEXDUMP("last known hash: ", last_hash, hash_length);
+
+        // compare the elements
+        if (!(memcmp(buffer, last_hash, hash_length))) {
+            HIP_DEBUG("hash verfied\n");
+
+            err = i;
+            goto out_err;
+        }
+    }
+
+    HIP_DEBUG("no matches found within tolerance: %i!\n", tolerance);
+
+out_err:
+    return err;
 }
 
 /** creates a new hash chain
@@ -145,91 +139,88 @@
  * @param      link_tree the link tree, if HHL is used
  * @return  pointer to the newly created hash chain, NULL on error
  */
-hash_chain_t * hchain_create(const hash_function_t hash_function, const int 
hash_length,
-               const int hchain_length, const int hchain_hierarchy, 
hash_tree_t *link_tree)
+hash_chain_t *hchain_create(const hash_function_t hash_function,
+                            const int hash_length,
+                            const int hchain_length,
+                            const int hchain_hierarchy,
+                            hash_tree_t *link_tree)
 {
-       hash_chain_t *hchain = NULL;
-       /* the hash function output might be longer than needed
-        * allocate enough memory for the hash function output
-        *
-        * @note we also allow a concatenation with the link tree root and the 
jump chain element here */
-       unsigned char hash_value[3 * MAX_HASH_LENGTH];
-       int hash_data_length = 0;
-       int i, err = 0;
-
-       HIP_ASSERT(hash_function != NULL);
-       // make sure that the hash we want to use is smaller than the max output
-       HIP_ASSERT(hash_length > 0 && hash_length <= MAX_HASH_LENGTH);
-       HIP_ASSERT(hchain_length > 0);
-       HIP_ASSERT(!(hchain_hierarchy == 0 && link_tree));
-
-       // allocate memory for a new hash chain
-       HIP_IFEL(!(hchain = (hash_chain_t *) malloc(sizeof(hash_chain_t))), -1,
-                       "failed to allocate memory\n");
-       memset(hchain, 0, sizeof(hash_chain_t));
-
-       // allocate memory for the hash chain elements
-       HIP_IFEL(!(hchain->elements = (unsigned char *) malloc(hash_length * 
hchain_length)), -1,
-                               "failed to allocate memory\n");
-       memset(hchain->elements, 0, hash_length * hchain_length);
-
-       // set the link tree if we are using different hierarchies
-       if (link_tree)
-       {
-               hchain->link_tree = link_tree;
-               hash_data_length = 2 * hash_length;
-
-       } else
-       {
-               hchain->link_tree = NULL;
-               hash_data_length = hash_length;
-       }
-
-       for (i = 0; i < hchain_length; i++)
-       {
-               if (i > 0)
-               {
-                       // (input, input_length, output) -> output_length == 20
-                       HIP_IFEL(!(hash_function(hash_value, hash_data_length, 
hash_value)), -1,
-                                       "failed to calculate hash\n");
-                       // only consider highest bytes of digest with length of 
actual element
-                       memcpy( &hchain->elements[i * hash_length], hash_value, 
hash_length);
-               } else
-               {
-                       // random bytes as seed -> need a copy in hash_value 
for further computations
-                       HIP_IFEL(RAND_bytes(hash_value, hash_length) <= 0, -1,
-                                       "failed to get random bytes for source 
element\n");
-
-                       memcpy(&hchain->elements[i * hash_length], hash_value, 
hash_length);
-               }
-
-               /* concatenate used part of the calculated hash with the link 
tree root */
-               if (link_tree)
-               {
-                       memcpy(&hash_value[hash_length], link_tree->root, 
link_tree->node_length);
-               }
-
-               _HIP_HEXDUMP("element created: ", &hchain->elements[i], 
hash_length);
-       }
-
-       hchain->hash_function = hash_function;
-       hchain->hash_length = hash_length;
-       hchain->hchain_length = hchain_length;
-       hchain->current_index = hchain_length;
-       hchain->hchain_hierarchy = hchain_hierarchy;
-
-       HIP_DEBUG("Hash-chain with %i elements of length %i created!\n", 
hchain_length,
-                       hash_length);
-
-  out_err:
-    if (err)
-    {
-               // hchain was fully created
-               hchain_free(hchain);
-       hchain = NULL;
-    }
-
-       return hchain;
+    hash_chain_t *hchain = NULL;
+    /* the hash function output might be longer than needed
+     * allocate enough memory for the hash function output
+     *
+     * @note we also allow a concatenation with the link tree root and the 
jump chain element here */
+    unsigned char hash_value[3 * MAX_HASH_LENGTH];
+    int hash_data_length = 0;
+    int i, err = 0;
+
+    HIP_ASSERT(hash_function != NULL);
+    // make sure that the hash we want to use is smaller than the max output
+    HIP_ASSERT(hash_length > 0 && hash_length <= MAX_HASH_LENGTH);
+    HIP_ASSERT(hchain_length > 0);
+    HIP_ASSERT(!(hchain_hierarchy == 0 && link_tree));
+
+    // allocate memory for a new hash chain
+    HIP_IFEL(!(hchain = (hash_chain_t *) malloc(sizeof(hash_chain_t))), -1,
+             "failed to allocate memory\n");
+    memset(hchain, 0, sizeof(hash_chain_t));
+
+    // allocate memory for the hash chain elements
+    HIP_IFEL(!(hchain->elements = (unsigned char *) malloc(hash_length * 
hchain_length)),
+             -1,
+             "failed to allocate memory\n");
+    memset(hchain->elements, 0, hash_length * hchain_length);
+
+    // set the link tree if we are using different hierarchies
+    if (link_tree) {
+        hchain->link_tree = link_tree;
+        hash_data_length  = 2 * hash_length;
+    } else {
+        hchain->link_tree = NULL;
+        hash_data_length  = hash_length;
+    }
+
+    for (i = 0; i < hchain_length; i++) {
+        if (i > 0) {
+            // (input, input_length, output) -> output_length == 20
+            HIP_IFEL(!(hash_function(hash_value, hash_data_length, 
hash_value)), -1,
+                     "failed to calculate hash\n");
+            // only consider highest bytes of digest with length of actual 
element
+            memcpy( &hchain->elements[i * hash_length], hash_value, 
hash_length);
+        } else {
+            // random bytes as seed -> need a copy in hash_value for further 
computations
+            HIP_IFEL(RAND_bytes(hash_value, hash_length) <= 0, -1,
+                     "failed to get random bytes for source element\n");
+
+            memcpy(&hchain->elements[i * hash_length], hash_value, 
hash_length);
+        }
+
+        /* concatenate used part of the calculated hash with the link tree 
root */
+        if (link_tree) {
+            memcpy(&hash_value[hash_length], link_tree->root, 
link_tree->node_length);
+        }
+
+        _HIP_HEXDUMP("element created: ", &hchain->elements[i], hash_length);
+    }
+
+    hchain->hash_function    = hash_function;
+    hchain->hash_length      = hash_length;
+    hchain->hchain_length    = hchain_length;
+    hchain->current_index    = hchain_length;
+    hchain->hchain_hierarchy = hchain_hierarchy;
+
+    HIP_DEBUG("Hash-chain with %i elements of length %i created!\n",
+              hchain_length,
+              hash_length);
+
+out_err:
+    if (err) {
+        // hchain was fully created
+        hchain_free(hchain);
+        hchain = NULL;
+    }
+
+    return hchain;
 }
 
 /* getter function for the hash chain anchor element
@@ -237,11 +228,11 @@
  * @param      hash_chain hash chain from which the anchor should be returned
  * @return     anchor element of the given hash chain
  */
-unsigned char * hchain_get_anchor(const hash_chain_t *hash_chain)
+unsigned char *hchain_get_anchor(const hash_chain_t *hash_chain)
 {
-       HIP_ASSERT(hash_chain);
+    HIP_ASSERT(hash_chain);
 
-       return hchain_element_by_index(hash_chain, hash_chain->hchain_length - 
1);
+    return hchain_element_by_index(hash_chain, hash_chain->hchain_length - 1);
 }
 
 /* getter function for the hash chain seed element
@@ -249,11 +240,11 @@
  * @param      hash_chain hash chain from which the seed should be returned
  * @return     seed element of the given hash chain
  */
-unsigned char * hchain_get_seed(const hash_chain_t *hash_chain)
+unsigned char *hchain_get_seed(const hash_chain_t *hash_chain)
 {
-       HIP_ASSERT(hash_chain);
+    HIP_ASSERT(hash_chain);
 
-       return hchain_element_by_index(hash_chain, 0);
+    return hchain_element_by_index(hash_chain, 0);
 }
 
 /* getter function for a specific element of the given hash chain
@@ -262,32 +253,30 @@
  * @param      index index to the hash chain element
  * @return     element of the given hash chain
  */
-unsigned char * hchain_element_by_index(const hash_chain_t *hash_chain, const 
int index)
+unsigned char *hchain_element_by_index(const hash_chain_t *hash_chain, const 
int index)
 {
-       unsigned char *element = NULL;
-       int err = 0;
-
-       HIP_ASSERT(hash_chain);
-
-       if (index >= 0 && index < hash_chain->hchain_length)
-       {
-               element = &hash_chain->elements[index * 
hash_chain->hash_length];
-
-       } else
-       {
-               HIP_ERROR("Element from uninited hash chain or out-of-bound 
element requested!");
-
-               err = -1;
-               goto out_err;
-       }
-
-       HIP_HEXDUMP("Hash chain element: ", element, hash_chain->hash_length);
-
-  out_err:
-       if (err)
-               element = NULL;
-
-       return element;
+    unsigned char *element = NULL;
+    int err                = 0;
+
+    HIP_ASSERT(hash_chain);
+
+    if (index >= 0 && index < hash_chain->hchain_length) {
+        element = &hash_chain->elements[index * hash_chain->hash_length];
+    } else {
+        HIP_ERROR("Element from uninited hash chain or out-of-bound element 
requested!");
+
+        err = -1;
+        goto out_err;
+    }
+
+    HIP_HEXDUMP("Hash chain element: ", element, hash_chain->hash_length);
+
+out_err:
+    if (err) {
+        element = NULL;
+    }
+
+    return element;
 }
 
 /* setter function for a specific index of the given hash chain
@@ -298,14 +287,14 @@
  */
 int hchain_set_current_index(hash_chain_t *hash_chain, const int index)
 {
-       int err = 0;
-
-       HIP_ASSERT(hash_chain);
-       HIP_ASSERT(index >= 0 && index <= hash_chain->hchain_length);
-
-       hash_chain->current_index = index;
-
-       return err;
+    int err = 0;
+
+    HIP_ASSERT(hash_chain);
+    HIP_ASSERT(index >= 0 && index <= hash_chain->hchain_length);
+
+    hash_chain->current_index = index;
+
+    return err;
 }
 
 /** returns the next element of the hash chain but does not advance the 
current element
@@ -315,13 +304,13 @@
  * @param      hash_chain the hash chain
  * @return     next element of the hash chain or NULL if the hash chain 
reached boundary
  */
-unsigned char * hchain_next(const hash_chain_t *hash_chain)
+unsigned char *hchain_next(const hash_chain_t *hash_chain)
 {
-       unsigned char *element = NULL;
-
-       element = hchain_element_by_index(hash_chain, hash_chain->current_index 
- 1);
-
-       return element;
+    unsigned char *element = NULL;
+
+    element = hchain_element_by_index(hash_chain, hash_chain->current_index - 
1);
+
+    return element;
 }
 
 /** returns the previous element of the hash chain but does not advance the 
current element
@@ -330,13 +319,13 @@
  * @param      hash_chain given hash chain
  * @return     previous element of the hash chain or NULL if the hash chain 
reached boundary
  */
-unsigned char * hchain_previous(const hash_chain_t * hash_chain)
+unsigned char *hchain_previous(const hash_chain_t *hash_chain)
 {
-       unsigned char *element = NULL;
-
-       element = hchain_element_by_index(hash_chain, hash_chain->current_index 
+ 1);
-
-       return element;
+    unsigned char *element = NULL;
+
+    element = hchain_element_by_index(hash_chain, hash_chain->current_index + 
1);
+
+    return element;
 }
 
 /** returns the current element of the hash chain but does not advance the 
current element
@@ -345,13 +334,13 @@
  * @param      hash_chain given hash chain
  * @return     current element of the hash chain or NULL if the hash chain 
reached boundary
  */
-unsigned char * hchain_current(const hash_chain_t *hash_chain)
+unsigned char *hchain_current(const hash_chain_t *hash_chain)
 {
-       unsigned char *element = NULL;
-
-       element = hchain_element_by_index(hash_chain, 
hash_chain->current_index);
-
-       return element;
+    unsigned char *element = NULL;
+
+    element = hchain_element_by_index(hash_chain, hash_chain->current_index);
+
+    return element;
 }
 
 /** removes and returns the next element from the hash chain advances current 
element pointer
@@ -359,18 +348,18 @@
  * @param      hash_chain hash chain which has to be popped
  * @return     pointer to the next hashchain element or NULL if the hash chain 
is depleted
  */
-unsigned char * hchain_pop(hash_chain_t * hash_chain)
+unsigned char *hchain_pop(hash_chain_t *hash_chain)
 {
-       unsigned char *element = NULL;
-
-       HIP_ASSERT(hash_chain);
-
-       HCHAIN_LOCK(&hash_chain);
-       element = hchain_next(hash_chain);
-       hash_chain->current_index--;
-       HCHAIN_UNLOCK(&hash_chain);
-
-       return element;
+    unsigned char *element = NULL;
+
+    HIP_ASSERT(hash_chain);
+
+    HCHAIN_LOCK(&hash_chain);
+    element = hchain_next(hash_chain);
+    hash_chain->current_index--;
+    HCHAIN_UNLOCK(&hash_chain);
+
+    return element;
 }
 
 /** returns the previous element from the hash chain and decreases current 
element pointer
@@ -378,18 +367,18 @@
  * @param      hash_chain hash chain which has to be popped
  * @return     pointer to the previous hashchain element or NULL if the hash 
chain is depleted
  */
-unsigned char * hchain_push(hash_chain_t * hash_chain)
+unsigned char *hchain_push(hash_chain_t *hash_chain)
 {
-       unsigned char *element = NULL;
-
-       HIP_ASSERT(hash_chain);
-
-       HCHAIN_LOCK(&hash_chain);
-       element = hchain_previous(hash_chain);
-       hash_chain->current_index++;
-       HCHAIN_UNLOCK(&hash_chain);
-
-       return element;
+    unsigned char *element = NULL;
+
+    HIP_ASSERT(hash_chain);
+
+    HCHAIN_LOCK(&hash_chain);
+    element = hchain_previous(hash_chain);
+    hash_chain->current_index++;
+    HCHAIN_UNLOCK(&hash_chain);
+
+    return element;
 }
 
 /** resets the pointer to the current element
@@ -399,11 +388,11 @@
  */
 int hchain_reset(hash_chain_t *hash_chain)
 {
-       int err = 0;
-
-       hash_chain->current_index = hash_chain->hchain_length;
-
-       return err;
+    int err = 0;
+
+    hash_chain->current_index = hash_chain->hchain_length;
+
+    return err;
 }
 
 /** delete hash chain and free memory
@@ -413,22 +402,22 @@
  */
 int hchain_free(hash_chain_t *hash_chain)
 {
-       int err = 0;
-
-       if(hash_chain)
-       {
-               htree_free(hash_chain->link_tree);
-               hash_chain->link_tree = NULL;
-
-               if (hash_chain->elements)
-                       free(hash_chain->elements);
-
-               free(hash_chain);
-       }
-
-       HIP_DEBUG("all hash-chain elements and dependencies freed\n");
-
-       return err;
+    int err = 0;
+
+    if (hash_chain) {
+        htree_free(hash_chain->link_tree);
+        hash_chain->link_tree = NULL;
+
+        if (hash_chain->elements) {
+            free(hash_chain->elements);
+        }
+
+        free(hash_chain);
+    }
+
+    HIP_DEBUG("all hash-chain elements and dependencies freed\n");
+
+    return err;
 }
 
 /** accessor function which returns the number of remaining hash chain elements
@@ -436,7 +425,7 @@
  * @param      hash_chain the hash chain
  * @return     number of remaining elements
  */
-int hchain_get_num_remaining(const hash_chain_t * hash_chain)
+int hchain_get_num_remaining(const hash_chain_t *hash_chain)
 {
-       return hash_chain->current_index;
+    return hash_chain->current_index;
 }

=== modified file 'lib/core/hashchain.h'
--- lib/core/hashchain.h        2010-02-06 15:19:35 +0000
+++ lib/core/hashchain.h        2010-02-10 23:55:24 +0000
@@ -28,47 +28,55 @@
 
 /* hash function used for the creation and verification of the hash chain */
 #ifndef CONFIG_HIP_MAEMO
-typedef unsigned char * (*hash_function_t)(const unsigned char *, size_t,
-               unsigned char *);
+typedef unsigned char * (*hash_function_t)(const unsigned char *,
+                                           size_t,
+                                           unsigned char *);
 #else
 /* The maemo environment uses a different version of the OpenSSL library */
-typedef unsigned char * (*hash_function_t)(const unsigned char *, unsigned 
long,
-               unsigned char *);
+typedef unsigned char * (*hash_function_t)(const unsigned char *,
+                                           unsigned long,
+                                           unsigned char *);
 #endif
 
-typedef struct hash_chain
-{
-       /* pointer to the hash-function used to create and verify the hchain
-        *
-        * @note params: (in_buffer, in_length, out_buffer)
-        * @note out_buffer should be size MAX_HASH_LENGTH */
-       hash_function_t hash_function;
-       int hash_length;        /* length of the hashes, of which the hchain 
consist */
-       int hchain_length;      /* number of initial elements in the hash-chain 
*/
-       int hchain_hierarchy; /* hierarchy this hchain belongs to */
-       int current_index; /* index to currently revealed element for hchain 
traversal*/
-       unsigned char * elements; /* array containing the elements of the hash 
chain*/
-       hash_tree_t *link_tree; /* pointer to a hash tree for linking hchains */
+typedef struct hash_chain {
+    /* pointer to the hash-function used to create and verify the hchain
+     *
+     * @note params: (in_buffer, in_length, out_buffer)
+     * @note out_buffer should be size MAX_HASH_LENGTH */
+    hash_function_t hash_function;
+    int             hash_length; /* length of the hashes, of which the hchain 
consist */
+    int             hchain_length; /* number of initial elements in the 
hash-chain */
+    int             hchain_hierarchy; /* hierarchy this hchain belongs to */
+    int             current_index; /* index to currently revealed element for 
hchain traversal*/
+    unsigned char * elements;     /* array containing the elements of the hash 
chain*/
+    hash_tree_t *   link_tree;  /* pointer to a hash tree for linking hchains 
*/
 } hash_chain_t;
 
-
-void hchain_print(const hash_chain_t * hash_chain);
-int hchain_verify(const unsigned char * current_hash, const unsigned char * 
last_hash,
-               const hash_function_t hash_function, const int hash_length, 
const int tolerance,
-               const unsigned char *secret, const int secret_length);
-hash_chain_t * hchain_create(const hash_function_t hash_function, const int 
hash_length,
-               const int hchain_length, const int hchain_hierarchy, 
hash_tree_t *link_tree);
-unsigned char * hchain_get_anchor(const hash_chain_t *hash_chain);
-unsigned char * hchain_get_seed(const hash_chain_t *hash_chain);
-unsigned char * hchain_element_by_index(const hash_chain_t *hash_chain, const 
int index);
-unsigned char * hchain_next(const hash_chain_t *hash_chain);
-unsigned char * hchain_previous(const hash_chain_t * hash_chain);
+void hchain_print(const hash_chain_t *hash_chain);
+int hchain_verify(const unsigned char *current_hash,
+                  const unsigned char *last_hash,
+                  const hash_function_t hash_function,
+                  const int hash_length,
+                  const int tolerance,
+                  const unsigned char *secret,
+                  const int secret_length);
+hash_chain_t *hchain_create(const hash_function_t hash_function,
+                            const int hash_length,
+                            const int hchain_length,
+                            const int hchain_hierarchy,
+                            hash_tree_t *link_tree);
+unsigned char *hchain_get_anchor(const hash_chain_t *hash_chain);
+unsigned char *hchain_get_seed(const hash_chain_t *hash_chain);
+unsigned char *hchain_element_by_index(const hash_chain_t *hash_chain,
+                                       const int index);
+unsigned char *hchain_next(const hash_chain_t *hash_chain);
+unsigned char *hchain_previous(const hash_chain_t *hash_chain);
 int hchain_set_current_index(hash_chain_t *hash_chain, const int index);
-unsigned char * hchain_current(const hash_chain_t *hash_chain);
-unsigned char * hchain_pop(hash_chain_t * hash_chain);
-unsigned char * hchain_push(hash_chain_t * hash_chain);
+unsigned char *hchain_current(const hash_chain_t *hash_chain);
+unsigned char *hchain_pop(hash_chain_t *hash_chain);
+unsigned char *hchain_push(hash_chain_t *hash_chain);
 int hchain_reset(hash_chain_t *hash_chain);
 int hchain_free(hash_chain_t *hash_chain);
-int hchain_get_num_remaining(const hash_chain_t * hash_chain);
+int hchain_get_num_remaining(const hash_chain_t *hash_chain);
 
 #endif /*HASH_CHAIN_H*/

=== modified file 'lib/core/hashchain_store.c'
--- lib/core/hashchain_store.c  2010-01-19 09:28:42 +0000
+++ lib/core/hashchain_store.c  2010-02-10 23:55:24 +0000
@@ -24,7 +24,7 @@
  */
 static void hcstore_free_hchain(void *hchain)
 {
-       hchain_free((hash_chain_t *) hchain);
+    hchain_free((hash_chain_t *) hchain);
 }
 
 /** helper function to free a hash tree
@@ -33,7 +33,7 @@
  */
 static void hcstore_free_htree(void *htree)
 {
-       htree_free((hash_tree_t *) htree);
+    htree_free((hash_tree_t *) htree);
 }
 
 /** initializes a new hash item store
@@ -43,46 +43,44 @@
  * @param      refill_threshold the threshold below which a hierarchy level 
will be refilled
  * @return     always returns 0
  */
-int hcstore_init(hchain_store_t *hcstore, const int num_hchains_per_item, 
const double refill_threshold)
+int hcstore_init(hchain_store_t *hcstore,
+                 const int num_hchains_per_item,
+                 const double refill_threshold)
 {
-       int err = 0, i, j, g, h;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(num_hchains_per_item >= 0);
-       HIP_ASSERT(refill_threshold >= 0 && refill_threshold <= 1);
-
-       // set global values
-       hcstore->num_hchains_per_item = num_hchains_per_item;
-       hcstore->refill_threshold = refill_threshold;
-
-       hcstore->num_functions = 0;
-
-       for (i = 0; i < MAX_FUNCTIONS; i++)
-       {
-               hcstore->hash_functions[i] = NULL;
-               hcstore->num_hash_lengths[i] = 0;
-
-               for (j = 0; j < MAX_NUM_HASH_LENGTH; j++)
-               {
-                       hcstore->hash_lengths[i][j] = 0;
-                       hcstore->hchain_shelves[i][j].num_hchain_lengths = 0;
-
-                       for (g = 0; g < MAX_NUM_HCHAIN_LENGTH; g++)
-                       {
-                               hcstore->hchain_shelves[i][j].hchain_lengths[g] 
= 0;
-                               
hcstore->hchain_shelves[i][j].num_hierarchies[g] = 0;
-
-                               for (h = 0; h < MAX_NUM_HIERARCHIES; h++)
-                               {
-                                       
hip_ll_init(&hcstore->hchain_shelves[i][j].hchains[g][h]);
-                               }
-                       }
-               }
-       }
-
-       HIP_DEBUG("hash-chain store initialized\n");
-
-       return err;
+    int err = 0, i, j, g, h;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(num_hchains_per_item >= 0);
+    HIP_ASSERT(refill_threshold >= 0 && refill_threshold <= 1);
+
+    // set global values
+    hcstore->num_hchains_per_item = num_hchains_per_item;
+    hcstore->refill_threshold     = refill_threshold;
+
+    hcstore->num_functions        = 0;
+
+    for (i = 0; i < MAX_FUNCTIONS; i++) {
+        hcstore->hash_functions[i]   = NULL;
+        hcstore->num_hash_lengths[i] = 0;
+
+        for (j = 0; j < MAX_NUM_HASH_LENGTH; j++) {
+            hcstore->hash_lengths[i][j]                      = 0;
+            hcstore->hchain_shelves[i][j].num_hchain_lengths = 0;
+
+            for (g = 0; g < MAX_NUM_HCHAIN_LENGTH; g++) {
+                hcstore->hchain_shelves[i][j].hchain_lengths[g]  = 0;
+                hcstore->hchain_shelves[i][j].num_hierarchies[g] = 0;
+
+                for (h = 0; h < MAX_NUM_HIERARCHIES; h++) {
+                    hip_ll_init(&hcstore->hchain_shelves[i][j].hchains[g][h]);
+                }
+            }
+        }
+    }
+
+    HIP_DEBUG("hash-chain store initialized\n");
+
+    return err;
 }
 
 /** un-initializes a hash structure store
@@ -92,44 +90,38 @@
  */
 void hcstore_uninit(hchain_store_t *hcstore, const int use_hash_trees)
 {
-       int i, j, g, h;
-
-       HIP_ASSERT(hcstore != NULL);
-
-       hcstore->num_functions = 0;
-
-       for (i = 0; i < MAX_FUNCTIONS; i++)
-       {
-               hcstore->hash_functions[i] = NULL;
-               hcstore->num_hash_lengths[i] = 0;
-
-               for (j = 0; j < MAX_NUM_HASH_LENGTH; j++)
-               {
-                       hcstore->hash_lengths[i][j] = 0;
-                       hcstore->hchain_shelves[i][j].num_hchain_lengths = 0;
-
-                       for (g = 0; g < MAX_NUM_HCHAIN_LENGTH; g++)
-                       {
-                               hcstore->hchain_shelves[i][j].hchain_lengths[g] 
= 0;
-                               
hcstore->hchain_shelves[i][j].num_hierarchies[g] = 0;
-
-                               for (h = 0; h < MAX_NUM_HIERARCHIES; h++)
-                               {
-                                       if (use_hash_trees)
-                                       {
-                                               
hip_ll_uninit(&hcstore->hchain_shelves[i][j].hchains[g][h],
-                                                                               
                                hcstore_free_htree);
-                                       } else
-                                       {
-                                               
hip_ll_uninit(&hcstore->hchain_shelves[i][j].hchains[g][h],
-                                                               
hcstore_free_hchain);
-                                       }
-                               }
-                       }
-               }
-       }
-
-       HIP_DEBUG("hash-chain store uninitialized\n");
+    int i, j, g, h;
+
+    HIP_ASSERT(hcstore != NULL);
+
+    hcstore->num_functions = 0;
+
+    for (i = 0; i < MAX_FUNCTIONS; i++) {
+        hcstore->hash_functions[i]   = NULL;
+        hcstore->num_hash_lengths[i] = 0;
+
+        for (j = 0; j < MAX_NUM_HASH_LENGTH; j++) {
+            hcstore->hash_lengths[i][j]                      = 0;
+            hcstore->hchain_shelves[i][j].num_hchain_lengths = 0;
+
+            for (g = 0; g < MAX_NUM_HCHAIN_LENGTH; g++) {
+                hcstore->hchain_shelves[i][j].hchain_lengths[g]  = 0;
+                hcstore->hchain_shelves[i][j].num_hierarchies[g] = 0;
+
+                for (h = 0; h < MAX_NUM_HIERARCHIES; h++) {
+                    if (use_hash_trees) {
+                        
hip_ll_uninit(&hcstore->hchain_shelves[i][j].hchains[g][h],
+                                      hcstore_free_htree);
+                    } else {
+                        
hip_ll_uninit(&hcstore->hchain_shelves[i][j].hchains[g][h],
+                                      hcstore_free_hchain);
+                    }
+                }
+            }
+        }
+    }
+
+    HIP_DEBUG("hash-chain store uninitialized\n");
 }
 
 /** registers a new hash function for utilization in the store
@@ -139,38 +131,37 @@
  * @return     returns the index to the hash function in the store,
  *          -1 if MAX_FUNCTIONS is reached
  */
-int hcstore_register_function(hchain_store_t *hcstore, const hash_function_t 
hash_function)
+int hcstore_register_function(hchain_store_t *hcstore,
+                              const hash_function_t hash_function)
 {
-       int err = 0, i;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(hash_function != NULL);
-
-       // first check that there's still some space left
-       HIP_IFEL(hcstore->num_functions == MAX_FUNCTIONS, -1,
-                       "space for function-storage is full\n");
-
-       // also check if the function is already stored
-       for (i = 0; i < hcstore->num_functions; i++)
-       {
-               if (hcstore->hash_functions[i] == hash_function)
-               {
-                       HIP_DEBUG("hchain store already contains this 
function\n");
-
-                       err = i;
-                       goto out_err;
-               }
-       }
-
-       // store the hash-function
-       err = hcstore->num_functions;
-       hcstore->hash_functions[hcstore->num_functions] = hash_function;
-       hcstore->num_functions++;
-
-       HIP_DEBUG("hash function successfully registered\n");
-
-  out_err:
-       return err;
+    int err = 0, i;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(hash_function != NULL);
+
+    // first check that there's still some space left
+    HIP_IFEL(hcstore->num_functions == MAX_FUNCTIONS, -1,
+             "space for function-storage is full\n");
+
+    // also check if the function is already stored
+    for (i = 0; i < hcstore->num_functions; i++) {
+        if (hcstore->hash_functions[i] == hash_function) {
+            HIP_DEBUG("hchain store already contains this function\n");
+
+            err = i;
+            goto out_err;
+        }
+    }
+
+    // store the hash-function
+    err                                             = hcstore->num_functions;
+    hcstore->hash_functions[hcstore->num_functions] = hash_function;
+    hcstore->num_functions++;
+
+    HIP_DEBUG("hash function successfully registered\n");
+
+out_err:
+    return err;
 }
 
 /** registers a new hash length for utilization in the store
@@ -182,40 +173,37 @@
  *          -1 if MAX_NUM_HASH_LENGTH is reached
  */
 int hcstore_register_hash_length(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length)
+                                 const int hash_length)
 {
-       int err = 0, i;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length > 0);
-
-       // first check that there's still some space left
-       HIP_IFEL(hcstore->num_hash_lengths[function_id] == MAX_NUM_HASH_LENGTH, 
-1,
-                       "space for hash_length-storage is full\n");
-
-       // also check if the hash length is already stored for this function
-       for (i = 0; i < hcstore->num_hash_lengths[function_id]; i++)
-       {
-               if (hcstore->hash_lengths[function_id][i] == hash_length)
-               {
-                       HIP_DEBUG("hchain store already contains this hash 
length\n");
-
-                       err = i;
-                       goto out_err;
-               }
-       }
-
-       // store the hash length
-       err = hcstore->num_hash_lengths[function_id];
-       
hcstore->hash_lengths[function_id][hcstore->num_hash_lengths[function_id]] =
-                               hash_length;
-       hcstore->num_hash_lengths[function_id]++;
-
-       HIP_DEBUG("hash length successfully registered\n");
-
-  out_err:
-       return err;
+    int err = 0, i;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length > 0);
+
+    // first check that there's still some space left
+    HIP_IFEL(hcstore->num_hash_lengths[function_id] == MAX_NUM_HASH_LENGTH, -1,
+             "space for hash_length-storage is full\n");
+
+    // also check if the hash length is already stored for this function
+    for (i = 0; i < hcstore->num_hash_lengths[function_id]; i++) {
+        if (hcstore->hash_lengths[function_id][i] == hash_length) {
+            HIP_DEBUG("hchain store already contains this hash length\n");
+
+            err = i;
+            goto out_err;
+        }
+    }
+
+    // store the hash length
+    err  = hcstore->num_hash_lengths[function_id];
+    hcstore->hash_lengths[function_id][hcstore->num_hash_lengths[function_id]] 
= hash_length;
+    hcstore->num_hash_lengths[function_id]++;
+
+    HIP_DEBUG("hash length successfully registered\n");
+
+out_err:
+    return err;
 }
 
 /** registers a new hash structure length for utilization in the store
@@ -227,46 +215,46 @@
  * @return     returns the index to the hash structure length in the store,
  *          -1 if MAX_NUM_HCHAIN_LENGTH is reached
  */
-int hcstore_register_hash_item_length(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hitem_length)
+int hcstore_register_hash_item_length(hchain_store_t *hcstore,
+                                      const int function_id,
+                                      const int hash_length_id,
+                                      const int hitem_length)
 {
-       int err = 0, i;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length_id >= 0
-                       && hash_length_id < 
hcstore->num_hash_lengths[function_id]);
-       HIP_ASSERT(hitem_length > 0);
-
-       // first check that there's still some space left
-       
HIP_IFEL(hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths
-                       == MAX_NUM_HCHAIN_LENGTH, -1, "space for 
hchain_length-storage is full\n");
-
-       // also check if the hash length is already stored for this function
-       for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hchain_lengths; i++)
-       {
-               if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
-                         == hitem_length)
-               {
-                       HIP_DEBUG("hchain store already contains this hchain 
length\n");
-
-                       err = i;
-                       goto out_err;
-               }
-       }
-
-       // store the hchain length
-       err = 
hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths;
-       hcstore->hchain_shelves[function_id][hash_length_id].
-                       
hchain_lengths[hcstore->hchain_shelves[function_id][hash_length_id].
-                               num_hchain_lengths] = hitem_length;
-       
hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths++;
-
-       HIP_DEBUG("hchain length successfully registered\n");
-
-  out_err:
-       return err;
+    int err = 0, i;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length_id >= 0
+               && hash_length_id < hcstore->num_hash_lengths[function_id]);
+    HIP_ASSERT(hitem_length > 0);
+
+    // first check that there's still some space left
+    
HIP_IFEL(hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths
+             == MAX_NUM_HCHAIN_LENGTH, -1, "space for hchain_length-storage is 
full\n");
+
+    // also check if the hash length is already stored for this function
+    for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
+         num_hchain_lengths; i++) {
+        if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
+            == hitem_length) {
+            HIP_DEBUG("hchain store already contains this hchain length\n");
+
+            err = i;
+            goto out_err;
+        }
+    }
+
+    // store the hchain length
+    err = 
hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths;
+    hcstore->hchain_shelves[function_id][hash_length_id].
+    hchain_lengths[hcstore->hchain_shelves[function_id][hash_length_id].
+                   num_hchain_lengths] = hitem_length;
+    hcstore->hchain_shelves[function_id][hash_length_id].num_hchain_lengths++;
+
+    HIP_DEBUG("hchain length successfully registered\n");
+
+out_err:
+    return err;
 }
 
 /** registers additional hierarchy levels for utilization in the store
@@ -277,52 +265,53 @@
  * @param      hitem_length hash length to be added
  * @return     returns the hierarchy count, -1 if MAX_NUM_HIERARCHIES is 
reached
  */
-int hcstore_register_hash_item_hierarchy(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hitem_length, const int 
addtional_hierarchies)
+int hcstore_register_hash_item_hierarchy(hchain_store_t *hcstore,
+                                         const int function_id,
+                                         const int hash_length_id,
+                                         const int hitem_length,
+                                         const int addtional_hierarchies)
 {
-       int item_offset = -1;
-       int err = 0, i;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length_id >= 0
-                       && hash_length_id < 
hcstore->num_hash_lengths[function_id]);
-       HIP_ASSERT(hitem_length > 0);
-       HIP_ASSERT(addtional_hierarchies > 0);
-
-       // first find the correct hchain item
-       for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hchain_lengths; i++)
-       {
-               if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
-                               == hitem_length)
-               {
-                       // set item_offset
-                       item_offset = i;
-
-                       break;
-               }
-       }
-
-       // handle unregistered hchain length
-       HIP_IFEL(item_offset < 0, -1, "hchain with unregistered hchain length 
requested\n");
-
-       // first check that there's still enough space left
-       HIP_IFEL(hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hierarchies[item_offset] + addtional_hierarchies >
-                       MAX_NUM_HIERARCHIES, -1,
-                       "insufficient space in hchain_hierarchies-storage\n");
-
-       // add hierarchies
-       hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hierarchies[item_offset] += addtional_hierarchies;
-       err = hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hierarchies[item_offset];
-
-       HIP_DEBUG("additional hchain hierarchies successfully registered\n");
-
-  out_err:
-       return err;
+    int item_offset = -1;
+    int err         = 0, i;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length_id >= 0
+               && hash_length_id < hcstore->num_hash_lengths[function_id]);
+    HIP_ASSERT(hitem_length > 0);
+    HIP_ASSERT(addtional_hierarchies > 0);
+
+    // first find the correct hchain item
+    for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
+         num_hchain_lengths; i++) {
+        if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
+            == hitem_length) {
+            // set item_offset
+            item_offset = i;
+
+            break;
+        }
+    }
+
+    // handle unregistered hchain length
+    HIP_IFEL(item_offset < 0, -1, "hchain with unregistered hchain length 
requested\n");
+
+    // first check that there's still enough space left
+    HIP_IFEL(hcstore->hchain_shelves[function_id][hash_length_id].
+             num_hierarchies[item_offset] + addtional_hierarchies >
+             MAX_NUM_HIERARCHIES, -1,
+             "insufficient space in hchain_hierarchies-storage\n");
+
+    // add hierarchies
+    hcstore->hchain_shelves[function_id][hash_length_id].
+    num_hierarchies[item_offset] += addtional_hierarchies;
+    err                           = 
hcstore->hchain_shelves[function_id][hash_length_id].
+                                    num_hierarchies[item_offset];
+
+    HIP_DEBUG("additional hchain hierarchies successfully registered\n");
+
+out_err:
+    return err;
 }
 
 /** helper function to refill the store
@@ -336,157 +325,164 @@
  * @param      use_hash_trees indicates whether hash chains or hash trees are 
stored
  * @return     number of created hash structures, -1 in case of an error
  */
-static int hcstore_fill_item(hchain_store_t *hcstore, const int hash_func_id, 
const int hash_length_id,
-               const int hchain_length_id, const int hierarchy_level, const 
int update_higher_level,
-               const int use_hash_trees)
+static int hcstore_fill_item(hchain_store_t *hcstore,
+                             const int hash_func_id,
+                             const int hash_length_id,
+                             const int hchain_length_id,
+                             const int hierarchy_level,
+                             const int update_higher_level,
+                             const int use_hash_trees)
 {
-       hash_chain_t *hchain = NULL;
-       hash_tree_t *htree = NULL;
-       hash_tree_t *link_tree = NULL;
-       hash_function_t hash_function = NULL;
-       int hash_length = 0, hchain_length = 0;
-       int create_hchains = 0;
-       hash_chain_t *tmp_hchain = NULL;
-       hash_tree_t *tmp_htree = NULL;
-       unsigned char *root = NULL;
-       int root_length = 0;
-       int err = 0, i, j;
-
-       // set necessary parameters
-       hash_function = hcstore->hash_functions[hash_func_id];
-       hash_length = hcstore->hash_lengths[hash_func_id][hash_length_id];
-       hchain_length = hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                               
hchain_lengths[hchain_length_id];
-
-       // how many hchains are missing to fill up the item again
-       create_hchains = hcstore->num_hchains_per_item
-               - 
hip_ll_get_size(&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                               hchains[hchain_length_id][hierarchy_level]);
-
-       // only update if we reached the threshold or higher level update
-       if ((create_hchains >= hcstore->refill_threshold * 
hcstore->num_hchains_per_item) ||
-                       update_higher_level)
-       {
-               if (hierarchy_level > 0)
-               {
-                       /* if we refill a higher level, first make sure the 
lower levels
-                        * are full */
-                       HIP_IFEL((err = hcstore_fill_item(hcstore, 
hash_func_id, hash_length_id,
-                                       hchain_length_id, hierarchy_level - 1, 
1, use_hash_trees)) < 0, -1,
-                                       "failed to fill item\n");
-               }
-
-               // create one hchain at a time
-               for (i = 0; i < create_hchains; i++)
-               {
-                       // hierarchy level 0 does not use any link trees
-                       link_tree = NULL;
-                       root = NULL;
-                       root_length = 0;
-
-                       if (hierarchy_level > 0)
-                       {
-                               // right now the trees only support hashes of 
20 bytes
-                               HIP_ASSERT(hash_length == 20);
-
-                               // create a link tree for each hchain on level 
> 0
-                               link_tree = 
htree_init(hcstore->num_hchains_per_item, hash_length,
-                                               hash_length, hash_length, NULL, 
0);
-                               htree_add_random_secrets(link_tree);
-
-                               // lower items should be full by now
-                               HIP_ASSERT(hip_ll_get_size(
-                                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                               
hchains[hchain_length_id][hierarchy_level - 1]) ==
-                                               hcstore->num_hchains_per_item);
-
-                               // add the anchors of the next lower level as 
data
-                               for (j = 0; j < hcstore->num_hchains_per_item; 
j++)
-                               {
-                                       if (use_hash_trees)
-                                       {
-                                               tmp_htree = (hash_tree_t *) 
hip_ll_get(
-                                                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                                               
hchains[hchain_length_id][hierarchy_level - 1], j);
-
-                                               htree_add_data(link_tree, 
tmp_htree->root,
-                                                               hash_length);
-                                       } else
-                                       {
-                                               tmp_hchain = (hash_chain_t *) 
hip_ll_get(
-                                                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                                               
hchains[hchain_length_id][hierarchy_level - 1], j);
-
-                                               htree_add_data(link_tree, 
hchain_get_anchor(tmp_hchain),
-                                                               hash_length);
-                                       }
-                               }
-
-                               // calculate the tree
-                               htree_calc_nodes(link_tree, 
htree_leaf_generator,
-                                               htree_node_generator, NULL);
-                       }
-
-                       if (use_hash_trees)
-                       {
-                               // create a new htree
-                               HIP_IFEL(!(htree = htree_init(hchain_length, 
hash_length,
-                                               hash_length, 0, link_tree, 
hierarchy_level)), -1,
-                                               "failed to alloc memory or to 
init htree\n");
-                               HIP_IFEL(htree_add_random_data(htree, 
hchain_length), -1,
-                                               "failed to add random 
secrets\n");
-
-                               // calculate the tree
-                               HIP_IFEL(htree_calc_nodes(htree, 
htree_leaf_generator,
-                                               htree_node_generator, NULL), -1,
-                                               "failed to calculate tree 
nodes\n");
-
-                               // add it as last element to have some 
circulation
-                               HIP_IFEL(hip_ll_add_last(
-                                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                               
hchains[hchain_length_id][hierarchy_level], htree), -1,
-                                               "failed to store new htree\n");
-                       }
-                       else {
-                               // create a new hchain
-                               HIP_IFEL(!(hchain = 
hchain_create(hash_function, hash_length,
-                                               hchain_length, hierarchy_level, 
link_tree)), -1,
-                                               "failed to create new 
hchain\n");
-
-                               // add it as last element to have some 
circulation
-                               HIP_IFEL(hip_ll_add_last(
-                                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
-                                               
hchains[hchain_length_id][hierarchy_level], hchain), -1,
-                                               "failed to store new hchain\n");
-                       }
+    hash_chain_t *hchain          = NULL;
+    hash_tree_t *htree            = NULL;
+    hash_tree_t *link_tree        = NULL;
+    hash_function_t hash_function = NULL;
+    int hash_length               = 0, hchain_length = 0;
+    int create_hchains            = 0;
+    hash_chain_t *tmp_hchain      = NULL;
+    hash_tree_t *tmp_htree        = NULL;
+    unsigned char *root           = NULL;
+    int root_length               = 0;
+    int err                       = 0, i, j;
+
+    // set necessary parameters
+    hash_function  = hcstore->hash_functions[hash_func_id];
+    hash_length    = hcstore->hash_lengths[hash_func_id][hash_length_id];
+    hchain_length  = hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                     hchain_lengths[hchain_length_id];
+
+    // how many hchains are missing to fill up the item again
+    create_hchains = hcstore->num_hchains_per_item
+                     - 
hip_ll_get_size(&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                                       
hchains[hchain_length_id][hierarchy_level]);
+
+    // only update if we reached the threshold or higher level update
+    if ((create_hchains >= hcstore->refill_threshold * 
hcstore->num_hchains_per_item) ||
+        update_higher_level) {
+        if (hierarchy_level > 0) {
+            /* if we refill a higher level, first make sure the lower levels
+             * are full */
+            HIP_IFEL((err = hcstore_fill_item(hcstore,
+                                              hash_func_id,
+                                              hash_length_id,
+                                              hchain_length_id,
+                                              hierarchy_level - 1,
+                                              1,
+                                              use_hash_trees)) < 0,
+                    -1,
+                    "failed to fill item\n");
+        }
+
+        // create one hchain at a time
+        for (i = 0; i < create_hchains; i++) {
+            // hierarchy level 0 does not use any link trees
+            link_tree   = NULL;
+            root        = NULL;
+            root_length = 0;
+
+            if (hierarchy_level > 0) {
+                // right now the trees only support hashes of 20 bytes
+                HIP_ASSERT(hash_length == 20);
+
+                // create a link tree for each hchain on level > 0
+                link_tree = htree_init(hcstore->num_hchains_per_item, 
hash_length,
+                                       hash_length, hash_length, NULL, 0);
+                htree_add_random_secrets(link_tree);
+
+                // lower items should be full by now
+                HIP_ASSERT(hip_ll_get_size(
+                               
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                               hchains[hchain_length_id][hierarchy_level - 1]) 
==
+                           hcstore->num_hchains_per_item);
+
+                // add the anchors of the next lower level as data
+                for (j = 0; j < hcstore->num_hchains_per_item; j++) {
+                    if (use_hash_trees) {
+                        tmp_htree = (hash_tree_t *) hip_ll_get(
+                            
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                            hchains[hchain_length_id][hierarchy_level - 1], j);
+
+                        htree_add_data(link_tree, tmp_htree->root,
+                                       hash_length);
+                    } else {
+                        tmp_hchain = (hash_chain_t *) hip_ll_get(
+                            
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                            hchains[hchain_length_id][hierarchy_level - 1], j);
+
+                        htree_add_data(link_tree, 
hchain_get_anchor(tmp_hchain),
+                                       hash_length);
+                    }
+                }
+
+                // calculate the tree
+                htree_calc_nodes(link_tree, htree_leaf_generator,
+                                 htree_node_generator, NULL);
+            }
+
+            if (use_hash_trees) {
+                // create a new htree
+                HIP_IFEL(!(htree = htree_init(hchain_length,
+                                              hash_length,
+                                              hash_length,
+                                              0,
+                                              link_tree,
+                                              hierarchy_level)),
+                          -1,
+                         "failed to alloc memory or to init htree\n");
+                HIP_IFEL(htree_add_random_data(htree, hchain_length),
+                         -1,
+                         "failed to add random secrets\n");
+
+                // calculate the tree
+                HIP_IFEL(htree_calc_nodes(htree,
+                                          htree_leaf_generator,
+                                          htree_node_generator,
+                                          NULL),
+                         -1,
+                         "failed to calculate tree nodes\n");
+
+                // add it as last element to have some circulation
+                HIP_IFEL(hip_ll_add_last(
+                                
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                                hchains[hchain_length_id][hierarchy_level], 
htree), -1,
+                        "failed to store new htree\n");
+            } else {
+                // create a new hchain
+                HIP_IFEL(!(hchain = hchain_create(hash_function, hash_length,
+                                        hchain_length, hierarchy_level, 
link_tree)), -1,
+                        "failed to create new hchain\n");
+
+                // add it as last element to have some circulation
+                HIP_IFEL(hip_ll_add_last(
+                                
&hcstore->hchain_shelves[hash_func_id][hash_length_id].
+                                hchains[hchain_length_id][hierarchy_level], 
hchain), -1,
+                        "failed to store new hchain\n");
+            }
 
 // useful for testing
 #if 0
-                       if (hchain->link_tree)
-                       {
-                               /* if the next_hchain has got a link_tree, we 
need its root for
-                                * the verification of the next_hchain's 
elements */
-                               root = htree_get_root(hchain->link_tree, 
&root_length);
-                       }
+            if (hchain->link_tree) {
+                /* if the next_hchain has got a link_tree, we need its root for
+                 * the verification of the next_hchain's elements */
+                root = htree_get_root(hchain->link_tree, &root_length);
+            }
 
-                       if (!hchain_verify(hchain->source_element->hash,
-                                       hchain->anchor_element->hash, 
hash_function,
-                                       hash_length, hchain->hchain_length,
-                                       root, root_length))
-                       {
-                               HIP_DEBUG("failed to verify next_hchain\n");
-                       }
+            if (!hchain_verify(hchain->source_element->hash,
+                               hchain->anchor_element->hash, hash_function,
+                               hash_length, hchain->hchain_length,
+                               root, root_length)) {
+                HIP_DEBUG("failed to verify next_hchain\n");
+            }
 #endif
-
-               }
-
-               err += create_hchains;
-       }
-
-       HIP_DEBUG("created %i hchains on hierarchy level %i\n", err, 
hierarchy_level);
-
-  out_err:
-       return err;
+        }
+
+        err += create_hchains;
+    }
+
+    HIP_DEBUG("created %i hchains on hierarchy level %i\n", err, 
hierarchy_level);
+
+out_err:
+    return err;
 }
 
 /** refills the store in case it contains less than ITEM_THRESHOLD * 
MAX_HCHAINS_PER_ITEM
@@ -498,31 +494,27 @@
  */
 int hcstore_refill(hchain_store_t *hcstore, const int use_hash_trees)
 {
-       int err = 0, i, j, g, h;
-
-       HIP_ASSERT(hcstore != NULL);
-
-       /* go through the store setting up information necessary for creating a 
new
-        * hchain in the respective item */
-       for (i = 0; i < hcstore->num_functions; i++)
-       {
-               for (j = 0; j < hcstore->num_hash_lengths[i]; j++)
-               {
-                       for (g = 0; g < 
hcstore->hchain_shelves[i][j].num_hchain_lengths; g++)
-                       {
-                               for (h = 0; h < 
hcstore->hchain_shelves[i][j].num_hierarchies[g]; h++)
-                               {
-                                       HIP_IFEL((err = 
hcstore_fill_item(hcstore, i, j, g, h, 0, use_hash_trees)) < 0,
-                                                       -1, "failed to refill 
hchain_store\n");
-                               }
-                       }
-               }
-       }
-
-       HIP_DEBUG("total amount of created hash-chains: %i\n", err);
-
-  out_err:
-       return err;
+    int err = 0, i, j, g, h;
+
+    HIP_ASSERT(hcstore != NULL);
+
+    /* go through the store setting up information necessary for creating a new
+     * hchain in the respective item */
+    for (i = 0; i < hcstore->num_functions; i++) {
+        for (j = 0; j < hcstore->num_hash_lengths[i]; j++) {
+            for (g = 0; g < hcstore->hchain_shelves[i][j].num_hchain_lengths; 
g++) {
+                for (h = 0; h < 
hcstore->hchain_shelves[i][j].num_hierarchies[g]; h++) {
+                    HIP_IFEL((err = hcstore_fill_item(hcstore, i, j, g, h, 0, 
use_hash_trees)) < 0,
+                             -1, "failed to refill hchain_store\n");
+                }
+            }
+        }
+    }
+
+    HIP_DEBUG("total amount of created hash-chains: %i\n", err);
+
+out_err:
+    return err;
 }
 
 /** gets a stored hash structure with the provided properties
@@ -533,60 +525,59 @@
  * @param      hchain_length length of the hash structure
  * @return     pointer to the hash structure, NULL in case of an error or no 
such structure
  */
-void * hcstore_get_hash_item(hchain_store_t *hcstore, const int function_id,
-               const int hash_length_id, const int hchain_length)
+void *hcstore_get_hash_item(hchain_store_t *hcstore,
+                            const int function_id,
+                            const int hash_length_id,
+                            const int hchain_length)
 {
-       // inited to invalid values
-       int item_offset = -1;
-       void *stored_item = NULL;
-       int hierarchy_level = 0;
-       int err = 0, i;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length_id >= 0
-                       && hash_length_id < 
hcstore->num_hash_lengths[function_id]);
-       HIP_ASSERT(hchain_length > 0);
-
-       // first find the correct hchain item
-       for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hchain_lengths; i++)
-       {
-               if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
-                               == hchain_length)
-               {
-                       // set item_offset
-                       item_offset = i;
-
-                       break;
-               }
-       }
-
-       // handle unregistered hchain length or hierarchy
-       HIP_IFEL(item_offset < 0, -1,
-                       "hchain with unregistered hchain length or hierarchy 
level requested\n");
-
-       // this exclusively returns a hchain from the highest hierarchy level
-       hierarchy_level = hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hierarchies[item_offset] - 1;
-
-       HIP_DEBUG("hierarchy_level: %i\n", hierarchy_level);
-
-       HIP_IFEL(!(stored_item = 
hip_ll_del_first(&hcstore->hchain_shelves[function_id]
-               [hash_length_id].hchains[item_offset][hierarchy_level], NULL)), 
-1,
-                       "no hchain available\n");
-
-  out_err:
-       if (err)
-       {
-               // TODO modify this to support htrees
-               //if (stored_hchain)
-               //      hchain_free(stored_hchain);
-
-               stored_item = NULL;
-       }
-
-       return stored_item;
+    // inited to invalid values
+    int item_offset     = -1;
+    void *stored_item   = NULL;
+    int hierarchy_level = 0;
+    int err             = 0, i;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length_id >= 0
+               && hash_length_id < hcstore->num_hash_lengths[function_id]);
+    HIP_ASSERT(hchain_length > 0);
+
+    // first find the correct hchain item
+    for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
+         num_hchain_lengths; i++) {
+        if 
(hcstore->hchain_shelves[function_id][hash_length_id].hchain_lengths[i]
+            == hchain_length) {
+            // set item_offset
+            item_offset = i;
+
+            break;
+        }
+    }
+
+    // handle unregistered hchain length or hierarchy
+    HIP_IFEL(item_offset < 0, -1,
+             "hchain with unregistered hchain length or hierarchy level 
requested\n");
+
+    // this exclusively returns a hchain from the highest hierarchy level
+    hierarchy_level = hcstore->hchain_shelves[function_id][hash_length_id].
+                      num_hierarchies[item_offset] - 1;
+
+    HIP_DEBUG("hierarchy_level: %i\n", hierarchy_level);
+
+    HIP_IFEL(!(stored_item = 
hip_ll_del_first(&hcstore->hchain_shelves[function_id]
+                                              
[hash_length_id].hchains[item_offset][hierarchy_level], NULL)), -1,
+             "no hchain available\n");
+
+out_err:
+    if (err) {
+        // TODO modify this to support htrees
+        //if (stored_hchain)
+        //     hchain_free(stored_hchain);
+
+        stored_item = NULL;
+    }
+
+    return stored_item;
 }
 
 /** gets a stored hash structure for the provided anchor element
@@ -599,91 +590,91 @@
  * @param      use_hash_trees indicates whether hash chains or hash trees are 
stored
  * @return     pointer to the hash structure, NULL in case of an error or no 
such structure
  */
-void * hcstore_get_item_by_anchor(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hierarchy_level, const 
unsigned char *anchor, const int use_hash_trees)
+void *hcstore_get_item_by_anchor(hchain_store_t *hcstore,
+                                 const int function_id,
+                                 const int hash_length_id,
+                                 const int hierarchy_level,
+                                 const unsigned char *anchor,
+                                 const int use_hash_trees)
 {
-       int hash_length = 0;
-       hash_chain_t *hchain = NULL;
-       hash_tree_t *htree = NULL;
-       void *stored_item = NULL;
-       int err = 0, i, j;
-
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length_id >= 0
-                       && hash_length_id < 
hcstore->num_hash_lengths[function_id]);
-       HIP_ASSERT(hierarchy_level >= 0);
-       HIP_ASSERT(anchor != NULL);
-
-       hash_length = hcstore_get_hash_length(hcstore, function_id, 
hash_length_id);
-
-       HIP_ASSERT(hash_length > 0);
-
-       HIP_HEXDUMP("searching item with anchor: ", anchor, hash_length);
-
-       for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
-                       num_hchain_lengths; i++)
-       {
-               // look for the anchor at each hchain_length with the 
respective hierarchy level
-               HIP_ASSERT(hierarchy_level < 
hcstore->hchain_shelves[function_id][hash_length_id].
-                               num_hierarchies[i]);
-
-               for (j = 0; j < 
hip_ll_get_size(&hcstore->hchain_shelves[function_id]
-                       [hash_length_id].hchains[i][hierarchy_level]); j++)
-               {
-                       stored_item = hip_ll_get(&hcstore->
-                                       
hchain_shelves[function_id][hash_length_id].
-                                       hchains[i][hierarchy_level], j);
-
-                       if (use_hash_trees)
-                       {
-                               htree = (hash_tree_t *)stored_item;
-
-                               if (!memcmp(anchor, htree->root, hash_length))
-                               {
-                                       stored_item = hip_ll_del(&hcstore->
-                                                       
hchain_shelves[function_id][hash_length_id].
-                                                       
hchains[i][hierarchy_level], j, NULL);
-
-                                       HIP_DEBUG("hash-tree matching the 
anchor found\n");
-                                       //hchain_print(stored_hchain);
-
-                                       goto out_err;
-                               }
-                       } else
-                       {
-                               hchain = (hash_chain_t *)stored_item;
-
-                               if (!memcmp(anchor, hchain_get_anchor(hchain), 
hash_length))
-                               {
-                                       stored_item = hip_ll_del(&hcstore->
-                                                       
hchain_shelves[function_id][hash_length_id].
-                                                       
hchains[i][hierarchy_level], j, NULL);
-
-                                       HIP_DEBUG("hash-chain matching the 
anchor found\n");
-                                       //hchain_print(stored_hchain);
-
-                                       goto out_err;
-                               }
-                       }
-               }
-       }
-
-       HIP_ERROR("hash-chain matching the anchor NOT found\n");
-       stored_item = NULL;
-       err = -1;
-
-  out_err:
-       if (err)
-       {
-               // TODO modify this to support htrees
-               //if (stored_item)
-               //      hchain_free(stored_hchain);
-
-               stored_item = NULL;
-       }
-
-       return stored_item;
+    int hash_length      = 0;
+    hash_chain_t *hchain = NULL;
+    hash_tree_t *htree   = NULL;
+    void *stored_item    = NULL;
+    int err              = 0, i, j;
+
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length_id >= 0
+               && hash_length_id < hcstore->num_hash_lengths[function_id]);
+    HIP_ASSERT(hierarchy_level >= 0);
+    HIP_ASSERT(anchor != NULL);
+
+    hash_length = hcstore_get_hash_length(hcstore, function_id, 
hash_length_id);
+
+    HIP_ASSERT(hash_length > 0);
+
+    HIP_HEXDUMP("searching item with anchor: ", anchor, hash_length);
+
+    for (i = 0; i < hcstore->hchain_shelves[function_id][hash_length_id].
+         num_hchain_lengths; i++) {
+        // look for the anchor at each hchain_length with the respective 
hierarchy level
+        HIP_ASSERT(hierarchy_level < 
hcstore->hchain_shelves[function_id][hash_length_id].
+                   num_hierarchies[i]);
+
+        for (j = 0; j < hip_ll_get_size(&hcstore->hchain_shelves[function_id]
+                                        
[hash_length_id].hchains[i][hierarchy_level]); j++) {
+            stored_item = hip_ll_get(&hcstore->
+                                     
hchain_shelves[function_id][hash_length_id].
+                                     hchains[i][hierarchy_level], j);
+
+            if (use_hash_trees) {
+                htree = (hash_tree_t *) stored_item;
+
+                if (!memcmp(anchor, htree->root, hash_length)) {
+                    stored_item =
+                        hip_ll_del(&hcstore->
+                                       
hchain_shelves[function_id][hash_length_id].
+                                       hchains[i][hierarchy_level],
+                                   j,
+                                   NULL);
+
+                    HIP_DEBUG("hash-tree matching the anchor found\n");
+                    //hchain_print(stored_hchain);
+
+                    goto out_err;
+                }
+            } else {
+                hchain = (hash_chain_t *) stored_item;
+
+                if (!memcmp(anchor, hchain_get_anchor(hchain), hash_length)) {
+                    stored_item = hip_ll_del(&hcstore->
+                                             
hchain_shelves[function_id][hash_length_id].
+                                             hchains[i][hierarchy_level], j, 
NULL);
+
+                    HIP_DEBUG("hash-chain matching the anchor found\n");
+                    //hchain_print(stored_hchain);
+
+                    goto out_err;
+                }
+            }
+        }
+    }
+
+    HIP_ERROR("hash-chain matching the anchor NOT found\n");
+    stored_item = NULL;
+    err         = -1;
+
+out_err:
+    if (err) {
+        // TODO modify this to support htrees
+        //if (stored_item)
+        //     hchain_free(stored_hchain);
+
+        stored_item = NULL;
+    }
+
+    return stored_item;
 }
 
 /** gets a pointer to the hash function for a given index
@@ -692,12 +683,13 @@
  * @param      function_id index of the hash function
  * @return     pointer to the hash function, NULL if no such hash function
  */
-hash_function_t hcstore_get_hash_function(hchain_store_t *hcstore, const int 
function_id)
+hash_function_t hcstore_get_hash_function(hchain_store_t *hcstore,
+                                          const int function_id)
 {
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
 
-       return hcstore->hash_functions[function_id];
+    return hcstore->hash_functions[function_id];
 }
 
 /** gets the hash length for a given index
@@ -707,12 +699,14 @@
  * @param      hash_length_id index of the hash length
  * @return     the hash length, 0 if no such hash length
  */
-int hcstore_get_hash_length(hchain_store_t *hcstore, const int function_id, 
const int hash_length_id)
+int hcstore_get_hash_length(hchain_store_t *hcstore,
+                            const int function_id,
+                            const int hash_length_id)
 {
-       HIP_ASSERT(hcstore != NULL);
-       HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
-       HIP_ASSERT(hash_length_id >= 0
-                       && hash_length_id < 
hcstore->num_hash_lengths[function_id]);
+    HIP_ASSERT(hcstore != NULL);
+    HIP_ASSERT(function_id >= 0 && function_id < hcstore->num_functions);
+    HIP_ASSERT(hash_length_id >= 0
+               && hash_length_id < hcstore->num_hash_lengths[function_id]);
 
-       return hcstore->hash_lengths[function_id][hash_length_id];
+    return hcstore->hash_lengths[function_id][hash_length_id];
 }

=== modified file 'lib/core/hashchain_store.h'
--- lib/core/hashchain_store.h  2010-01-19 09:28:42 +0000
+++ lib/core/hashchain_store.h  2010-02-10 23:55:24 +0000
@@ -21,65 +21,80 @@
 
 
 /* max amount of different hash-functions that can be stored */
-#define MAX_FUNCTIONS                  5
+#define MAX_FUNCTIONS                   5
 /* max amount of different hash lengths that can be stored */
-#define MAX_NUM_HASH_LENGTH            5
+#define MAX_NUM_HASH_LENGTH             5
 /* this includes the BEX-item */
-#define MAX_NUM_HCHAIN_LENGTH  5
+#define MAX_NUM_HCHAIN_LENGTH   5
 // max number of hierarchies for which hchains can be linked
-#define MAX_NUM_HIERARCHIES            100
-
-
-typedef struct hchain_shelf
-{
-       /* number of different hchain lengths currently used for this
-        * (hash-function, hash_length)-combination */
-       int num_hchain_lengths;
-       /* the different hchain lengths */
-       int hchain_lengths[MAX_NUM_HCHAIN_LENGTH];
-       /* number of hierarchies in this shelf */
-       int num_hierarchies[MAX_NUM_HCHAIN_LENGTH];
-       /* hchains with the respective hchain length */
-       hip_ll_t hchains[MAX_NUM_HCHAIN_LENGTH][MAX_NUM_HIERARCHIES];
+#define MAX_NUM_HIERARCHIES             100
+
+
+typedef struct hchain_shelf {
+    /* number of different hchain lengths currently used for this
+     * (hash-function, hash_length)-combination */
+    int      num_hchain_lengths;
+    /* the different hchain lengths */
+    int      hchain_lengths[MAX_NUM_HCHAIN_LENGTH];
+    /* number of hierarchies in this shelf */
+    int      num_hierarchies[MAX_NUM_HCHAIN_LENGTH];
+    /* hchains with the respective hchain length */
+    hip_ll_t hchains[MAX_NUM_HCHAIN_LENGTH][MAX_NUM_HIERARCHIES];
 } hchain_shelf_t;
 
-typedef struct hchain_store
-{
-       /* determines at which volume a store item should be refilled */
-       double refill_threshold;
-       /* number of hash structures stored per item, when it is full */
-       int num_hchains_per_item;
-       /* amount of currently used hash-functions */
-       int num_functions;
-       /* pointer to the hash-function used to create and verify the hchain
-        *
-        * @note params: (in_buffer, in_length, out_buffer)
-        * @note out_buffer should be size MAX_HASH_LENGTH */
-       hash_function_t hash_functions[MAX_FUNCTIONS];
-       /* amount of different hash_lengths per hash-function */
-       int num_hash_lengths[MAX_FUNCTIONS];
-       /* length of the hashes, of which the respective hchain items consist */
-       int hash_lengths[MAX_FUNCTIONS][MAX_NUM_HASH_LENGTH];
-       /* contains hchains and meta-information about how to process them */
-       hchain_shelf_t hchain_shelves[MAX_FUNCTIONS][MAX_NUM_HASH_LENGTH];
+typedef struct hchain_store {
+    /* determines at which volume a store item should be refilled */
+    double refill_threshold;
+    /* number of hash structures stored per item, when it is full */
+    int    num_hchains_per_item;
+    /* amount of currently used hash-functions */
+    int    num_functions;
+    /* pointer to the hash-function used to create and verify the hchain
+     *
+     * @note params: (in_buffer, in_length, out_buffer)
+     * @note out_buffer should be size MAX_HASH_LENGTH */
+    hash_function_t hash_functions[MAX_FUNCTIONS];
+    /* amount of different hash_lengths per hash-function */
+    int             num_hash_lengths[MAX_FUNCTIONS];
+    /* length of the hashes, of which the respective hchain items consist */
+    int             hash_lengths[MAX_FUNCTIONS][MAX_NUM_HASH_LENGTH];
+    /* contains hchains and meta-information about how to process them */
+    hchain_shelf_t  hchain_shelves[MAX_FUNCTIONS][MAX_NUM_HASH_LENGTH];
 } hchain_store_t;
 
-
-int hcstore_init(hchain_store_t *hcstore, const int num_hchains_per_item, 
const double refill_threshold);
+int hcstore_init(hchain_store_t *hcstore,
+                 const int num_hchains_per_item,
+                 const double refill_threshold);
 void hcstore_uninit(hchain_store_t *hcstore, const int use_hash_trees);
-int hcstore_register_function(hchain_store_t *hcstore, const hash_function_t 
hash_function);
-int hcstore_register_hash_length(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length);
-int hcstore_register_hash_item_length(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hitem_length);
-int hcstore_register_hash_item_hierarchy(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hitem_length, const int 
addtional_hierarchies);
+int hcstore_register_function(hchain_store_t *hcstore,
+                              const hash_function_t hash_function);
+int hcstore_register_hash_length(hchain_store_t *hcstore,
+                                 const int function_id,
+                                 const int hash_length);
+int hcstore_register_hash_item_length(hchain_store_t *hcstore,
+                                      const int function_id,
+                                      const int hash_length_id,
+                                      const int hitem_length);
+int hcstore_register_hash_item_hierarchy(hchain_store_t *hcstore,
+                                         const int function_id,
+                                         const int hash_length_id,
+                                         const int hitem_length,
+                                         const int addtional_hierarchies);
 int hcstore_refill(hchain_store_t *hcstore, const int use_hash_trees);
-void * hcstore_get_hash_item(hchain_store_t *hcstore, const int function_id,
-               const int hash_length_id, const int hchain_length);
-void * hcstore_get_item_by_anchor(hchain_store_t *hcstore, const int 
function_id,
-               const int hash_length_id, const int hierarchy_level, const 
unsigned char *anchor, const int use_hash_trees);
-hash_function_t hcstore_get_hash_function(hchain_store_t *hcstore, const int 
function_id);
-int hcstore_get_hash_length(hchain_store_t *hcstore, const int function_id, 
const int hash_length_id);
+void *hcstore_get_hash_item(hchain_store_t *hcstore,
+                            const int function_id,
+                            const int hash_length_id,
+                            const int hchain_length);
+void *hcstore_get_item_by_anchor(hchain_store_t *hcstore,
+                                 const int function_id,
+                                 const int hash_length_id,
+                                 const int hierarchy_level,
+                                 const unsigned char *anchor,
+                                 const int use_hash_trees);
+hash_function_t hcstore_get_hash_function(hchain_store_t *hcstore,
+                                          const int function_id);
+int hcstore_get_hash_length(hchain_store_t *hcstore,
+                            const int function_id,
+                            const int hash_length_id);
 
 #endif /* HASHCHAIN_STORE_H */

=== modified file 'lib/core/hashtable.c'
--- lib/core/hashtable.c        2010-01-19 09:28:42 +0000
+++ lib/core/hashtable.c        2010-02-10 23:55:24 +0000
@@ -4,49 +4,48 @@
 
 LHASH_OF(HIP_HT) * hip_ht_init(LHASH_HASH_FN_TYPE hashfunc, LHASH_COMP_FN_TYPE 
cmpfunc)
 {
-       return (LHASH_OF(HIP_HT) *) lh_new(hashfunc, cmpfunc);
+    return (LHASH_OF(HIP_HT) *)lh_new(hashfunc, cmpfunc);
 }
 
 #else /* not HIPL_OPENSSL_100 */
 
-HIP_HASHTABLE * hip_ht_init(LHASH_HASH_FN_TYPE hashfunc,
-                                            LHASH_COMP_FN_TYPE cmpfunc)
+HIP_HASHTABLE *hip_ht_init(LHASH_HASH_FN_TYPE hashfunc,
+                           LHASH_COMP_FN_TYPE cmpfunc)
 {
-       return (HIP_HASHTABLE *) lh_new(hashfunc, cmpfunc);
+    return (HIP_HASHTABLE *) lh_new(hashfunc, cmpfunc);
 }
 
 #endif /* HIPL_OPENSSL_100 */
 
 void hip_ht_uninit(void *head)
 {
-       lh_free(head);
+    lh_free(head);
 }
 
 void *hip_ht_find(void *head, void *data)
 {
-       return lh_retrieve((LHASH100_CAST *) head, data);
+    return lh_retrieve((LHASH100_CAST *) head, data);
 }
 
 int hip_ht_add(void *head, void *data)
 {
-       if (lh_insert((LHASH100_CAST *) head, data)) {
-               HIP_DEBUG("hash replace did not occur\n");
-       }
-       return 0;
+    if (lh_insert((LHASH100_CAST *) head, data)) {
+        HIP_DEBUG("hash replace did not occur\n");
+    }
+    return 0;
 }
 
 void *hip_ht_delete(void *head, void *data)
 {
-       return lh_delete((LHASH100_CAST *) head, data);
+    return lh_delete((LHASH100_CAST *) head, data);
 }
 
 void hip_ht_doall(void *head, LHASH_DOALL_FN_TYPE func)
 {
-       lh_doall((LHASH100_CAST *) head, func);
+    lh_doall((LHASH100_CAST *) head, func);
 }
 
 void hip_ht_doall_arg(void *head, LHASH_DOALL_ARG_FN_TYPE func, void *arg)
 {
-       lh_doall_arg((LHASH100_CAST *) head, func, arg);
+    lh_doall_arg((LHASH100_CAST *) head, func, arg);
 }
-

=== modified file 'lib/core/hashtable.c.doxyme'
--- lib/core/hashtable.c.doxyme 2010-01-19 09:28:42 +0000
+++ lib/core/hashtable.c.doxyme 2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,50 +45,49 @@
 
 
 /**
- * hip_ht_add 
- *
- *
- * @param head
- * @param data
- * @return 
- **/
-
-
-/**
- * hip_ht_delete 
- *
- *
- * @param head
- * @param data
- * @return 
- **/
-
-
-/**
- * hip_ht_find 
- *
- *
- * @param head
- * @param data
- * @return 
- **/
-
-
-/**
- * hip_ht_init 
+ * hip_ht_add
+ *
+ *
+ * @param head
+ * @param data
+ * @return
+ **/
+
+
+/**
+ * hip_ht_delete
+ *
+ *
+ * @param head
+ * @param data
+ * @return
+ **/
+
+
+/**
+ * hip_ht_find
+ *
+ *
+ * @param head
+ * @param data
+ * @return
+ **/
+
+
+/**
+ * hip_ht_init
  *
  *
  * @param hashfunc
  * @param cmpfunc
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_ht_uninit 
+ * hip_ht_uninit
  *
  *
  * @param head
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/hashtable.h'
--- lib/core/hashtable.h        2010-01-19 09:28:42 +0000
+++ lib/core/hashtable.h        2010-02-10 23:55:24 +0000
@@ -11,14 +11,14 @@
 #define HIP_LHASHTABLE_H
 
 /* OpenSSL 1.0.0 introduced backwards incompatible changes to the lhash.
-   These backwards compatibility hacks can be removed when all platforms
-   support OpenSSL 1.0.0 by default. */
+ * These backwards compatibility hacks can be removed when all platforms
+ * support OpenSSL 1.0.0 by default. */
 #ifdef LHASH_OF
 #define HIPL_OPENSSL_100
 #endif /* LHASH_OF */
 
 #undef MIN_NODES
-#define MIN_NODES      16
+#define MIN_NODES       16
 
 #define HIP_LOCK_HT(hash)
 #define HIP_UNLOCK_HT(hash)
@@ -32,7 +32,7 @@
 
 #define LHASH100_CAST _LHASH
 
-typedef DECLARE_LHASH_OF(HIP_HT) hip_ht_common;
+typedef DECLARE_LHASH_OF (HIP_HT) hip_ht_common;
 typedef hip_ht_common HIP_HASHTABLE;
 
 LHASH_OF(HIP_HT) * hip_ht_init(LHASH_HASH_FN_TYPE hashfunc, LHASH_COMP_FN_TYPE 
cmpfunc);
@@ -41,7 +41,7 @@
 
 #define LHASH100_CAST void
 
-#define LHASH_OF(type) struct lhash_st_##type
+#define LHASH_OF(type) struct lhash_st_ ## type
 #define DECLARE_LHASH_OF(type) LHASH_OF(type) { int dummy; }
 
 #undef IMPLEMENT_LHASH_HASH_FN
@@ -50,32 +50,31 @@
 #undef IMPLEMENT_LHASH_DOALL_ARG_FN
 
 #define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
-  unsigned long name##_LHASH_HASH(const void *arg) { \
-  const o_type *a = arg; \
-  return name##_hash(a); }
+    unsigned long name ## _LHASH_HASH(const void *arg) { \
+        const o_type *a = arg; \
+        return name ## _hash(a); }
 #define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
-  int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
-  const o_type *a = arg1;             \
-  const o_type *b = arg2; \
-  return name##_cmp(a,b); }
+    int name ## _LHASH_COMP(const void *arg1, const void *arg2) { \
+        const o_type *a = arg1;             \
+        const o_type *b = arg2; \
+        return name ## _cmp(a, b); }
 #define IMPLEMENT_LHASH_DOALL_FN(name, o_type) \
-  void name##_LHASH_DOALL(void *arg) { \
-  o_type *a = arg; \
-  name##_doall(a); }
+    void name ## _LHASH_DOALL(void *arg) { \
+        o_type *a = arg; \
+        name ## _doall(a); }
 #define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
-  void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
-  o_type *a = arg1; \
-  a_type *b = arg2; \
-  name##_doall_arg(a, b); }
-typedef DECLARE_LHASH_OF(HIP_HT) hip_ht_common;
+    void name ## _LHASH_DOALL_ARG(void *arg1, void *arg2) { \
+        o_type *a = arg1; \
+        a_type *b = arg2; \
+        name ## _doall_arg(a, b); }
+typedef DECLARE_LHASH_OF (HIP_HT) hip_ht_common;
 typedef LHASH HIP_HASHTABLE;
 
-HIP_HASHTABLE * hip_ht_init(LHASH_HASH_FN_TYPE hashfunc,
-                           LHASH_COMP_FN_TYPE cmpfunc);
+HIP_HASHTABLE *hip_ht_init(LHASH_HASH_FN_TYPE hashfunc,
+                           LHASH_COMP_FN_TYPE cmpfunc);
 #endif
 
-void hip_ht_doall(void *head, LHASH_DOALL_FN_TYPE func);                       
         
+void hip_ht_doall(void *head, LHASH_DOALL_FN_TYPE func);
 void hip_ht_doall_arg(void *head, LHASH_DOALL_ARG_FN_TYPE func, void *arg);
 
 #endif /* LHASHTABLE_H */
-

=== modified file 'lib/core/hashtable.h.doxyme'
--- lib/core/hashtable.h.doxyme 2010-01-19 09:28:42 +0000
+++ lib/core/hashtable.h.doxyme 2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/hashtable.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/hashtree.c'
--- lib/core/hashtree.c 2010-01-19 09:28:42 +0000
+++ lib/core/hashtree.c 2010-02-10 23:55:24 +0000
@@ -28,7 +28,7 @@
  */
 double log_x(const int base, const double value)
 {
-       return log(value) / log(base);
+    return log(value) / log(base);
 }
 
 /** creates an empty hash tree.
@@ -41,13 +41,17 @@
  * @param      hierarchy_level the hierarchy level of the created hash tree
  * @return     pointer to the inited tree, NULL in case of an error.
  */
-hash_tree_t* htree_init(const int num_data_blocks, const int max_data_length, 
const int node_length,
-               const int secret_length, hash_tree_t *link_tree, const int 
hierarchy_level)
+hash_tree_t *htree_init(const int num_data_blocks,
+                        const int max_data_length,
+                        const int node_length,
+                        const int secret_length,
+                        hash_tree_t *link_tree,
+                        const int hierarchy_level)
 {
     hash_tree_t *tree = NULL;
-    int tmp_length = 0;
-    int err = 0, i;
-    double log = 0.0;
+    int tmp_length    = 0;
+    int err           = 0, i;
+    double log        = 0.0;
 
     HIP_ASSERT(num_data_blocks > 0);
     HIP_ASSERT(max_data_length > 0);
@@ -55,91 +59,84 @@
 
 
     // allocate the memory for the tree
-    HIP_IFEL(!(tree = (hash_tree_t *) malloc(sizeof(hash_tree_t))), -1, 
"failed to allocate memory\n");
+    HIP_IFEL(!(tree = (hash_tree_t *) malloc(sizeof(hash_tree_t))),
+             -1,
+             "failed to allocate memory\n");
     bzero(tree, sizeof(hash_tree_t));
 
     // check here whether leaf_set_size is a power of 2 and compute correct 
value if it is not
     log = log_x(2, num_data_blocks);
-    if (num_data_blocks == 1)
-       {
-               tree->leaf_set_size = 2;
-
-       } else if (floor(log) != ceil(log))
-    {
-       tree->leaf_set_size = pow(2, ceil(log));
-
-    } else
-    {
-       tree->leaf_set_size = num_data_blocks;
+    if (num_data_blocks == 1) {
+        tree->leaf_set_size = 2;
+    } else if (floor(log) != ceil(log)) {
+        tree->leaf_set_size = pow(2, ceil(log));
+    } else {
+        tree->leaf_set_size = num_data_blocks;
     }
     HIP_DEBUG("num_data_blocks: %i\n", num_data_blocks);
     HIP_DEBUG("tree->leaf_set_size: %i\n", tree->leaf_set_size);
 
-    HIP_IFEL(!(tree->data = (unsigned char *) malloc(max_data_length * 
tree->leaf_set_size)), -1,
-               "failed to allocate memory\n");
+    HIP_IFEL(!(tree->data = (unsigned char *) malloc(max_data_length * 
tree->leaf_set_size)),
+             -1,
+             "failed to allocate memory\n");
     // a binary tree with n leafs has got 2n-1 total nodes
-    HIP_IFEL(!(tree->nodes = (unsigned char *) malloc(node_length * 
tree->leaf_set_size * 2)), -1,
-               "failed to allocate memory\n");
+    HIP_IFEL(!(tree->nodes = (unsigned char *) malloc(node_length * 
tree->leaf_set_size * 2)),
+             -1,
+             "failed to allocate memory\n");
 
     // if link_tree is set, overwrite secret_length
-       if (link_tree)
-       {
-               HIP_DEBUG("link_tree set\n");
-
-               tmp_length = link_tree->node_length;
-
-       } else
-       {
-               tmp_length = secret_length;
-       }
+    if (link_tree) {
+        HIP_DEBUG("link_tree set\n");
+
+        tmp_length = link_tree->node_length;
+    } else {
+        tmp_length = secret_length;
+    }
 
     // init array elements to 0
     bzero(tree->data, max_data_length * tree->leaf_set_size);
     bzero(tree->nodes, node_length * tree->leaf_set_size * 2);
 
-    tree->is_open = 1;
-    tree->data_position = 0;
+    tree->is_open         = 1;
+    tree->data_position   = 0;
     tree->num_data_blocks = num_data_blocks;
     tree->max_data_length = max_data_length;
-    tree->node_length = node_length;
-    tree->secret_length = tmp_length;
-    tree->depth = ceil(log_x(2, tree->leaf_set_size));
+    tree->node_length     = node_length;
+    tree->secret_length   = tmp_length;
+    tree->depth           = ceil(log_x(2, tree->leaf_set_size));
     // set the link tree
-       tree->link_tree = link_tree;
-       tree->hierarchy_level = hierarchy_level;
+    tree->link_tree       = link_tree;
+    tree->hierarchy_level = hierarchy_level;
 
     HIP_DEBUG("tree->depth: %i\n", tree->depth);
 
-    tree->root = NULL;
+    tree->root            = NULL;
 
     // now we can init the secret array
-    if (secret_length > 0)
-       {
-               HIP_IFEL(!(tree->secrets = (unsigned char *) 
malloc(secret_length * tree->leaf_set_size)), -1,
-                               "failed to allocate memory\n");
-
-               if (link_tree)
-               {
-                       // add the root as secret for each leaf
-                       for (i = 0; i < num_data_blocks; i++)
-                       {
-                               HIP_IFEL(htree_add_secret(tree, 
link_tree->root, secret_length, i), -1,
-                                               "failed to add linking root as 
secrets\n");
-                       }
-
-                       bzero(&tree->secrets[num_data_blocks * secret_length], 
secret_length * (tree->leaf_set_size - num_data_blocks));
-
-               } else
-               {
-                       bzero(tree->secrets, secret_length * 
tree->leaf_set_size);
-               }
-       }
-
-  out_err:
-       if (err)
-       {
-               htree_free(tree);
-       }
+    if (secret_length > 0) {
+        HIP_IFEL(!(tree->secrets = (unsigned char *) malloc(secret_length * 
tree->leaf_set_size)),
+                 -1,
+                "failed to allocate memory\n");
+
+        if (link_tree) {
+            // add the root as secret for each leaf
+            for (i = 0; i < num_data_blocks; i++) {
+                HIP_IFEL(htree_add_secret(tree, link_tree->root, 
secret_length, i),
+                         -1,
+                         "failed to add linking root as secrets\n");
+            }
+
+            bzero(&tree->secrets[num_data_blocks * secret_length],
+                  secret_length * (tree->leaf_set_size - num_data_blocks));
+        } else {
+            bzero(tree->secrets, secret_length * tree->leaf_set_size);
+        }
+    }
+
+out_err:
+    if (err) {
+        htree_free(tree);
+    }
 
     return tree;
 }
@@ -150,37 +147,41 @@
  */
 void htree_free(hash_tree_t *tree)
 {
-       if (tree)
-       {
-               htree_free(tree->link_tree);
-
-               if (tree->nodes)
-                       free(tree->nodes);
-               if (tree->data)
-                       free(tree->data);
-               if (tree->secrets)
-                       free(tree->secrets);
-
-               free(tree);
-       }
-
-       tree = NULL;
+    if (tree) {
+        htree_free(tree->link_tree);
+
+        if (tree->nodes) {
+            free(tree->nodes);
+        }
+        if (tree->data) {
+            free(tree->data);
+        }
+        if (tree->secrets) {
+            free(tree->secrets);
+        }
+
+        free(tree);
+    }
+
+    tree = NULL;
 }
 
 /** adds a data item to the tree.
  *
  * @param      tree pointer to the tree
- * @param      data data to be added
+ * @param   data data to be added
  * @param      data_length length of the data item
  * @return     always 0
  */
-int htree_add_data(hash_tree_t *tree, const unsigned char *data, const int 
data_length)
+int htree_add_data(hash_tree_t *tree,
+                   const unsigned char *data,
+                   const int data_length)
 {
-       int err = 0;
+    int err = 0;
 
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(data != NULL);
-       HIP_ASSERT(data_length > 0 && data_length <= tree->max_data_length);
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(data != NULL);
+    HIP_ASSERT(data_length > 0 && data_length <= tree->max_data_length);
     HIP_ASSERT(tree->is_open > 0);
     HIP_ASSERT(tree->data_position >= 0 && tree->data_position < 
tree->num_data_blocks);
 
@@ -194,22 +195,21 @@
     HIP_DEBUG("added data block\n");
 
     // close the tree, if it is full
-    if(tree->data_position == tree->num_data_blocks)
-    {
-       HIP_DEBUG("tree is full! closing...\n");
-
-       // fill up unused leaf nodes
-       if (tree->num_data_blocks < tree->leaf_set_size)
-       {
-               HIP_IFEL(htree_add_random_data(tree, tree->leaf_set_size - 
tree->num_data_blocks), 1,
-                               "failed to fill unused leaf nodes\n");
-       }
-
-        tree->is_open = 0;
+    if (tree->data_position == tree->num_data_blocks) {
+        HIP_DEBUG("tree is full! closing...\n");
+
+        // fill up unused leaf nodes
+        if (tree->num_data_blocks < tree->leaf_set_size) {
+            HIP_IFEL(htree_add_random_data(tree, tree->leaf_set_size - 
tree->num_data_blocks),
+                     1,
+                     "failed to fill unused leaf nodes\n");
+        }
+
+        tree->is_open       = 0;
         tree->data_position = 0;
     }
 
-  out_err:
+out_err:
     return err;
 }
 
@@ -221,33 +221,32 @@
  */
 int htree_add_random_data(hash_tree_t *tree, const int num_random_blocks)
 {
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(num_random_blocks > 0);
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(num_random_blocks > 0);
     HIP_ASSERT(tree->is_open > 0);
     HIP_ASSERT(tree->data_position + num_random_blocks <= tree->leaf_set_size);
 
     // add num_random_blocks random data to the data-array
     RAND_bytes(&tree->data[tree->data_position * tree->max_data_length],
-               num_random_blocks * tree->max_data_length);
+               num_random_blocks * tree->max_data_length);
     // move to next free position
     tree->data_position += num_random_blocks;
     HIP_DEBUG("added %i random data block(s)\n", num_random_blocks);
 
     // close the tree, if it is full
-    if(tree->data_position >= tree->num_data_blocks)
-    {
+    if (tree->data_position >= tree->num_data_blocks) {
         HIP_DEBUG("tree is full! closing...\n");
 
-       // fill up unused leaf nodes
-       if (tree->num_data_blocks < tree->leaf_set_size)
-       {
-               RAND_bytes(&tree->data[tree->data_position * 
tree->max_data_length],
-                               (tree->leaf_set_size - tree->data_position) * 
tree->max_data_length);
-
-               HIP_DEBUG("added %i leaf slots as padding\n", 
tree->leaf_set_size - tree->data_position);
-       }
-
-        tree->is_open = 0;
+        // fill up unused leaf nodes
+        if (tree->num_data_blocks < tree->leaf_set_size) {
+            RAND_bytes(&tree->data[tree->data_position * 
tree->max_data_length],
+                       (tree->leaf_set_size - tree->data_position) * 
tree->max_data_length);
+
+            HIP_DEBUG("added %i leaf slots as padding\n",
+                      tree->leaf_set_size - tree->data_position);
+        }
+
+        tree->is_open       = 0;
         tree->data_position = 0;
     }
 
@@ -257,17 +256,20 @@
 /** adds a secret to the tree.
  *
  * @param      tree pointer to the tree
- * @param      secret the secret to be added
+ * @param   secret the secret to be added
  * @param      secret_length length of the secret
  * @param      secret_index position of the secret in the leaf set
  * @return     always 0
  */
-int htree_add_secret(hash_tree_t *tree, const unsigned char *secret, const int 
secret_length, const int secret_index)
+int htree_add_secret(hash_tree_t *tree,
+                     const unsigned char *secret,
+                     const int secret_length,
+                     const int secret_index)
 {
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(secret != NULL);
-       HIP_ASSERT(secret_length == tree->secret_length);
-       HIP_ASSERT(secret_index >= 0 && secret_index < tree->num_data_blocks);
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(secret != NULL);
+    HIP_ASSERT(secret_length == tree->secret_length);
+    HIP_ASSERT(secret_index >= 0 && secret_index < tree->num_data_blocks);
     HIP_ASSERT(tree->is_open > 0);
 
     memcpy(&tree->secrets[secret_index * secret_length], secret, 
secret_length);
@@ -283,17 +285,17 @@
  */
 int htree_add_random_secrets(hash_tree_t *tree)
 {
-       int err = 0;
-
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(tree->secrets != NULL);
-       HIP_ASSERT(tree->secret_length > 0);
-
-       // add num_random_blocks random data to the data-array
-       RAND_bytes(&tree->secrets[0],
-                       tree->num_data_blocks * tree->secret_length);
-
-       HIP_DEBUG("random secrets added\n");
+    int err = 0;
+
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(tree->secrets != NULL);
+    HIP_ASSERT(tree->secret_length > 0);
+
+    // add num_random_blocks random data to the data-array
+    RAND_bytes(&tree->secrets[0],
+               tree->num_data_blocks * tree->secret_length);
+
+    HIP_DEBUG("random secrets added\n");
 
     return err;
 }
@@ -307,35 +309,37 @@
  * @param      gen_args arguments for the generators
  * @return     0 on success, -1 otherwise
  */
-int htree_calc_nodes(hash_tree_t *tree, const htree_leaf_gen_t leaf_gen,
-               const htree_node_gen_t node_gen, const htree_gen_args_t 
*gen_args)
+int htree_calc_nodes(hash_tree_t *tree,
+                     const htree_leaf_gen_t leaf_gen,
+                     const htree_node_gen_t node_gen,
+                     const htree_gen_args_t *gen_args)
 {
-       int level_width = 0, i, err = 0;
-       // first leaf to be used when calculating next tree level in bytes
-    int source_index = 0;
-    int target_index = 0;
+    int level_width       = 0, i, err = 0;
+    // first leaf to be used when calculating next tree level in bytes
+    int source_index      = 0;
+    int target_index      = 0;
     unsigned char *secret = NULL;
 
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(tree->is_open == 0);
-       HIP_ASSERT(tree->data_position == 0);
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(tree->is_open == 0);
+    HIP_ASSERT(tree->data_position == 0);
 
     /* traverse all data blocks and create the leafs */
     HIP_DEBUG("computing leaf nodes: %i\n", tree->leaf_set_size);
 
-    for(i = 0; i < tree->leaf_set_size; i++)
-    {
-       _HIP_DEBUG("calling leaf generator function...\n");
-
-       // only use secrets if they are defined
-               if (tree->secret_length > 0)
-                       secret = &tree->secrets[i * tree->secret_length];
-
-       // input: i-th data block -> output as i-th node-array element
-       HIP_IFEL(leaf_gen(&tree->data[i * tree->max_data_length], 
tree->max_data_length,
-                               secret, tree->secret_length,
-                       &tree->nodes[i * tree->node_length], gen_args),
-                       -1, "failed to calculate leaf hashes\n");
+    for (i = 0; i < tree->leaf_set_size; i++) {
+        _HIP_DEBUG("calling leaf generator function...\n");
+
+        // only use secrets if they are defined
+        if (tree->secret_length > 0) {
+            secret = &tree->secrets[i * tree->secret_length];
+        }
+
+        // input: i-th data block -> output as i-th node-array element
+        HIP_IFEL(leaf_gen(&tree->data[i * tree->max_data_length], 
tree->max_data_length,
+                          secret, tree->secret_length,
+                          &tree->nodes[i * tree->node_length], gen_args),
+                 -1, "failed to calculate leaf hashes\n");
     }
 
     /* compute hashes on all other levels */
@@ -345,50 +349,49 @@
     level_width = tree->leaf_set_size;
 
     // based on the current level, we are calculating the nodes for the next 
level
-    while(level_width > 1)
-    {
-       HIP_DEBUG("calculating nodes: %i\n", level_width / 2);
+    while (level_width > 1) {
+        HIP_DEBUG("calculating nodes: %i\n", level_width / 2);
 
         /* set the target for the this level directly behind the
          * already calculated nodes of the previous level */
         target_index = source_index + (level_width * tree->node_length);
 
         /* we always handle two elements at once */
-        for(i = 0; i < level_width; i += 2)
-        {
-               _HIP_DEBUG("calling node generator function...\n");
-
-               HIP_IFEL(node_gen(&tree->nodes[source_index + (i * 
tree->node_length)],
-                               &tree->nodes[source_index + ((i + 1) * 
tree->node_length)],
-                               tree->node_length,
-                               &tree->nodes[target_index + ((i / 2) * 
tree->node_length)],
-                               gen_args), -1,
-                               "failed to calculate hashes of intermediate 
nodes\n");
-
-               // this means we're calculating the root node
-               if (level_width == 2)
-                       tree->root = &tree->nodes[target_index + ((i / 2) * 
tree->node_length)];
+        for (i = 0; i < level_width; i += 2) {
+            _HIP_DEBUG("calling node generator function...\n");
+
+            HIP_IFEL(node_gen(&tree->nodes[source_index + (i * 
tree->node_length)],
+                              &tree->nodes[source_index + ((i + 1) * 
tree->node_length)],
+                              tree->node_length,
+                              &tree->nodes[target_index + ((i / 2) * 
tree->node_length)],
+                              gen_args), -1,
+                     "failed to calculate hashes of intermediate nodes\n");
+
+            // this means we're calculating the root node
+            if (level_width == 2) {
+                tree->root = &tree->nodes[target_index + ((i / 2) * 
tree->node_length)];
+            }
         }
 
         // next level has got half the elements
-        level_width = level_width / 2;
+        level_width  = level_width / 2;
 
         /* use target index of this level as new source field */
         source_index = target_index;
     }
 
-  out_err:
+out_err:
     return err;
 }
 
 /** gets the number of remaining elements in the tee
- * 
+ *
  * @param      tree given tree
  * @return number of remaining elements
  */
 int htree_get_num_remaining(const hash_tree_t *tree)
 {
-       return tree->num_data_blocks - tree->data_position;
+    return tree->num_data_blocks - tree->data_position;
 }
 
 /** checks if the hash tree contains further unrevealed data items
@@ -398,7 +401,7 @@
  */
 int htree_has_more_data(const hash_tree_t *tree)
 {
-       return tree->data_position < tree->num_data_blocks;
+    return tree->data_position < tree->num_data_blocks;
 }
 
 /** gets the offset of the next unrevealed data item
@@ -410,13 +413,13 @@
  */
 int htree_get_next_data_offset(hash_tree_t *tree)
 {
-       int data_offset = 0;
-
-       data_offset = tree->data_position;
-
-       tree->data_position++;
-
-       return data_offset;
+    int data_offset = 0;
+
+    data_offset = tree->data_position;
+
+    tree->data_position++;
+
+    return data_offset;
 }
 
 /** gets the elements of the verification branch from a computed tree
@@ -427,22 +430,24 @@
  * @param      branch_length destination buffer length, returns used space
  * @return     buffer containing the branch nodes, NULL on error
  */
-unsigned char * htree_get_branch(const hash_tree_t *tree, const int 
data_index, unsigned char * nodes,
-               int *branch_length)
+unsigned char *htree_get_branch(const hash_tree_t *tree,
+                                const int data_index,
+                                unsigned char *nodes,
+                                int *branch_length)
 {
-       int tree_level = 0;
-       int level_width = 0;
-       int source_index = 0;
-    int sibling_offset = 0;
-    int tmp_index = 0;
-    unsigned char * branch_nodes = NULL;
-    int err = 0;
+    int tree_level              = 0;
+    int level_width             = 0;
+    int source_index            = 0;
+    int sibling_offset          = 0;
+    int tmp_index               = 0;
+    int err                     = 0;
+    unsigned char *branch_nodes = NULL;
 
     HIP_ASSERT(tree != NULL);
     HIP_ASSERT(data_index >= 0 && data_index < tree->num_data_blocks);
 
     // use local (unconst) variable for tree traversal
-    tmp_index = data_index;
+    tmp_index      = data_index;
 
     // branch includes all elements excluding the root
     *branch_length = tree->depth * tree->node_length;
@@ -450,41 +455,40 @@
     HIP_DEBUG("tree->depth: %i\n", tree->depth);
 
     // use provided buffer, if available; else alloc
-    if (!nodes)
-       branch_nodes = (unsigned char *) malloc(*branch_length);
-    else
-       branch_nodes = nodes;
+    if (!nodes) {
+        branch_nodes = (unsigned char *) malloc(*branch_length);
+    } else {
+        branch_nodes = nodes;
+    }
 
     // traverse bottom up
     level_width = tree->leaf_set_size;
 
     // don't include root
-    while (level_width > 1)
-    {
-       HIP_DEBUG("level_width: %i\n", level_width);
+    while (level_width > 1) {
+        HIP_DEBUG("level_width: %i\n", level_width);
 
-       // for an uneven data_index the previous node is the sibling, else the 
next
-       sibling_offset = tmp_index & 1 ? -1 : 1;
+        // for an uneven data_index the previous node is the sibling, else the 
next
+        sibling_offset = tmp_index & 1 ? -1 : 1;
 
         // copy branch-node from node-array to buffer
         memcpy(&branch_nodes[tree_level * tree->node_length],
                &tree->nodes[source_index +
-               ((tmp_index + sibling_offset) * tree->node_length)],
+                            ((tmp_index + sibling_offset) * 
tree->node_length)],
                tree->node_length);
 
         // proceed by one level
         source_index += level_width * tree->node_length;
-        level_width = level_width >> 1;
-        tmp_index = tmp_index >> 1;
+        level_width   = level_width >> 1;
+        tmp_index     = tmp_index >> 1;
         tree_level++;
     }
 
     _HIP_HEXDUMP("verification branch: ", branch_nodes, tree->depth * 
tree->node_length);
 
-    if (err)
-    {
-       free(branch_nodes);
-       branch_nodes = NULL;
+    if (err) {
+        free(branch_nodes);
+        branch_nodes = NULL;
     }
 
     return branch_nodes;
@@ -497,16 +501,17 @@
  * @param      data_length length of the returned data item
  * @return     pointer to the data item, NULL in case of an error
  */
-const unsigned char* htree_get_data(const hash_tree_t *tree, const int 
data_index,
-               int *data_length)
+const unsigned char *htree_get_data(const hash_tree_t *tree,
+                                    const int data_index,
+                                    int *data_length)
 {
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(data_index >= 0 && data_index < tree->num_data_blocks);
-       HIP_ASSERT(data_length != NULL);
-
-       *data_length = tree->max_data_length;
-
-       return &tree->data[data_index * tree->max_data_length];
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(data_index >= 0 && data_index < tree->num_data_blocks);
+    HIP_ASSERT(data_length != NULL);
+
+    *data_length = tree->max_data_length;
+
+    return &tree->data[data_index * tree->max_data_length];
 }
 
 /** gets the secret at the specified position
@@ -516,19 +521,21 @@
  * @param      secret_length length of the returned secret
  * @return     pointer to the secret, NULL in case of an error
  */
-const unsigned char* htree_get_secret(const hash_tree_t *tree, const int 
secret_index,
-               int *secret_length)
+const unsigned char *htree_get_secret(const hash_tree_t *tree,
+                                      const int secret_index,
+                                      int *secret_length)
 {
-       HIP_ASSERT(tree != NULL);
-       HIP_ASSERT(secret_index >= 0 && secret_index < tree->num_data_blocks);
-       HIP_ASSERT(secret_length != NULL);
-
-       *secret_length = tree->secret_length;
-
-       if (tree->secret_length > 0)
-               return &tree->secrets[secret_index * tree->secret_length];
-       else
-               return NULL;
+    HIP_ASSERT(tree != NULL);
+    HIP_ASSERT(secret_index >= 0 && secret_index < tree->num_data_blocks);
+    HIP_ASSERT(secret_length != NULL);
+
+    *secret_length = tree->secret_length;
+
+    if (tree->secret_length > 0) {
+        return &tree->secrets[secret_index * tree->secret_length];
+    } else {
+        return NULL;
+    }
 }
 
 /** gets the root node of the hash tree
@@ -537,16 +544,17 @@
  * @param      root_length length of the returned root element
  * @return     pointer to the root element, NULL in case of an error
  */
-const unsigned char* htree_get_root(const hash_tree_t *tree, int *root_length)
+const unsigned char *htree_get_root(const hash_tree_t *tree, int *root_length)
 {
-       HIP_ASSERT(tree != NULL);
-
-       if (tree->root)
-               *root_length = tree->node_length;
-       else
-               *root_length = 0;
-
-       return tree->root;
+    HIP_ASSERT(tree != NULL);
+
+    if (tree->root) {
+        *root_length = tree->node_length;
+    } else {
+        *root_length = 0;
+    }
+
+    return tree->root;
 }
 
 /** checks the data item and an verification branch against the root
@@ -565,19 +573,25 @@
  * @param      gen_args arguments for the generators
  * @return     0 if successful, 1 if invalid, -1 in case of an error
  */
-int htree_verify_branch(const unsigned char *root, const int root_length,
-               const unsigned char *branch_nodes, const uint32_t branch_length,
-               const unsigned char *verify_data, const int data_length, const 
uint32_t data_index,
-               const unsigned char *secret, const int secret_length,
-               const htree_leaf_gen_t leaf_gen, const htree_node_gen_t 
node_gen,
-               const htree_gen_args_t *gen_args)
+int htree_verify_branch(const unsigned char *root,
+                        const int root_length,
+                        const unsigned char *branch_nodes,
+                        const uint32_t branch_length,
+                        const unsigned char *verify_data,
+                        const int data_length,
+                        const uint32_t data_index,
+                        const unsigned char *secret,
+                        const int secret_length,
+                        const htree_leaf_gen_t leaf_gen,
+                        const htree_node_gen_t node_gen,
+                        const htree_gen_args_t *gen_args)
 {
     /* space for two nodes to be hashed together */
     unsigned char buffer[2 * root_length];
-    int num_nodes = 0;
+    int num_nodes      = 0;
     int sibling_offset = 0;
-    int tmp_index = 0;
-    int err = 0, i;
+    int tmp_index      = 0;
+    int err            = 0, i;
 
     HIP_ASSERT(root != NULL);
     HIP_ASSERT(root_length > 0);
@@ -587,8 +601,9 @@
     HIP_ASSERT(data_length > 0);
     HIP_ASSERT(data_index >= 0);
 
-    if (secret_length > 0)
-       HIP_ASSERT(secret != NULL);
+    if (secret_length > 0) {
+        HIP_ASSERT(secret != NULL);
+    }
 
     // use local (unconst) variable for tree traversal
     tmp_index = data_index;
@@ -600,63 +615,55 @@
     _HIP_DEBUG("data_length: %i\n", data_length);
     _HIP_HEXDUMP("verify_data: ", verify_data, data_length);
     _HIP_DEBUG("branch_length: %i\n", branch_length);
-       _HIP_HEXDUMP("verify_data: ", branch_nodes, branch_length);
+    _HIP_HEXDUMP("verify_data: ", branch_nodes, branch_length);
 
     // +1 as we have to calculate the leaf too
-       for(i = 0; i < num_nodes + 1; i++)
-       {
+    for (i = 0; i < num_nodes + 1; i++) {
         HIP_DEBUG("round %i\n", i);
 
         // determines where to put the sibling in the buffer
         sibling_offset = tmp_index & 1 ? 0 : 1;
 
         /* in first round we have to calculate the leaf */
-        if (i > 0)
-        {
+        if (i > 0) {
             /* hash previous buffer and overwrite partially */
             HIP_IFEL(node_gen(&buffer[0], &buffer[root_length], root_length,
-                       &buffer[(1 - sibling_offset) * root_length], gen_args),
-                       -1, "failed to calculate node hash\n");
-
-        } else
-        {
+                              &buffer[(1 - sibling_offset) * root_length], 
gen_args),
+                     -1, "failed to calculate node hash\n");
+        } else {
             /* hash data in order to derive the hash tree leaf */
             HIP_IFEL(leaf_gen(verify_data, data_length, secret, secret_length,
-                       &buffer[(1 - sibling_offset) * root_length], gen_args), 
-1,
-                       "failed to calculate leaf hash\n");
+                              &buffer[(1 - sibling_offset) * root_length], 
gen_args), -1,
+                     "failed to calculate leaf hash\n");
         }
 
-        if (i < num_nodes)
-        {
-                       // copy i-th branch node to the free slot in the buffer
-                       memcpy(&buffer[sibling_offset * root_length], 
&branch_nodes[i * root_length],
-                                       root_length);
+        if (i < num_nodes) {
+            // copy i-th branch node to the free slot in the buffer
+            memcpy(&buffer[sibling_offset * root_length], &branch_nodes[i * 
root_length],
+                   root_length);
 
-                       // proceed to next level
-                       tmp_index = tmp_index / 2;
+            // proceed to next level
+            tmp_index = tmp_index / 2;
         }
 
         HIP_HEXDUMP("buffer slot 1: ", &buffer[0], root_length);
-               HIP_HEXDUMP("buffer slot 2: ", &buffer[root_length], 
root_length);
+        HIP_HEXDUMP("buffer slot 2: ", &buffer[root_length], root_length);
     }
 
     HIP_HEXDUMP("calculated root: ", &buffer[(1 - sibling_offset) * 
root_length],
-               root_length);
+                root_length);
     HIP_HEXDUMP("stored root: ", root, root_length);
 
-       // check if the calculated root matches the stored one
-    if(!memcmp(&buffer[(1 - sibling_offset) * root_length], root, root_length))
-    {
+    // check if the calculated root matches the stored one
+    if (!memcmp(&buffer[(1 - sibling_offset) * root_length], root, 
root_length)) {
         HIP_DEBUG("branch successfully verified\n");
-
-    } else
-    {
-       HIP_DEBUG("branch invalid\n");
-
-               err = 1;
+    } else {
+        HIP_DEBUG("branch invalid\n");
+
+        err = 1;
     }
 
-  out_err:
+out_err:
     return err;
 }
 
@@ -670,34 +677,34 @@
  * @param      gen_args arguments for the generator
  * @return     always 0
  */
-int htree_leaf_generator(const unsigned char *data, const int data_length,
-               const unsigned char *secret, const int secret_length,
-               unsigned char *dst_buffer, const htree_gen_args_t *gen_args)
+int htree_leaf_generator(const unsigned char *data,
+                         const int data_length,
+                         const unsigned char *secret,
+                         const int secret_length,
+                         unsigned char *dst_buffer,
+                         const htree_gen_args_t *gen_args)
 {
-       int err = 0;
-       unsigned char buffer[data_length + secret_length];
-       const unsigned char *hash_data = NULL;
-       int hash_data_length = 0;
-
-       if (secret && secret_length > 0)
-       {
-               memcpy(&buffer[0], data, data_length);
-               memcpy(&buffer[data_length], secret, secret_length);
-
-               hash_data = buffer;
-               hash_data_length = data_length + secret_length;
-
-       } else
-       {
-               hash_data = data;
-               hash_data_length = data_length;
-       }
-
-       HIP_IFEL(!SHA1(hash_data, hash_data_length, dst_buffer), -1,
-                       "failed to calculate hash\n");
-
-  out_err:
-       return err;
+    int err                        = 0;
+    unsigned char buffer[data_length + secret_length];
+    const unsigned char *hash_data = NULL;
+    int hash_data_length           = 0;
+
+    if (secret && secret_length > 0) {
+        memcpy(&buffer[0], data, data_length);
+        memcpy(&buffer[data_length], secret, secret_length);
+
+        hash_data        = buffer;
+        hash_data_length = data_length + secret_length;
+    } else {
+        hash_data        = data;
+        hash_data_length = data_length;
+    }
+
+    HIP_IFEL(!SHA1(hash_data, hash_data_length, dst_buffer), -1,
+             "failed to calculate hash\n");
+
+out_err:
+    return err;
 }
 
 /** generates an intermediate node from two hash tree nodes
@@ -712,18 +719,21 @@
  * NOTE: the calling function has to ensure that left and right node are in
  *       subsequent memory blocks
  */
-int htree_node_generator(const unsigned char *left_node, const unsigned char 
*right_node,
-               const int node_length, unsigned char *dst_buffer, const 
htree_gen_args_t *gen_args)
+int htree_node_generator(const unsigned char *left_node,
+                         const unsigned char *right_node,
+                         const int node_length,
+                         unsigned char *dst_buffer,
+                         const htree_gen_args_t *gen_args)
 {
-       int err = 0;
-
-       /* the calling function has to ensure that left and right node are in
-        * subsequent memory blocks */
-       HIP_IFEL(!SHA1(left_node, 2 * node_length, dst_buffer), -1,
-                       "failed to calculate hash\n");
-
-  out_err:
-       return err;
+    int err = 0;
+
+    /* the calling function has to ensure that left and right node are in
+     * subsequent memory blocks */
+    HIP_IFEL(!SHA1(left_node, 2 * node_length, dst_buffer), -1,
+             "failed to calculate hash\n");
+
+out_err:
+    return err;
 }
 
 /** prints the data set
@@ -738,10 +748,10 @@
 
     HIP_DEBUG("printing data blocks...\n");
 
-    for(i = 0; i < tree->num_data_blocks; i++)
-    {
-        HIP_HEXDUMP("data block: ", &tree->data[i * tree->max_data_length],
-                       tree->max_data_length);
+    for (i = 0; i < tree->num_data_blocks; i++) {
+        HIP_HEXDUMP("data block: ",
+                    &tree->data[i * tree->max_data_length],
+                    tree->max_data_length);
     }
 }
 
@@ -751,10 +761,10 @@
  */
 void htree_print_nodes(const hash_tree_t *tree)
 {
-    int level_width = 0;
+    int level_width  = 0;
     int target_index = 0;
     int source_index = 0;
-    int i = 0;
+    int i            = 0;
 
     HIP_ASSERT(tree != NULL);
 
@@ -762,19 +772,19 @@
 
     HIP_DEBUG("printing hash tree nodes...\n");
 
-    while (level_width > 0)
-    {
+    while (level_width > 0) {
         i++;
         HIP_DEBUG("printing level %i:\n", i);
 
         target_index = source_index + (level_width * tree->node_length);
 
-        for(i = 0; i < level_width; i++){
-            HIP_HEXDUMP("node: ", &tree->nodes[source_index + (i * 
tree->node_length)],
-                       tree->node_length);
+        for (i = 0; i < level_width; i++) {
+            HIP_HEXDUMP("node: ",
+                        &tree->nodes[source_index + (i * tree->node_length)],
+                        tree->node_length);
         }
 
         source_index = target_index;
-        level_width = level_width / 2;
+        level_width  = level_width / 2;
     }
 }

=== modified file 'lib/core/hashtree.h'
--- lib/core/hashtree.h 2010-01-19 09:28:42 +0000
+++ lib/core/hashtree.h 2010-02-10 23:55:24 +0000
@@ -18,85 +18,114 @@
 #include <inttypes.h>
 
 /* arguments for the generator functionms */
-typedef struct htree_gen_args
-{
-       int index;
+typedef struct htree_gen_args {
+    int index;
 } htree_gen_args_t;
 
 /** leaf generator function pointer
  *
  * NOTE: if you need additional arguments here, add them to the gen_args struct
  */
-typedef int (*htree_leaf_gen_t) (const unsigned char *data, const int 
data_length,
-               const unsigned char *secret, const int secret_length,
-               unsigned char *dst_buffer, const htree_gen_args_t *gen_args);
+typedef int (*htree_leaf_gen_t)(const unsigned char *data,
+                                const int data_length,
+                                const unsigned char *secret,
+                                const int secret_length,
+                                unsigned char *dst_buffer,
+                                const htree_gen_args_t *gen_args);
 
 /** node generator function pointer
  *
  * NOTE: if you need additional arguments here, add them to the gen_args struct
  */
-typedef int (*htree_node_gen_t) (const unsigned char *left_node, const 
unsigned char *right_node,
-               const int node_length, unsigned char *dst_buffer,
-               const htree_gen_args_t *gen_args);
-
-typedef struct hash_tree
-{
-       // data variables
-       int leaf_set_size;       /* maximum number of data blocks to be stored 
in the tree */
-       int num_data_blocks; /* number of data blocks to be verified with the 
tree */
-       int max_data_length; /* max length for a single leaf element */
-       unsigned char *data; /* array containing the data to be validated with 
the tree */
-       int secret_length;      /* length of the secret */
-       unsigned char *secrets; /* individual secrets to be revealed with each 
data block */
-
-       struct hash_tree *link_tree;
-       int hierarchy_level;
-
-       // tree elements variables
-       int node_length; /* length of a single node element */
-       unsigned char *nodes; /* array containing the nodes of the tree */
-       unsigned char *root; /* the root of the tree -> points into nodes-array 
*/
-
-       // management variables
-       int depth; /* depth of the tree */
-       int data_position; /* index of the next free leaf */
-       int is_open; /* can one enter new entries?
-                                       This is only true if the nodes have not 
been
-                                       computed yet. */
+typedef int (*htree_node_gen_t)(const unsigned char *left_node,
+                                const unsigned char *right_node,
+                                const int node_length,
+                                unsigned char *dst_buffer,
+                                const htree_gen_args_t *gen_args);
+
+typedef struct hash_tree {
+    // data variables
+    int               leaf_set_size; /* maximum number of data blocks to be 
stored in the tree */
+    int               num_data_blocks; /* number of data blocks to be verified 
with the tree */
+    int               max_data_length; /* max length for a single leaf element 
*/
+    unsigned char *   data;  /* array containing the data to be validated with 
the tree */
+    int               secret_length; /* length of the secret */
+    unsigned char *   secrets;  /* individual secrets to be revealed with each 
data block */
+
+    struct hash_tree *link_tree;
+    int               hierarchy_level;
+
+    // tree elements variables
+    int               node_length; /* length of a single node element */
+    unsigned char *   nodes;  /* array containing the nodes of the tree */
+    unsigned char *   root;  /* the root of the tree -> points into 
nodes-array */
+
+    // management variables
+    int               depth; /* depth of the tree */
+    int               data_position; /* index of the next free leaf */
+    int               is_open; /* can one enter new entries?
+                      *                 This is only true if the nodes have 
not been
+                      *                 computed yet. */
 } hash_tree_t;
 
-
 double log_x(const int base, const double value);
-hash_tree_t* htree_init(const int num_data_blocks, const int max_data_length, 
const int node_length,
-               const int secret_length, hash_tree_t *link_tree, const int 
hierarchy_level);
+hash_tree_t *htree_init(const int num_data_blocks,
+                        const int max_data_length,
+                        const int node_length,
+                        const int secret_length,
+                        hash_tree_t *link_tree,
+                        const int hierarchy_level);
 void htree_free(hash_tree_t *tree);
-int htree_add_data(hash_tree_t *tree, const unsigned char *data, const int 
data_length);
+int htree_add_data(hash_tree_t *tree,
+                   const unsigned char *data,
+                   const int data_length);
 int htree_add_random_data(hash_tree_t *tree, const int num_random_blocks);
-int htree_add_secret(hash_tree_t *tree, const unsigned char *secret, const int 
secret_length, const int secret_index);
+int htree_add_secret(hash_tree_t *tree,
+                     const unsigned char *secret,
+                     const int secret_length,
+                     const int secret_index);
 int htree_add_random_secrets(hash_tree_t *tree);
-int htree_calc_nodes(hash_tree_t *tree, const htree_leaf_gen_t leaf_gen,
-               const htree_node_gen_t node_gen, const htree_gen_args_t 
*gen_args);
+int htree_calc_nodes(hash_tree_t *tree,
+                     const htree_leaf_gen_t leaf_gen,
+                     const htree_node_gen_t node_gen,
+                     const htree_gen_args_t *gen_args);
 int htree_get_num_remaining(const hash_tree_t *tree);
 int htree_has_more_data(const hash_tree_t *tree);
 int htree_get_next_data_offset(hash_tree_t *tree);
-unsigned char * htree_get_branch(const hash_tree_t *tree, const int 
data_index, unsigned char * nodes,
-               int *branch_length);
-const unsigned char* htree_get_data(const hash_tree_t *tree, const int 
data_index,
-               int *data_length);
-const unsigned char* htree_get_secret(const hash_tree_t *tree, const int 
secret_index,
-               int *secret_length);
-const unsigned char* htree_get_root(const hash_tree_t *tree, int *root_length);
-int htree_verify_branch(const unsigned char *root, const int root_length,
-               const unsigned char *branch_nodes, const uint32_t branch_length,
-               const unsigned char *verify_data, const int data_length, const 
uint32_t data_index,
-               const unsigned char *secret, const int secret_length,
-               const htree_leaf_gen_t leaf_gen, const htree_node_gen_t 
node_gen,
-               const htree_gen_args_t *gen_args);
-int htree_leaf_generator(const unsigned char *data, const int data_length,
-               const unsigned char *secret, const int secret_length,
-               unsigned char *dst_buffer, const htree_gen_args_t *gen_args);
-int htree_node_generator(const unsigned char *left_node, const unsigned char 
*right_node,
-               const int node_length, unsigned char *dst_buffer, const 
htree_gen_args_t *gen_args);
+unsigned char *htree_get_branch(const hash_tree_t *tree,
+                                const int data_index,
+                                unsigned char *nodes,
+                                int *branch_length);
+const unsigned char *htree_get_data(const hash_tree_t *tree,
+                                    const int data_index,
+                                    int *data_length);
+const unsigned char *htree_get_secret(const hash_tree_t *tree,
+                                      const int secret_index,
+                                      int *secret_length);
+const unsigned char *htree_get_root(const hash_tree_t *tree, int *root_length);
+int htree_verify_branch(const unsigned char *root,
+                        const int root_length,
+                        const unsigned char *branch_nodes,
+                        const uint32_t branch_length,
+                        const unsigned char *verify_data,
+                        const int data_length,
+                        const uint32_t data_index,
+                        const unsigned char *secret,
+                        const int secret_length,
+                        const htree_leaf_gen_t leaf_gen,
+                        const htree_node_gen_t node_gen,
+                        const htree_gen_args_t *gen_args);
+int htree_leaf_generator(const unsigned char *data,
+                         const int data_length,
+                         const unsigned char *secret,
+                         const int secret_length,
+                         unsigned char *dst_buffer,
+                         const htree_gen_args_t *gen_args);
+int htree_node_generator(const unsigned char *left_node,
+                         const unsigned char *right_node,
+                         const int node_length,
+                         unsigned char *dst_buffer,
+                         const htree_gen_args_t *gen_args);
 void htree_print_data(const hash_tree_t *tree);
 void htree_print_nodes(const hash_tree_t *tree);
 

=== modified file 'lib/core/hip_capability.c'
--- lib/core/hip_capability.c   2010-01-19 12:03:04 +0000
+++ lib/core/hip_capability.c   2010-02-10 23:55:24 +0000
@@ -1,4 +1,3 @@
-
 #ifdef HAVE_CONFIG_H
   #include "config.h"
 #endif /* HAVE_CONFIG_H */
@@ -8,7 +7,7 @@
 /* Note: OpenWRT has to use <linux/capability.h> */
 #include <linux/capability.h>
 int capget(cap_user_header_t header, cap_user_data_t data);
-int capset(cap_user_header_t header, const cap_user_data_t data); 
+int capset(cap_user_header_t header, const cap_user_data_t data);
 #else
 #include <sys/capability.h>
 #endif /* CONFIG_HIP_ALTSEP */
@@ -30,109 +29,111 @@
 #define USER_HIPD "hipd"
 #endif /* CONFIG_HIP_PRIVSEP */
 
-int hip_user_to_uid(char *name) {
-       int uid = -1;
+int hip_user_to_uid(char *name)
+{
+    int uid            = -1;
 #ifndef CONFIG_HIP_OPENWRT
-       int i;
-       struct passwd *pwp = NULL, pw;
-       char buf[4096];
+    int i;
+    struct passwd *pwp = NULL, pw;
+    char buf[4096];
 
-       setpwent();
-       while (1) {
-               i = getpwent_r(&pw, buf, sizeof(buf), &pwp);
-               if (i)
-                       break;
-               _HIP_DEBUG("%s (%d)\tHOME %s\tSHELL %s\n", pwp->pw_name,
-                         pwp->pw_uid, pwp->pw_dir, pwp->pw_shell);
-               if (!strcmp(pwp->pw_name, name)) {
-                       uid = pwp->pw_uid;
-                       break;
-               }
-       }
-       endpwent();
+    setpwent();
+    while (1) {
+        i = getpwent_r(&pw, buf, sizeof(buf), &pwp);
+        if (i) {
+            break;
+        }
+        _HIP_DEBUG("%s (%d)\tHOME %s\tSHELL %s\n", pwp->pw_name,
+                   pwp->pw_uid, pwp->pw_dir, pwp->pw_shell);
+        if (!strcmp(pwp->pw_name, name)) {
+            uid = pwp->pw_uid;
+            break;
+        }
+    }
+    endpwent();
 #endif
-       return uid;
+    return uid;
 }
 
 #ifdef CONFIG_HIP_ALTSEP
 
-#define _LINUX_CAPABILITY_VERSION_HIPL 0x19980330
+#define _LINUX_CAPABILITY_VERSION_HIPL  0x19980330
 
-#define _LINUX_CAPABILITY_VERSION_HIPL 0x19980330
+#define _LINUX_CAPABILITY_VERSION_HIPL  0x19980330
 
 /*
  * Note: this function does not go well with valgrind
  */
-int hip_set_lowcapability(int run_as_sudo) {
-  int err = 0;
+int hip_set_lowcapability(int run_as_sudo)
+{
+    int err = 0;
 
 #ifdef CONFIG_HIP_PRIVSEP
-  uid_t uid;
-  //struct __user_cap_header_struct header;
-  //struct __user_cap_data_struct data; 
-  struct __user_cap_header_struct header;
-  struct __user_cap_data_struct data; 
-
-  header.pid=0;
-  header.version = _LINUX_CAPABILITY_VERSION_HIPL;
-  data.effective = data.permitted = data.inheritable = 0;
-
-  /* openwrt code */
-
-  HIP_IFEL(prctl(PR_SET_KEEPCAPS, 1), -1, "prctl err\n");
-
-  HIP_DEBUG("Now PR_SET_KEEPCAPS=%d\n", prctl(PR_GET_KEEPCAPS));
+    uid_t uid;
+    //struct __user_cap_header_struct header;
+    //struct __user_cap_data_struct data;
+    struct __user_cap_header_struct header;
+    struct __user_cap_data_struct data;
+
+    header.pid     = 0;
+    header.version = _LINUX_CAPABILITY_VERSION_HIPL;
+    data.effective = data.permitted = data.inheritable = 0;
+
+    /* openwrt code */
+
+    HIP_IFEL(prctl(PR_SET_KEEPCAPS, 1), -1, "prctl err\n");
+
+    HIP_DEBUG("Now PR_SET_KEEPCAPS=%d\n", prctl(PR_GET_KEEPCAPS));
 
 #ifndef CONFIG_HIP_OPENWRT
-  uid = hip_user_to_uid(USER_NOBODY);
+    uid = hip_user_to_uid(USER_NOBODY);
 #else
-  /* todo: hardcode the uid for a suitable user for openwrt */
-  uid = -1;
+    /* todo: hardcode the uid for a suitable user for openwrt */
+    uid = -1;
 #endif
-  HIP_IFEL((uid < 0), -1,
-          "Error while retrieving USER 'nobody' uid\n"); 
-  HIP_IFEL(capget(&header, &data), -1,
-          "error while retrieving capabilities through capget()\n");
-  HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
-           data.effective, data.permitted, data.inheritable);
-
-  //ruid=nobody_pswd->pw_uid; 
-  //euid=nobody_pswd->pw_uid;
-
-  HIP_DEBUG("Before setreuid(,) UID=%d and EFF_UID=%d\n",
-           getuid(), geteuid());
-
-  /* openwrt code */
-
-  HIP_IFEL(setreuid(uid, uid), -1, "setruid failed\n");
-
-  HIP_DEBUG("After setreuid(,) UID=%d and EFF_UID=%d\n",
-           getuid(), geteuid());
-  HIP_IFEL(capget(&header, &data), -1,
-          "error while retrieving capabilities through 'capget()'\n");
-
-  HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
-           data.effective,data.permitted, data.inheritable);
-  HIP_DEBUG ("Going to clear all capabilities except the ones needed\n");
-  data.effective = data.permitted = data.inheritable = 0;
-  // for CAP_NET_RAW capability 
-  data.effective |= (1 <<CAP_NET_RAW );
-  data.permitted |= (1 <<CAP_NET_RAW );
-  // for CAP_NET_ADMIN capability 
-  data.effective |= (1 <<CAP_NET_ADMIN );
-  data.permitted |= (1 <<CAP_NET_ADMIN );
-
-  /* openwrt code */
-  HIP_IFEL(capset(&header, &data), -1, 
-          "error in capset (do you have capabilities kernel module?)");
-  HIP_DEBUG("UID=%d EFF_UID=%d\n", getuid(), geteuid());  
-  HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
-           data.effective, data.permitted, data.inheritable);
+    HIP_IFEL((uid < 0), -1,
+             "Error while retrieving USER 'nobody' uid\n");
+    HIP_IFEL(capget(&header, &data), -1,
+             "error while retrieving capabilities through capget()\n");
+    HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
+              data.effective, data.permitted, data.inheritable);
+
+    //ruid=nobody_pswd->pw_uid;
+    //euid=nobody_pswd->pw_uid;
+
+    HIP_DEBUG("Before setreuid(,) UID=%d and EFF_UID=%d\n",
+              getuid(), geteuid());
+
+    /* openwrt code */
+
+    HIP_IFEL(setreuid(uid, uid), -1, "setruid failed\n");
+
+    HIP_DEBUG("After setreuid(,) UID=%d and EFF_UID=%d\n",
+              getuid(), geteuid());
+    HIP_IFEL(capget(&header, &data), -1,
+             "error while retrieving capabilities through 'capget()'\n");
+
+    HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
+              data.effective, data.permitted, data.inheritable);
+    HIP_DEBUG("Going to clear all capabilities except the ones needed\n");
+    data.effective  = data.permitted = data.inheritable = 0;
+    // for CAP_NET_RAW capability
+    data.effective |= (1 << CAP_NET_RAW);
+    data.permitted |= (1 << CAP_NET_RAW);
+    // for CAP_NET_ADMIN capability
+    data.effective |= (1 << CAP_NET_ADMIN);
+    data.permitted |= (1 << CAP_NET_ADMIN);
+
+    /* openwrt code */
+    HIP_IFEL(capset(&header, &data), -1,
+             "error in capset (do you have capabilities kernel module?)");
+    HIP_DEBUG("UID=%d EFF_UID=%d\n", getuid(), geteuid());
+    HIP_DEBUG("effective=%u, permitted = %u, inheritable=%u\n",
+              data.effective, data.permitted, data.inheritable);
 #endif /* CONFIG_HIP_PRIVSEP */
 
- out_err:
-  return err;
-
+out_err:
+    return err;
 }
 
 #else /* ! ALTSEP */
@@ -140,80 +141,82 @@
 /*
  * Note: this function does not go well with valgrind
  */
-int hip_set_lowcapability(int run_as_sudo) {
-       int err = 0;
+int hip_set_lowcapability(int run_as_sudo)
+{
+    int err                = 0;
 
 #ifdef CONFIG_HIP_PRIVSEP
-       uid_t uid = -1;
-       cap_value_t cap_list[] = {CAP_NET_RAW, CAP_NET_ADMIN };
-       int ncap_list = 2; 
-       cap_t cap_p = NULL;
-       char *cap_s = NULL;
-       char *name = NULL;
-
-       /* @todo: does this work when you start hipd as root (without sudo) */
-         
-       if (run_as_sudo) {
-               HIP_IFEL(!(name = getenv("SUDO_USER")), -1,
-                        "Failed to determine current username\n");
-       } else {
-               /* Check if user "hipd" exists if it does use it
-                  otherwise use "nobody" */
-               if (hip_user_to_uid(USER_HIPD) >= 0)
-                       name = USER_HIPD;
-               else if (hip_user_to_uid(USER_NOBODY) >= 0)
-                       name = USER_NOBODY;
-               else
-                       HIP_IFEL(1, -1, "System does not have nobody 
account\n");
-       }
-
-       HIP_IFEL(prctl(PR_SET_KEEPCAPS, 1), -1, "prctl err\n");
-
-       HIP_DEBUG("Now PR_SET_KEEPCAPS=%d\n", prctl(PR_GET_KEEPCAPS));
-
-       uid = hip_user_to_uid(name);
-        HIP_IFEL((uid < 0), -1,
-                 "Error while retrieving USER '%s' uid\n", name);
-
-       HIP_IFEL(!(cap_p = cap_get_proc()), -1,
-                "Error getting capabilities\n");
-       HIP_DEBUG("cap_p %s\n", cap_s = cap_to_text(cap_p, NULL));
-       /* It would be better to use #if DEBUG */
-       if (cap_s != NULL) {
-               cap_free(cap_s);
-               cap_s = NULL;
-       }
-
-       HIP_DEBUG("Before setreuid UID=%d and EFF_UID=%d\n",
-                 getuid(), geteuid());
-
-       HIP_IFEL(setreuid(uid,uid), -1, "setruid failed\n");
-
-       HIP_DEBUG("After setreuid UID=%d and EFF_UID=%d\n",
-                 getuid(), geteuid());
-
-       HIP_DEBUG ("Going to clear all capabilities except the ones needed\n");
-       HIP_IFEL(cap_clear(cap_p)<0, -1, "Error clearing capabilities\n");
-
-       HIP_IFEL(cap_set_flag(cap_p, CAP_EFFECTIVE, ncap_list, cap_list, 
CAP_SET)<0, 
-                -1, "Error setting capability flags\n");
-       HIP_IFEL(cap_set_flag(cap_p, CAP_PERMITTED, ncap_list, cap_list, 
CAP_SET)<0, 
-                -1, "Error setting capability flags\n");
-       HIP_IFEL(cap_set_proc(cap_p)<0, -1, "Error modifying capabilities\n");
-       HIP_DEBUG("UID=%d EFF_UID=%d\n", getuid(), geteuid());  
-       HIP_DEBUG("cap_p %s\n", cap_s = cap_to_text(cap_p, NULL));
-       /* It would be better to use #if DEBUG */
-       if (cap_s != NULL) {
-               cap_free(cap_s);
-               cap_s = NULL;
-       }
+    uid_t uid              = -1;
+    cap_value_t cap_list[] = {CAP_NET_RAW, CAP_NET_ADMIN };
+    int ncap_list          = 2;
+    cap_t cap_p            = NULL;
+    char *cap_s            = NULL;
+    char *name             = NULL;
+
+    /* @todo: does this work when you start hipd as root (without sudo) */
+
+    if (run_as_sudo) {
+        HIP_IFEL(!(name = getenv("SUDO_USER")), -1,
+                 "Failed to determine current username\n");
+    } else {
+        /* Check if user "hipd" exists if it does use it
+         * otherwise use "nobody" */
+        if (hip_user_to_uid(USER_HIPD) >= 0) {
+            name = USER_HIPD;
+        } else if (hip_user_to_uid(USER_NOBODY) >= 0) {
+            name = USER_NOBODY;
+        } else {
+            HIP_IFEL(1, -1, "System does not have nobody account\n");
+        }
+    }
+
+    HIP_IFEL(prctl(PR_SET_KEEPCAPS, 1), -1, "prctl err\n");
+
+    HIP_DEBUG("Now PR_SET_KEEPCAPS=%d\n", prctl(PR_GET_KEEPCAPS));
+
+    uid = hip_user_to_uid(name);
+    HIP_IFEL((uid < 0), -1,
+             "Error while retrieving USER '%s' uid\n", name);
+
+    HIP_IFEL(!(cap_p = cap_get_proc()), -1,
+             "Error getting capabilities\n");
+    HIP_DEBUG("cap_p %s\n", cap_s = cap_to_text(cap_p, NULL));
+    /* It would be better to use #if DEBUG */
+    if (cap_s != NULL) {
+        cap_free(cap_s);
+        cap_s = NULL;
+    }
+
+    HIP_DEBUG("Before setreuid UID=%d and EFF_UID=%d\n",
+              getuid(), geteuid());
+
+    HIP_IFEL(setreuid(uid, uid), -1, "setruid failed\n");
+
+    HIP_DEBUG("After setreuid UID=%d and EFF_UID=%d\n",
+              getuid(), geteuid());
+
+    HIP_DEBUG("Going to clear all capabilities except the ones needed\n");
+    HIP_IFEL(cap_clear(cap_p) < 0, -1, "Error clearing capabilities\n");
+
+    HIP_IFEL(cap_set_flag(cap_p, CAP_EFFECTIVE, ncap_list, cap_list, CAP_SET) 
< 0,
+             -1, "Error setting capability flags\n");
+    HIP_IFEL(cap_set_flag(cap_p, CAP_PERMITTED, ncap_list, cap_list, CAP_SET) 
< 0,
+             -1, "Error setting capability flags\n");
+    HIP_IFEL(cap_set_proc(cap_p) < 0, -1, "Error modifying capabilities\n");
+    HIP_DEBUG("UID=%d EFF_UID=%d\n", getuid(), geteuid());
+    HIP_DEBUG("cap_p %s\n", cap_s = cap_to_text(cap_p, NULL));
+    /* It would be better to use #if DEBUG */
+    if (cap_s != NULL) {
+        cap_free(cap_s);
+        cap_s = NULL;
+    }
 
 out_err:
-       cap_free(cap_p);
+    cap_free(cap_p);
 
 #endif /* CONFIG_HIP_PRIVSEP */
 
-       return err;
-
+    return err;
 }
+
 #endif

=== modified file 'lib/core/hip_capability.c.doxyme'
--- lib/core/hip_capability.c.doxyme    2010-01-19 09:28:42 +0000
+++ lib/core/hip_capability.c.doxyme    2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,19 +45,18 @@
 
 
 /**
- * hip_set_lowcapability 
+ * hip_set_lowcapability
  *
  *
  * @param run_as_sudo
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_user_to_uid 
+ * hip_user_to_uid
  *
  *
  * @param name
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/hip_capability.h'
--- lib/core/hip_capability.h   2010-01-19 09:28:42 +0000
+++ lib/core/hip_capability.h   2010-02-10 23:55:24 +0000
@@ -1,6 +1,6 @@
 /** @file
  * The header for hip_capability.c.
- * 
+ *
  * @author  Tobias Heer  <heer@xxxxxxxxxxxxxxxxx> (header file only)
  * @note    Distributed under <a 
href="http://www.gnu.org/licenses/gpl2.txt";>GNU/GPL</a>.
  */

=== modified file 'lib/core/hip_capability.h.doxyme'
--- lib/core/hip_capability.h.doxyme    2010-01-19 09:28:42 +0000
+++ lib/core/hip_capability.h.doxyme    2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/capability.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/hip_statistics.c'
--- lib/core/hip_statistics.c   2010-01-19 09:28:42 +0000
+++ lib/core/hip_statistics.c   2010-02-10 23:55:24 +0000
@@ -5,123 +5,136 @@
 
 static uint64_t timeval_to_uint64(const struct timeval *timeval)
 {
-       HIP_ASSERT(timeval != NULL);
-
-       /* convert values to microseconds and add */
-       return ((timeval->tv_sec * STATS_IN_USECS) + timeval->tv_usec);
-}
-
-static double calc_avg(const statistics_data_t *statistics_data, const double 
scaling_factor)
-{
-       double avg = 0.0;
-
-       HIP_ASSERT(statistics_data != NULL);
-       HIP_ASSERT(scaling_factor > 0);
-
-       if (statistics_data->num_items >= 1)
-       {
-               avg = (statistics_data->added_values / scaling_factor)
-                                       / statistics_data->num_items;
-       }
-
-       return avg;
-}
-
-static double calc_std_dev(const statistics_data_t *statistics_data, const 
double scaling_factor)
-{
-       double std_dev = 0.0;
-       double sum1 = 0.0, sum2 = 0.0;
-
-       HIP_ASSERT(statistics_data != NULL);
-
-       if (statistics_data->num_items >= 1)
-       {
-               sum1 = (double)statistics_data->added_values / 
statistics_data->num_items;
-               sum2 = (double)statistics_data->added_squared_values
-                                       / statistics_data->num_items;
-
-               std_dev = sqrt(sum2 - (sum1 * sum1));
-       }
-
-       return std_dev / scaling_factor;
+    HIP_ASSERT(timeval != NULL);
+
+    /* convert values to microseconds and add */
+    return (timeval->tv_sec * STATS_IN_USECS) + timeval->tv_usec;
+}
+
+static double calc_avg(const statistics_data_t *statistics_data,
+                       const double scaling_factor)
+{
+    double avg = 0.0;
+
+    HIP_ASSERT(statistics_data != NULL);
+    HIP_ASSERT(scaling_factor > 0);
+
+    if (statistics_data->num_items >= 1) {
+        avg = (statistics_data->added_values / scaling_factor)
+              / statistics_data->num_items;
+    }
+
+    return avg;
+}
+
+static double calc_std_dev(const statistics_data_t *statistics_data,
+                           const double scaling_factor)
+{
+    double std_dev = 0.0;
+    double sum1    = 0.0, sum2 = 0.0;
+
+    HIP_ASSERT(statistics_data != NULL);
+
+    if (statistics_data->num_items >= 1) {
+        sum1 = (double) statistics_data->added_values / 
statistics_data->num_items;
+        sum2 = (double) statistics_data->added_squared_values
+                / statistics_data->num_items;
+
+        std_dev = sqrt(sum2 - (sum1 * sum1));
+    }
+
+    return std_dev / scaling_factor;
 }
 
 uint64_t calc_timeval_diff(const struct timeval *timeval_start,
-               const struct timeval *timeval_end)
+                           const struct timeval *timeval_end)
 {
-       struct timeval rel_timeval;
-
-       HIP_ASSERT(timeval_start != NULL);
-       HIP_ASSERT(timeval_end != NULL);
-
-       // check that timeval_high really is higher
-       if ((timeval_end->tv_sec > timeval_start->tv_sec) && 
(timeval_end->tv_usec > timeval_start->tv_usec)) {
-               rel_timeval.tv_sec = timeval_end->tv_sec - 
timeval_start->tv_sec;
-               rel_timeval.tv_usec = timeval_end->tv_usec - 
timeval_start->tv_usec;
-       }
-       else {
-               rel_timeval.tv_sec = 0;
-               rel_timeval.tv_usec = 0;
-       }
-
-       return timeval_to_uint64(&rel_timeval);
+    struct timeval rel_timeval;
+
+    HIP_ASSERT(timeval_start != NULL);
+    HIP_ASSERT(timeval_end != NULL);
+
+    // check that timeval_high really is higher
+    if ((timeval_end->tv_sec > timeval_start->tv_sec) &&
+        (timeval_end->tv_usec > timeval_start->tv_usec))
+    {
+        rel_timeval.tv_sec  = timeval_end->tv_sec - timeval_start->tv_sec;
+        rel_timeval.tv_usec = timeval_end->tv_usec - timeval_start->tv_usec;
+    } else {
+        rel_timeval.tv_sec  = 0;
+        rel_timeval.tv_usec = 0;
+    }
+
+    return timeval_to_uint64(&rel_timeval);
 }
 
-int add_statistics_item(statistics_data_t *statistics_data, const uint64_t 
item_value)
+int add_statistics_item(statistics_data_t *statistics_data,
+                        const uint64_t item_value)
 {
-       int err = 0;
-
-       HIP_ASSERT(statistics_data != NULL);
-
-       HIP_IFEL(!(statistics_data->num_items < statistics_data->num_items + 
1), -1,
-                       "value exceeds data type range\n");
-       statistics_data->num_items++;
-
-       HIP_IFEL(!(statistics_data->added_values < 
statistics_data->added_values + item_value), -1,
-                       "value exceeds data type range\n")
-       statistics_data->added_values += item_value;
-
-
-       HIP_IFEL(!(statistics_data->added_squared_values < 
statistics_data->added_squared_values + item_value * item_value), -1,
-                       "value exceeds data type range\n");
-       statistics_data->added_squared_values += item_value * item_value;
-
-       if (item_value > statistics_data->max_value) {
-               statistics_data->max_value = item_value;
-       }
-
-       if (item_value < statistics_data->min_value ||
-                       statistics_data->min_value == 0.0) {
-               statistics_data->min_value = item_value;
-       }
-
-  out_err:
-       if (err) {
-               HIP_DEBUG("resetting statistics\n");
-
-               statistics_data->num_items = 0;
-               statistics_data->added_values = 0;
-               statistics_data->added_squared_values = 0;
-       }
-
-       return err;
+    int err = 0;
+
+    HIP_ASSERT(statistics_data != NULL);
+
+    HIP_IFEL(!(statistics_data->num_items < statistics_data->num_items + 1), 
-1,
+             "value exceeds data type range\n");
+    statistics_data->num_items++;
+
+    HIP_IFEL(!(statistics_data->added_values < statistics_data->added_values + 
item_value),
+             -1,
+             "value exceeds data type range\n")
+    statistics_data->added_values += item_value;
+
+
+    HIP_IFEL(!(statistics_data->added_squared_values < 
statistics_data->added_squared_values + item_value * item_value),
+             -1,
+             "value exceeds data type range\n");
+    statistics_data->added_squared_values += item_value * item_value;
+
+    if (item_value > statistics_data->max_value) {
+        statistics_data->max_value = item_value;
+    }
+
+    if (item_value < statistics_data->min_value ||
+        statistics_data->min_value == 0.0) {
+        statistics_data->min_value = item_value;
+    }
+
+out_err:
+    if (err) {
+        HIP_DEBUG("resetting statistics\n");
+
+        statistics_data->num_items            = 0;
+        statistics_data->added_values         = 0;
+        statistics_data->added_squared_values = 0;
+    }
+
+    return err;
 }
 
 /* only returns values for non-NULL pointers */
-void calc_statistics(const statistics_data_t *statistics_data, uint32_t 
*num_items,
-               double *min, double *max, double *avg, double *std_dev,
-               double scaling_factor)
+void calc_statistics(const statistics_data_t *statistics_data,
+                     uint32_t *num_items,
+                     double *min,
+                     double *max,
+                     double *avg,
+                     double *std_dev,
+                     double scaling_factor)
 {
-       HIP_ASSERT(statistics_data != NULL);
+    HIP_ASSERT(statistics_data != NULL);
 
-       if (num_items)
-               *num_items = statistics_data->num_items;
-       if (min)
-               *min = statistics_data->min_value / scaling_factor;
-       if (max)
-               *max = statistics_data->max_value / scaling_factor;
-       if (avg)
-               *avg = calc_avg(statistics_data, scaling_factor);
-       if (std_dev)
-               *std_dev = calc_std_dev(statistics_data, scaling_factor);
+    if (num_items) {
+        *num_items = statistics_data->num_items;
+    }
+    if (min) {
+        *min = statistics_data->min_value / scaling_factor;
+    }
+    if (max) {
+        *max = statistics_data->max_value / scaling_factor;
+    }
+    if (avg) {
+        *avg = calc_avg(statistics_data, scaling_factor);
+    }
+    if (std_dev) {
+        *std_dev = calc_std_dev(statistics_data, scaling_factor);
+    }
 }

=== modified file 'lib/core/hip_statistics.c.doxyme'
--- lib/core/hip_statistics.c.doxyme    2010-01-19 09:28:42 +0000
+++ lib/core/hip_statistics.c.doxyme    2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,27 +45,27 @@
 
 
 /**
- * add_statistics_item 
+ * add_statistics_item
  *
  *
  * @param statistics_data
  * @param item_value
- * @return 
+ * @return
  **/
 
 
 /**
- * calc_avg 
+ * calc_avg
  *
  *
  * @param statistics_data
  * @param scaling_factor
- * @return 
+ * @return
  **/
 
 
 /**
- * calc_statistics 
+ * calc_statistics
  *
  *
  * @param statistics_data
@@ -74,35 +75,34 @@
  * @param avg
  * @param std_dev
  * @param scaling_factor
- * @return 
+ * @return
  **/
 
 
 /**
- * calc_std_dev 
+ * calc_std_dev
  *
  *
  * @param statistics_data
  * @param scaling_factor
- * @return 
+ * @return
  **/
 
 
 /**
- * calc_timeval_diff 
+ * calc_timeval_diff
  *
  *
  * @param timeval_start
  * @param timeval_end
- * @return 
+ * @return
  **/
 
 
 /**
- * timeval_to_uint64 
+ * timeval_to_uint64
  *
  *
  * @param timeval
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/hip_statistics.h'
--- lib/core/hip_statistics.h   2010-02-08 15:18:06 +0000
+++ lib/core/hip_statistics.h   2010-02-10 23:55:24 +0000
@@ -4,22 +4,27 @@
 #include <stdlib.h>
 #include <inttypes.h>
 
-#define STATS_IN_MSECS 1000
-#define STATS_IN_USECS 1000000
+#define STATS_IN_MSECS  1000
+#define STATS_IN_USECS  1000000
 
-typedef struct statistics_data
-{
-       uint32_t num_items;
-       uint64_t added_values;
-       uint64_t added_squared_values;
-       uint64_t min_value;
-       uint64_t max_value;
+typedef struct statistics_data {
+    uint32_t num_items;
+    uint64_t added_values;
+    uint64_t added_squared_values;
+    uint64_t min_value;
+    uint64_t max_value;
 } statistics_data_t;
 
 uint64_t calc_timeval_diff(const struct timeval *timeval_start,
-               const struct timeval *timeval_end);
-int add_statistics_item(statistics_data_t *statistics_data, const uint64_t 
item_value);
-void calc_statistics(const statistics_data_t *statistics_data, uint32_t 
*num_items,
-               double *min, double *max, double *avg, double *std_dev, double 
scaling_factor);
+                           const struct timeval *timeval_end);
+int add_statistics_item(statistics_data_t *statistics_data,
+                        const uint64_t item_value);
+void calc_statistics(const statistics_data_t *statistics_data,
+                     uint32_t *num_items,
+                     double *min,
+                     double *max,
+                     double *avg,
+                     double *std_dev,
+                     double scaling_factor);
 
 #endif /* HIP_STATISTICS_H_ */

=== modified file 'lib/core/hip_statistics.h.doxyme'
--- lib/core/hip_statistics.h.doxyme    2010-01-19 09:28:42 +0000
+++ lib/core/hip_statistics.h.doxyme    2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/hip_statistics.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/icomm.h'
--- lib/core/icomm.h    2010-02-08 15:18:06 +0000
+++ lib/core/icomm.h    2010-02-10 23:55:24 +0000
@@ -12,12 +12,12 @@
 #include "protodefs.h"
 
 /* Use this port to send asynchronous/unidirectional messages
-   from hipd to hipfw */
+ * from hipd to hipfw */
 #define HIP_FIREWALL_PORT                      971
 /* Use this port to send messages from hipd to agent */
 #define HIP_AGENT_PORT                         972
 /* Use this port to send synchronous/bidirectional (request-response)
-   messages from hipd to firewall*/
+ * messages from hipd to firewall*/
 #define HIP_DAEMON_LOCAL_PORT                  973
 #define HIP_FIREWALL_SYNC_PORT                 974
 
@@ -36,7 +36,7 @@
  * @todo Should socket option values 1 - 64 be renumbered starting from 65?
  * @{
  */
-#define HIP_SO_ANY_MIN                                 1
+#define HIP_SO_ANY_MIN                          1
 #define SO_HIP_ADD_PEER_MAP_HIT_IP              2
 #define SO_HIP_DEL_PEER_MAP_HIT_IP              3
 /* slot free */
@@ -47,15 +47,15 @@
 #define SO_HIP_QUERY_OPPORTUNISTIC_MODE         9
 #define SO_HIP_ANSWER_OPPORTUNISTIC_MODE_QUERY  10
 /* slot free */
-#define SO_HIP_QUERY_IP_HIT_MAPPING            12
-#define SO_HIP_ANSWER_IP_HIT_MAPPING_QUERY     13
-#define SO_HIP_GET_PEER_HIT                    14
+#define SO_HIP_QUERY_IP_HIT_MAPPING             12
+#define SO_HIP_ANSWER_IP_HIT_MAPPING_QUERY      13
+#define SO_HIP_GET_PEER_HIT                     14
 /* free slot */
-#define SO_HIP_DEFAULT_HIT                     16
+#define SO_HIP_DEFAULT_HIT                      16
 #define SO_HIP_GET_PEER_LIST                    17
 /* Free slots here */
 #define SO_HIP_GET_HITS                         21
-#define SO_HIP_GET_HA_INFO                     22
+#define SO_HIP_GET_HA_INFO                      22
 #define SO_HIP_DHT_SERVING_GW                   24
 /* free slot */
 #define SO_HIP_GET_LSI_PEER                     26
@@ -64,16 +64,16 @@
 /* inclusive */
 #define SO_HIP_PING                             32
 #define SO_HIP_TRIGGER_BEX                      33
-#define SO_HIP_MAP_ID_TO_ADDR                  34
-#define SO_HIP_LSI_TO_HIT                      35
-#define HIP_SO_ANY_MAX                                 63
+#define SO_HIP_MAP_ID_TO_ADDR                   34
+#define SO_HIP_LSI_TO_HIT                       35
+#define HIP_SO_ANY_MAX                          63
 
 
 /** @addtogroup hip_so
  * HIP socket options.
  * @{
  */
-#define HIP_SO_ROOT_MIN                        64
+#define HIP_SO_ROOT_MIN                         64
 #define SO_HIP_ADD_LOCAL_HI                     65
 #define SO_HIP_DEL_LOCAL_HI                     66
 #define SO_HIP_RUN_UNIT_TEST                    67
@@ -92,31 +92,31 @@
 #define SO_HIP_SET_BLIND_OFF                    80
 /** Socket option for hipconf to change the used gateway with OpenDHT */
 #define SO_HIP_DHT_GW                           81
-#define SO_HIP_SET_DEBUG_ALL                   82
-#define SO_HIP_SET_DEBUG_MEDIUM                        83
-#define SO_HIP_SET_DEBUG_NONE                  84
+#define SO_HIP_SET_DEBUG_ALL                    82
+#define SO_HIP_SET_DEBUG_MEDIUM                 83
+#define SO_HIP_SET_DEBUG_NONE                   84
 /** Socket option for hipconf to ask about the used gateway with OpenDHT */
 #define SO_HIP_LOCATOR_GET                      85
-#define SO_HIP_MHADDR_ACTIVE                   86
-#define SO_HIP_MHADDR_LAZY                     87
+#define SO_HIP_MHADDR_ACTIVE                    86
+#define SO_HIP_MHADDR_LAZY                      87
 /** Socket option for hipconf to restart daemon. */
-#define SO_HIP_RESTART                         88
+#define SO_HIP_RESTART                          88
 #define SO_HIP_SET_LOCATOR_ON                   89
 #define SO_HIP_SET_LOCATOR_OFF                  90
 #define SO_HIP_DHT_SET                          91
 #define SO_HIP_DHT_ON                           92
 #define SO_HIP_DHT_OFF                          93
-#define SO_HIP_SET_OPPTCP_ON                   94
-#define SO_HIP_SET_OPPTCP_OFF                  95
-#define SO_HIP_SET_HI3_ON                      96
-#define SO_HIP_SET_HI3_OFF                     97
-#define SO_HIP_RESET_FIREWALL_DB               98
+#define SO_HIP_SET_OPPTCP_ON                    94
+#define SO_HIP_SET_OPPTCP_OFF                   95
+#define SO_HIP_SET_HI3_ON                       96
+#define SO_HIP_SET_HI3_OFF                      97
+#define SO_HIP_RESET_FIREWALL_DB                98
 
-#define SO_HIP_OPPTCP_SEND_TCP_PACKET          99
+#define SO_HIP_OPPTCP_SEND_TCP_PACKET           99
 #define SO_HIP_TRANSFORM_ORDER                  100
 
 /** Socket option for the server to offer the RVS service. (server side) */
-#define SO_HIP_OFFER_RVS                       101
+#define SO_HIP_OFFER_RVS                        101
 /** Socket option for the server to cancel the RVS service. (server side) */
 #define SO_HIP_CANCEL_RVS                       102
 /** Socket option for the server to reinit the RVS service. (server side) */
@@ -127,10 +127,10 @@
  */
 #define SO_HIP_ADD_DEL_SERVER                   104
 /** Socket option for the server to offer the HIP relay service. (server
-    side) */
+ *  side) */
 #define SO_HIP_OFFER_HIPRELAY                   106
 /** Socket option for the server to cancel the HIP relay service. (server
-    side) */
+ *  side) */
 #define SO_HIP_CANCEL_HIPRELAY                  107
 /** Socket option for hipconf to reinit the HIP relay service. (server side) */
 #define SO_HIP_REINIT_RELAY                     108
@@ -147,12 +147,12 @@
 #define SO_HIP_SET_NAT_PLAIN_UDP                129
 #define SO_HIP_SET_NAT_NONE                     130
 #define SO_HIP_SET_NAT_OFF                      SO_HIP_SET_NAT_NONE // XX 
FIXME: REMOVE
-#define SO_HIP_SET_HIPPROXY_ON                 131
-#define SO_HIP_SET_HIPPROXY_OFF                        132
-#define SO_HIP_GET_PROXY_LOCAL_ADDRESS         133
-#define SO_HIP_HIPPROXY_STATUS_REQUEST         134
+#define SO_HIP_SET_HIPPROXY_ON                  131
+#define SO_HIP_SET_HIPPROXY_OFF                 132
+#define SO_HIP_GET_PROXY_LOCAL_ADDRESS          133
+#define SO_HIP_HIPPROXY_STATUS_REQUEST          134
 #define SO_HIP_OPPTCP_UNBLOCK_AND_BLACKLIST     135
-#define SO_HIP_IPSEC_ADD_SA                    136
+#define SO_HIP_IPSEC_ADD_SA                     136
 #define SO_HIP_SET_TCPTIMEOUT_ON                137
 #define SO_HIP_SET_TCPTIMEOUT_OFF               138
 #define SO_HIP_SET_NAT_ICE_UDP                  139
@@ -161,18 +161,18 @@
 #define SO_HIP_CERT_SPKI_VERIFY                 142
 #define SO_HIP_CERT_X509V3_SIGN                 143
 #define SO_HIP_CERT_X509V3_VERIFY               144
-#define SO_HIP_USERSPACE_IPSEC                 145
-#define SO_HIP_ESP_PROT_TFM                    146
-#define SO_HIP_BEX_STORE_UPDATE                        147
+#define SO_HIP_USERSPACE_IPSEC                  145
+#define SO_HIP_ESP_PROT_TFM                     146
+#define SO_HIP_BEX_STORE_UPDATE                 147
 // free slot
-#define SO_HIP_TRIGGER_UPDATE                  149
+#define SO_HIP_TRIGGER_UPDATE                   149
 #define SO_HIP_FW_UPDATE_DB                     152
 #define SO_HIP_IPSEC_DELETE_SA                  153
-#define SO_HIP_IPSEC_FLUSH_ALL_SA              154
-#define SO_HIP_ANCHOR_CHANGE                   155
+#define SO_HIP_IPSEC_FLUSH_ALL_SA               154
+#define SO_HIP_ANCHOR_CHANGE                    155
 /* free slot */
 #define SO_HIP_FW_BEX_DONE                      157
-#define SO_HIP_RESTART_DUMMY_INTERFACE         158
+#define SO_HIP_RESTART_DUMMY_INTERFACE          158
 #define SO_HIP_VERIFY_DHT_HDRR_RESP             159
 /* free slots */
 #define SO_HIP_BUDDIES_ON                       162
@@ -196,30 +196,30 @@
 #define SO_HIP_HIT_TO_IP_OFF                    181
 #define SO_HIP_HIT_TO_IP_ON                     182
 #define SO_HIP_HIT_TO_IP_SET                    183
-#define SO_HIP_SET_NAT_PORT                    184
+#define SO_HIP_SET_NAT_PORT                     184
 #define SO_HIP_SHOTGUN_ON                       185
 #define SO_HIP_SHOTGUN_OFF                      186
 #define SO_HIP_SIGN_BUDDY_X509V3                187
 #define SO_HIP_SIGN_BUDDY_SPKI                  188
 #define SO_HIP_VERIFY_BUDDY_X509V3              189
 #define SO_HIP_VERIFY_BUDDY_SPKI                190
-#define SO_HIP_OFFER_FULLRELAY                 191
-#define SO_HIP_CANCEL_FULLRELAY                        192
-#define SO_HIP_REINIT_FULLRELAY                        193
-#define SO_HIP_FIREWALL_START                  194
+#define SO_HIP_OFFER_FULLRELAY                  191
+#define SO_HIP_CANCEL_FULLRELAY                 192
+#define SO_HIP_REINIT_FULLRELAY                 193
+#define SO_HIP_FIREWALL_START                   194
 #define SO_HIP_SET_DATAPACKET_MODE_ON           195
 #define SO_HIP_SET_DATAPACKET_MODE_OFF          196
 #define SO_HIP_BUILD_HOST_ID_SIGNATURE_DATAPACKET 197
 #define SO_HIP_MANUAL_UPDATE_PACKET             198
 /** Socket option for hipconf to set handover mode, hard or soft. */
-#define SO_HIP_HANDOVER_HARD                   199
-#define SO_HIP_HANDOVER_SOFT                   200
-#define SO_HIP_FIREWALL_STATUS                 201
-#define SO_HIP_FW_FLUSH_SYS_OPP_HIP            202
+#define SO_HIP_HANDOVER_HARD                    199
+#define SO_HIP_HANDOVER_SOFT                    200
+#define SO_HIP_FIREWALL_STATUS                  201
+#define SO_HIP_FW_FLUSH_SYS_OPP_HIP             202
 
 /** @} */
 /* inclusive */
-#define HIP_SO_ROOT_MAX                        255
+#define HIP_SO_ROOT_MAX                         255
 
 #define SO_HIP_SET_NAT_ON                     SO_HIP_SET_NAT_PLAIN_UDP
 #define FLUSH_HA_INFO_DB                        1
@@ -228,17 +228,17 @@
 /****** FIREWALL ******/
 
 // the states of the connections as kept in the firewall
-#define FIREWALL_STATE_BEX_DEFAULT             -1  //default entry
-#define FIREWALL_STATE_BEX_NOT_SUPPORTED        0  //detected lack of HIP 
support at peer
-#define FIREWALL_STATE_BEX_ESTABLISHED          1  //detected HIP support at 
peer
+#define FIREWALL_STATE_BEX_DEFAULT              -1  //default entry
+#define FIREWALL_STATE_BEX_NOT_SUPPORTED         0  //detected lack of HIP 
support at peer
+#define FIREWALL_STATE_BEX_ESTABLISHED           1  //detected HIP support at 
peer
 
 //definition of firewall db records
-struct firewall_hl{
-       struct in6_addr ip_peer;
-       hip_lsi_t       lsi;
-       hip_hit_t       hit_our;
-        hip_hit_t      hit_peer;
-        int            bex_state;
+struct firewall_hl {
+    struct in6_addr ip_peer;
+    hip_lsi_t       lsi;
+    hip_hit_t       hit_our;
+    hip_hit_t       hit_peer;
+    int             bex_state;
 };
 typedef struct firewall_hl firewall_hl_t;
 typedef struct hip_hadb_user_info_state firewall_cache_hl_t;
@@ -246,16 +246,14 @@
 
 /*----Firewall cache----*/
 /*Values for the port cache of the firewall*/
-#define FIREWALL_PORT_CACHE_IPV6_TRAFFIC       1
-#define FIREWALL_PORT_CACHE_IPV4_TRAFFIC       3
-#define FIREWALL_PORT_CACHE_KEY_LENGTH         20
+#define FIREWALL_PORT_CACHE_IPV6_TRAFFIC        1
+#define FIREWALL_PORT_CACHE_IPV4_TRAFFIC        3
+#define FIREWALL_PORT_CACHE_KEY_LENGTH          20
 
-struct firewall_port_cache_hl
-{
-       char port_and_protocol[FIREWALL_PORT_CACHE_KEY_LENGTH]; //key
-       int  traffic_type;                                      //value
+struct firewall_port_cache_hl {
+    char port_and_protocol[FIREWALL_PORT_CACHE_KEY_LENGTH];     //key
+    int  traffic_type;                                          //value
 };
 typedef struct firewall_port_cache_hl firewall_port_cache_hl_t;
 
 #endif /* _HIP_ICOMM */
-

=== modified file 'lib/core/icomm.h.doxyme'
--- lib/core/icomm.h.doxyme     2010-01-19 09:28:42 +0000
+++ lib/core/icomm.h.doxyme     2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/icomm.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/ife.h'
--- lib/core/ife.h      2010-02-08 15:18:06 +0000
+++ lib/core/ife.h      2010-02-10 23:55:24 +0000
@@ -3,13 +3,13 @@
 
 #define GOTO_OUT -3
 /** A generic HIP error. This should be a value whose value does not overlap
-    with the global errno values. */
+ *  with the global errno values. */
 #define EHIP       500
 /** A generic error value for getaddrinfo() error since the negated library
-    error values overlap ernno values. */
+ *  error values overlap ernno values. */
 #define EHADDRINFO 501
 
-/** 
+/**
  * @addtogroup ife
  * @{
  */
@@ -24,12 +24,12 @@
  * @param eval Set variable called 'err' to this value.
  */
 #define HIP_IFE(func, eval) \
-{ \
-       if (func) { \
-               err = eval; \
-               goto out_err; \
-       } \
-}
+    { \
+        if (func) { \
+            err = eval; \
+            goto out_err; \
+        } \
+    }
 
 /**
  * Use this macro to detect failures and exit function in case
@@ -41,59 +41,58 @@
  * @param eval Set variable called 'err' to this value.
  * @param args Arguments for HIP_ERROR(), use like with printf().
  */
-#define HIP_IFEL(func, eval, args...) \
-{ \
-       if (func) { \
-               HIP_ERROR(args); \
-               err = eval; \
-               goto out_err; \
-       } \
-}
+#define HIP_IFEL(func, eval, args ...) \
+    { \
+        if (func) { \
+            HIP_ERROR(args); \
+            err = eval; \
+            goto out_err; \
+        } \
+    }
 
 #define HIP_IFEB(func, eval, finally) \
-{ \
-       if (func) { \
-               err = eval; \
-                finally;\
-               goto out_err; \
-       } else {\
-               finally;\
-        }\
-}
-
-#define HIP_IFEBL(func, eval, finally, args...) \
-{ \
-       if (func) { \
-               HIP_ERROR(args); \
-               err = eval; \
-                finally;\
-               goto out_err; \
-       } else {\
-               finally;\
-        }\
-}
-
-#define HIP_IFEBL2(func, eval, finally, args...) \
-{ \
-       if (func) { \
-               HIP_ERROR(args); \
-               err = eval; \
-                finally;\
-        }\
-}
+    { \
+        if (func) { \
+            err = eval; \
+            finally; \
+            goto out_err; \
+        } else { \
+            finally; \
+        } \
+    }
+
+#define HIP_IFEBL(func, eval, finally, args ...) \
+    { \
+        if (func) { \
+            HIP_ERROR(args); \
+            err = eval; \
+            finally; \
+            goto out_err; \
+        } else { \
+            finally; \
+        } \
+    }
+
+#define HIP_IFEBL2(func, eval, finally, args ...) \
+    { \
+        if (func) { \
+            HIP_ERROR(args); \
+            err = eval; \
+            finally; \
+        } \
+    }
 
 /**
  * HIP_IFCS takes a pointer and an command to execute and executes the
  * @c command if @c condition is @b not NULL.
- */ 
-#define HIP_IFCS(condition, consequence)\
-        if( condition ) {      \
-               consequence ;                                           \
-        } else {                                                       \
-               HIP_DEBUG("No state information found.\n");             \
-        }
+ */
+#define HIP_IFCS(condition, consequence) \
+    if (condition) {      \
+        consequence;      \
+    } else {              \
+        HIP_DEBUG("No state information found.\n"); \
+    }
 
 /** @} */
 
 #endif /* _HIP_IFE */
-

=== modified file 'lib/core/ife.h.doxyme'
--- lib/core/ife.h.doxyme       2010-01-19 09:28:42 +0000
+++ lib/core/ife.h.doxyme       2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/ife.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/kerncompat.h'
--- lib/core/kerncompat.h       2010-01-19 09:28:42 +0000
+++ lib/core/kerncompat.h       2010-02-10 23:55:24 +0000
@@ -13,16 +13,17 @@
 #include <string.h>
 
 typedef struct { } rwlock_t;
-typedef uint8_t   u8;
-typedef uint16_t  u16;
-typedef uint32_t  u32;
-typedef struct { volatile int counter; } atomic_t;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef struct { volatile int counter;
+} atomic_t;
 typedef struct {
-       /** @todo Is empty. */
+    /** @todo Is empty. */
 } spinlock_t;
 
 struct list_head {
-       struct list_head *next, *prev;
+    struct list_head *next, *prev;
 };
 
 #ifndef IPPROTO_HIP
@@ -38,7 +39,7 @@
   #define hton64(i) (i)
   #define ntoh64(i) (i)
 #else
-  #define hton64(i) ( ((__u64)(htonl((i) & 0xffffffff)) << 32) | htonl(((i) >> 
32) & 0xffffffff ) )
+  #define hton64(i) (((__u64) (htonl((i) & 0xffffffff)) << 32) | htonl(((i) >> 
32) & 0xffffffff ))
   #define ntoh64 hton64
 #endif
 
@@ -49,22 +50,22 @@
 #define jiffies random()
 
 #define atomic_inc(x) \
-         (++(*x).counter)
+    (++(*x).counter)
 
 #define atomic_read(x) \
-         ((*x).counter)
+    ((*x).counter)
 
 #define atomic_dec_and_test(x) \
-         (--((*x).counter) == 0)
+    (--((*x).counter) == 0)
 
 #define atomic_set(x, v) \
-         ((*x).counter = v)
+    ((*x).counter = v)
 
 /* XX FIX: implement the locking for userspace properly */
-#define read_lock_irqsave(a,b) do {} while(0)
-#define spin_unlock_irqrestore(a,b) do {} while(0)
-#define write_lock_irqsave(a,b) do {} while(0)
-#define write_unlock_irqrestore(a,b) do {} while(0)
-#define read_unlock_irqrestore(a,b) do {} while(0)
+#define read_lock_irqsave(a, b) do {} while (0)
+#define spin_unlock_irqrestore(a, b) do {} while (0)
+#define write_lock_irqsave(a, b) do {} while (0)
+#define write_unlock_irqrestore(a, b) do {} while (0)
+#define read_unlock_irqrestore(a, b) do {} while (0)
 
 #endif /* __HIP_KERN_COMPATIBILITY__ */

=== modified file 'lib/core/kerncompat.h.doxyme'
--- lib/core/kerncompat.h.doxyme        2010-01-19 09:28:42 +0000
+++ lib/core/kerncompat.h.doxyme        2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/kerncompat.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/linkedlist.c'
--- lib/core/linkedlist.c       2010-02-06 15:19:35 +0000
+++ lib/core/linkedlist.c       2010-02-10 23:55:24 +0000
@@ -1,6 +1,6 @@
 /** @file
  * This file defines a linked list for storing pointers.
- * 
+ *
  * @author  Lauri Silvennoinen
  * @note    Distributed under <a 
href="http://www.gnu.org/licenses/gpl2.txt";>GNU/GPL</a>.
  * @see     linkedlist.h for usage instructions.
@@ -13,188 +13,191 @@
 
 void hip_ll_init(hip_ll_t *linkedlist)
 {
-       if(linkedlist != NULL) {
-               linkedlist->head = NULL;
-               linkedlist->element_count = 0;
-       }
+    if (linkedlist != NULL) {
+        linkedlist->head          = NULL;
+        linkedlist->element_count = 0;
+    }
 }
 
 void hip_ll_uninit(hip_ll_t *linkedlist, free_elem_fn_t free_element)
 {
-       if(linkedlist == NULL || linkedlist->head == NULL)
-               return;
-
-       hip_ll_node_t *pointer = NULL;
-       
-       /* Free the node currently at list head and move the next item to list
-          head. Continue this until the item at list head is NULL. If
-          free_element() is non-NULL we also free the memory allocated for the
-          actual element. */
-       if(free_element != NULL) {
-               while(linkedlist->head != NULL) {
-                       pointer = linkedlist->head->next;
-                       free_element(linkedlist->head->ptr);
-                       free(linkedlist->head);
-                       linkedlist->head = pointer;
-               }
-       } else {
-               while(linkedlist->head != NULL) {
-                       pointer = linkedlist->head->next;
-                       free(linkedlist->head);
-                       linkedlist->head = pointer;
-               }
-       }
-
-       linkedlist->element_count = 0;
+    if (linkedlist == NULL || linkedlist->head == NULL) {
+        return;
+    }
+
+    hip_ll_node_t *pointer = NULL;
+
+    /* Free the node currently at list head and move the next item to list
+     * head. Continue this until the item at list head is NULL. If
+     * free_element() is non-NULL we also free the memory allocated for the
+     * actual element. */
+    if (free_element != NULL) {
+        while (linkedlist->head != NULL) {
+            pointer          = linkedlist->head->next;
+            free_element(linkedlist->head->ptr);
+            free(linkedlist->head);
+            linkedlist->head = pointer;
+        }
+    } else {
+        while (linkedlist->head != NULL) {
+            pointer          = linkedlist->head->next;
+            free(linkedlist->head);
+            linkedlist->head = pointer;
+        }
+    }
+
+    linkedlist->element_count = 0;
 }
 
 unsigned int hip_ll_get_size(const hip_ll_t *linkedlist)
 {
-       if(linkedlist == NULL)
-               return 0;
-       
-       return linkedlist->element_count;
+    if (linkedlist == NULL) {
+        return 0;
+    }
+
+    return linkedlist->element_count;
 }
 
 int hip_ll_add(hip_ll_t *linkedlist, const unsigned int index, void *ptr)
 {
-       if (linkedlist == NULL || ptr == NULL)
-               return -1;
-       
-       hip_ll_node_t *newnode = NULL, *pointer = NULL;
-       unsigned int current_index = 0;
-       
-       if ((newnode =
-            (hip_ll_node_t*) malloc(sizeof(hip_ll_node_t))) == NULL) {
-               HIP_ERROR("Error on allocating memory for a linked list 
node.\n");
-               return -1;
-       }
-
-       newnode->ptr = ptr;
-       pointer = linkedlist->head;
-               
-       /* Item to add is the first item of the list or it is to be added as the
-          first one. */
-       if(pointer == NULL || index == 0) {
-               newnode->next = pointer;
-               linkedlist->head = newnode;
-               linkedlist->element_count++;
-       } 
-       /* There exist at least one element in the list and the new element is
-          not to be added as the first one. */
-       else {
-               hip_ll_node_t *previous = pointer;
-               
-               /* Loop until "pointer" is at the last item. */
-               while(pointer->next != NULL) {
-
-                       previous = pointer;
-                       pointer = pointer->next;
-                       current_index++;
-                       
-                       /* We have reached the target index and the index is not
-                          the index of the last item in the list. */
-                       if(current_index == index) {
-                               
-                               newnode->next = pointer;
-                               previous->next = newnode;
-                               linkedlist->element_count++;
-                               return 0;
-                       }
-               }
-               /* The node is to be added as the last item of the list. */
-               newnode->next = NULL;
-               pointer->next = newnode;
-               linkedlist->element_count++;
-       }
-
-       return 0;
+    if (linkedlist == NULL || ptr == NULL) {
+        return -1;
+    }
+
+    hip_ll_node_t *newnode     = NULL, *pointer = NULL;
+    unsigned int current_index = 0;
+
+    if ((newnode =
+             (hip_ll_node_t *) malloc(sizeof(hip_ll_node_t))) == NULL) {
+        HIP_ERROR("Error on allocating memory for a linked list node.\n");
+        return -1;
+    }
+
+    newnode->ptr = ptr;
+    pointer      = linkedlist->head;
+
+    /* Item to add is the first item of the list or it is to be added as the
+     * first one. */
+    if (pointer == NULL || index == 0) {
+        newnode->next    = pointer;
+        linkedlist->head = newnode;
+        linkedlist->element_count++;
+    }
+    /* There exist at least one element in the list and the new element is
+     * not to be added as the first one. */
+    else {
+        hip_ll_node_t *previous = pointer;
+
+        /* Loop until "pointer" is at the last item. */
+        while (pointer->next != NULL) {
+            previous = pointer;
+            pointer  = pointer->next;
+            current_index++;
+
+            /* We have reached the target index and the index is not
+             * the index of the last item in the list. */
+            if (current_index == index) {
+                newnode->next  = pointer;
+                previous->next = newnode;
+                linkedlist->element_count++;
+                return 0;
+            }
+        }
+        /* The node is to be added as the last item of the list. */
+        newnode->next = NULL;
+        pointer->next = newnode;
+        linkedlist->element_count++;
+    }
+
+    return 0;
 }
 
-void *hip_ll_del(hip_ll_t *linkedlist, const unsigned int index, 
-                free_elem_fn_t free_element)
+void *hip_ll_del(hip_ll_t *linkedlist, const unsigned int index,
+                 free_elem_fn_t free_element)
 {
-       if(linkedlist == NULL || linkedlist->head == NULL) {
-               return NULL;
-       } else if(index > (linkedlist->element_count -1)) { 
-               return NULL;
-       }
-       
-       hip_ll_node_t *pointer = NULL, *previous = NULL;
-       void *ptr = NULL;
-       unsigned int current_index = 0;
-       
-       if(index == 0) {
-               ptr = linkedlist->head->ptr;
-               pointer = linkedlist->head->next;
-               if(free_element != NULL) {
-                       free_element(ptr);
-                       ptr = NULL;
-               }
-               free(linkedlist->head);
-               linkedlist->head = pointer;
-               linkedlist->element_count--;
-               return ptr;
-       }
-       
-       pointer = previous = linkedlist->head;
-       
-       while(pointer->next != NULL) {
-               previous = pointer;
-               pointer = pointer->next;
-               current_index++;
-               
-               /* We have reached the target index. */
-               if(current_index == index) {
-                       if(pointer == NULL) {
-                               previous->next = NULL;
-                       } else {
-                               previous->next = pointer->next;
-                       }
-                       ptr = pointer->ptr;
-                       if(free_element != NULL) {
-                               free_element(ptr);
-                               ptr = NULL;
-                       }
-                       free(pointer);
-                       linkedlist->element_count--;
-                       break;
-               }
-       }
-       
-       return ptr;
+    if (linkedlist == NULL || linkedlist->head == NULL) {
+        return NULL;
+    } else if (index > (linkedlist->element_count - 1)) {
+        return NULL;
+    }
+
+    hip_ll_node_t *pointer     = NULL, *previous = NULL;
+    void *ptr                  = NULL;
+    unsigned int current_index = 0;
+
+    if (index == 0) {
+        ptr     = linkedlist->head->ptr;
+        pointer = linkedlist->head->next;
+        if (free_element != NULL) {
+            free_element(ptr);
+            ptr = NULL;
+        }
+        free(linkedlist->head);
+        linkedlist->head = pointer;
+        linkedlist->element_count--;
+        return ptr;
+    }
+
+    pointer = previous = linkedlist->head;
+
+    while (pointer->next != NULL) {
+        previous = pointer;
+        pointer  = pointer->next;
+        current_index++;
+
+        /* We have reached the target index. */
+        if (current_index == index) {
+            if (pointer == NULL) {
+                previous->next = NULL;
+            } else {
+                previous->next = pointer->next;
+            }
+            ptr = pointer->ptr;
+            if (free_element != NULL) {
+                free_element(ptr);
+                ptr = NULL;
+            }
+            free(pointer);
+            linkedlist->element_count--;
+            break;
+        }
+    }
+
+    return ptr;
 }
 
 void *hip_ll_get(hip_ll_t *linkedlist, const unsigned int index)
 {
-       if(linkedlist == NULL || linkedlist->head == NULL) {
-               return NULL;
-       } else if(index > (linkedlist->element_count -1)) { 
-               return NULL;
-       }
-       
-       hip_ll_node_t *pointer = linkedlist->head;
-       unsigned int current_index = 0;
-       
-       while(pointer != NULL) {
-               if(current_index == index) {
-                       break;
-               }
-               
-               pointer = pointer->next;
-               current_index++;
-       }
-       
-       return pointer->ptr;
+    if (linkedlist == NULL || linkedlist->head == NULL) {
+        return NULL;
+    } else if (index > (linkedlist->element_count - 1)) {
+        return NULL;
+    }
+
+    hip_ll_node_t *pointer     = linkedlist->head;
+    unsigned int current_index = 0;
+
+    while (pointer != NULL) {
+        if (current_index == index) {
+            break;
+        }
+
+        pointer = pointer->next;
+        current_index++;
+    }
+
+    return pointer->ptr;
 }
 
 hip_ll_node_t *hip_ll_iterate(const hip_ll_t *linkedlist,
-                             hip_ll_node_t *current)
+                              hip_ll_node_t *current)
 {
-       if(linkedlist == NULL)
-               return NULL;
-       if(current == NULL)
-               return linkedlist->head;
-       
-       return current->next;
+    if (linkedlist == NULL) {
+        return NULL;
+    }
+    if (current == NULL) {
+        return linkedlist->head;
+    }
+
+    return current->next;
 }

=== modified file 'lib/core/linkedlist.c.doxyme'
--- lib/core/linkedlist.c.doxyme        2010-01-19 09:28:42 +0000
+++ lib/core/linkedlist.c.doxyme        2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,71 +45,70 @@
 
 
 /**
- * hip_ll_add 
+ * hip_ll_add
  *
  *
  * @param linkedlist
  * @param index
  * @param ptr
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_ll_del 
+ * hip_ll_del
  *
  *
  * @param linkedlist
  * @param index
  * @param free_element
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_ll_get 
+ * hip_ll_get
  *
  *
  * @param linkedlist
  * @param index
- * @return 
- **/
-
-
-/**
- * hip_ll_get_size 
- *
- *
- * @param linkedlist
- * @return 
- **/
-
-
-/**
- * hip_ll_init 
- *
- *
- * @param linkedlist
- * @return 
- **/
-
-
-/**
- * hip_ll_iterate 
+ * @return
+ **/
+
+
+/**
+ * hip_ll_get_size
+ *
+ *
+ * @param linkedlist
+ * @return
+ **/
+
+
+/**
+ * hip_ll_init
+ *
+ *
+ * @param linkedlist
+ * @return
+ **/
+
+
+/**
+ * hip_ll_iterate
  *
  *
  * @param linkedlist
  * @param current
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_ll_uninit 
+ * hip_ll_uninit
  *
  *
  * @param linkedlist
  * @param free_element
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/linkedlist.h'
--- lib/core/linkedlist.h       2010-02-06 15:19:35 +0000
+++ lib/core/linkedlist.h       2010-02-10 23:55:24 +0000
@@ -22,16 +22,16 @@
 #define HIP_LL_H
 
 /** Linked list node. */
-typedef struct hip_ll_node{
-       void *ptr; /**< A pointer to node payload data. */
-       struct hip_ll_node *next; /**< A pointer to next node. */ 
-}hip_ll_node_t;
+typedef struct hip_ll_node {
+    void *              ptr; /**< A pointer to node payload data. */
+    struct hip_ll_node *next;     /**< A pointer to next node. */
+} hip_ll_node_t;
 
 /** Linked list. */
-typedef struct{
-       unsigned int element_count; /**< Total number of nodes in the list. */
-       hip_ll_node_t *head; /**< A pointer to the first node of the list. */
-}hip_ll_t;
+typedef struct {
+    unsigned int   element_count;   /**< Total number of nodes in the list. */
+    hip_ll_node_t *head;     /**< A pointer to the first node of the list. */
+} hip_ll_t;
 
 /** Linked list element memory deallocator function pointer. */
 typedef void (*free_elem_fn_t)(void *ptr);
@@ -42,7 +42,7 @@
  * does nothing.
  *
  * @param linkedlist the list to init.
- */ 
+ */
 void hip_ll_init(hip_ll_t *linkedlist);
 
 /**
@@ -57,7 +57,7 @@
  * <li>When @c free_element is <b>NULL</b> the memory allocated for the 
elements
  * is not freed, but only the nodes are freed.</li>
  * </ul>
- * 
+ *
  * @param linkedlist   the list to uninitialize.
  * @param free_element a function pointer to a function for freeing the memory
  *                     allocated for an element stored in a node.
@@ -66,7 +66,7 @@
  *                     the memory allocated for the elements manually before
  *                     invoking this function, and then call this function with
  *                     NULL as @c free_element.
- */ 
+ */
 void hip_ll_uninit(hip_ll_t *linkedlist, free_elem_fn_t free_element);
 
 /**
@@ -74,7 +74,7 @@
  *
  * @param  linkedlist the list whose node count is to be returned.
  * @return number of nodes in the list.
- */ 
+ */
 unsigned int hip_ll_get_size(const hip_ll_t *linkedlist);
 
 /**
@@ -82,14 +82,14 @@
  * parameter @c linkedlist with payload data @c ptr. If there are less than
  * (<code>index  -1</code>) elements in the list, the element will be added as
  * the last element of the list.
- * 
+ *
  * <b>Example:</b>
- * 
+ *
  * <code>hip_ll_add(&mylist, 2, mydata);</code> will add @c mydata as the
  * third item of the list when there are more than two elements in @c mylist.
  * When there are less than two items in the list @c mydata will be added as
  * the last element of @c mylist.
- * 
+ *
  * @param  linkedlist the list where to add the new node.
  * @param  index      the list index where to store the node. Indexing starts
  *                    from zero.
@@ -112,7 +112,7 @@
  */
 static inline int hip_ll_add_first(hip_ll_t *linkedlist, void *ptr)
 {
-       return hip_ll_add(linkedlist, 0, ptr);
+    return hip_ll_add(linkedlist, 0, ptr);
 }
 
 /**
@@ -127,7 +127,7 @@
  */
 static inline int hip_ll_add_last(hip_ll_t *linkedlist, void *ptr)
 {
-       return hip_ll_add(linkedlist, linkedlist->element_count, ptr);
+    return hip_ll_add(linkedlist, linkedlist->element_count, ptr);
 }
 
 /**
@@ -154,7 +154,7 @@
  *                     the list @c linkedlist itself is NULL.
  */
 void *hip_ll_del(hip_ll_t *linkedlist, const unsigned int index,
-                free_elem_fn_t free_element);
+                 free_elem_fn_t free_element);
 
 
 /**
@@ -177,9 +177,9 @@
  *                     @c linkedlist itself is NULL.
  */
 static inline void *hip_ll_del_first(hip_ll_t *linkedlist,
-                                    free_elem_fn_t free_element)
+                                     free_elem_fn_t free_element)
 {
-       return hip_ll_del(linkedlist, 0, free_element);
+    return hip_ll_del(linkedlist, 0, free_element);
 }
 
 /**
@@ -202,10 +202,10 @@
  *                     @c linkedlist itself is NULL.
  */
 static inline void *hip_ll_del_last(hip_ll_t *linkedlist,
-                                   free_elem_fn_t free_element)
+                                    free_elem_fn_t free_element)
 {
-       return hip_ll_del(linkedlist, linkedlist->element_count - 1,
-                         free_element);
+    return hip_ll_del(linkedlist, linkedlist->element_count - 1,
+                      free_element);
 }
 
 /**
@@ -213,7 +213,7 @@
  * stored in node at @c index. When there are less than (<code>index  
-1</code>)
  * nodes in the list, no action will be taken.
  *
- * @param linkedlist the linked list from where to retrieve the element.  
+ * @param linkedlist the linked list from where to retrieve the element.
  * @param index      the list index of the @c node from where the element is to
  *                   be retrieved. Indexing starts from zero.
  * @return           the next element or NULL if the list end has been reached
@@ -230,10 +230,10 @@
  * <pre>
  * hip_ll_node_t *iter = NULL;
  * while((iter = hip_ll_iterate(&list, iter)) != NULL) {
- *         ... Do stuff with iter ... 
- * } 
+ *         ... Do stuff with iter ...
+ * }
  * </pre>
- * 
+ *
  * @param  linkedlist the linked list from where to retrieve the node.
  * @param  current    the current node or NULL if the first node from the list
  *                    is to be retrieved.
@@ -244,6 +244,6 @@
  *                    hip_ll_uninit() for deleting nodes and elements.
  */
 hip_ll_node_t *hip_ll_iterate(const hip_ll_t *linkedlist,
-                             hip_ll_node_t *current);
+                              hip_ll_node_t *current);
 
 #endif /* HIP_LL_H */

=== modified file 'lib/core/linkedlist.h.doxyme'
--- lib/core/linkedlist.h.doxyme        2010-01-19 09:28:42 +0000
+++ lib/core/linkedlist.h.doxyme        2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/linkedlist.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/list.h'
--- lib/core/list.h     2010-01-19 09:28:42 +0000
+++ lib/core/list.h     2010-02-10 23:55:24 +0000
@@ -7,8 +7,8 @@
 typedef LHASH_NODE hip_list_t;
 
 /* OpenSSL 1.0.0 introduced backwards incompatible changes to the lhash.
-   These backwards compatibility hacks can be removed when all platforms
-   support OpenSSL 1.0.0 by default. */
+ * These backwards compatibility hacks can be removed when all platforms
+ * support OpenSSL 1.0.0 by default. */
 #ifdef LHASH_OF
 #ifndef HIPL_OPENSSL_100
 #define HIPL_OPENSSL_100
@@ -29,7 +29,7 @@
  * @param head the head for your list.
  */
 #ifdef HIPL_OPENSSL_100
-#define list_find(entry, head) lh_retrieve((_LHASH *)head, entry)
+#define list_find(entry, head) lh_retrieve((_LHASH *) head, entry)
 #else
 #define list_find(entry, head) lh_retrieve(head, entry)
 #endif
@@ -41,8 +41,8 @@
  * @param member the name of the list_struct within the struct.
  */
 #define list_for_each(pos, head, counter) \
-  for ((counter = ((struct lhash_st *)(head))->num_nodes - 1); counter >= 0; 
counter--) \
-      for (pos = ((struct lhash_st *)(head))->b[counter]; pos != NULL; pos = 
pos->next)
+    for ((counter = ((struct lhash_st *) (head))->num_nodes - 1); counter >= 
0; counter--) \
+              for (pos = ((struct lhash_st *) (head))->b[counter]; pos != 
NULL; pos = pos->next)
 
 /**
  * list_for_each_safe
@@ -52,9 +52,9 @@
  * @param member the name of the list_struct within the struct.
  */
 #define list_for_each_safe(pos, iter, head, counter) \
-  for ((counter = (((struct lhash_st *) (head)))->num_nodes - 1); counter >= 
0; counter--) \
-      for (pos = (((struct lhash_st *)(head)))->b[counter], (iter = pos ? 
pos->next : NULL); \
-            pos != NULL; pos = iter, (iter = pos ? pos->next : NULL))
+    for ((counter = (((struct lhash_st *) (head)))->num_nodes - 1); counter >= 
0; counter--) \
+              for (pos = (((struct lhash_st *) (head)))->b[counter], (iter = 
pos ? pos->next : NULL); \
+                                                                      pos != 
NULL; pos = iter, (iter = pos ? pos->next : NULL))
 
 /**
  * list_add - add a new entry

=== modified file 'lib/core/list.h.doxyme'
--- lib/core/list.h.doxyme      2010-01-19 09:28:42 +0000
+++ lib/core/list.h.doxyme      2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/list.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/message.c'
--- lib/core/message.c  2010-01-19 09:28:42 +0000
+++ lib/core/message.c  2010-02-10 23:55:24 +0000
@@ -22,351 +22,367 @@
  * @return Number of bytes received on success or a negative error value on
  *         error.
  */
-int hip_peek_recv_total_len(int socket, int encap_hdr_size, unsigned long 
timeout)
-{
-       int bytes = 0, err = 0, flags = MSG_PEEK;
-       unsigned long timeout_left = timeout;
-       int hdr_size = encap_hdr_size + sizeof(struct hip_common);
-       char *msg = NULL;
-       hip_common_t *hip_hdr = NULL;
-       struct timespec ts;
-
-       ts.tv_sec = 0;
-       ts.tv_nsec =  100000000;
-
-        /* We're using system call here add thus reseting errno. */
-       errno = 0;
-
-       msg = (char *)malloc(hdr_size);
-       HIP_IFEL(!msg, -ENOMEM, "Error allocating memory.\n");
-
-       /* Make sure the socket does not block (bug id 806) */
-       if (timeout >= 0)
-               flags |= MSG_DONTWAIT;
-
-       do {
-               errno = 0;
-               nanosleep(&ts, NULL);
-               bytes = recv(socket, msg, hdr_size, flags);
-               timeout_left -= ts.tv_nsec;
-               _HIP_DEBUG("tol=%ld, ts=%ld, bytes=%d errno=%d\n",
-                          timeout_left, ts.tv_nsec, bytes, errno);
-       } while (timeout_left > 0 && errno == EAGAIN && bytes < 0);
-
-       if(bytes < 0) {
-               HIP_ERROR("recv() peek error (is hipd running?)\n");
-               err = -EAGAIN;
-               goto out_err;
-       } else if (bytes < hdr_size) {
-               HIP_ERROR("Packet payload is smaller than HIP header. 
Dropping.\n");
-               /* Read and discard the datagram */
-               recv(socket, msg, 0, 0);
-               err = -bytes;
-               goto out_err;
-       }
-
-       hip_hdr = (struct hip_common *) (msg + encap_hdr_size);
-       bytes = hip_get_msg_total_len(hip_hdr);
-
-       if(bytes == 0) {
-               HIP_ERROR("HIP message is of zero length. Dropping.\n");
-               recv(socket, msg, 0, 0);
-               err = -EBADMSG;
-               errno = EBADMSG;
-               goto out_err;
-       }
-
-       /* The maximum possible length value is equal to HIP_MAX_PACKET.
-       if(bytes > HIP_MAX_PACKET) {
-               HIP_ERROR("HIP message max length exceeded. Dropping.\n");
-               recv(socket, msg, 0, 0);
-               err = -EMSGSIZE;
-               errno = EMSGSIZE;
-               goto out_err;
-       } */
-
-       bytes += encap_hdr_size;
-
- out_err:
-       if (msg != NULL)
-               free(msg);
-
-       if (err)
-               return err;
-
-       return bytes;
-}
-
-int hip_daemon_connect(int hip_user_sock) {
-       int err = 0;
-       struct sockaddr_in6 daemon_addr;
-       // We're using system call here add thus reseting errno.
-       errno = 0;
-
-       memset(&daemon_addr, 0, sizeof(daemon_addr));
-       daemon_addr.sin6_family = AF_INET6;
-       daemon_addr.sin6_port = htons(HIP_DAEMON_LOCAL_PORT);
-       daemon_addr.sin6_addr = in6addr_loopback;
-
-       HIP_IFEL(connect(hip_user_sock, (struct sockaddr *) &daemon_addr,
-                        sizeof(daemon_addr)), -1,
-                "connection to daemon failed\n");
-
- out_err:
-
-       return err;
-}
-
-int hip_daemon_bind_socket(int socket, struct sockaddr *sa) {
-       int err = 0, port = 0, on = 1;
-       struct sockaddr_in6 *addr = (struct sockaddr_in6 *) sa;
-
-       HIP_ASSERT(addr->sin6_family == AF_INET6);
-
-       errno = 0;
-
-       if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == 
-1) {
-               HIP_DEBUG ("Failed to set socket option SO_REUSEADDR %s \n",  
strerror(errno));
-       }
-
-       if (addr->sin6_port) {
-               HIP_DEBUG("Bind to fixed port %d\n", addr->sin6_port);
-               err = bind(socket,(struct sockaddr *)addr,
-                          sizeof(struct sockaddr_in6));
-               err = -errno;
-               goto out_err;
-       }
-
-       /* try to bind first to a priviledged port and then to ephemeral */
-       port = 1000;
-       while (port++ < 61000) {
-               _HIP_DEBUG("trying bind() to port %d\n", port);
-               addr->sin6_port = htons(port);
-               err = bind(socket,(struct sockaddr *)addr,
-                          hip_sockaddr_len(addr));
-               if (err == -1) {
-                       if (errno == EACCES) {
-                               /* Ephemeral ports:
-                                  /proc/sys/net/ipv4/ip_local_port_range */
-                               _HIP_DEBUG("Skipping to ephemeral range\n");
-                               port = 32768;
-                               errno = 0;
-                               err = 0;
-                       } else if (errno == EADDRINUSE) {
-                               _HIP_DEBUG("Port %d in use, skip\n", port);
-                               errno = 0;
-                               err = 0;
-                       } else {
-                               HIP_ERROR("Error %d bind() wasn't succesful\n",
-                                         errno);
-                               err = -1;
-                               goto out_err;
-                       }
-               }
-               else {
-                       _HIP_DEBUG("Bind() to port %d successful\n", port);
-                       goto out_err;
-               }
-       }
-
-       if (port == 61000) {
-               HIP_ERROR("All privileged ports were occupied\n");
-               err = -1;
-       }
-
- out_err:
-       return err;
+int hip_peek_recv_total_len(int socket,
+                            int encap_hdr_size,
+                            unsigned long timeout)
+{
+    int bytes                  = 0, err = 0, flags = MSG_PEEK;
+    unsigned long timeout_left = timeout;
+    int hdr_size               = encap_hdr_size + sizeof(struct hip_common);
+    char *msg                  = NULL;
+    hip_common_t *hip_hdr      = NULL;
+    struct timespec ts;
+
+    ts.tv_sec  = 0;
+    ts.tv_nsec =  100000000;
+
+    /* We're using system call here add thus reseting errno. */
+    errno      = 0;
+
+    msg        = (char *) malloc(hdr_size);
+    HIP_IFEL(!msg, -ENOMEM, "Error allocating memory.\n");
+
+    /* Make sure the socket does not block (bug id 806) */
+    if (timeout >= 0) {
+        flags |= MSG_DONTWAIT;
+    }
+
+    do {
+        errno         = 0;
+        nanosleep(&ts, NULL);
+        bytes         = recv(socket, msg, hdr_size, flags);
+        timeout_left -= ts.tv_nsec;
+        _HIP_DEBUG("tol=%ld, ts=%ld, bytes=%d errno=%d\n",
+                   timeout_left, ts.tv_nsec, bytes, errno);
+    } while (timeout_left > 0 && errno == EAGAIN && bytes < 0);
+
+    if (bytes < 0) {
+        HIP_ERROR("recv() peek error (is hipd running?)\n");
+        err = -EAGAIN;
+        goto out_err;
+    } else if (bytes < hdr_size) {
+        HIP_ERROR("Packet payload is smaller than HIP header. Dropping.\n");
+        /* Read and discard the datagram */
+        recv(socket, msg, 0, 0);
+        err = -bytes;
+        goto out_err;
+    }
+
+    hip_hdr = (struct hip_common *) (msg + encap_hdr_size);
+    bytes   = hip_get_msg_total_len(hip_hdr);
+
+    if (bytes == 0) {
+        HIP_ERROR("HIP message is of zero length. Dropping.\n");
+        recv(socket, msg, 0, 0);
+        err   = -EBADMSG;
+        errno = EBADMSG;
+        goto out_err;
+    }
+
+    /* The maximum possible length value is equal to HIP_MAX_PACKET.
+     * if(bytes > HIP_MAX_PACKET) {
+     *      HIP_ERROR("HIP message max length exceeded. Dropping.\n");
+     *      recv(socket, msg, 0, 0);
+     *      err = -EMSGSIZE;
+     *      errno = EMSGSIZE;
+     *      goto out_err;
+     * } */
+
+    bytes += encap_hdr_size;
+
+out_err:
+    if (msg != NULL) {
+        free(msg);
+    }
+
+    if (err) {
+        return err;
+    }
+
+    return bytes;
+}
+
+int hip_daemon_connect(int hip_user_sock)
+{
+    int err = 0;
+    struct sockaddr_in6 daemon_addr;
+    // We're using system call here add thus reseting errno.
+    errno                   = 0;
+
+    memset(&daemon_addr, 0, sizeof(daemon_addr));
+    daemon_addr.sin6_family = AF_INET6;
+    daemon_addr.sin6_port   = htons(HIP_DAEMON_LOCAL_PORT);
+    daemon_addr.sin6_addr   = in6addr_loopback;
+
+    HIP_IFEL(connect(hip_user_sock, (struct sockaddr *) &daemon_addr,
+                     sizeof(daemon_addr)), -1,
+             "connection to daemon failed\n");
+
+out_err:
+
+    return err;
+}
+
+int hip_daemon_bind_socket(int socket, struct sockaddr *sa)
+{
+    int err                   = 0, port = 0, on = 1;
+    struct sockaddr_in6 *addr = (struct sockaddr_in6 *) sa;
+
+    HIP_ASSERT(addr->sin6_family == AF_INET6);
+
+    errno = 0;
+
+    if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
+        HIP_DEBUG("Failed to set socket option SO_REUSEADDR %s \n",
+                  strerror(errno));
+    }
+
+    if (addr->sin6_port) {
+        HIP_DEBUG("Bind to fixed port %d\n", addr->sin6_port);
+        err = bind(socket, (struct sockaddr *) addr,
+                   sizeof(struct sockaddr_in6));
+        err = -errno;
+        goto out_err;
+    }
+
+    /* try to bind first to a priviledged port and then to ephemeral */
+    port = 1000;
+    while (port++ < 61000) {
+        _HIP_DEBUG("trying bind() to port %d\n", port);
+        addr->sin6_port = htons(port);
+        err             = bind(socket, (struct sockaddr *) addr,
+                               hip_sockaddr_len(addr));
+        if (err == -1) {
+            if (errno == EACCES) {
+                /* Ephemeral ports:
+                 * /proc/sys/net/ipv4/ip_local_port_range */
+                _HIP_DEBUG("Skipping to ephemeral range\n");
+                port  = 32768;
+                errno = 0;
+                err   = 0;
+            } else if (errno == EADDRINUSE) {
+                _HIP_DEBUG("Port %d in use, skip\n", port);
+                errno = 0;
+                err   = 0;
+            } else {
+                HIP_ERROR("Error %d bind() wasn't succesful\n",
+                          errno);
+                err = -1;
+                goto out_err;
+            }
+        } else {
+            _HIP_DEBUG("Bind() to port %d successful\n", port);
+            goto out_err;
+        }
+    }
+
+    if (port == 61000) {
+        HIP_ERROR("All privileged ports were occupied\n");
+        err = -1;
+    }
+
+out_err:
+    return err;
 }
 
 /* do not call this function directly, use hip_send_recv_daemon_info instead */
 int hip_sendto_hipd(int socket, struct hip_common *msg, int len)
 {
-       /* Variables. */
-       struct sockaddr_in6 sock_addr;
-       int n = -1, alen;
-
-       memset(&sock_addr, 0, sizeof(sock_addr));
-       sock_addr.sin6_family = AF_INET6;
-       sock_addr.sin6_port = htons(HIP_DAEMON_LOCAL_PORT);
-       sock_addr.sin6_addr = in6addr_loopback;
-
-       alen = sizeof(sock_addr);
-
-       HIP_DEBUG("Sending user message %d to HIPD on socket %d\n",
-                 hip_get_msg_type(msg), socket);
-
-       n = sendto(socket, msg, /*hip_get_msg_total_len(msg)*/ len, 
MSG_NOSIGNAL,
-                  (struct sockaddr *)&sock_addr, alen);
-       HIP_DEBUG("Sent %d bytes\n", n);
-
-       return n;
+    /* Variables. */
+    struct sockaddr_in6 sock_addr;
+    int n = -1, alen;
+
+    memset(&sock_addr, 0, sizeof(sock_addr));
+    sock_addr.sin6_family = AF_INET6;
+    sock_addr.sin6_port   = htons(HIP_DAEMON_LOCAL_PORT);
+    sock_addr.sin6_addr   = in6addr_loopback;
+
+    alen                  = sizeof(sock_addr);
+
+    HIP_DEBUG("Sending user message %d to HIPD on socket %d\n",
+              hip_get_msg_type(msg), socket);
+
+    n = sendto(socket, msg, /*hip_get_msg_total_len(msg)*/ len, MSG_NOSIGNAL,
+               (struct sockaddr *) &sock_addr, alen);
+    HIP_DEBUG("Sent %d bytes\n", n);
+
+    return n;
 }
 
 /*
  * Don't call this function directly. Use hip_send_recv_daemon_info instead
  */
-int hip_send_recv_daemon_info_internal(struct hip_common *msg, int opt_socket) 
{
-
-       int hip_user_sock = 0, err = 0, n = 0, len = 0;
-       struct sockaddr_in6 addr;
-       uint8_t msg_type_old, msg_type_new;
-       
-       msg_type_old = hip_get_msg_type(msg);
-
-       // We're using system call here and thus reseting errno.
-       errno = 0;
-
-       if (opt_socket) {
-               hip_user_sock = opt_socket;
-       } else {
-               HIP_IFE(((hip_user_sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 
0), EHIP);
-
-               memset(&addr, 0, sizeof(addr));
-               addr.sin6_family = AF_INET6;
-               addr.sin6_addr = in6addr_loopback;
-
-               HIP_IFEL(hip_daemon_bind_socket(hip_user_sock,
-                                               (struct sockaddr *) &addr), -1,
-                        "bind failed\n");
-               /* Connect to hipd. Otherwise e.g. "hipconf get ha all"
-                  blocks when hipd is not running. */
-               HIP_IFEL(hip_daemon_connect(hip_user_sock), -1,
-                        "connect failed\n");
-       }
-
-       if ((len = hip_get_msg_total_len(msg)) < 0) {
-               err = -EBADMSG;
-               goto out_err;
-       }
-
-       /* Require a response from hipd */
-       hip_set_msg_response(msg, 1);
-
-       n = hip_sendto_hipd(hip_user_sock, msg, len);
-       if (n < len) {
-               HIP_ERROR("Could not send message to daemon.\n");
-               err = -ECOMM;
-               goto out_err;
-       }
-
-       HIP_DEBUG("Waiting to receive daemon info.\n");
-
-       if((len = hip_peek_recv_total_len(hip_user_sock, 0, 
HIP_DEFAULT_MSG_TIMEOUT)) < 0) {
-               err = len;
-               goto out_err;
-       }
-
-       n = recv(hip_user_sock, msg, len, 0);
-
-       /* You have a message synchronization problem if you see this error. */
-       msg_type_new = hip_get_msg_type(msg);
-       HIP_IFEL((msg_type_new != msg_type_old), -1,
-                "Message sync problem. Expected %d, got %d\n",
-                msg_type_old, msg_type_new);
-
-       HIP_DEBUG("%d bytes received from HIP daemon\n", n);
-
-       if (n == 0) {
-               HIP_INFO("The HIP daemon has performed an "\
-                        "orderly shutdown.\n");
-               // Note. This is not an error condition, thus we return zero.
-               goto out_err;
-       } else if(n < sizeof(struct hip_common)) {
-               HIP_ERROR("Could not receive message from daemon.\n");
-               goto out_err;
-       }
-
-       if (hip_get_msg_err(msg)) {
-               HIP_ERROR("HIP message contained an error.\n");
-               err = -EHIP;
-       }
-
-       _HIP_DEBUG("Message received successfully\n");
-
- out_err:
-
-       if (!opt_socket && hip_user_sock)
-               close(hip_user_sock);
-
-       return err;
-}
-
-int hip_send_recv_daemon_info(struct hip_common *msg, int send_only, int 
opt_socket) {
-       int hip_user_sock = 0, err = 0, n, len;
-       struct sockaddr_in6 addr;
-
-       if (!send_only)
-               return hip_send_recv_daemon_info_internal(msg, opt_socket);
-
-       if (opt_socket) {
-               hip_user_sock = opt_socket;
-       } else {
-               HIP_IFE(((hip_user_sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 
0), -1);
-               memset(&addr, 0, sizeof(addr));
-               addr.sin6_family = AF_INET6;
-               addr.sin6_addr = in6addr_loopback;
-               
-               HIP_IFEL(hip_daemon_bind_socket(hip_user_sock,
-                                               (struct sockaddr *) &addr), -1,
-                        "bind failed\n");
-               HIP_IFEL(hip_daemon_connect(hip_user_sock), -1,
-                        "connect failed\n");
-       }
-
-       len = hip_get_msg_total_len(msg);
-       n = send(hip_user_sock, msg, len, 0);
-
-       if (n < len) {
-               HIP_ERROR("Could not send message to daemon.\n");
-               err = -1;
-               goto out_err;
-       }
-
- out_err:
-       if (!opt_socket && hip_user_sock)
-               close(hip_user_sock);
-
-       return err;
-}
-
-int hip_recv_daemon_info(struct hip_common *msg, uint16_t info_type) {
-       /** @todo required by the native HIP API */
-       /* Call first send_daemon_info with info_type and then recvfrom */
-       return -1;
+int hip_send_recv_daemon_info_internal(struct hip_common *msg, int opt_socket)
+{
+    int hip_user_sock = 0, err = 0, n = 0, len = 0;
+    struct sockaddr_in6 addr;
+    uint8_t msg_type_old, msg_type_new;
+
+    msg_type_old = hip_get_msg_type(msg);
+
+    // We're using system call here and thus reseting errno.
+    errno        = 0;
+
+    if (opt_socket) {
+        hip_user_sock = opt_socket;
+    } else {
+        HIP_IFE(((hip_user_sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0), EHIP);
+
+        memset(&addr, 0, sizeof(addr));
+        addr.sin6_family = AF_INET6;
+        addr.sin6_addr   = in6addr_loopback;
+
+        HIP_IFEL(hip_daemon_bind_socket(hip_user_sock,
+                                        (struct sockaddr *) &addr), -1,
+                 "bind failed\n");
+        /* Connect to hipd. Otherwise e.g. "hipconf get ha all"
+         * blocks when hipd is not running. */
+        HIP_IFEL(hip_daemon_connect(hip_user_sock), -1,
+                 "connect failed\n");
+    }
+
+    if ((len = hip_get_msg_total_len(msg)) < 0) {
+        err = -EBADMSG;
+        goto out_err;
+    }
+
+    /* Require a response from hipd */
+    hip_set_msg_response(msg, 1);
+
+    n = hip_sendto_hipd(hip_user_sock, msg, len);
+    if (n < len) {
+        HIP_ERROR("Could not send message to daemon.\n");
+        err = -ECOMM;
+        goto out_err;
+    }
+
+    HIP_DEBUG("Waiting to receive daemon info.\n");
+
+    if ((len = hip_peek_recv_total_len(hip_user_sock, 0, 
HIP_DEFAULT_MSG_TIMEOUT)) < 0) {
+        err = len;
+        goto out_err;
+    }
+
+    n = recv(hip_user_sock, msg, len, 0);
+
+    /* You have a message synchronization problem if you see this error. */
+    msg_type_new = hip_get_msg_type(msg);
+    HIP_IFEL((msg_type_new != msg_type_old), -1,
+             "Message sync problem. Expected %d, got %d\n",
+             msg_type_old, msg_type_new);
+
+    HIP_DEBUG("%d bytes received from HIP daemon\n", n);
+
+    if (n == 0) {
+        HIP_INFO("The HIP daemon has performed an " \
+                 "orderly shutdown.\n");
+        // Note. This is not an error condition, thus we return zero.
+        goto out_err;
+    } else if (n < sizeof(struct hip_common)) {
+        HIP_ERROR("Could not receive message from daemon.\n");
+        goto out_err;
+    }
+
+    if (hip_get_msg_err(msg)) {
+        HIP_ERROR("HIP message contained an error.\n");
+        err = -EHIP;
+    }
+
+    _HIP_DEBUG("Message received successfully\n");
+
+out_err:
+
+    if (!opt_socket && hip_user_sock) {
+        close(hip_user_sock);
+    }
+
+    return err;
+}
+
+int hip_send_recv_daemon_info(struct hip_common *msg,
+                              int send_only,
+                              int opt_socket)
+{
+    int hip_user_sock = 0, err = 0, n, len;
+    struct sockaddr_in6 addr;
+
+    if (!send_only) {
+        return hip_send_recv_daemon_info_internal(msg, opt_socket);
+    }
+
+    if (opt_socket) {
+        hip_user_sock = opt_socket;
+    } else {
+        HIP_IFE(((hip_user_sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0), -1);
+        memset(&addr, 0, sizeof(addr));
+        addr.sin6_family = AF_INET6;
+        addr.sin6_addr   = in6addr_loopback;
+
+        HIP_IFEL(hip_daemon_bind_socket(hip_user_sock,
+                                        (struct sockaddr *) &addr), -1,
+                 "bind failed\n");
+        HIP_IFEL(hip_daemon_connect(hip_user_sock), -1,
+                 "connect failed\n");
+    }
+
+    len = hip_get_msg_total_len(msg);
+    n   = send(hip_user_sock, msg, len, 0);
+
+    if (n < len) {
+        HIP_ERROR("Could not send message to daemon.\n");
+        err = -1;
+        goto out_err;
+    }
+
+out_err:
+    if (!opt_socket && hip_user_sock) {
+        close(hip_user_sock);
+    }
+
+    return err;
+}
+
+int hip_recv_daemon_info(struct hip_common *msg, uint16_t info_type)
+{
+    /** @todo required by the native HIP API */
+    /* Call first send_daemon_info with info_type and then recvfrom */
+    return -1;
 }
 
 int hip_read_user_control_msg(int socket, struct hip_common *hip_msg,
-                             struct sockaddr_in6 *saddr)
+                              struct sockaddr_in6 *saddr)
 {
-       int err = 0, bytes = 0, total;
-       socklen_t len;
-
-       memset(saddr, 0, sizeof(*saddr));
-
-       len = sizeof(*saddr);
-
-       HIP_IFEL(((total = hip_peek_recv_total_len(socket, 0, 
HIP_DEFAULT_MSG_TIMEOUT)) <= 0), -1,
-                "recv peek failed\n");
-
-       _HIP_DEBUG("msg total length = %d\n", total);
-
-       /** @todo Compiler warning;
-           warning: pointer targets in passing argument 6 of 'recvfrom'
-           differ in signedness. */
-       HIP_IFEL(((bytes = recvfrom(socket, hip_msg, total, 0,
-                                   (struct sockaddr *) saddr,
-                                   &len)) != total), -1, "recv\n");
-
-       HIP_DEBUG("received user message from local port %d\n",
-                  ntohs(saddr->sin6_port));
-       _HIP_DEBUG("read_user_control_msg recv len=%d\n", len);
-       _HIP_HEXDUMP("recv saddr ", saddr, sizeof(struct sockaddr_un));
-       _HIP_DEBUG("read %d bytes succesfully\n", bytes);
- out_err:
-       if (bytes < 0 || err)
-               HIP_PERROR("perror: ");
-
-       return err;
+    int err = 0, bytes = 0, total;
+    socklen_t len;
+
+    memset(saddr, 0, sizeof(*saddr));
+
+    len = sizeof(*saddr);
+
+    HIP_IFEL(((total = hip_peek_recv_total_len(socket, 0, 
HIP_DEFAULT_MSG_TIMEOUT)) <= 0),
+             -1,
+             "recv peek failed\n");
+
+    _HIP_DEBUG("msg total length = %d\n", total);
+
+    /** @todo Compiler warning;
+     *  warning: pointer targets in passing argument 6 of 'recvfrom'
+     *  differ in signedness. */
+    HIP_IFEL(((bytes = recvfrom(socket, hip_msg, total, 0,
+                                (struct sockaddr *) saddr,
+                                &len)) != total), -1, "recv\n");
+
+    HIP_DEBUG("received user message from local port %d\n",
+              ntohs(saddr->sin6_port));
+    _HIP_DEBUG("read_user_control_msg recv len=%d\n", len);
+    _HIP_HEXDUMP("recv saddr ", saddr, sizeof(struct sockaddr_un));
+    _HIP_DEBUG("read %d bytes succesfully\n", bytes);
+out_err:
+    if (bytes < 0 || err) {
+        HIP_PERROR("perror: ");
+    }
+
+    return err;
 }
 
 /* Moved function doxy descriptor to the header file. Lauri 11.03.2008 */
@@ -376,169 +392,174 @@
                              hip_portpair_t *msg_info,
                              int encap_hdr_size, int is_ipv4)
 {
-       struct sockaddr_storage addr_from, addr_to;
-       struct sockaddr_in *addr_from4 = ((struct sockaddr_in *) &addr_from);
-       struct sockaddr_in6 *addr_from6 =
-               ((struct sockaddr_in6 *) &addr_from);
-        struct cmsghdr *cmsg;
-        struct msghdr msg;
-       union {
-               struct in_pktinfo *pktinfo_in4;
-               struct inet6_pktinfo *pktinfo_in6;
-       } pktinfo;
-        struct iovec iov;
-        char cbuff[CMSG_SPACE(256)];
-        int err = 0, len;
-       int cmsg_level, cmsg_type;
-
-       HIP_ASSERT(saddr);
-       HIP_ASSERT(daddr);
-
-       HIP_DEBUG("hip_read_control_msg_all() invoked.\n");
-
-       HIP_IFEL(((len = hip_peek_recv_total_len(socket, encap_hdr_size, 
HIP_DEFAULT_MSG_TIMEOUT))<= 0),
-                -1, "Bad packet length (%d)\n", len);
-
-       memset(msg_info, 0, sizeof(hip_portpair_t));
-       memset(&msg, 0, sizeof(msg));
-       memset(cbuff, 0, sizeof(cbuff));
-       memset(&addr_to, 0, sizeof(addr_to));
-
-        /* setup message header with control and receive buffers */
-        msg.msg_name = &addr_from;
-        msg.msg_namelen = sizeof(struct sockaddr_storage);
-        msg.msg_iov = &iov;
-        msg.msg_iovlen = 1;
-
-        memset(cbuff, 0, sizeof(cbuff));
-        msg.msg_control = cbuff;
-        msg.msg_controllen = sizeof(cbuff);
-        msg.msg_flags = 0;
-
-        iov.iov_len = len;
-        iov.iov_base = hip_msg;
-
-       pktinfo.pktinfo_in4 = NULL;
-
-       len = recvmsg(socket, &msg, 0);
-
-       HIP_IFEL((len < 0), -1, "ICMP%s error: errno=%d, %s\n",
-                (is_ipv4 ? "v4" : "v6"), errno, strerror(errno));
-
-       cmsg_level = (is_ipv4) ? IPPROTO_IP : IPPROTO_IPV6;
-       cmsg_type = (is_ipv4) ? IP_PKTINFO : IPV6_2292PKTINFO;
-
-       /* destination address comes from ancillary data passed
-        * with msg due to IPV6_PKTINFO socket option */
-       for (cmsg=CMSG_FIRSTHDR(&msg); cmsg; cmsg=CMSG_NXTHDR(&msg,cmsg)){
-               if ((cmsg->cmsg_level == cmsg_level) &&
-                   (cmsg->cmsg_type == cmsg_type)) {
-                       /* The structure is a union, so this fills also the
-                          pktinfo_in6 pointer */
-                       pktinfo.pktinfo_in4 =
-                               (struct in_pktinfo*)CMSG_DATA(cmsg);
-                       break;
-               }
-       }
-
-       /* If this fails, change IPV6_2292PKTINFO to IPV6_PKTINFO in
-          hip_init_raw_sock_v6 */
-       HIP_IFEL(!pktinfo.pktinfo_in4, -1,
-                "Could not determine dst addr, dropping\n");
-
-       /* UDP port numbers */
-       if (is_ipv4 && encap_hdr_size == HIP_UDP_ZERO_BYTES_LEN) {
-               HIP_DEBUG("hip_read_control_msg_all() source port = %d\n",
-                         ntohs(addr_from4->sin_port));
-               msg_info->src_port = ntohs(addr_from4->sin_port);
-               /* Destination port is known from the bound socket. */
-               msg_info->dst_port = hip_get_local_nat_udp_port();
-       }
-
-       /* IPv4 addresses */
-       if (is_ipv4) {
-               struct sockaddr_in *addr_to4 = (struct sockaddr_in *) &addr_to;
-               IPV4_TO_IPV6_MAP(&addr_from4->sin_addr, saddr);
-               IPV4_TO_IPV6_MAP(&pktinfo.pktinfo_in4->ipi_addr,
-                                daddr);
-               addr_to4->sin_family = AF_INET;
-               addr_to4->sin_addr = pktinfo.pktinfo_in4->ipi_addr;
-               addr_to4->sin_port = msg_info->dst_port;
-       } else /* IPv6 addresses */ {
-               struct sockaddr_in6 *addr_to6 =
-                       (struct sockaddr_in6 *) &addr_to;
-               memcpy(saddr, &addr_from6->sin6_addr,
-                      sizeof(struct in6_addr));
-               memcpy(daddr, &pktinfo.pktinfo_in6->ipi6_addr,
-                      sizeof(struct in6_addr));
-               addr_to6->sin6_family = AF_INET6;
-               ipv6_addr_copy(&addr_to6->sin6_addr, daddr);
-       }
+    struct sockaddr_storage addr_from, addr_to;
+    struct sockaddr_in *addr_from4  = ((struct sockaddr_in *) &addr_from);
+    struct sockaddr_in6 *addr_from6 = ((struct sockaddr_in6 *) &addr_from);
+    struct cmsghdr *cmsg = NULL;
+    struct msghdr msg;
+    union {
+        struct in_pktinfo *   pktinfo_in4;
+        struct inet6_pktinfo *pktinfo_in6;
+    } pktinfo;
+    struct iovec iov;
+    char cbuff[CMSG_SPACE(256)];
+    int err = 0, len;
+    int cmsg_level, cmsg_type;
+
+    HIP_ASSERT(saddr);
+    HIP_ASSERT(daddr);
+
+    HIP_DEBUG("hip_read_control_msg_all() invoked.\n");
+
+    HIP_IFEL(((len = hip_peek_recv_total_len(socket, encap_hdr_size, 
HIP_DEFAULT_MSG_TIMEOUT)) <= 0),
+             -1, "Bad packet length (%d)\n", len);
+
+    memset(msg_info, 0, sizeof(hip_portpair_t));
+    memset(&msg, 0, sizeof(msg));
+    memset(cbuff, 0, sizeof(cbuff));
+    memset(&addr_to, 0, sizeof(addr_to));
+
+    /* setup message header with control and receive buffers */
+    msg.msg_name        = &addr_from;
+    msg.msg_namelen     = sizeof(struct sockaddr_storage);
+    msg.msg_iov         = &iov;
+    msg.msg_iovlen      = 1;
+
+    memset(cbuff, 0, sizeof(cbuff));
+    msg.msg_control     = cbuff;
+    msg.msg_controllen  = sizeof(cbuff);
+    msg.msg_flags       = 0;
+
+    iov.iov_len         = len;
+    iov.iov_base        = hip_msg;
+
+    pktinfo.pktinfo_in4 = NULL;
+
+    len                 = recvmsg(socket, &msg, 0);
+
+    HIP_IFEL((len < 0), -1, "ICMP%s error: errno=%d, %s\n",
+             (is_ipv4 ? "v4" : "v6"), errno, strerror(errno));
+
+    cmsg_level = (is_ipv4) ? IPPROTO_IP : IPPROTO_IPV6;
+    cmsg_type  = (is_ipv4) ? IP_PKTINFO : IPV6_2292PKTINFO;
+
+    /* destination address comes from ancillary data passed
+     * with msg due to IPV6_PKTINFO socket option */
+    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+        if ((cmsg->cmsg_level == cmsg_level) &&
+            (cmsg->cmsg_type == cmsg_type)) {
+            /* The structure is a union, so this fills also the
+             * pktinfo_in6 pointer */
+            pktinfo.pktinfo_in4 =
+                (struct in_pktinfo *) CMSG_DATA(cmsg);
+            break;
+        }
+    }
+
+    /* If this fails, change IPV6_2292PKTINFO to IPV6_PKTINFO in
+     * hip_init_raw_sock_v6 */
+    HIP_IFEL(!pktinfo.pktinfo_in4, -1,
+             "Could not determine dst addr, dropping\n");
+
+    /* UDP port numbers */
+    if (is_ipv4 && encap_hdr_size == HIP_UDP_ZERO_BYTES_LEN) {
+        HIP_DEBUG("hip_read_control_msg_all() source port = %d\n",
+                  ntohs(addr_from4->sin_port));
+        msg_info->src_port = ntohs(addr_from4->sin_port);
+        /* Destination port is known from the bound socket. */
+        msg_info->dst_port = hip_get_local_nat_udp_port();
+    }
+
+    /* IPv4 addresses */
+    if (is_ipv4) {
+        struct sockaddr_in *addr_to4 = (struct sockaddr_in *) &addr_to;
+        IPV4_TO_IPV6_MAP(&addr_from4->sin_addr, saddr);
+        IPV4_TO_IPV6_MAP(&pktinfo.pktinfo_in4->ipi_addr,
+                         daddr);
+        addr_to4->sin_family = AF_INET;
+        addr_to4->sin_addr   = pktinfo.pktinfo_in4->ipi_addr;
+        addr_to4->sin_port   = msg_info->dst_port;
+    } else {   /* IPv6 addresses */
+        struct sockaddr_in6 *addr_to6 =
+            (struct sockaddr_in6 *) &addr_to;
+        memcpy(saddr, &addr_from6->sin6_addr,
+               sizeof(struct in6_addr));
+        memcpy(daddr, &pktinfo.pktinfo_in6->ipi6_addr,
+               sizeof(struct in6_addr));
+        addr_to6->sin6_family = AF_INET6;
+        ipv6_addr_copy(&addr_to6->sin6_addr, daddr);
+    }
 
 //added by santtu
-       if (hip_read_control_msg_plugin_handler(hip_msg,len, 
saddr,msg_info->src_port))
-               goto out_err;
+    if (hip_read_control_msg_plugin_handler(hip_msg, len, saddr, 
msg_info->src_port)) {
+        goto out_err;
+    }
 //endadd
 
-       if (is_ipv4 && (encap_hdr_size == IPV4_HDR_SIZE)) {/* raw IPv4, !UDP */
-               /* For some reason, the IPv4 header is always included.
-                  Let's remove it here. */
-               memmove(hip_msg, ((char *)hip_msg) + IPV4_HDR_SIZE,
-                       HIP_MAX_PACKET - IPV4_HDR_SIZE);
-       } else if (is_ipv4 && encap_hdr_size == HIP_UDP_ZERO_BYTES_LEN) {
-               /* remove 32-bits of zeroes between UDP and HIP headers */
-               memmove(hip_msg, ((char *)hip_msg) + HIP_UDP_ZERO_BYTES_LEN,
-                       HIP_MAX_PACKET - HIP_UDP_ZERO_BYTES_LEN);
-       }
-
-       HIP_IFEL(hip_verify_network_header(hip_msg,
-                                          (struct sockaddr *) &addr_from,
-                                          (struct sockaddr *) &addr_to,
-                                          len - encap_hdr_size), -1,
-                "verifying network header failed\n");
-
-
-
-       if (saddr)
-               HIP_DEBUG_IN6ADDR("src", saddr);
-       if (daddr)
-               HIP_DEBUG_IN6ADDR("dst", daddr);
-
- out_err:
-       return err;
+    if (is_ipv4 && (encap_hdr_size == IPV4_HDR_SIZE)) {    /* raw IPv4, !UDP */
+        /* For some reason, the IPv4 header is always included.
+         * Let's remove it here. */
+        memmove(hip_msg, ((char *) hip_msg) + IPV4_HDR_SIZE,
+                HIP_MAX_PACKET - IPV4_HDR_SIZE);
+    } else if (is_ipv4 && encap_hdr_size == HIP_UDP_ZERO_BYTES_LEN) {
+        /* remove 32-bits of zeroes between UDP and HIP headers */
+        memmove(hip_msg, ((char *) hip_msg) + HIP_UDP_ZERO_BYTES_LEN,
+                HIP_MAX_PACKET - HIP_UDP_ZERO_BYTES_LEN);
+    }
+
+    HIP_IFEL(hip_verify_network_header(hip_msg,
+                                       (struct sockaddr *) &addr_from,
+                                       (struct sockaddr *) &addr_to,
+                                       len - encap_hdr_size), -1,
+             "verifying network header failed\n");
+
+
+
+    if (saddr) {
+        HIP_DEBUG_IN6ADDR("src", saddr);
+    }
+    if (daddr) {
+        HIP_DEBUG_IN6ADDR("dst", daddr);
+    }
+
+out_err:
+    return err;
 }
 
 int hip_read_control_msg_v6(int socket, struct hip_common *hip_msg,
-                           struct in6_addr *saddr,
-                           struct in6_addr *daddr,
+                            struct in6_addr *saddr,
+                            struct in6_addr *daddr,
                             hip_portpair_t *msg_info,
                             int encap_hdr_size)
 {
-       return hip_read_control_msg_all(socket, hip_msg, saddr,
-                                       daddr, msg_info, encap_hdr_size, 0);
+    return hip_read_control_msg_all(socket, hip_msg, saddr,
+                                    daddr, msg_info, encap_hdr_size, 0);
 }
 
 int hip_read_control_msg_v4(int socket, struct hip_common *hip_msg,
-                           struct in6_addr *saddr,
-                           struct in6_addr *daddr,
-                           hip_portpair_t *msg_info,
-                           int encap_hdr_size)
+                            struct in6_addr *saddr,
+                            struct in6_addr *daddr,
+                            hip_portpair_t *msg_info,
+                            int encap_hdr_size)
 {
-       return hip_read_control_msg_all(socket, hip_msg, saddr,
-                                       daddr, msg_info, encap_hdr_size, 1);
+    return hip_read_control_msg_all(socket, hip_msg, saddr,
+                                    daddr, msg_info, encap_hdr_size, 1);
 }
 
 /* TODO Can this function be removed? */
-int hip_read_control_msg_plugin_handler(void* msg, int len, in6_addr_t * 
src_addr,in_port_t port)
+int hip_read_control_msg_plugin_handler(void *msg,
+                                        int len,
+                                        in6_addr_t *src_addr,
+                                        in_port_t port)
 {
-       int err = 0;
+    int err = 0;
 #if 0
-       //handle stun msg
-       if (hip_external_ice_receive_pkt_all(msg, len, src_addr,port)) {
-               err = 1;
-               goto out_err;
-       }
+    //handle stun msg
+    if (hip_external_ice_receive_pkt_all(msg, len, src_addr, port)) {
+        err = 1;
+        goto out_err;
+    }
 out_err:
 #endif
-       return err;
+    return err;
 }

=== modified file 'lib/core/message.c.doxyme'
--- lib/core/message.c.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/message.c.doxyme   2010-02-10 23:55:24 +0000
@@ -14,20 +14,20 @@
 
 
 
- ///  Single line comment for dOxygen.
+///  Single line comment for dOxygen.
 
 /**
  * my_great_function
  *
  * Write description of function here.
  * The function should follow these comments.
- * 
+ *
  * Document the use of each function variable and indicate if this
  * argument is used to return information to the calling context. Use
- * [out] for outut parameters (This is very important). Align the 
+ * [out] for outut parameters (This is very important). Align the
  * descriptions to improve readability.
  *
- *  @note: put important usage informations to notes. 
+ *  @note: put important usage informations to notes.
  *
  *  @param      firstArg     Description of first function argument.
  *  @param[out] secondArg    Description of second function argument.
@@ -35,7 +35,8 @@
  *  @return Description of returned value.
  **/
 
-int my_great_function(int firstArg, char** secondArg, int thirdArg){
+int my_great_function(int firstArg, char **secondArg, int thirdArg)
+{
     .....
 
 /// Now it's your turn.
@@ -44,37 +45,37 @@
 
 
 /**
- * hip_daemon_bind_socket 
+ * hip_daemon_bind_socket
  *
  *
  * @param socket
  * @param sa
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_daemon_connect 
+ * hip_daemon_connect
  *
  *
  * @param hip_user_sock
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_peek_recv_total_len 
+ * hip_peek_recv_total_len
  *
  *
  * @param socket
  * @param encap_hdr_size
  * @param timeout
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_read_control_msg_all 
+ * hip_read_control_msg_all
  *
  *
  * @param socket
@@ -84,98 +85,97 @@
  * @param msg_info
  * @param encap_hdr_size
  * @param is_ipv4
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_read_control_msg_plugin_handler 
+ * hip_read_control_msg_plugin_handler
  *
  *
  * @param msg
  * @param len
  * @param autogen.sh
- * @return 
- **/
-
-
-/**
- * hip_read_control_msg_v4 
- *
- *
- * @param socket
- * @param hip_msg
- * @param saddr
- * @param daddr
- * @param msg_info
- * @param encap_hdr_size
- * @return 
- **/
-
-
-/**
- * hip_read_control_msg_v6 
- *
- *
- * @param socket
- * @param hip_msg
- * @param saddr
- * @param daddr
- * @param msg_info
- * @param encap_hdr_size
- * @return 
- **/
-
-
-/**
- * hip_read_user_control_msg 
- *
- *
- * @param socket
- * @param hip_msg
- * @param saddr
- * @return 
- **/
-
-
-/**
- * hip_recv_daemon_info 
+ * @return
+ **/
+
+
+/**
+ * hip_read_control_msg_v4
+ *
+ *
+ * @param socket
+ * @param hip_msg
+ * @param saddr
+ * @param daddr
+ * @param msg_info
+ * @param encap_hdr_size
+ * @return
+ **/
+
+
+/**
+ * hip_read_control_msg_v6
+ *
+ *
+ * @param socket
+ * @param hip_msg
+ * @param saddr
+ * @param daddr
+ * @param msg_info
+ * @param encap_hdr_size
+ * @return
+ **/
+
+
+/**
+ * hip_read_user_control_msg
+ *
+ *
+ * @param socket
+ * @param hip_msg
+ * @param saddr
+ * @return
+ **/
+
+
+/**
+ * hip_recv_daemon_info
  *
  *
  * @param msg
  * @param info_type
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_send_recv_daemon_info 
+ * hip_send_recv_daemon_info
  *
  *
  * @param msg
  * @param send_only
  * @param opt_socket
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_send_recv_daemon_info_internal 
+ * hip_send_recv_daemon_info_internal
  *
  *
  * @param msg
  * @param opt_socket
- * @return 
+ * @return
  **/
 
 
 /**
- * hip_sendto_hipd 
+ * hip_sendto_hipd
  *
  *
  * @param socket
  * @param msg
  * @param len
- * @return 
+ * @return
  **/
-

=== modified file 'lib/core/message.h'
--- lib/core/message.h  2010-01-19 11:26:32 +0000
+++ lib/core/message.h  2010-02-10 23:55:24 +0000
@@ -1,6 +1,6 @@
 /** @file
  * A header file for message.c.
- * 
+ *
  * @author  Miika Komu <miika_iki.fi>
  * @author  Bing Zhou <bingzhou_cc.hut.fi>
  * @version 1.0
@@ -32,8 +32,8 @@
  *
  * @param  socket         a socket file descriptor.
  * @param  encap_hdr_size .
- * @return 
- */ 
+ * @return
+ */
 int hip_peek_recv_total_len(int socket, int encap_hdr_size, unsigned long 
timeout);
 
 /**
@@ -61,7 +61,7 @@
 /**
  * .
  *
- * @param  msg       a pointer to a HIP message. 
+ * @param  msg       a pointer to a HIP message.
  * @param  only_send .
  * @return           .
  */
@@ -70,7 +70,7 @@
 /**
  * .
  *
- * @param  msg       a pointer to a HIP message. 
+ * @param  msg       a pointer to a HIP message.
  * @param  info_type .
  * @return           .
  */
@@ -80,18 +80,19 @@
  * .
  *
  * @param  socket  a socket file descriptor.
- * @param  hip_msg a pointer to a HIP message. 
+ * @param  hip_msg a pointer to a HIP message.
  * @param  saddr   a pointer to an IPv6 source address socket
  *                 structure.
  * @return           .
  */
-int hip_read_user_control_msg(int socket, struct hip_common *hip_msg,
-                             struct sockaddr_in6 *saddr);
+int hip_read_user_control_msg(int socket,
+                              struct hip_common *hip_msg,
+                              struct sockaddr_in6 *saddr);
 
 
 /**
  * Prepares a @c hip_common struct based on information received from a socket.
- * 
+ *
  * Prepares a @c hip_common struct, allocates memory for buffers and nested
  * structs. Receives a message from socket and fills the @c hip_common struct
  * with the values from this message.
@@ -108,56 +109,63 @@
  * @param daddr          a pointer to a buffer where to put the destination IP
  *                       address of the received message (if @c read_addr is 
set
  *                       to 1).
- * @param msg_info       a pointer to a buffer where to put the source and 
+ * @param msg_info       a pointer to a buffer where to put the source and
  *                       destination ports of the received message.
  * @param encap_hdr_size size of encapsulated header in bytes.
  * @param is_ipv4        a boolean value to indicate whether message is 
received
  *                       on IPv4.
  * @return               -1 in case of an error, 0 otherwise.
  */
-int hip_read_control_msg_all(int socket, struct hip_common *hip_msg,
+int hip_read_control_msg_all(int socket,
+                             struct hip_common *hip_msg,
                              struct in6_addr *saddr,
                              struct in6_addr *daddr,
                              hip_portpair_t *msg_info,
-                             int encap_hdr_size, int is_ipv4
-                                                       );
+                             int encap_hdr_size,
+                             int is_ipv4);
 
 /**
  * Reads an IPv6 control message.
  *
  * @param  socket         a socket file descriptor.
- * @param  hip_msg        a pointer to a HIP message. 
+ * @param  hip_msg        a pointer to a HIP message.
  * @param  saddr          source IPv6 address.
  * @param  daddr          destination IPv6 address.
  * @param  msg_info       transport layer source and destination port numbers.
  * @param  encap_hdr_size .
  * @return                .
  */
-int hip_read_control_msg_v6(int socket, struct hip_common *hip_msg,
-                           struct in6_addr *saddr,
-                           struct in6_addr *daddr,
+int hip_read_control_msg_v6(int socket,
+                            struct hip_common *hip_msg,
+                            struct in6_addr *saddr,
+                            struct in6_addr *daddr,
                             hip_portpair_t *msg_info,
                             int encap_hdr_size);
 /**
  * Reads an IPv4 control message.
  *
  * @param  socket         a socket file descriptor.
- * @param  hip_msg        a pointer to a HIP message. 
+ * @param  hip_msg        a pointer to a HIP message.
  * @param  saddr          source IPv4 address.
  * @param  daddr          destination IPv4 address.
  * @param  msg_info       transport layer source and destination port numbers.
  * @param  encap_hdr_size .
  * @return                .
  */
-int hip_read_control_msg_v4(int socket, struct hip_common *hip_msg,
-                           struct in6_addr *saddr,
-                           struct in6_addr *daddr,
-                           hip_portpair_t *msg_info,
-                           int encap_hdr_size);
-
-int hip_sendto(int sock, const struct hip_common *msg,
-              const struct sockaddr_in6 *dst);
-
-int hip_read_control_msg_plugin_handler(void* msg, int len, in6_addr_t * 
src_addr,in_port_t port);
+int hip_read_control_msg_v4(int socket,
+                            struct hip_common *hip_msg,
+                            struct in6_addr *saddr,
+                            struct in6_addr *daddr,
+                            hip_portpair_t *msg_info,
+                            int encap_hdr_size);
+
+int hip_sendto(int sock,
+               const struct hip_common *msg,
+               const struct sockaddr_in6 *dst);
+
+int hip_read_control_msg_plugin_handler(void *msg,
+                                        int len,
+                                        in6_addr_t *src_addr,
+                                        in_port_t port);
 
 #endif /* HIP_MESSAGE_H */

=== modified file 'lib/core/message.h.doxyme'
--- lib/core/message.h.doxyme   2010-01-19 09:28:42 +0000
+++ lib/core/message.h.doxyme   2010-02-10 23:55:24 +0000
@@ -1,8 +1,8 @@
 /**
  * @file ./libhipcore/message.h
- * 
+ *
  *  <LICENSE TEMLPATE LINE - LEAVE THIS LINE INTACT>
- * 
+ *
  * Write description of header file here for dOxygen. Be as precise as 
possible.
  * Please also note how and by which parts of the code this file should be 
used.
  *

=== modified file 'lib/core/misc.c'
--- lib/core/misc.c     2010-02-08 21:28:25 +0000
+++ lib/core/misc.c     2010-02-10 23:55:24 +0000
@@ -18,7 +18,7 @@
 
 // needed due to missing system inlcude for openWRT
 #ifndef HOST_NAME_MAX
-#define HOST_NAME_MAX          64
+#define HOST_NAME_MAX           64
 #endif
 
 /* Definitions */
@@ -29,7 +29,7 @@
 
 /** Port numbers for NAT traversal of hip control packets. */
 in_port_t hip_local_nat_udp_port = HIP_NAT_UDP_PORT;
-in_port_t hip_peer_nat_udp_port = HIP_NAT_UDP_PORT;
+in_port_t hip_peer_nat_udp_port  = HIP_NAT_UDP_PORT;
 
 #ifdef CONFIG_HIP_OPPORTUNISTIC
 /**
@@ -43,32 +43,35 @@
  * href="http://hipl.hiit.fi/hipl/thesis_teresa_finez.pdf";>T. Finez,
  * Backwards Compatibility Experimentation with Host Identity Protocol
  * and Legacy Software and Networks , final project, December 2008</a>
-
+ *
  */
 int hip_opportunistic_ipv6_to_hit(const struct in6_addr *ip,
-                                 struct in6_addr *hit,
-                                 int hit_type){
-  int err = 0;
-  u8 digest[HIP_AH_SHA_LEN];
-  char *key = (char *) (ip);
-  unsigned int key_len = sizeof(struct in6_addr);
-
-  HIP_IFE(hit_type != HIP_HIT_TYPE_HASH100, -ENOSYS);
-  _HIP_HEXDUMP("key", key, key_len);
-  HIP_IFEL((err = hip_build_digest(HIP_DIGEST_SHA1, key, key_len, digest)), 
err,
-          "Building of digest failed\n");
-
-  memcpy(hit, digest + (HIP_AH_SHA_LEN - sizeof(struct in6_addr)),
-        sizeof(struct in6_addr));
-
-  hit->s6_addr32[3] = 0; // this separates phit from normal hit
-
-  set_hit_prefix(hit);
-
- out_err:
-
-       return err;
+                                  struct in6_addr *hit,
+                                  int hit_type)
+{
+    int err              = 0;
+    u8 digest[HIP_AH_SHA_LEN];
+    char *key            = (char *) (ip);
+    unsigned int key_len = sizeof(struct in6_addr);
+
+    HIP_IFE(hit_type != HIP_HIT_TYPE_HASH100, -ENOSYS);
+    _HIP_HEXDUMP("key", key, key_len);
+    HIP_IFEL((err = hip_build_digest(HIP_DIGEST_SHA1, key, key_len, digest)),
+             err,
+             "Building of digest failed\n");
+
+    memcpy(hit, digest + (HIP_AH_SHA_LEN - sizeof(struct in6_addr)),
+           sizeof(struct in6_addr));
+
+    hit->s6_addr32[3] = 0; // this separates phit from normal hit
+
+    set_hit_prefix(hit);
+
+out_err:
+
+    return err;
 }
+
 #endif //CONFIG_HIP_OPPORTUNISTIC
 
 
@@ -85,46 +88,47 @@
  * @return 1 if t1 is equal or later than t2, else 0.
  */
 int hip_timeval_diff(const struct timeval *t1,
-                    const struct timeval *t2,
-                    struct timeval *result){
-       struct timeval _t1, _t2;
-       _t1 = *t1;
-       _t2 = *t2;
-
-       if (_t1.tv_usec < _t2.tv_usec) {
-               int nsec = (_t2.tv_usec - _t1.tv_usec) / 1000000 + 1;
-               _t2.tv_usec -= 1000000 * nsec;
-               _t2.tv_sec += nsec;
-       }
-       if (_t1.tv_usec - _t2.tv_usec > 1000000) {
-               int nsec = (_t1.tv_usec - _t2.tv_usec) / 1000000;
-               _t2.tv_usec += 1000000 * nsec;
-               _t2.tv_sec -= nsec;
-       }
-
-       result->tv_sec = _t2.tv_sec - _t1.tv_sec;
-       result->tv_usec = _t2.tv_usec - _t1.tv_usec;
-
-       return _t1.tv_sec >= _t2.tv_sec;
-}
-
-
-int hip_convert_hit_to_str(const hip_hit_t *hit, const char *prefix, char 
*hit_str)
-{
-       int err = 0;
-
-       HIP_ASSERT(hit);
-
-       memset(hit_str, 0, INET6_ADDRSTRLEN);
-       err = !hip_in6_ntop(hit, hit_str);
-
-       if (prefix) {
-               memcpy(hit_str + strlen(hit_str), prefix, strlen(prefix));
-       }
-
-       return err;
-}
-
+                     const struct timeval *t2,
+                     struct timeval *result)
+{
+    struct timeval _t1, _t2;
+    _t1 = *t1;
+    _t2 = *t2;
+
+    if (_t1.tv_usec < _t2.tv_usec) {
+        int nsec = (_t2.tv_usec - _t1.tv_usec) / 1000000 + 1;
+        _t2.tv_usec -= 1000000 * nsec;
+        _t2.tv_sec  += nsec;
+    }
+    if (_t1.tv_usec - _t2.tv_usec > 1000000) {
+        int nsec = (_t1.tv_usec - _t2.tv_usec) / 1000000;
+        _t2.tv_usec += 1000000 * nsec;
+        _t2.tv_sec  -= nsec;
+    }
+
+    result->tv_sec  = _t2.tv_sec - _t1.tv_sec;
+    result->tv_usec = _t2.tv_usec - _t1.tv_usec;
+
+    return _t1.tv_sec >= _t2.tv_sec;
+}
+
+int hip_convert_hit_to_str(const hip_hit_t *hit,
+                           const char *prefix,
+                           char *hit_str)
+{
+    int err = 0;
+
+    HIP_ASSERT(hit);
+
+    memset(hit_str, 0, INET6_ADDRSTRLEN);
+    err = !hip_in6_ntop(hit, hit_str);
+
+    if (prefix) {
+        memcpy(hit_str + strlen(hit_str), prefix, strlen(prefix));
+    }
+
+    return err;
+}
 
 /*
  * function maxof()
@@ -134,27 +138,28 @@
  * out:         Returns the integer with the largest value from the
  *              list provided.
  */
-int maxof(int num_args, ...){
-        int max, i, a;
-        va_list ap;
+int maxof(int num_args, ...)
+{
+    int max, i, a;
+    va_list ap;
 
-        va_start(ap, num_args);
-        max = va_arg(ap, int);
-        for (i = 2; i <= num_args; i++) {
-                if ((a = va_arg(ap, int)) > max)
-                        max = a;
+    va_start(ap, num_args);
+    max = va_arg(ap, int);
+    for (i = 2; i <= num_args; i++) {
+        if ((a = va_arg(ap, int)) > max) {
+            max = a;
         }
-        va_end(ap);
-        return(max);
+    }
+    va_end(ap);
+    return max;
 }
 
-
 int hip_lsi_are_equal(const hip_lsi_t *lsi1,
-                     const hip_lsi_t *lsi2){
-       return (ipv4_addr_cmp(lsi1, lsi2) == 0);
+                      const hip_lsi_t *lsi2)
+{
+    return ipv4_addr_cmp(lsi1, lsi2) == 0;
 }
 
-
 /**
  * hip_hit_is_bigger - compare two HITs
  * @param hit1 the first HIT to be compared
@@ -163,73 +168,78 @@
  * @return 1 if hit1 was bigger than hit2, or else 0
  */
 int hip_hit_is_bigger(const struct in6_addr *hit1,
-                     const struct in6_addr *hit2){
-       return (ipv6_addr_cmp(hit1, hit2) > 0);
+                      const struct in6_addr *hit2)
+{
+    return ipv6_addr_cmp(hit1, hit2) > 0;
 }
 
-
 int hip_hit_are_equal(const struct in6_addr *hit1,
-                     const struct in6_addr *hit2){
-       return (ipv6_addr_cmp(hit1, hit2) == 0);
+                      const struct in6_addr *hit2)
+{
+    return ipv6_addr_cmp(hit1, hit2) == 0;
 }
 
-
 /*
  * return value: 0 = match, >0 means non-match, -1 = error
  */
-int hip_id_type_match(const struct in6_addr *id, int id_type) {
-  int ret = 0, is_lsi = 0, is_hit = 0;
-  hip_lsi_t lsi;
-
-  if (ipv6_addr_is_hit(id)) {
-    is_hit = 1;
-  } else if (IN6_IS_ADDR_V4MAPPED(id)) {
-    IPV6_TO_IPV4_MAP(id, &lsi);
-    if (IS_LSI32(lsi.s_addr))
-      is_lsi = 1;
-  }
-
-  HIP_ASSERT(!(is_lsi && is_hit));
-
-  if (id_type == HIP_ID_TYPE_HIT)
-    ret = (is_hit ? 1 : 0);
-  else if (id_type == HIP_ID_TYPE_LSI)
-    ret = (is_lsi ? 1 : 0);
-  else
-    ret = ((is_hit || is_lsi) ? 0 : 1);
-
-  return ret;
+int hip_id_type_match(const struct in6_addr *id, int id_type)
+{
+    int ret = 0, is_lsi = 0, is_hit = 0;
+    hip_lsi_t lsi;
+
+    if (ipv6_addr_is_hit(id)) {
+        is_hit = 1;
+    } else if (IN6_IS_ADDR_V4MAPPED(id)) {
+        IPV6_TO_IPV4_MAP(id, &lsi);
+        if (IS_LSI32(lsi.s_addr)) {
+            is_lsi = 1;
+        }
+    }
+
+    HIP_ASSERT(!(is_lsi && is_hit));
+
+    if (id_type == HIP_ID_TYPE_HIT) {
+        ret = (is_hit ? 1 : 0);
+    } else if (id_type == HIP_ID_TYPE_LSI) {
+        ret = (is_lsi ? 1 : 0);
+    } else {
+        ret = ((is_hit || is_lsi) ? 0 : 1);
+    }
+
+    return ret;
 }
 
-char* hip_in6_ntop(const struct in6_addr *in6, char *buf){
-        if (!buf)
-                return NULL;
-        sprintf(buf,
-                "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
-                ntohs(in6->s6_addr16[0]), ntohs(in6->s6_addr16[1]),
-                ntohs(in6->s6_addr16[2]), ntohs(in6->s6_addr16[3]),
-                ntohs(in6->s6_addr16[4]), ntohs(in6->s6_addr16[5]),
-                ntohs(in6->s6_addr16[6]), ntohs(in6->s6_addr16[7]));
-        return buf;
+char *hip_in6_ntop(const struct in6_addr *in6, char *buf)
+{
+    if (!buf) {
+        return NULL;
+    }
+    sprintf(buf,
+            "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
+            ntohs(in6->s6_addr16[0]), ntohs(in6->s6_addr16[1]),
+            ntohs(in6->s6_addr16[2]), ntohs(in6->s6_addr16[3]),
+            ntohs(in6->s6_addr16[4]), ntohs(in6->s6_addr16[5]),
+            ntohs(in6->s6_addr16[6]), ntohs(in6->s6_addr16[7]));
+    return buf;
 }
 
 unsigned long hip_hash_generic(const void *ptr)
 {
-       unsigned long hash = (unsigned long)(*((uint32_t *)ptr));
-       return (hash % ULONG_MAX);
+    unsigned long hash = (unsigned long) (*((uint32_t *) ptr));
+    return hash % ULONG_MAX;
 }
 
 int hip_match_generic(const void *ptr1, const void *ptr2)
 {
-       return (ptr1 != ptr2);
+    return ptr1 != ptr2;
 }
 
 /**
- * Returns a generic linked list based on the hash table implementation. 
+ * Returns a generic linked list based on the hash table implementation.
  */
 HIP_HASHTABLE *hip_linked_list_init()
 {
-        return (HIP_HASHTABLE *)hip_ht_init(hip_hash_generic, 
hip_match_generic);
+    return (HIP_HASHTABLE *) hip_ht_init(hip_hash_generic, hip_match_generic);
 }
 
 /**
@@ -239,36 +249,36 @@
  *
  * Returns value in range: 0 <= x < range
  */
-unsigned long hip_hash_hit(const void *ptr){
-      uint8_t hash[HIP_AH_SHA_LEN];
-
-      hip_build_digest(HIP_DIGEST_SHA1, ptr + sizeof(uint16_t),
-       7 * sizeof(uint16_t), hash);
-      //hip_build_digest(HIP_DIGEST_SHA1, ptr, sizeof(hip_hit_t), hash);
-
-      return *((unsigned long *)hash);
-}
-
-
-int hip_match_hit(const void *ptr1, const void *ptr2){
-       return (hip_hash_hit(ptr1) != hip_hash_hit(ptr2));
-}
-
+unsigned long hip_hash_hit(const void *ptr)
+{
+    uint8_t hash[HIP_AH_SHA_LEN];
+
+    hip_build_digest(HIP_DIGEST_SHA1, ptr + sizeof(uint16_t),
+                     7 * sizeof(uint16_t), hash);
+    //hip_build_digest(HIP_DIGEST_SHA1, ptr, sizeof(hip_hit_t), hash);
+
+    return *((unsigned long *) hash);
+}
+
+int hip_match_hit(const void *ptr1, const void *ptr2)
+{
+    return hip_hash_hit(ptr1) != hip_hash_hit(ptr2);
+}
 
 /*
-unsigned long hip_hidb_hash(const void *ptr){
-       hip_hit_t *hit = &(((struct hip_host_id_entry *) ptr)->lhi.hit);
-       unsigned long hash;
-
-       hip_build_digest(HIP_DIGEST_SHA1, hit, sizeof(hip_hit_t), &hash);
-
-       return hash;
-}
-
-int hip_hidb_match(const void *ptr1, const void *ptr2){
-       return (hip_hidb_hash(ptr1) != hip_hidb_hash(ptr2));
-}
-*/
+ * unsigned long hip_hidb_hash(const void *ptr){
+ *      hip_hit_t *hit = &(((struct hip_host_id_entry *) ptr)->lhi.hit);
+ *      unsigned long hash;
+ *
+ *      hip_build_digest(HIP_DIGEST_SHA1, hit, sizeof(hip_hit_t), &hash);
+ *
+ *      return hash;
+ * }
+ *
+ * int hip_hidb_match(const void *ptr1, const void *ptr2){
+ *      return (hip_hidb_hash(ptr1) != hip_hidb_hash(ptr2));
+ * }
+ */
 
 
 
@@ -279,50 +289,50 @@
  * @return the encryption key length based on the chosen transform,
  * otherwise < 0 on error.
  */
-int hip_enc_key_length(int tid){
-       int ret = -1;
-
-       switch(tid) {
-       case HIP_ESP_AES_SHA1:
-               ret = 16;
-               break;
-       case HIP_ESP_3DES_SHA1:
-               ret = 24;
-               break;
-       case HIP_ESP_NULL_SHA1:
-       case HIP_ESP_NULL_NULL:
-               ret = 0;
-               break;
-       default:
-               HIP_ERROR("unknown tid=%d\n", tid);
-               HIP_ASSERT(0);
-               break;
-       }
-
-       return ret;
-}
-
-
-int hip_hmac_key_length(int tid){
-       int ret = -1;
-       switch(tid) {
-               case HIP_ESP_AES_SHA1:
-       case HIP_ESP_3DES_SHA1:
-       case HIP_ESP_NULL_SHA1:
-               ret = 20;
-               break;
-       case HIP_ESP_NULL_NULL:
-               ret = 0;
-               break;
-       default:
-               HIP_ERROR("unknown tid=%d\n", tid);
-               HIP_ASSERT(0);
-               break;
-       }
-
-       return ret;
-}
-
+int hip_enc_key_length(int tid)
+{
+    int ret = -1;
+
+    switch (tid) {
+    case HIP_ESP_AES_SHA1:
+        ret = 16;
+        break;
+    case HIP_ESP_3DES_SHA1:
+        ret = 24;
+        break;
+    case HIP_ESP_NULL_SHA1:
+    case HIP_ESP_NULL_NULL:
+        ret = 0;
+        break;
+    default:
+        HIP_ERROR("unknown tid=%d\n", tid);
+        HIP_ASSERT(0);
+        break;
+    }
+
+    return ret;
+}
+
+int hip_hmac_key_length(int tid)
+{
+    int ret = -1;
+    switch (tid) {
+    case HIP_ESP_AES_SHA1:
+    case HIP_ESP_3DES_SHA1:
+    case HIP_ESP_NULL_SHA1:
+        ret = 20;
+        break;
+    case HIP_ESP_NULL_NULL:
+        ret = 0;
+        break;
+    default:
+        HIP_ERROR("unknown tid=%d\n", tid);
+        HIP_ASSERT(0);
+        break;
+    }
+
+    return ret;
+}
 
 /**
  * hip_transform_key_length - get transform key length of a transform
@@ -331,29 +341,29 @@
  * @return the transform key length based on the chosen transform,
  * otherwise < 0 on error.
  */
-int hip_transform_key_length(int tid){
-       int ret = -1;
-
-       switch(tid) {
-       case HIP_HIP_AES_SHA1:
-               ret = 16;
-               break;
-       case HIP_HIP_3DES_SHA1:
-               ret = 24;
-               break;
-       case HIP_HIP_NULL_SHA1: // XX FIXME: SHOULD BE NULL_SHA1?
-               ret = 0;
-               break;
-       default:
-               HIP_ERROR("unknown tid=%d\n", tid);
-               HIP_ASSERT(0);
-               break;
-       }
-
-       return ret;
+int hip_transform_key_length(int tid)
+{
+    int ret = -1;
+
+    switch (tid) {
+    case HIP_HIP_AES_SHA1:
+        ret = 16;
+        break;
+    case HIP_HIP_3DES_SHA1:
+        ret = 24;
+        break;
+    case HIP_HIP_NULL_SHA1:     // XX FIXME: SHOULD BE NULL_SHA1?
+        ret = 0;
+        break;
+    default:
+        HIP_ERROR("unknown tid=%d\n", tid);
+        HIP_ASSERT(0);
+        break;
+    }
+
+    return ret;
 }
 
-
 /**
  * hip_auth_key_length_esp - get authentication key length of a transform
  * @param tid transform
@@ -361,30 +371,30 @@
  * @return the authentication key length based on the chosen transform.
  * otherwise < 0 on error.
  */
-int hip_auth_key_length_esp(int tid){
-       int ret = -1;
-
-       switch(tid) {
-       case HIP_ESP_AES_SHA1:
-               //ret = 16;
-               //break;
-       case HIP_ESP_NULL_SHA1:
-       case HIP_ESP_3DES_SHA1:
-               ret = 20;
-               break;
-       case HIP_ESP_NULL_NULL:
-               ret = 0;
-               break;
-       default:
-               HIP_ERROR("unknown tid=%d\n", tid);
-               HIP_ASSERT(0);
-               break;
-       }
-
-       return ret;
+int hip_auth_key_length_esp(int tid)
+{
+    int ret = -1;
+
+    switch (tid) {
+    case HIP_ESP_AES_SHA1:
+    //ret = 16;
+    //break;
+    case HIP_ESP_NULL_SHA1:
+    case HIP_ESP_3DES_SHA1:
+        ret = 20;
+        break;
+    case HIP_ESP_NULL_NULL:
+        ret = 0;
+        break;
+    default:
+        HIP_ERROR("unknown tid=%d\n", tid);
+        HIP_ASSERT(0);
+        break;
+    }
+
+    return ret;
 }
 
-
 /**
  * hip_select_hip_transform - select a HIP transform to use
  * @param ht HIP_TRANSFORM payload where the transform is selected from
@@ -392,51 +402,51 @@
  * @return the first acceptable Transform-ID, otherwise < 0 if no
  * acceptable transform was found. The return value is in host byte order.
  */
-hip_transform_suite_t hip_select_hip_transform(struct hip_hip_transform *ht){
-       hip_transform_suite_t tid = 0;
-       int i;
-       int length;
-       hip_transform_suite_t *suggestion;
-
-       length = ntohs(ht->length);
-       suggestion = (hip_transform_suite_t *) &ht->suite_id[0];
-
-       if ( (length >> 1) > 6) {
-               HIP_ERROR("Too many transforms (%d)\n", length >> 1);
-               goto out;
-       }
-
-       for (i=0; i<length; i++) {
-               switch(ntohs(*suggestion)) {
-
-               case HIP_HIP_AES_SHA1:
-               case HIP_HIP_3DES_SHA1:
-               case HIP_HIP_NULL_SHA1:
-                       tid = ntohs(*suggestion);
-                       goto out;
-                       break;
-
-               default:
-                       /* Specs don't say what to do when unknown are found.
-                        * We ignore.
-                        */
-                       HIP_ERROR("Unknown HIP suite id suggestion (%u)\n",
-                                 ntohs(*suggestion));
-                       break;
-               }
-               suggestion++;
-       }
-
- out:
-       if(tid == 0)
-               HIP_ERROR("None HIP transforms accepted\n");
-       else
-               HIP_DEBUG("Chose HIP transform: %d\n", tid);
-
-       return tid;
+hip_transform_suite_t hip_select_hip_transform(struct hip_hip_transform *ht)
+{
+    hip_transform_suite_t tid = 0;
+    int i;
+    int length;
+    hip_transform_suite_t *suggestion;
+
+    length     = ntohs(ht->length);
+    suggestion = (hip_transform_suite_t *) &ht->suite_id[0];
+
+    if ((length >> 1) > 6) {
+        HIP_ERROR("Too many transforms (%d)\n", length >> 1);
+        goto out;
+    }
+
+    for (i = 0; i < length; i++) {
+        switch (ntohs(*suggestion)) {
+        case HIP_HIP_AES_SHA1:
+        case HIP_HIP_3DES_SHA1:
+        case HIP_HIP_NULL_SHA1:
+            tid = ntohs(*suggestion);
+            goto out;
+            break;
+
+        default:
+            /* Specs don't say what to do when unknown are found.
+             * We ignore.
+             */
+            HIP_ERROR("Unknown HIP suite id suggestion (%u)\n",
+                      ntohs(*suggestion));
+            break;
+        }
+        suggestion++;
+    }
+
+out:
+    if (tid == 0) {
+        HIP_ERROR("None HIP transforms accepted\n");
+    } else {
+        HIP_DEBUG("Chose HIP transform: %d\n", tid);
+    }
+
+    return tid;
 }
 
-
 /**
  * hip_select_esp_transform - select an ESP transform to use
  * @param ht ESP_TRANSFORM payload where the transform is selected from
@@ -444,154 +454,158 @@
  * @return the first acceptable Suite-ID. otherwise < 0 if no
  * acceptable Suite-ID was found.
  */
-hip_transform_suite_t hip_select_esp_transform(struct hip_esp_transform *ht){
-       hip_transform_suite_t tid = 0;
-       int i;
-       int length;
-       hip_transform_suite_t *suggestion;
-
-       length = hip_get_param_contents_len(ht);
-       suggestion = (uint16_t*) &ht->suite_id[0];
-
-       if (length > sizeof(struct hip_esp_transform) -
-           sizeof(struct hip_common)) {
-               HIP_ERROR("Too many transforms\n");
-               goto out;
-       }
-
-       for (i=0; i<length; i++) {
-               switch(ntohs(*suggestion)) {
-
-               case HIP_ESP_AES_SHA1:
-               case HIP_ESP_NULL_NULL:
-               case HIP_ESP_3DES_SHA1:
-               case HIP_ESP_NULL_SHA1:
-                       tid = ntohs(*suggestion);
-                       goto out;
-                       break;
-               default:
-                       /* Specs don't say what to do when unknowns are found.
-                        * We ignore.
-                        */
-                       HIP_ERROR("Unknown ESP suite id suggestion (%u)\n",
-                                 ntohs(*suggestion));
-                       break;
-               }
-               suggestion++;
-       }
-
- out:
-       HIP_DEBUG("Took ESP transform %d\n", tid);
-
-       if(tid == 0)
-               HIP_ERROR("Faulty ESP transform\n");
-
-       return tid;
+hip_transform_suite_t hip_select_esp_transform(struct hip_esp_transform *ht)
+{
+    hip_transform_suite_t tid = 0;
+    int i;
+    int length;
+    hip_transform_suite_t *suggestion;
+
+    length     = hip_get_param_contents_len(ht);
+    suggestion = (uint16_t *) &ht->suite_id[0];
+
+    if (length > sizeof(struct hip_esp_transform) -
+        sizeof(struct hip_common)) {
+        HIP_ERROR("Too many transforms\n");
+        goto out;
+    }
+
+    for (i = 0; i < length; i++) {
+        switch (ntohs(*suggestion)) {
+        case HIP_ESP_AES_SHA1:
+        case HIP_ESP_NULL_NULL:
+        case HIP_ESP_3DES_SHA1:
+        case HIP_ESP_NULL_SHA1:
+            tid = ntohs(*suggestion);
+            goto out;
+            break;
+        default:
+            /* Specs don't say what to do when unknowns are found.
+             * We ignore.
+             */
+            HIP_ERROR("Unknown ESP suite id suggestion (%u)\n",
+                      ntohs(*suggestion));
+            break;
+        }
+        suggestion++;
+    }
+
+out:
+    HIP_DEBUG("Took ESP transform %d\n", tid);
+
+    if (tid == 0) {
+        HIP_ERROR("Faulty ESP transform\n");
+    }
+
+    return tid;
 }
 
 #ifndef __KERNEL__
 u16 ipv4_checksum(u8 protocol, u8 src[], u8 dst[], u8 data[], u16 len)
 {
-
-       u16 word16;
-       u32 sum;
-       u16 i;
-
-       //initialize sum to zero
-       sum=0;
-
-       // make 16 bit words out of every two adjacent 8 bit words and
-       // calculate the sum of all 16 vit words
-       for (i=0;i<len;i=i+2){
-               word16 =((((u16)(data[i]<<8)))&0xFF00)+(((u16)data[i+1])&0xFF);
-               sum = sum + (unsigned long)word16;
-       }
-       // add the TCP pseudo header which contains:
-       // the IP source and destination addresses,
-       for (i=0;i<4;i=i+2){
-               word16 =((src[i]<<8)&0xFF00)+(src[i+1]&0xFF);
-               sum=sum+word16;
-       }
-       for (i=0;i<4;i=i+2)
-       {
-               word16 =((dst[i]<<8)&0xFF00)+(dst[i+1]&0xFF);
-               sum=sum+word16;
-       }
-       // the protocol number and the length of the TCP packet
-       sum = sum + protocol + len;
-
-       // keep only the last 16 bits of the 32 bit calculated sum and add the 
carries
-       while (sum>>16)
-               sum = (sum & 0xFFFF)+(sum >> 16);
-
-       // Take the one's complement of sum
-       sum = ~sum;
-       return (htons((unsigned short) sum));
+    u16 word16;
+    u32 sum;
+    u16 i;
+
+    //initialize sum to zero
+    sum = 0;
+
+    // make 16 bit words out of every two adjacent 8 bit words and
+    // calculate the sum of all 16 vit words
+    for (i = 0; i < len; i = i + 2) {
+        word16 = ((((u16) (data[i] << 8))) & 0xFF00) + (((u16) data[i + 1]) & 
0xFF);
+        sum    = sum + (unsigned long) word16;
+    }
+    // add the TCP pseudo header which contains:
+    // the IP source and destination addresses,
+    for (i = 0; i < 4; i = i + 2) {
+        word16 = ((src[i] << 8) & 0xFF00) + (src[i + 1] & 0xFF);
+        sum    = sum + word16;
+    }
+    for (i = 0; i < 4; i = i + 2) {
+        word16 = ((dst[i] << 8) & 0xFF00) + (dst[i + 1] & 0xFF);
+        sum    = sum + word16;
+    }
+    // the protocol number and the length of the TCP packet
+    sum = sum + protocol + len;
+
+    // keep only the last 16 bits of the 32 bit calculated sum and add the 
carries
+    while (sum >> 16) {
+        sum = (sum & 0xFFFF) + (sum >> 16);
+    }
+
+    // Take the one's complement of sum
+    sum = ~sum;
+    return htons((unsigned short) sum);
 }
 
-int convert_string_to_address_v4(const char *str, struct in_addr *ip){
-       int ret = 0, err = 0;
+int convert_string_to_address_v4(const char *str, struct in_addr *ip)
+{
+    int ret = 0, err = 0;
 
-       ret = inet_pton(AF_INET, str, ip);
-       HIP_IFEL((ret < 0 && errno == EAFNOSUPPORT), -1,
-                "inet_pton: not a valid address family\n");
-       HIP_IFEL((ret == 0), -1,
-                "inet_pton: %s: not a valid network address\n", str);
- out_err:
-       return err;
+    ret = inet_pton(AF_INET, str, ip);
+    HIP_IFEL((ret < 0 && errno == EAFNOSUPPORT), -1,
+             "inet_pton: not a valid address family\n");
+    HIP_IFEL((ret == 0), -1,
+             "inet_pton: %s: not a valid network address\n", str);
+out_err:
+    return err;
 }
 
 int convert_string_to_address(const char *str,
-                             struct in6_addr *ip6){
-       int ret = 0, err = 0;
-       struct in_addr ip4;
-
-       ret = inet_pton(AF_INET6, str, ip6);
-       HIP_IFEL((ret < 0 && errno == EAFNOSUPPORT), -1,
-                "\"%s\" is not of valid address family.\n", str);
-       if (ret > 0) {
-                /* IPv6 address conversion was ok */
-               _HIP_DEBUG_IN6ADDR("Converted IPv6", ip6);
-               goto out_err;
-       }
-
-       /* Might be an ipv4 address (ret == 0). Lets catch it here. */
-       err = convert_string_to_address_v4(str, &ip4);
-       if (err)
-               goto out_err;
-
-       IPV4_TO_IPV6_MAP(&ip4, ip6);
-       HIP_DEBUG("Mapped v4 to v6.\n");
-       HIP_DEBUG_IN6ADDR("mapped v6", ip6);
-
- out_err:
-       return err;
+                              struct in6_addr *ip6)
+{
+    int ret = 0, err = 0;
+    struct in_addr ip4;
+
+    ret = inet_pton(AF_INET6, str, ip6);
+    HIP_IFEL((ret < 0 && errno == EAFNOSUPPORT), -1,
+             "\"%s\" is not of valid address family.\n", str);
+    if (ret > 0) {
+        /* IPv6 address conversion was ok */
+        _HIP_DEBUG_IN6ADDR("Converted IPv6", ip6);
+        goto out_err;
+    }
+
+    /* Might be an ipv4 address (ret == 0). Lets catch it here. */
+    err = convert_string_to_address_v4(str, &ip4);
+    if (err) {
+        goto out_err;
+    }
+
+    IPV4_TO_IPV6_MAP(&ip4, ip6);
+    HIP_DEBUG("Mapped v4 to v6.\n");
+    HIP_DEBUG_IN6ADDR("mapped v6", ip6);
+
+out_err:
+    return err;
 }
 
-
 /* the lengths are in bits */
 int khi_encode(unsigned char *orig, int orig_len,
-              unsigned char *encoded,
-              int encoded_len){
-       BIGNUM *bn = NULL;
-       int err = 0, shift = (orig_len - encoded_len) / 2,
-         len = encoded_len / 8 + ((encoded_len % 8) ? 1 : 0);
-
-       HIP_IFEL((encoded_len > orig_len), -1, "len mismatch\n");
-       HIP_IFEL((!(bn = BN_bin2bn(orig, orig_len / 8, NULL))), -1,
-                "BN_bin2bn\n");
-       HIP_IFEL(!BN_rshift(bn, bn, shift), -1, "BN_lshift\n");
-       HIP_IFEL(!BN_mask_bits(bn, encoded_len), -1,
-               "BN_mask_bits\n");
-       HIP_IFEL((bn2bin_safe(bn, encoded, len) != len), -1,
-                 "BN_bn2bin_safe\n");
-
-       _HIP_HEXDUMP("encoded: ", encoded, len);
-
- out_err:
-       if(bn)
-               BN_free(bn);
-       return err;
+               unsigned char *encoded,
+               int encoded_len)
+{
+    BIGNUM *bn = NULL;
+    int err    = 0, shift = (orig_len - encoded_len) / 2,
+        len    = encoded_len / 8 + ((encoded_len % 8) ? 1 : 0);
+
+    HIP_IFEL((encoded_len > orig_len), -1, "len mismatch\n");
+    HIP_IFEL((!(bn = BN_bin2bn(orig, orig_len / 8, NULL))), -1,
+             "BN_bin2bn\n");
+    HIP_IFEL(!BN_rshift(bn, bn, shift), -1, "BN_lshift\n");
+    HIP_IFEL(!BN_mask_bits(bn, encoded_len), -1,
+             "BN_mask_bits\n");
+    HIP_IFEL((bn2bin_safe(bn, encoded, len) != len), -1,
+             "BN_bn2bin_safe\n");
+
+    _HIP_HEXDUMP("encoded: ", encoded, len);
+
+out_err:
+    if (bn) {
+        BN_free(bn);
+    }
+    return err;
 }
 
 /**
@@ -606,181 +620,182 @@
  * @return          zero on success, negative otherwise.
  */
 int hip_dsa_host_id_to_hit(const struct hip_host_id *host_id,
-               struct in6_addr *hit, int hit_type)
+                           struct in6_addr *hit, int hit_type)
 {
-       int err = 0;
-       u8 digest[HIP_AH_SHA_LEN];
-       u8 *key_rr = (u8 *) host_id->key; /* skip the header */
-       /* hit excludes rdata but it is included in hi_length;
-         subtract rdata */
-       unsigned int key_rr_len = ntohs(host_id->hi_length) -
-        sizeof(struct hip_host_id_key_rdata);
-       u8 *khi_data = NULL;
-       u8 khi_context_id[] = HIP_KHI_CONTEXT_ID_INIT;
-       int khi_data_len = key_rr_len + sizeof(khi_context_id);
-       int khi_index = 0;
-
-       _HIP_DEBUG("key_rr_len=%u\n", key_rr_len);
-       HIP_IFE(hit_type != HIP_HIT_TYPE_HASH100, -ENOSYS);
-       _HIP_HEXDUMP("key_rr", key_rr, key_rr_len);
-
-       /* Hash Input :=  Context ID | Input */
-       khi_data = HIP_MALLOC(khi_data_len, 0);
-       khi_index = 0;
-       memcpy(khi_data + khi_index, khi_context_id, sizeof(khi_context_id));
-       khi_index += sizeof(khi_context_id);
-       memcpy(khi_data + khi_index, key_rr, key_rr_len);
-       khi_index += key_rr_len;
-
-       HIP_ASSERT(khi_index == khi_data_len);
-
-       _HIP_HEXDUMP("khi data", khi_data, khi_data_len);
-
-       /* Hash :=  SHA1( Expand( Hash Input ) ) */
-       HIP_IFEL((err = hip_build_digest(HIP_DIGEST_SHA1, khi_data,
-                                       khi_data_len, digest)), err,
-               "Building of digest failed\n");
-
-       _HIP_HEXDUMP("digest", digest, sizeof(digest));
-
-       memset(hit, 0, sizeof(hip_hit_t));
-       HIP_IFEL(khi_encode(digest, sizeof(digest) * 8,
-                          ((u8 *) hit) + 3,
-                          sizeof(hip_hit_t) * 8 - HIP_HIT_PREFIX_LEN),
-               -1, "encoding failed\n");
-
-       _HIP_DEBUG_HIT("HIT before prefix: ", hit);
-       set_hit_prefix(hit);
-       _HIP_DEBUG_HIT("HIT after prefix: ", hit);
-
- out_err:
-       if (khi_data)
-              HIP_FREE(khi_data);
-
-       return err;
+    int err                 = 0;
+    u8 digest[HIP_AH_SHA_LEN];
+    u8 *key_rr              = (u8 *) host_id->key; /* skip the header */
+    /* hit excludes rdata but it is included in hi_length;
+     * subtract rdata */
+    unsigned int key_rr_len = ntohs(host_id->hi_length) -
+                              sizeof(struct hip_host_id_key_rdata);
+    u8 *khi_data            = NULL;
+    u8 khi_context_id[]     = HIP_KHI_CONTEXT_ID_INIT;
+    int khi_data_len        = key_rr_len + sizeof(khi_context_id);
+    int khi_index           = 0;
+
+    _HIP_DEBUG("key_rr_len=%u\n", key_rr_len);
+    HIP_IFE(hit_type != HIP_HIT_TYPE_HASH100, -ENOSYS);
+    _HIP_HEXDUMP("key_rr", key_rr, key_rr_len);
+
+    /* Hash Input :=  Context ID | Input */
+    khi_data   = HIP_MALLOC(khi_data_len, 0);
+    khi_index  = 0;
+    memcpy(khi_data + khi_index, khi_context_id, sizeof(khi_context_id));
+    khi_index += sizeof(khi_context_id);
+    memcpy(khi_data + khi_index, key_rr, key_rr_len);
+    khi_index += key_rr_len;
+
+    HIP_ASSERT(khi_index == khi_data_len);
+
+    _HIP_HEXDUMP("khi data", khi_data, khi_data_len);
+
+    /* Hash :=  SHA1( Expand( Hash Input ) ) */
+    HIP_IFEL((err = hip_build_digest(HIP_DIGEST_SHA1, khi_data,
+                                     khi_data_len, digest)), err,
+             "Building of digest failed\n");
+
+    _HIP_HEXDUMP("digest", digest, sizeof(digest));
+
+    memset(hit, 0, sizeof(hip_hit_t));
+    HIP_IFEL(khi_encode(digest, sizeof(digest) * 8,
+                        ((u8 *) hit) + 3,
+                        sizeof(hip_hit_t) * 8 - HIP_HIT_PREFIX_LEN),
+             -1, "encoding failed\n");
+
+    _HIP_DEBUG_HIT("HIT before prefix: ", hit);
+    set_hit_prefix(hit);
+    _HIP_DEBUG_HIT("HIT after prefix: ", hit);
+
+out_err:
+    if (khi_data) {
+        HIP_FREE(khi_data);
+    }
+
+    return err;
 }
 
-
 int hip_host_id_to_hit(const struct hip_host_id *host_id,
-                      struct in6_addr *hit,
-                      int hit_type){
-       int algo = hip_get_host_id_algo(host_id);
-       int err = 0;
-
-       if (algo == HIP_HI_DSA) {
-               err = hip_dsa_host_id_to_hit(host_id, hit, hit_type);
-       } else if (algo == HIP_HI_RSA) {
-               err = hip_rsa_host_id_to_hit(host_id, hit, hit_type);
-       } else {
-               err = -ENOSYS;
-       }
-
-       return err;
+                       struct in6_addr *hit,
+                       int hit_type)
+{
+    int algo = hip_get_host_id_algo(host_id);
+    int err  = 0;
+
+    if (algo == HIP_HI_DSA) {
+        err = hip_dsa_host_id_to_hit(host_id, hit, hit_type);
+    } else if (algo == HIP_HI_RSA) {
+        err = hip_rsa_host_id_to_hit(host_id, hit, hit_type);
+    } else {
+        err = -ENOSYS;
+    }
+
+    return err;
 }
 
-
 int hip_private_dsa_host_id_to_hit(const struct hip_host_id_priv *host_id,
-                                  struct in6_addr *hit,
-                                  int hit_type){
-       int err = 0;
-       struct hip_host_id *host_id_pub = NULL;
-       int contents_len;
-       int total_len;
-
-       contents_len = hip_get_param_contents_len(host_id);
-       total_len = hip_get_param_total_len(host_id);
-
-       /*! \todo add an extra check for the T val */
-
-       HIP_IFEL(contents_len <= 20, -EMSGSIZE, "Host id too short\n");
-
-       /* Allocate enough space for host id; there will be 20 bytes extra
-          to avoid hassle with padding. */
-       host_id_pub = (struct hip_host_id *)HIP_MALLOC(total_len, GFP_KERNEL);
-       HIP_IFE(!host_id_pub, -EFAULT);
-       memset(host_id_pub, 0, total_len);
-
-       memcpy(host_id_pub, host_id,
-              sizeof(struct hip_tlv_common) + contents_len - DSA_PRIV);
-
-       host_id_pub->hi_length = htons(ntohs(host_id_pub->hi_length) - 
DSA_PRIV);
-       hip_set_param_contents_len((struct hip_tlv_common*) host_id_pub, 
contents_len - DSA_PRIV);
-
-       _HIP_HEXDUMP("extracted pubkey", host_id_pub,
-                    hip_get_param_total_len(host_id_pub));
-
-       if ( (err = hip_dsa_host_id_to_hit(host_id_pub, hit, hit_type)) ) {
-               HIP_ERROR("Failed to convert HI to HIT.\n");
-               goto out_err;
-       }
-
- out_err:
-
-       if (host_id_pub) {
-               HIP_FREE(host_id_pub);
-       }
-
-       return err;
+                                   struct in6_addr *hit,
+                                   int hit_type)
+{
+    int err                         = 0;
+    struct hip_host_id *host_id_pub = NULL;
+    int contents_len;
+    int total_len;
+
+    contents_len = hip_get_param_contents_len(host_id);
+    total_len    = hip_get_param_total_len(host_id);
+
+    /*! \todo add an extra check for the T val */
+
+    HIP_IFEL(contents_len <= 20, -EMSGSIZE, "Host id too short\n");
+
+    /* Allocate enough space for host id; there will be 20 bytes extra
+     * to avoid hassle with padding. */
+    host_id_pub = (struct hip_host_id *) HIP_MALLOC(total_len, GFP_KERNEL);
+    HIP_IFE(!host_id_pub, -EFAULT);
+    memset(host_id_pub, 0, total_len);
+
+    memcpy(host_id_pub, host_id,
+           sizeof(struct hip_tlv_common) + contents_len - DSA_PRIV);
+
+    host_id_pub->hi_length = htons(ntohs(host_id_pub->hi_length) - DSA_PRIV);
+    hip_set_param_contents_len((struct hip_tlv_common *) host_id_pub,
+                               contents_len - DSA_PRIV);
+
+    _HIP_HEXDUMP("extracted pubkey", host_id_pub,
+                 hip_get_param_total_len(host_id_pub));
+
+    if ((err = hip_dsa_host_id_to_hit(host_id_pub, hit, hit_type))) {
+        HIP_ERROR("Failed to convert HI to HIT.\n");
+        goto out_err;
+    }
+
+out_err:
+
+    if (host_id_pub) {
+        HIP_FREE(host_id_pub);
+    }
+
+    return err;
 }
 
-
 int hip_private_rsa_host_id_to_hit(const struct hip_host_id_priv *host_id,
-                                  struct in6_addr *hit,
-                                  int hit_type){
-       int err = 0;
-       struct hip_host_id host_id_pub;
-       int rsa_pub_len, rsa_priv_len;
-       struct hip_rsa_keylen keylen;
-
-       /* Length of the private part of the RSA key d + p + q
-          is twice the length of the public modulus. 
-          dmp1 + dmq1 + iqmp is another 1.5 times */
-
-       hip_get_rsa_keylen(host_id, &keylen, 1);
-       rsa_pub_len = keylen.e_len + keylen.e + keylen.n;
-       rsa_priv_len = keylen.n * 7 / 2;
-
-       memcpy(&host_id_pub, host_id, sizeof(host_id_pub)
-               - sizeof(host_id_pub.key) - sizeof(host_id_pub.hostname));
-
-       host_id_pub.hi_length =
-                       htons(ntohs(host_id_pub.hi_length) - rsa_priv_len);
-       memcpy(host_id_pub.key, host_id->key, rsa_pub_len);
-
-       _HIP_HEXDUMP("extracted pubkey", &host_id_pub,
-                                hip_get_param_total_len(host_id_pub));
-
-       if ( (err = hip_rsa_host_id_to_hit(&host_id_pub, hit, hit_type)) ) {
-               HIP_ERROR("Failed to convert HI to HIT.\n");
-               goto out_err;
-       }
-
- out_err:
-
-       return err;
+                                   struct in6_addr *hit,
+                                   int hit_type)
+{
+    int err = 0;
+    struct hip_host_id host_id_pub;
+    int rsa_pub_len, rsa_priv_len;
+    struct hip_rsa_keylen keylen;
+
+    /* Length of the private part of the RSA key d + p + q
+     * is twice the length of the public modulus.
+     * dmp1 + dmq1 + iqmp is another 1.5 times */
+
+    hip_get_rsa_keylen(host_id, &keylen, 1);
+    rsa_pub_len  = keylen.e_len + keylen.e + keylen.n;
+    rsa_priv_len = keylen.n * 7 / 2;
+
+    memcpy(&host_id_pub, host_id, sizeof(host_id_pub)
+           - sizeof(host_id_pub.key) - sizeof(host_id_pub.hostname));
+
+    host_id_pub.hi_length =
+        htons(ntohs(host_id_pub.hi_length) - rsa_priv_len);
+    memcpy(host_id_pub.key, host_id->key, rsa_pub_len);
+
+    _HIP_HEXDUMP("extracted pubkey", &host_id_pub,
+                 hip_get_param_total_len(host_id_pub));
+
+    if ((err = hip_rsa_host_id_to_hit(&host_id_pub, hit, hit_type))) {
+        HIP_ERROR("Failed to convert HI to HIT.\n");
+        goto out_err;
+    }
+
+out_err:
+
+    return err;
 }
 
-
 int hip_private_host_id_to_hit(const struct hip_host_id_priv *host_id,
-                              struct in6_addr *hit,
-                              int hit_type){
-       int algo = hip_get_host_id_algo((struct hip_host_id *)host_id);
-       int err = 0;
-
-       if (algo == HIP_HI_DSA) {
-               err = hip_private_dsa_host_id_to_hit(host_id, hit,
-                                                    hit_type);
-       } else if (algo == HIP_HI_RSA) {
-               err = hip_private_rsa_host_id_to_hit(host_id, hit,
-                                                    hit_type);
-       } else {
-               err = -ENOSYS;
-       }
-
-       return err;
+                               struct in6_addr *hit,
+                               int hit_type)
+{
+    int algo = hip_get_host_id_algo((struct hip_host_id *) host_id);
+    int err  = 0;
+
+    if (algo == HIP_HI_DSA) {
+        err = hip_private_dsa_host_id_to_hit(host_id, hit,
+                                             hit_type);
+    } else if (algo == HIP_HI_RSA) {
+        err = hip_private_rsa_host_id_to_hit(host_id, hit,
+                                             hit_type);
+    } else {
+        err = -ENOSYS;
+    }
+
+    return err;
 }
 
-
 /**
  * check_and_create_dir - check and create a directory
  * @param dirname the name of the directory
@@ -790,23 +805,23 @@
  */
 int check_and_create_dir(char *dirname, mode_t mode)
 {
-       int err = 0;
-       struct stat dir_stat;
-
-       HIP_INFO("dirname=%s mode=%o\n", dirname, mode);
-       err = stat(dirname, &dir_stat);
-       if (err && errno == ENOENT) { /* no such file or directory */
-               err = mkdir(dirname, mode);
-               if (err) {
-                       HIP_ERROR("mkdir %s failed: %s\n", dirname,
-                                 strerror(errno));
-               }
-       } else if (err) {
-               HIP_ERROR("stat %s failed: %s\n", dirname,
-                         strerror(errno));
-       }
-
-       return err;
+    int err = 0;
+    struct stat dir_stat;
+
+    HIP_INFO("dirname=%s mode=%o\n", dirname, mode);
+    err = stat(dirname, &dir_stat);
+    if (err && errno == ENOENT) {     /* no such file or directory */
+        err = mkdir(dirname, mode);
+        if (err) {
+            HIP_ERROR("mkdir %s failed: %s\n", dirname,
+                      strerror(errno));
+        }
+    } else if (err) {
+        HIP_ERROR("stat %s failed: %s\n", dirname,
+                  strerror(errno));
+    }
+
+    return err;
 }
 
 /**
@@ -818,529 +833,535 @@
  */
 int check_and_create_file(char *filename, mode_t mode)
 {
-       int err = 0, fd = 0;
-       struct stat file_stat;
-
-       HIP_INFO("filename=%s mode=%o\n", filename, mode);
-       err = stat(filename, &file_stat);
-       if (err && errno == ENOENT) { /* no such file or file */
-               fd = open(filename, O_RDWR | O_CREAT, 0644);
-               if (fd < 0) {
-                       HIP_ERROR("creating file %s failed: %s\n", filename,
-                                 strerror(errno));
-               }
-       } else {
-               fd = open(filename, O_RDWR);
-               if (fd < 0) {
-                       HIP_ERROR("opening file %s failed: %s\n", filename,
-                                 strerror(errno));
-               }
-       }
-
-       return fd;
-}
-
-int hip_host_id_contains_private_key(struct hip_host_id *host_id){
-       uint16_t len = hip_get_param_contents_len(host_id);
-       u8 *buf = (u8 *) host_id->key;
-       u8 t = *buf;
-
-       return len >= 3 * (64 + 8 * t) + 2 * 20; /* PQGXY 3*(64+8*t) + 2*20 */
-}
-
-
-void change_key_file_perms(char *filenamebase){
-  char *pubfilename = NULL;
-  int pubfilename_len;
-
-  pubfilename_len =
-    strlen(filenamebase) + strlen(DEFAULT_PUB_FILE_SUFFIX) + 1;
-  pubfilename = malloc(pubfilename_len);
-  if (!pubfilename) {
-    HIP_ERROR("malloc(%d) failed\n", pubfilename_len);
-    goto out_err;
-  }
-
-  /* check retval */
-  snprintf(pubfilename, pubfilename_len, "%s%s", filenamebase,
-          DEFAULT_PUB_FILE_SUFFIX);
-
-  chmod(filenamebase, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
-  chmod(pubfilename, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
-
- out_err:
-  if (pubfilename)
-    HIP_FREE(pubfilename);
-
-  return;
-}
-
-int hip_serialize_host_id_action(struct hip_common *msg, int action, int anon,
-                                int use_default, const char *hi_fmt,
-                                const char *hi_file, int rsa_key_bits,
-                                int dsa_key_bits)
-{
-       int err = 0, dsa_key_rr_len = 0, rsa_key_rr_len = 0;
-       int dsa_pub_key_rr_len = 0, rsa_pub_key_rr_len = 0;
-       hip_hdr_type_t numeric_action = 0;
-       char addrstr[INET6_ADDRSTRLEN], hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
-       char *dsa_filenamebase = NULL, *rsa_filenamebase = NULL;
-       char *dsa_filenamebase_pub = NULL, *rsa_filenamebase_pub = NULL;
-       unsigned char *dsa_key_rr = NULL, *rsa_key_rr = NULL;
-       unsigned char *dsa_pub_key_rr = NULL, *rsa_pub_key_rr = NULL;
-       DSA *dsa_key = NULL, *dsa_pub_key = NULL;
-       RSA *rsa_key = NULL, *rsa_pub_key = NULL;
-       struct hip_lhi rsa_lhi, dsa_lhi, rsa_pub_lhi, dsa_pub_lhi;
-       struct hip_host_id *dsa_host_id = NULL, *rsa_host_id = NULL;
-       struct hip_host_id *dsa_pub_host_id = NULL, *rsa_pub_host_id = NULL;
-       struct endpoint_hip *endpoint_dsa_hip = NULL;
-       struct endpoint_hip *endpoint_dsa_pub_hip = NULL;
-       struct endpoint_hip *endpoint_rsa_hip = NULL;
-       struct endpoint_hip *endpoint_rsa_pub_hip = NULL;
-
-
-       if (action == ACTION_ADD)
-               numeric_action = SO_HIP_ADD_LOCAL_HI;
-
-       if ( (err = hip_build_user_hdr(msg, numeric_action, 0)) ) {
-               HIP_ERROR("build hdr error %d\n", err);
-               goto out_err;
-       }
-
-       memset(addrstr, '\0', INET6_ADDRSTRLEN);
-       memset(hostname, '\0', HIP_HOST_ID_HOSTNAME_LEN_MAX);
-
-       if ( (err = -gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1)) ) 
{
-               HIP_ERROR("Failed to get hostname. Err is (%d).\n", err);
-               goto out_err;
-       }
-
-       HIP_INFO("Using hostname: %s\n", hostname);
-
-       HIP_IFEL((!use_default && strcmp(hi_fmt, "rsa") && strcmp(hi_fmt, 
"dsa")),
-                -ENOSYS, "Only RSA and DSA keys are supported\n");
-
-       /* Set filenamebase (depending on whether the user supplied a
-          filenamebase or not) */
-       if (!use_default) {
-               if(!strcmp(hi_fmt, "dsa")) {
-                       dsa_filenamebase = malloc(strlen(hi_file) + 1);
-                       HIP_IFEL(!dsa_filenamebase, -ENOMEM,
-                                "Could not allocate DSA filename.\n");
-                       memcpy(dsa_filenamebase, hi_file, strlen(hi_file));
-               } else /*rsa*/ {
-                       rsa_filenamebase = malloc(strlen(hi_file) + 1);
-                       HIP_IFEL(!rsa_filenamebase, -ENOMEM,
-                                "Could not allocate RSA filename.\n");
-                       memcpy(rsa_filenamebase, hi_file, strlen(hi_file));
-               }
-       } else { /* create dynamically default filenamebase */
-               int rsa_filenamebase_len = 0, dsa_filenamebase_len = 0, ret = 0;
-
-               HIP_INFO("No key file given, using default.\n");
-
-               /* Default_config_dir/default_host_dsa_key_file_base/
-                  default_anon_hi_file_name_suffix\0 */
-               /* Creation of default keys is called with hi_fmt = NULL,
-                  adding is called separately for DSA, RSA anon and RSA pub */
-               if (hi_fmt == NULL || !strcmp(hi_fmt, "dsa")) {
-                       dsa_filenamebase_len =
-                               strlen(DEFAULT_CONFIG_DIR) + strlen("/") +
-                               strlen(DEFAULT_HOST_DSA_KEY_FILE_BASE) + 1;
-                       dsa_filenamebase = malloc(HOST_ID_FILENAME_MAX_LEN);
-                       HIP_IFEL(!dsa_filenamebase, -ENOMEM,
-                                "Could not allocate DSA filename.\n");
-
-                       ret = snprintf(dsa_filenamebase,
-                                      dsa_filenamebase_len +
-                                      strlen(DEFAULT_ANON_HI_FILE_NAME_SUFFIX),
-                                      "%s/%s%s",
-                                      DEFAULT_CONFIG_DIR,
-                                      DEFAULT_HOST_DSA_KEY_FILE_BASE,
-                                      DEFAULT_ANON_HI_FILE_NAME_SUFFIX);
-                       HIP_IFE(ret <= 0, -EINVAL);
-
-                       dsa_filenamebase_pub = malloc(HOST_ID_FILENAME_MAX_LEN);
-                       HIP_IFEL(!dsa_filenamebase_pub, -ENOMEM,
-                                "Could not allocate DSA (pub) filename.\n");
-
-                       ret = snprintf(dsa_filenamebase_pub,
-                                      HOST_ID_FILENAME_MAX_LEN, "%s/%s%s",
-                                      DEFAULT_CONFIG_DIR,
-                                      DEFAULT_HOST_DSA_KEY_FILE_BASE,
-                                      DEFAULT_PUB_HI_FILE_NAME_SUFFIX);
-                       HIP_IFE(ret <= 0, -EINVAL);
-
-                       HIP_DEBUG("Using dsa (anon hi) filenamebase: %s\n",
-                                 dsa_filenamebase);
-                       HIP_DEBUG("Using dsa (pub hi) filenamebase: %s\n",
-                                 dsa_filenamebase_pub);
-               }
-
-               if (hi_fmt == NULL || !strcmp(hi_fmt, "rsa")) {
-                       rsa_filenamebase_len =
-                               strlen(DEFAULT_CONFIG_DIR) + strlen("/") +
-                               strlen(DEFAULT_HOST_RSA_KEY_FILE_BASE) + 1;
-
-                       if (anon || hi_fmt == NULL) {
-                               rsa_filenamebase =
-                                       malloc(HOST_ID_FILENAME_MAX_LEN);
-                               HIP_IFEL(!rsa_filenamebase, -ENOMEM,
-                                        "Could not allocate RSA filename.\n");
-
-                               ret = snprintf(
-                                       rsa_filenamebase,
-                                       HOST_ID_FILENAME_MAX_LEN, "%s/%s%s",
-                                       DEFAULT_CONFIG_DIR,
-                                       DEFAULT_HOST_RSA_KEY_FILE_BASE,
-                                       DEFAULT_ANON_HI_FILE_NAME_SUFFIX);
-
-                               HIP_IFE(ret <= 0, -EINVAL);
-
-                               HIP_DEBUG("Using RSA (anon HI) filenamebase: "\
-                                         "%s.\n", rsa_filenamebase);
-                       }
-
-                       if (!anon || hi_fmt == NULL) {
-                               rsa_filenamebase_pub =
-                                       malloc(HOST_ID_FILENAME_MAX_LEN);
-                               HIP_IFEL(!rsa_filenamebase_pub, -ENOMEM,
-                                        "Could not allocate RSA (pub) "\
-                                        "filename.\n");
-
-                               ret = snprintf(
-                                       rsa_filenamebase_pub,
-                                       rsa_filenamebase_len +
-                                       strlen(DEFAULT_PUB_HI_FILE_NAME_SUFFIX),
-                                       "%s/%s%s", DEFAULT_CONFIG_DIR,
-                                       DEFAULT_HOST_RSA_KEY_FILE_BASE,
-                                       DEFAULT_PUB_HI_FILE_NAME_SUFFIX);
-
-                               HIP_IFE(ret <= 0, -EINVAL);
-
-                               HIP_DEBUG("Using RSA (pub HI) filenamebase: "\
-                                         "%s\n", rsa_filenamebase_pub);
-                       }
-               }
-       }
-
-       switch(action) {
-       case ACTION_NEW:
-               /* Default directory is created only in "hipconf new default 
hi" */
-               if (use_default) {
-                       if ( (err = check_and_create_dir(DEFAULT_CONFIG_DIR,
-                                                                               
         DEFAULT_CONFIG_DIR_MODE)) )
-                       {
-                               HIP_ERROR("Could not create default 
directory.\n");
-                               goto out_err;
-                       }
-               } else if (!use_default) {
-
-                       if (!strcmp(hi_fmt, "dsa")) {
-                               dsa_key = create_dsa_key(dsa_key_bits);
-                               HIP_IFEL(!dsa_key, -EINVAL,
-                                        "Creation of DSA key failed.\n");
-                               if ( (err = 
save_dsa_private_key(dsa_filenamebase, dsa_key)) ) {
-                                       HIP_ERROR("Saving of DSA key 
failed.\n");
-                                       goto out_err;
-                               }
-                       } else { /*RSA*/
-                               rsa_key = create_rsa_key(rsa_key_bits);
-                               HIP_IFEL(!rsa_key, -EINVAL,
-                                        "Creation of RSA key failed.\n");
-                               if ( (err = 
save_rsa_private_key(rsa_filenamebase, rsa_key)) ) {
-                                       HIP_ERROR("Saving of RSA key 
failed.\n");
-                                       goto out_err;
-                               }
-                       }
-                       HIP_DEBUG("Key saved.\n");
-                       break;
-               }
-
-               /* Using default */
-               dsa_key = create_dsa_key(dsa_key_bits);
-               HIP_IFEL(!dsa_key, -EINVAL,
-                        "Creation of DSA key failed.\n");
-
-               dsa_pub_key = create_dsa_key(dsa_key_bits);
-               HIP_IFEL(!dsa_pub_key, -EINVAL,
-                        "Creation of public DSA key failed.\n");
-
-               rsa_key = create_rsa_key(rsa_key_bits);
-               HIP_IFEL(!rsa_key, -EINVAL,
-                        "Creation of RSA key failed.\n");
-
-               rsa_pub_key = create_rsa_key(rsa_key_bits);
-               HIP_IFEL(!dsa_pub_key, -EINVAL,
-                        "Creation of public RSA key failed.\n");
-
-               if ( (err = save_dsa_private_key(dsa_filenamebase, dsa_key)) ) {
-                       HIP_ERROR("Saving of DSA key failed.\n");
-                       goto out_err;
-               }
-
-               if ( (err = 
save_dsa_private_key(dsa_filenamebase_pub,dsa_pub_key)) ) {
-                       HIP_ERROR("Saving of public DSA key failed.\n");
-                       goto out_err;
-               }
-
-               if ( (err = save_rsa_private_key(rsa_filenamebase, rsa_key)) ) {
-                       HIP_ERROR("Saving of RSA key failed.\n");
-                       goto out_err;
-               }
-
-               if ( (err = 
save_rsa_private_key(rsa_filenamebase_pub,rsa_pub_key)) ) {
-                       HIP_ERROR("Saving of public RSA key failed.\n");
-                       goto out_err;
-               }
-
-               break;
-
-       case ACTION_ADD:
+    int err = 0, fd = 0;
+    struct stat file_stat;
+
+    HIP_INFO("filename=%s mode=%o\n", filename, mode);
+    err = stat(filename, &file_stat);
+    if (err && errno == ENOENT) {     /* no such file or file */
+        fd = open(filename, O_RDWR | O_CREAT, 0644);
+        if (fd < 0) {
+            HIP_ERROR("creating file %s failed: %s\n", filename,
+                      strerror(errno));
+        }
+    } else {
+        fd = open(filename, O_RDWR);
+        if (fd < 0) {
+            HIP_ERROR("opening file %s failed: %s\n", filename,
+                      strerror(errno));
+        }
+    }
+
+    return fd;
+}
+
+int hip_host_id_contains_private_key(struct hip_host_id *host_id)
+{
+    uint16_t len = hip_get_param_contents_len(host_id);
+    u8 *buf      = (u8 *) host_id->key;
+    u8 t         = *buf;
+
+    return len >= 3 * (64 + 8 * t) + 2 * 20;     /* PQGXY 3*(64+8*t) + 2*20 */
+}
+
+void change_key_file_perms(char *filenamebase)
+{
+    char *pubfilename = NULL;
+    int pubfilename_len;
+
+    pubfilename_len =
+        strlen(filenamebase) + strlen(DEFAULT_PUB_FILE_SUFFIX) + 1;
+    pubfilename     = malloc(pubfilename_len);
+    if (!pubfilename) {
+        HIP_ERROR("malloc(%d) failed\n", pubfilename_len);
+        goto out_err;
+    }
+
+    /* check retval */
+    snprintf(pubfilename, pubfilename_len, "%s%s", filenamebase,
+             DEFAULT_PUB_FILE_SUFFIX);
+
+    chmod(filenamebase, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+    chmod(pubfilename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
+
+out_err:
+    if (pubfilename) {
+        HIP_FREE(pubfilename);
+    }
+
+    return;
+}
+
+int hip_serialize_host_id_action(struct hip_common *msg,
+                                 int action,
+                                 int anon,
+                                 int use_default,
+                                 const char *hi_fmt,
+                                 const char *hi_file,
+                                 int rsa_key_bits,
+                                 int dsa_key_bits)
+{
+    int err = 0, dsa_key_rr_len = 0, rsa_key_rr_len = 0;
+    int dsa_pub_key_rr_len = 0, rsa_pub_key_rr_len = 0;
+    hip_hdr_type_t numeric_action             = 0;
+    char addrstr[INET6_ADDRSTRLEN], hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
+    char *dsa_filenamebase                    = NULL, *rsa_filenamebase = NULL;
+    char *dsa_filenamebase_pub                = NULL, *rsa_filenamebase_pub = 
NULL;
+    unsigned char *dsa_key_rr                 = NULL, *rsa_key_rr = NULL;
+    unsigned char *dsa_pub_key_rr             = NULL, *rsa_pub_key_rr = NULL;
+    DSA *dsa_key                              = NULL, *dsa_pub_key = NULL;
+    RSA *rsa_key                              = NULL, *rsa_pub_key = NULL;
+    struct hip_lhi rsa_lhi, dsa_lhi, rsa_pub_lhi, dsa_pub_lhi;
+    struct hip_host_id *dsa_host_id           = NULL, *rsa_host_id = NULL;
+    struct hip_host_id *dsa_pub_host_id       = NULL, *rsa_pub_host_id = NULL;
+    struct endpoint_hip *endpoint_dsa_hip     = NULL;
+    struct endpoint_hip *endpoint_dsa_pub_hip = NULL;
+    struct endpoint_hip *endpoint_rsa_hip     = NULL;
+    struct endpoint_hip *endpoint_rsa_pub_hip = NULL;
+
+    if (action == ACTION_ADD) {
+        numeric_action = SO_HIP_ADD_LOCAL_HI;
+    }
+
+    if ((err = hip_build_user_hdr(msg, numeric_action, 0))) {
+        HIP_ERROR("build hdr error %d\n", err);
+        goto out_err;
+    }
+
+    memset(addrstr, '\0', INET6_ADDRSTRLEN);
+    memset(hostname, '\0', HIP_HOST_ID_HOSTNAME_LEN_MAX);
+
+    if ((err = -gethostname(hostname, HIP_HOST_ID_HOSTNAME_LEN_MAX - 1))) {
+        HIP_ERROR("Failed to get hostname. Err is (%d).\n", err);
+        goto out_err;
+    }
+
+    HIP_INFO("Using hostname: %s\n", hostname);
+
+    HIP_IFEL((!use_default && strcmp(hi_fmt, "rsa") && strcmp(hi_fmt, "dsa")),
+             -ENOSYS, "Only RSA and DSA keys are supported\n");
+
+    /* Set filenamebase (depending on whether the user supplied a
+     * filenamebase or not) */
     if (!use_default) {
-      if (!strcmp(hi_fmt, "dsa")) {
-       if ( (err = load_dsa_private_key(dsa_filenamebase, &dsa_key)) ) {
-           HIP_ERROR("Loading of the DSA key failed\n");
-           goto out_err;
-       }
-       dsa_key_rr_len = dsa_to_dns_key_rr(dsa_key, &dsa_key_rr);
-       HIP_IFEL(dsa_key_rr_len <= 0, -EFAULT, "dsa_key_rr_len <= 0\n");
-
-       if ( (err = dsa_to_hip_endpoint(dsa_key, &endpoint_dsa_hip,
-                               anon ? HIP_ENDPOINT_FLAG_ANON : 0, hostname)) )
-       {
-           HIP_ERROR("Failed to allocate and build DSA endpoint.\n");
-           goto out_err;
-       }
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_dsa_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-
-      } else { /*RSA*/
-       if ( (err = load_rsa_private_key(rsa_filenamebase, &rsa_key)) ) {
-           HIP_ERROR("Loading of the RSA key failed\n");
-           goto out_err;
-       }
-       rsa_key_rr_len = rsa_to_dns_key_rr(rsa_key, &rsa_key_rr);
-       HIP_IFEL(rsa_key_rr_len <= 0, -EFAULT, "rsa_key_rr_len <= 0\n");
-
-       if ( (err = rsa_to_hip_endpoint(rsa_key, &endpoint_rsa_hip,
-                                 anon ? HIP_ENDPOINT_FLAG_ANON : 0, hostname)) 
)
-       {
-           HIP_ERROR("Failed to allocate and build RSA endpoint.\n");
-           goto out_err;
-       }
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_rsa_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-
-      }
-      goto skip_host_id;
-    }
-
-    /* using default */
-
-    HIP_IFEL(hi_fmt == NULL, -1, "Key type is null.\n");
+        if (!strcmp(hi_fmt, "dsa")) {
+            dsa_filenamebase = malloc(strlen(hi_file) + 1);
+            HIP_IFEL(!dsa_filenamebase, -ENOMEM,
+                     "Could not allocate DSA filename.\n");
+            memcpy(dsa_filenamebase, hi_file, strlen(hi_file));
+        } else {       /*rsa*/
+            rsa_filenamebase = malloc(strlen(hi_file) + 1);
+            HIP_IFEL(!rsa_filenamebase, -ENOMEM,
+                     "Could not allocate RSA filename.\n");
+            memcpy(rsa_filenamebase, hi_file, strlen(hi_file));
+        }
+    } else {     /* create dynamically default filenamebase */
+        int rsa_filenamebase_len = 0, dsa_filenamebase_len = 0, ret = 0;
+
+        HIP_INFO("No key file given, using default.\n");
+
+        /* Default_config_dir/default_host_dsa_key_file_base/
+         * default_anon_hi_file_name_suffix\0 */
+        /* Creation of default keys is called with hi_fmt = NULL,
+         * adding is called separately for DSA, RSA anon and RSA pub */
+        if (hi_fmt == NULL || !strcmp(hi_fmt, "dsa")) {
+            dsa_filenamebase_len =
+                strlen(DEFAULT_CONFIG_DIR) + strlen("/") +
+                strlen(DEFAULT_HOST_DSA_KEY_FILE_BASE) + 1;
+            dsa_filenamebase     = malloc(HOST_ID_FILENAME_MAX_LEN);
+            HIP_IFEL(!dsa_filenamebase, -ENOMEM,
+                     "Could not allocate DSA filename.\n");
+
+            ret = snprintf(dsa_filenamebase,
+                           dsa_filenamebase_len +
+                           strlen(DEFAULT_ANON_HI_FILE_NAME_SUFFIX),
+                           "%s/%s%s",
+                           DEFAULT_CONFIG_DIR,
+                           DEFAULT_HOST_DSA_KEY_FILE_BASE,
+                           DEFAULT_ANON_HI_FILE_NAME_SUFFIX);
+
+            HIP_IFE(ret <= 0, -EINVAL);
+
+            dsa_filenamebase_pub = malloc(HOST_ID_FILENAME_MAX_LEN);
+            HIP_IFEL(!dsa_filenamebase_pub, -ENOMEM,
+                     "Could not allocate DSA (pub) filename.\n");
+
+            ret = snprintf(dsa_filenamebase_pub,
+                           HOST_ID_FILENAME_MAX_LEN, "%s/%s%s",
+                           DEFAULT_CONFIG_DIR,
+                           DEFAULT_HOST_DSA_KEY_FILE_BASE,
+                           DEFAULT_PUB_HI_FILE_NAME_SUFFIX);
+
+            HIP_IFE(ret <= 0, -EINVAL);
+
+            HIP_DEBUG("Using dsa (anon hi) filenamebase: %s\n",
+                      dsa_filenamebase);
+            HIP_DEBUG("Using dsa (pub hi) filenamebase: %s\n",
+                      dsa_filenamebase_pub);
+        }
+
+        if (hi_fmt == NULL || !strcmp(hi_fmt, "rsa")) {
+            rsa_filenamebase_len =
+                strlen(DEFAULT_CONFIG_DIR) + strlen("/") +
+                strlen(DEFAULT_HOST_RSA_KEY_FILE_BASE) + 1;
+
+            if (anon || hi_fmt == NULL) {
+                rsa_filenamebase =
+                    malloc(HOST_ID_FILENAME_MAX_LEN);
+                HIP_IFEL(!rsa_filenamebase, -ENOMEM,
+                         "Could not allocate RSA filename.\n");
+
+                ret = snprintf(
+                    rsa_filenamebase,
+                    HOST_ID_FILENAME_MAX_LEN, "%s/%s%s",
+                    DEFAULT_CONFIG_DIR,
+                    DEFAULT_HOST_RSA_KEY_FILE_BASE,
+                    DEFAULT_ANON_HI_FILE_NAME_SUFFIX);
+
+                HIP_IFE(ret <= 0, -EINVAL);
+
+                HIP_DEBUG("Using RSA (anon HI) filenamebase: " \
+                          "%s.\n", rsa_filenamebase);
+            }
+
+            if (!anon || hi_fmt == NULL) {
+                rsa_filenamebase_pub =
+                    malloc(HOST_ID_FILENAME_MAX_LEN);
+                HIP_IFEL(!rsa_filenamebase_pub, -ENOMEM,
+                         "Could not allocate RSA (pub) " \
+                         "filename.\n");
+
+                ret = snprintf(
+                    rsa_filenamebase_pub,
+                    rsa_filenamebase_len +
+                    strlen(DEFAULT_PUB_HI_FILE_NAME_SUFFIX),
+                    "%s/%s%s", DEFAULT_CONFIG_DIR,
+                    DEFAULT_HOST_RSA_KEY_FILE_BASE,
+                    DEFAULT_PUB_HI_FILE_NAME_SUFFIX);
+
+                HIP_IFE(ret <= 0, -EINVAL);
+
+                HIP_DEBUG("Using RSA (pub HI) filenamebase: " \
+                          "%s\n", rsa_filenamebase_pub);
+            }
+        }
+    }
+
+    switch (action) {
+    case ACTION_NEW:
+        /* Default directory is created only in "hipconf new default hi" */
+        if (use_default) {
+            if ((err = check_and_create_dir(DEFAULT_CONFIG_DIR,
+                                            DEFAULT_CONFIG_DIR_MODE))) {
+                HIP_ERROR("Could not create default directory.\n");
+                goto out_err;
+            }
+        } else if (!use_default) {
+            if (!strcmp(hi_fmt, "dsa")) {
+                dsa_key = create_dsa_key(dsa_key_bits);
+                HIP_IFEL(!dsa_key, -EINVAL,
+                         "Creation of DSA key failed.\n");
+                if ((err = save_dsa_private_key(dsa_filenamebase, dsa_key))) {
+                    HIP_ERROR("Saving of DSA key failed.\n");
+                    goto out_err;
+                }
+            } else {             /*RSA*/
+                rsa_key = create_rsa_key(rsa_key_bits);
+                HIP_IFEL(!rsa_key, -EINVAL,
+                         "Creation of RSA key failed.\n");
+                if ((err = save_rsa_private_key(rsa_filenamebase, rsa_key))) {
+                    HIP_ERROR("Saving of RSA key failed.\n");
+                    goto out_err;
+                }
+            }
+            HIP_DEBUG("Key saved.\n");
+            break;
+        }
+
+        /* Using default */
+        dsa_key     = create_dsa_key(dsa_key_bits);
+        HIP_IFEL(!dsa_key, -EINVAL,
+                 "Creation of DSA key failed.\n");
+
+        dsa_pub_key = create_dsa_key(dsa_key_bits);
+        HIP_IFEL(!dsa_pub_key, -EINVAL,
+                 "Creation of public DSA key failed.\n");
+
+        rsa_key     = create_rsa_key(rsa_key_bits);
+        HIP_IFEL(!rsa_key, -EINVAL,
+                 "Creation of RSA key failed.\n");
+
+        rsa_pub_key = create_rsa_key(rsa_key_bits);
+        HIP_IFEL(!dsa_pub_key, -EINVAL,
+                 "Creation of public RSA key failed.\n");
+
+        if ((err = save_dsa_private_key(dsa_filenamebase, dsa_key))) {
+            HIP_ERROR("Saving of DSA key failed.\n");
+            goto out_err;
+        }
+
+        if ((err = save_dsa_private_key(dsa_filenamebase_pub, dsa_pub_key))) {
+            HIP_ERROR("Saving of public DSA key failed.\n");
+            goto out_err;
+        }
+
+        if ((err = save_rsa_private_key(rsa_filenamebase, rsa_key))) {
+            HIP_ERROR("Saving of RSA key failed.\n");
+            goto out_err;
+        }
+
+        if ((err = save_rsa_private_key(rsa_filenamebase_pub, rsa_pub_key))) {
+            HIP_ERROR("Saving of public RSA key failed.\n");
+            goto out_err;
+        }
+
+        break;
+
+    case ACTION_ADD:
+        if (!use_default) {
+            if (!strcmp(hi_fmt, "dsa")) {
+                if ((err = load_dsa_private_key(dsa_filenamebase, &dsa_key))) {
+                    HIP_ERROR("Loading of the DSA key failed\n");
+                    goto out_err;
+                }
+                dsa_key_rr_len = dsa_to_dns_key_rr(dsa_key, &dsa_key_rr);
+                HIP_IFEL(dsa_key_rr_len <= 0, -EFAULT, "dsa_key_rr_len <= 
0\n");
+
+                if ((err = dsa_to_hip_endpoint(dsa_key, &endpoint_dsa_hip,
+                                               anon ? HIP_ENDPOINT_FLAG_ANON : 
0, hostname))) {
+                    HIP_ERROR("Failed to allocate and build DSA endpoint.\n");
+                    goto out_err;
+                }
+                if ((err = hip_build_param_eid_endpoint(msg, 
endpoint_dsa_hip))) {
+                    HIP_ERROR("Building of host id failed\n");
+                    goto out_err;
+                }
+            } else { /*RSA*/
+                if ((err = load_rsa_private_key(rsa_filenamebase, &rsa_key))) {
+                    HIP_ERROR("Loading of the RSA key failed\n");
+                    goto out_err;
+                }
+                rsa_key_rr_len = rsa_to_dns_key_rr(rsa_key, &rsa_key_rr);
+                HIP_IFEL(rsa_key_rr_len <= 0, -EFAULT, "rsa_key_rr_len <= 
0\n");
+
+                if ((err = rsa_to_hip_endpoint(rsa_key, &endpoint_rsa_hip,
+                                               anon ? HIP_ENDPOINT_FLAG_ANON : 
0, hostname))) {
+                    HIP_ERROR("Failed to allocate and build RSA endpoint.\n");
+                    goto out_err;
+                }
+                if ((err = hip_build_param_eid_endpoint(msg, 
endpoint_rsa_hip))) {
+                    HIP_ERROR("Building of host id failed\n");
+                    goto out_err;
+                }
+            }
+            goto skip_host_id;
+        }
+
+        /* using default */
+
+        HIP_IFEL(hi_fmt == NULL, -1, "Key type is null.\n");
+
+        if (!strcmp(hi_fmt, "dsa")) {
+            if ((err = load_dsa_private_key(dsa_filenamebase, &dsa_key))) {
+                HIP_ERROR("Loading of the DSA key failed\n");
+                goto out_err;
+            }
+
+            dsa_key_rr_len = dsa_to_dns_key_rr(dsa_key, &dsa_key_rr);
+            HIP_IFEL(dsa_key_rr_len <= 0, -EFAULT, "dsa_key_rr_len <= 0\n");
+
+            if ((err = dsa_to_hip_endpoint(dsa_key, &endpoint_dsa_hip,
+                                           HIP_ENDPOINT_FLAG_ANON, hostname))) 
{
+                HIP_ERROR("Failed to allocate and build DSA endpoint 
(anon).\n");
+                goto out_err;
+            }
+
+            if ((err = hip_private_dsa_to_hit(dsa_key, dsa_key_rr,
+                                              HIP_HIT_TYPE_HASH100, 
&dsa_lhi.hit))) {
+                HIP_ERROR("Conversion from DSA to HIT failed\n");
+                goto out_err;
+            }
+
+            if ((err = load_dsa_private_key(dsa_filenamebase_pub, 
&dsa_pub_key))) {
+                HIP_ERROR("Loading of the DSA key (pub) failed\n");
+                goto out_err;
+            }
+
+            dsa_pub_key_rr_len = dsa_to_dns_key_rr(dsa_pub_key, 
&dsa_pub_key_rr);
+            HIP_IFEL(dsa_pub_key_rr_len <= 0, -EFAULT, "dsa_pub_key_rr_len <= 
0\n");
+
+            HIP_DEBUG_HIT("DSA HIT", &dsa_lhi.hit);
+
+            if ((err = hip_private_dsa_to_hit(dsa_pub_key, dsa_pub_key_rr,
+                                              HIP_HIT_TYPE_HASH100, 
&dsa_pub_lhi.hit))) {
+                HIP_ERROR("Conversion from DSA to HIT failed\n");
+                goto out_err;
+            }
+            HIP_DEBUG_HIT("DSA HIT", &dsa_pub_lhi.hit);
+
+            if ((err = dsa_to_hip_endpoint(dsa_pub_key,
+                                           &endpoint_dsa_pub_hip, 0, 
hostname))) {
+                HIP_ERROR("Failed to allocate and build DSA endpoint 
(pub).\n");
+                goto out_err;
+            }
+        } else if (anon) { /* rsa anon */
+            if ((err = load_rsa_private_key(rsa_filenamebase, &rsa_key))) {
+                HIP_ERROR("Loading of the RSA key failed\n");
+                goto out_err;
+            }
+
+            rsa_key_rr_len = rsa_to_dns_key_rr(rsa_key, &rsa_key_rr);
+            HIP_IFEL(rsa_key_rr_len <= 0, -EFAULT, "rsa_key_rr_len <= 0\n");
+
+            if ((err = rsa_to_hip_endpoint(rsa_key, &endpoint_rsa_hip,
+                                           HIP_ENDPOINT_FLAG_ANON, hostname))) 
{
+                HIP_ERROR("Failed to allocate and build RSA endpoint 
(anon).\n");
+                goto out_err;
+            }
+
+            if ((err = hip_private_rsa_to_hit(rsa_key, rsa_key_rr,
+                                              HIP_HIT_TYPE_HASH100,  
&rsa_lhi.hit))) {
+                HIP_ERROR("Conversion from RSA to HIT failed\n");
+                goto out_err;
+            }
+            HIP_DEBUG_HIT("RSA HIT", &rsa_lhi.hit);
+        } else { /* rsa pub */
+            if ((err = load_rsa_private_key(rsa_filenamebase_pub, 
&rsa_pub_key))) {
+                HIP_ERROR("Loading of the RSA key (pub) failed\n");
+                goto out_err;
+            }
+
+            rsa_pub_key_rr_len = rsa_to_dns_key_rr(rsa_pub_key, 
&rsa_pub_key_rr);
+            HIP_IFEL(rsa_pub_key_rr_len <= 0, -EFAULT, "rsa_pub_key_rr_len <= 
0\n");
+
+            if ((err = rsa_to_hip_endpoint(rsa_pub_key,
+                                           &endpoint_rsa_pub_hip, 0, 
hostname))) {
+                HIP_ERROR("Failed to allocate and build RSA endpoint 
(pub).\n");
+                goto out_err;
+            }
+
+            if ((err = hip_private_rsa_to_hit(rsa_pub_key, rsa_pub_key_rr,
+                                              HIP_HIT_TYPE_HASH100, 
&rsa_pub_lhi.hit))) {
+                HIP_ERROR("Conversion from RSA to HIT failed\n");
+                goto out_err;
+            }
+            HIP_DEBUG_HIT("RSA HIT", &rsa_pub_lhi.hit);
+        }
+
+        break;
+    } /* end switch */
+
+    if (numeric_action == 0) {
+        goto skip_msg;
+    }
 
     if (!strcmp(hi_fmt, "dsa")) {
-       if ( (err = load_dsa_private_key(dsa_filenamebase, &dsa_key)) ) {
-           HIP_ERROR("Loading of the DSA key failed\n");
-           goto out_err;
-       }
-
-       dsa_key_rr_len = dsa_to_dns_key_rr(dsa_key, &dsa_key_rr);
-       HIP_IFEL(dsa_key_rr_len <= 0, -EFAULT, "dsa_key_rr_len <= 0\n");
-
-       if ( (err = dsa_to_hip_endpoint(dsa_key, &endpoint_dsa_hip,
-                             HIP_ENDPOINT_FLAG_ANON, hostname)) )
-       {
-           HIP_ERROR("Failed to allocate and build DSA endpoint (anon).\n");
-           goto out_err;
-       }
-
-       if ( (err = hip_private_dsa_to_hit(dsa_key, dsa_key_rr,
-                                HIP_HIT_TYPE_HASH100, &dsa_lhi.hit)) )
-       {
-           HIP_ERROR("Conversion from DSA to HIT failed\n");
-           goto out_err;
-       }
-
-       if ( (err = load_dsa_private_key(dsa_filenamebase_pub, &dsa_pub_key)) ) 
{
-           HIP_ERROR("Loading of the DSA key (pub) failed\n");
-           goto out_err;
-       }
-
-       dsa_pub_key_rr_len = dsa_to_dns_key_rr(dsa_pub_key, &dsa_pub_key_rr);
-       HIP_IFEL(dsa_pub_key_rr_len <= 0, -EFAULT, "dsa_pub_key_rr_len <= 0\n");
-
-       HIP_DEBUG_HIT("DSA HIT", &dsa_lhi.hit);
-
-       if ( (err = hip_private_dsa_to_hit(dsa_pub_key, dsa_pub_key_rr,
-                                HIP_HIT_TYPE_HASH100, &dsa_pub_lhi.hit)) )
-       {
-           HIP_ERROR("Conversion from DSA to HIT failed\n");
-           goto out_err;
-       }
-       HIP_DEBUG_HIT("DSA HIT", &dsa_pub_lhi.hit);
-
-       if ( (err = dsa_to_hip_endpoint(dsa_pub_key,
-                       &endpoint_dsa_pub_hip, 0, hostname)) )
-       {
-           HIP_ERROR("Failed to allocate and build DSA endpoint (pub).\n");
-           goto out_err;
-       }
-
-    } else if (anon) { /* rsa anon */
-
-       if ( (err = load_rsa_private_key(rsa_filenamebase, &rsa_key)) ) {
-           HIP_ERROR("Loading of the RSA key failed\n");
-           goto out_err;
-       }
-
-       rsa_key_rr_len = rsa_to_dns_key_rr(rsa_key, &rsa_key_rr);
-       HIP_IFEL(rsa_key_rr_len <= 0, -EFAULT, "rsa_key_rr_len <= 0\n");
-
-       if ( (err = rsa_to_hip_endpoint(rsa_key, &endpoint_rsa_hip,
-                                       HIP_ENDPOINT_FLAG_ANON, hostname)) )
-       {
-           HIP_ERROR("Failed to allocate and build RSA endpoint (anon).\n");
-           goto out_err;
-       }
-
-       if ( (err = hip_private_rsa_to_hit(rsa_key, rsa_key_rr,
-                                       HIP_HIT_TYPE_HASH100,  &rsa_lhi.hit)) )
-       {
-           HIP_ERROR("Conversion from RSA to HIT failed\n");
-           goto out_err;
-       }
-       HIP_DEBUG_HIT("RSA HIT", &rsa_lhi.hit);
-
-    } else { /* rsa pub */
-
-       if ( (err = load_rsa_private_key(rsa_filenamebase_pub, &rsa_pub_key)) )
-       {
-           HIP_ERROR("Loading of the RSA key (pub) failed\n");
-           goto out_err;
-       }
-
-       rsa_pub_key_rr_len = rsa_to_dns_key_rr(rsa_pub_key, &rsa_pub_key_rr);
-       HIP_IFEL(rsa_pub_key_rr_len <= 0, -EFAULT, "rsa_pub_key_rr_len <= 0\n");
-
-       if ( (err = rsa_to_hip_endpoint(rsa_pub_key,
-                                       &endpoint_rsa_pub_hip, 0, hostname)) )
-       {
-           HIP_ERROR("Failed to allocate and build RSA endpoint (pub).\n");
-           goto out_err;
-       }
-
-       if ( (err = hip_private_rsa_to_hit(rsa_pub_key, rsa_pub_key_rr,
-                                HIP_HIT_TYPE_HASH100, &rsa_pub_lhi.hit)) )
-       {
-           HIP_ERROR("Conversion from RSA to HIT failed\n");
-           goto out_err;
-       }
-       HIP_DEBUG_HIT("RSA HIT", &rsa_pub_lhi.hit);
-
-    }
-
-    break;
-  } /* end switch */
-
-  if (numeric_action == 0)
-    goto skip_msg;
-
-  if (!strcmp(hi_fmt, "dsa")) {
-
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_dsa_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_dsa_pub_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-
-  } else if (anon) {
-
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_rsa_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-
-  } else {
-
-       if ( (err = hip_build_param_eid_endpoint(msg, endpoint_rsa_pub_hip)) ) {
-           HIP_ERROR("Building of host id failed\n");
-           goto out_err;
-       }
-
-  }
-
- skip_host_id:
- skip_msg:
-
- out_err:
-  if (dsa_filenamebase != NULL)
-          change_key_file_perms(dsa_filenamebase);
-  if (rsa_filenamebase != NULL)
-          change_key_file_perms(rsa_filenamebase);
-  if (dsa_filenamebase_pub != NULL)
-          change_key_file_perms(dsa_filenamebase_pub);
-  if (rsa_filenamebase_pub != NULL)
-          change_key_file_perms(rsa_filenamebase_pub);
-
-  if (dsa_host_id)
-    free(dsa_host_id);
-  if (dsa_pub_host_id)
-    free(dsa_pub_host_id);
-  if (rsa_host_id)
-    free(rsa_host_id);
-  if (rsa_pub_host_id)
-    free(rsa_pub_host_id);
-  if (dsa_key)
-    DSA_free(dsa_key);
-  if (rsa_key)
-    RSA_free(rsa_key);
-  if (dsa_pub_key)
-    DSA_free(dsa_pub_key);
-  if (rsa_pub_key)
-    RSA_free(rsa_pub_key);
-  if (dsa_key_rr)
-    free(dsa_key_rr);
-  if (rsa_key_rr)
-    free(rsa_key_rr);
-  if (dsa_pub_key_rr)
-    free(dsa_pub_key_rr);
-  if (rsa_pub_key_rr)
-    free(rsa_pub_key_rr);
-  if (dsa_filenamebase)
-    free(dsa_filenamebase);
-  if (rsa_filenamebase)
-    free(rsa_filenamebase);
-  if (dsa_filenamebase_pub)
-    free(dsa_filenamebase_pub);
-  if (rsa_filenamebase_pub)
-    free(rsa_filenamebase_pub);
-  if (endpoint_dsa_hip)
-    free(endpoint_dsa_hip);
-  if (endpoint_rsa_hip)
-    free(endpoint_rsa_hip);
-  if (endpoint_dsa_pub_hip)
-    free(endpoint_dsa_pub_hip);
-  if (endpoint_rsa_pub_hip)
-    free(endpoint_rsa_pub_hip);
-
-  return err;
+        if ((err = hip_build_param_eid_endpoint(msg, endpoint_dsa_hip))) {
+            HIP_ERROR("Building of host id failed\n");
+            goto out_err;
+        }
+        if ((err = hip_build_param_eid_endpoint(msg, endpoint_dsa_pub_hip))) {
+            HIP_ERROR("Building of host id failed\n");
+            goto out_err;
+        }
+    } else if (anon) {
+        if ((err = hip_build_param_eid_endpoint(msg, endpoint_rsa_hip))) {
+            HIP_ERROR("Building of host id failed\n");
+            goto out_err;
+        }
+    } else {
+        if ((err = hip_build_param_eid_endpoint(msg, endpoint_rsa_pub_hip))) {
+            HIP_ERROR("Building of host id failed\n");
+            goto out_err;
+        }
+    }
+
+skip_host_id:
+skip_msg:
+
+out_err:
+    if (dsa_filenamebase != NULL) {
+        change_key_file_perms(dsa_filenamebase);
+    }
+    if (rsa_filenamebase != NULL) {
+        change_key_file_perms(rsa_filenamebase);
+    }
+    if (dsa_filenamebase_pub != NULL) {
+        change_key_file_perms(dsa_filenamebase_pub);
+    }
+    if (rsa_filenamebase_pub != NULL) {
+        change_key_file_perms(rsa_filenamebase_pub);
+    }
+
+    if (dsa_host_id) {
+        free(dsa_host_id);
+    }
+    if (dsa_pub_host_id) {
+        free(dsa_pub_host_id);
+    }
+    if (rsa_host_id) {
+        free(rsa_host_id);
+    }
+    if (rsa_pub_host_id) {
+        free(rsa_pub_host_id);
+    }
+    if (dsa_key) {
+        DSA_free(dsa_key);
+    }
+    if (rsa_key) {
+        RSA_free(rsa_key);
+    }
+    if (dsa_pub_key) {
+        DSA_free(dsa_pub_key);
+    }
+    if (rsa_pub_key) {
+        RSA_free(rsa_pub_key);
+    }
+    if (dsa_key_rr) {
+        free(dsa_key_rr);
+    }
+    if (rsa_key_rr) {
+        free(rsa_key_rr);
+    }
+    if (dsa_pub_key_rr) {
+        free(dsa_pub_key_rr);
+    }
+    if (rsa_pub_key_rr) {
+        free(rsa_pub_key_rr);
+    }
+    if (dsa_filenamebase) {
+        free(dsa_filenamebase);
+    }
+    if (rsa_filenamebase) {
+        free(rsa_filenamebase);
+    }
+    if (dsa_filenamebase_pub) {
+        free(dsa_filenamebase_pub);
+    }
+    if (rsa_filenamebase_pub) {
+        free(rsa_filenamebase_pub);
+    }
+    if (endpoint_dsa_hip) {
+        free(endpoint_dsa_hip);
+    }
+    if (endpoint_rsa_hip) {
+        free(endpoint_rsa_hip);
+    }
+    if (endpoint_dsa_pub_hip) {
+        free(endpoint_dsa_pub_hip);
+    }
+    if (endpoint_rsa_pub_hip) {
+        free(endpoint_rsa_pub_hip);
+    }
+
+    return err;
 }
 
 void get_random_bytes(void *buf, int n)
 {
-       RAND_bytes(buf, n);
+    RAND_bytes(buf, n);
 }
 
-
 /**
  * hip_build_digest - calculate a digest over given data
  * @param type the type of digest, e.g. "sha1"
@@ -1353,29 +1374,30 @@
  *
  * @return 0 on success, otherwise < 0.
  */
-int hip_build_digest(const int type, const void *in, int in_len, void *out){
-       SHA_CTX sha;
-       MD5_CTX md5;
-
-       switch(type) {
-       case HIP_DIGEST_SHA1:
-               SHA1_Init(&sha);
-               SHA1_Update(&sha, in, in_len);
-               SHA1_Final(out, &sha);
-               break;
-
-       case HIP_DIGEST_MD5:
-               MD5_Init(&md5);
-               MD5_Update(&md5, in, in_len);
-               MD5_Final(out, &md5);
-               break;
-
-       default:
-               HIP_ERROR("Unknown digest: %x\n",type);
-               return -EFAULT;
-       }
-
-       return 0;
+int hip_build_digest(const int type, const void *in, int in_len, void *out)
+{
+    SHA_CTX sha;
+    MD5_CTX md5;
+
+    switch (type) {
+    case HIP_DIGEST_SHA1:
+        SHA1_Init(&sha);
+        SHA1_Update(&sha, in, in_len);
+        SHA1_Final(out, &sha);
+        break;
+
+    case HIP_DIGEST_MD5:
+        MD5_Init(&md5);
+        MD5_Update(&md5, in, in_len);
+        MD5_Final(out, &md5);
+        break;
+
+    default:
+        HIP_ERROR("Unknown digest: %x\n", type);
+        return -EFAULT;
+    }
+
+    return 0;
 }
 
 /**
@@ -1390,107 +1412,110 @@
  * DNS KEY RR is stored at dsa_key_rr. On error function returns negative
  * and sets dsa_key_rr to NULL.
  */
-int dsa_to_dns_key_rr(DSA *dsa, unsigned char **dsa_key_rr){
-  int err = 0;
-  int dsa_key_rr_len = -1;
-  signed char t; /* in units of 8 bytes */
-  unsigned char *p;
-  int key_len;
-
-  HIP_ASSERT(dsa != NULL); /* should not happen */
-
-  *dsa_key_rr = NULL;
-
-  _HIP_DEBUG("numbytes p=%d\n", BN_num_bytes(dsa->p));
-  _HIP_DEBUG("numbytes q=%d\n", BN_num_bytes(dsa->q));
-  _HIP_DEBUG("numbytes g=%d\n", BN_num_bytes(dsa->g));
-  _HIP_DEBUG("numbytes pubkey=%d\n", BN_num_bytes(dsa->pub_key)); // shouldn't 
this be NULL also?
-
-  /* notice that these functions allocate memory */
-  _HIP_DEBUG("p=%s\n", BN_bn2hex(dsa->p));
-  _HIP_DEBUG("q=%s\n", BN_bn2hex(dsa->q));
-  _HIP_DEBUG("g=%s\n", BN_bn2hex(dsa->g));
-  _HIP_DEBUG("pubkey=%s\n", BN_bn2hex(dsa->pub_key));
-
-  /* ***** is use of BN_num_bytes ok ? ***** */
-  t = (BN_num_bytes(dsa->p) - 64) / 8;
-  HIP_IFEL((t < 0 || t > 8), -EINVAL,
-                       "Invalid RSA key length %d bits\n", (64 + t * 8) * 8);
-  _HIP_DEBUG("t=%d\n", t);
-
-  /* RFC 2536 section 2 */
-  /*
-           Field     Size
-           -----     ----
-            T         1  octet
-            Q        20  octets
-            P        64 + T*8  octets
-            G        64 + T*8  octets
-            Y        64 + T*8  octets
-         [ X        20 optional octets (private key hack) ]
-
-  */
-  key_len = 64 + t * 8;
-  dsa_key_rr_len = 1 + DSA_PRIV + 3 * key_len;
-
-  if (dsa->priv_key) {
-    dsa_key_rr_len += DSA_PRIV; /* private key hack */
-    _HIP_DEBUG("Private key included\n");
-  } else {
-    _HIP_DEBUG("No private key\n");
-  }
-
-  _HIP_DEBUG("dsa key rr len = %d\n", dsa_key_rr_len);
-  *dsa_key_rr = malloc(dsa_key_rr_len);
-  HIP_IFEL(!*dsa_key_rr, -ENOMEM, "Malloc for *dsa_key_rr failed\n");
-  memset(*dsa_key_rr, 0, dsa_key_rr_len);
-
-  p = *dsa_key_rr;
-
-  /* set T */
-  memset(p, t, 1); // XX FIX: WTF MEMSET?
-  p++;
-  _HIP_HEXDUMP("DSA KEY RR after T:", *dsa_key_rr, p - *dsa_key_rr);
-
-  /* add given dsa_param to the *dsa_key_rr */
-
-  bn2bin_safe(dsa->q, p, DSA_PRIV);
-  p += DSA_PRIV;
-  _HIP_HEXDUMP("DSA KEY RR after Q:", *dsa_key_rr, p-*dsa_key_rr);
-
-  bn2bin_safe(dsa->p, p, key_len);
-  p += key_len;
-  _HIP_HEXDUMP("DSA KEY RR after P:", *dsa_key_rr, p-*dsa_key_rr);
-
-  bn2bin_safe(dsa->g, p, key_len);
-  p += key_len;
-  _HIP_HEXDUMP("DSA KEY RR after G:", *dsa_key_rr, p-*dsa_key_rr);
-
-  bn2bin_safe(dsa->pub_key, p, key_len);
-  p += key_len;
-  _HIP_HEXDUMP("DSA KEY RR after Y:", *dsa_key_rr, p-*dsa_key_rr);
-
-  if(dsa->priv_key){
-      bn2bin_safe(dsa->priv_key, p, DSA_PRIV);
-      _HIP_HEXDUMP("DSA KEY RR after X:", *dsa_key_rr, p-*dsa_key_rr);
-  }
-
- out_err:
-
-  if (err) {
-    if (*dsa_key_rr)
-       free(*dsa_key_rr);
-    return err;
-  }
-  else
-    return dsa_key_rr_len;
+int dsa_to_dns_key_rr(DSA *dsa, unsigned char **dsa_key_rr)
+{
+    int err            = 0;
+    int dsa_key_rr_len = -1;
+    signed char t; /* in units of 8 bytes */
+    unsigned char *p = NULL;
+    int key_len;
+
+    HIP_ASSERT(dsa != NULL); /* should not happen */
+
+    *dsa_key_rr = NULL;
+
+    _HIP_DEBUG("numbytes p=%d\n", BN_num_bytes(dsa->p));
+    _HIP_DEBUG("numbytes q=%d\n", BN_num_bytes(dsa->q));
+    _HIP_DEBUG("numbytes g=%d\n", BN_num_bytes(dsa->g));
+    // shouldn't this be NULL also?
+    _HIP_DEBUG("numbytes pubkey=%d\n", BN_num_bytes(dsa->pub_key));
+
+
+    /* notice that these functions allocate memory */
+    _HIP_DEBUG("p=%s\n", BN_bn2hex(dsa->p));
+    _HIP_DEBUG("q=%s\n", BN_bn2hex(dsa->q));
+    _HIP_DEBUG("g=%s\n", BN_bn2hex(dsa->g));
+    _HIP_DEBUG("pubkey=%s\n", BN_bn2hex(dsa->pub_key));
+
+    /* ***** is use of BN_num_bytes ok ? ***** */
+    t = (BN_num_bytes(dsa->p) - 64) / 8;
+    HIP_IFEL((t < 0 || t > 8), -EINVAL,
+             "Invalid RSA key length %d bits\n", (64 + t * 8) * 8);
+    _HIP_DEBUG("t=%d\n", t);
+
+    /* RFC 2536 section 2 */
+    /*
+     *       Field     Size
+     *       -----     ----
+     *        T         1  octet
+     *        Q        20  octets
+     *        P        64 + T*8  octets
+     *        G        64 + T*8  octets
+     *        Y        64 + T*8  octets
+     *      [ X        20 optional octets (private key hack) ]
+     *
+     */
+    key_len        = 64 + t * 8;
+    dsa_key_rr_len = 1 + DSA_PRIV + 3 * key_len;
+
+    if (dsa->priv_key) {
+        dsa_key_rr_len += DSA_PRIV; /* private key hack */
+        _HIP_DEBUG("Private key included\n");
+    } else {
+        _HIP_DEBUG("No private key\n");
+    }
+
+    _HIP_DEBUG("dsa key rr len = %d\n", dsa_key_rr_len);
+    *dsa_key_rr = malloc(dsa_key_rr_len);
+    HIP_IFEL(!*dsa_key_rr, -ENOMEM, "Malloc for *dsa_key_rr failed\n");
+    memset(*dsa_key_rr, 0, dsa_key_rr_len);
+
+    p           = *dsa_key_rr;
+
+    /* set T */
+    memset(p, t, 1); // XX FIX: WTF MEMSET?
+    p++;
+    _HIP_HEXDUMP("DSA KEY RR after T:", *dsa_key_rr, p - *dsa_key_rr);
+
+    /* add given dsa_param to the *dsa_key_rr */
+
+    bn2bin_safe(dsa->q, p, DSA_PRIV);
+    p += DSA_PRIV;
+    _HIP_HEXDUMP("DSA KEY RR after Q:", *dsa_key_rr, p - *dsa_key_rr);
+
+    bn2bin_safe(dsa->p, p, key_len);
+    p += key_len;
+    _HIP_HEXDUMP("DSA KEY RR after P:", *dsa_key_rr, p - *dsa_key_rr);
+
+    bn2bin_safe(dsa->g, p, key_len);
+    p += key_len;
+    _HIP_HEXDUMP("DSA KEY RR after G:", *dsa_key_rr, p - *dsa_key_rr);
+
+    bn2bin_safe(dsa->pub_key, p, key_len);
+    p += key_len;
+    _HIP_HEXDUMP("DSA KEY RR after Y:", *dsa_key_rr, p - *dsa_key_rr);
+
+    if (dsa->priv_key) {
+        bn2bin_safe(dsa->priv_key, p, DSA_PRIV);
+        _HIP_HEXDUMP("DSA KEY RR after X:", *dsa_key_rr, p - *dsa_key_rr);
+    }
+
+out_err:
+
+    if (err) {
+        if (*dsa_key_rr) {
+            free(*dsa_key_rr);
+        }
+        return err;
+    } else {
+        return dsa_key_rr_len;
+    }
 }
 
-
 /**
  * rsa_to_dns_key_rr - This is a new version of the function above. This 
function
  *                     assumes that RSA given as a parameter is always public 
(Laura/10.4.2006)
-                       Creates DNS KEY RR record from host RSA public key
+ *                     Creates DNS KEY RR record from host RSA public key
  * @param rsa the RSA structure from where the KEY RR record is to be created
  * @param rsa_key_rr where the resultin KEY RR is stored
  *
@@ -1501,87 +1526,89 @@
  * DNS KEY RR is stored at rsa_key_rr. On error function returns negative
  * and sets rsa_key_rr to NULL.
  */
-int rsa_to_dns_key_rr(RSA *rsa, unsigned char **rsa_key_rr){
-  int err = 0;
-  int rsa_key_rr_len = -1;
-  unsigned char *c;
-  int public = -1;
-  int e_len_bytes = 1;
-  int e_len, key_len;
-
-  HIP_ASSERT(rsa != NULL); // should not happen
-
-  *rsa_key_rr = NULL;
-
-  e_len = BN_num_bytes(rsa->e);
-  key_len = RSA_size(rsa);
-
-  /* RFC 3110 limits e to 4096 bits */
-  HIP_IFEL(e_len > 512, -EINVAL,  "Invalid rsa->e length %d bytes\n", e_len);
-  if (e_len > 255)
-       e_len_bytes = 3;
-
-  /* let's check if the RSA key is public or private
-     private exponent is NULL in public keys */
-  if(rsa->d == NULL) {
-    public = 1;
-    rsa_key_rr_len = e_len_bytes + e_len + key_len;
-
-    /*
-       See RFC 2537 for flags, protocol and algorithm and check RFC 3110 for
-       the RSA public key part ( 1-3 octets defining length of the exponent,
-       exponent is as many octets as the length defines and the modulus is
-       all the rest of the bytes).
-    */
-
-  } else{
-    public = 0;
-    rsa_key_rr_len = e_len_bytes + e_len + key_len * 9 / 2;
-  }
-
-  *rsa_key_rr = malloc(rsa_key_rr_len);
-  HIP_IFEL(!*rsa_key_rr, -ENOMEM, "Malloc for *rsa_key_rr failed\n");
-  memset(*rsa_key_rr, 0, rsa_key_rr_len);
-
-  c = *rsa_key_rr;
-
-  if (e_len_bytes == 1) {
-       *c = (unsigned char) e_len;
-  }
-  c++; /* If e_len is more than one byte, first byte is 0. */
-  if (e_len_bytes == 3) {
-       *c = htons((u16) e_len);
-       c += 2;
-  }
-
-  bn2bin_safe(rsa->e, c, e_len);
-  c += e_len;
-  bn2bin_safe(rsa->n, c, key_len);
-  c += key_len;
-
-  if(!public){
-          bn2bin_safe(rsa->d, c, key_len);
-          c += key_len;
-          bn2bin_safe(rsa->p, c, key_len / 2);
-          c += key_len / 2;
-          bn2bin_safe(rsa->q, c, key_len / 2);
-          c += key_len / 2;
-          bn2bin_safe(rsa->dmp1, c, key_len / 2);
-          c += key_len / 2;
-          bn2bin_safe(rsa->dmq1, c, key_len / 2);
-          c += key_len / 2;
-          bn2bin_safe(rsa->iqmp, c, key_len / 2);
-  }
-
- out_err:
-
-  if (err) {
-    if (*rsa_key_rr)
-       free(*rsa_key_rr);
-    return err;
-  }
-
-  return rsa_key_rr_len;
+int rsa_to_dns_key_rr(RSA *rsa, unsigned char **rsa_key_rr)
+{
+    int err            = 0;
+    int rsa_key_rr_len = -1;
+    unsigned char *c = NULL;
+    int public = -1;
+    int e_len_bytes    = 1;
+    int e_len, key_len;
+
+    HIP_ASSERT(rsa != NULL); // should not happen
+
+    *rsa_key_rr = NULL;
+
+    e_len       = BN_num_bytes(rsa->e);
+    key_len     = RSA_size(rsa);
+
+    /* RFC 3110 limits e to 4096 bits */
+    HIP_IFEL(e_len > 512, -EINVAL,  "Invalid rsa->e length %d bytes\n", e_len);
+    if (e_len > 255) {
+        e_len_bytes = 3;
+    }
+
+    /* let's check if the RSA key is public or private
+     * private exponent is NULL in public keys */
+    if (rsa->d == NULL) {
+        public         = 1;
+        rsa_key_rr_len = e_len_bytes + e_len + key_len;
+
+        /*
+         * See RFC 2537 for flags, protocol and algorithm and check RFC 3110 
for
+         * the RSA public key part ( 1-3 octets defining length of the 
exponent,
+         * exponent is as many octets as the length defines and the modulus is
+         * all the rest of the bytes).
+         */
+    } else {
+        public         = 0;
+        rsa_key_rr_len = e_len_bytes + e_len + key_len * 9 / 2;
+    }
+
+    *rsa_key_rr = malloc(rsa_key_rr_len);
+    HIP_IFEL(!*rsa_key_rr, -ENOMEM, "Malloc for *rsa_key_rr failed\n");
+    memset(*rsa_key_rr, 0, rsa_key_rr_len);
+
+    c           = *rsa_key_rr;
+
+    if (e_len_bytes == 1) {
+        *c = (unsigned char) e_len;
+    }
+    c++; /* If e_len is more than one byte, first byte is 0. */
+    if (e_len_bytes == 3) {
+        *c = htons((u16) e_len);
+        c += 2;
+    }
+
+    bn2bin_safe(rsa->e, c, e_len);
+    c += e_len;
+    bn2bin_safe(rsa->n, c, key_len);
+    c += key_len;
+
+    if (!public) {
+        bn2bin_safe(rsa->d, c, key_len);
+        c += key_len;
+        bn2bin_safe(rsa->p, c, key_len / 2);
+        c += key_len / 2;
+        bn2bin_safe(rsa->q, c, key_len / 2);
+        c += key_len / 2;
+        bn2bin_safe(rsa->dmp1, c, key_len / 2);
+        c += key_len / 2;
+        bn2bin_safe(rsa->dmq1, c, key_len / 2);
+        c += key_len / 2;
+        bn2bin_safe(rsa->iqmp, c, key_len / 2);
+    }
+
+out_err:
+
+    if (err) {
+        if (*rsa_key_rr) {
+            free(*rsa_key_rr);
+        }
+        return err;
+    }
+
+    return rsa_key_rr_len;
 }
 
 /**
@@ -1597,175 +1624,174 @@
  *                  NULL if the cast fails.
  */
 
-void *hip_cast_sa_addr(const struct sockaddr *sa) {
-       
-       if(sa == NULL){
-               return NULL;
-       }
-
-       switch(sa->sa_family) {
-       case AF_INET:
-               return &(((struct sockaddr_in *) sa)->sin_addr);
-       case AF_INET6:
-               return &(((struct sockaddr_in6 *) sa)->sin6_addr);
-       default:
-               return NULL;
-       }
-}
-
-int hip_sockaddr_is_v6_mapped(struct sockaddr *sa) {
-  int family = sa->sa_family;
-
-  HIP_ASSERT(family == AF_INET || family == AF_INET6);
-  if (family != AF_INET6)
-    return 0;
-  else
-    return IN6_IS_ADDR_V4MAPPED((struct in6_addr *)hip_cast_sa_addr(sa));
-}
-
-int hip_sockaddr_len(const void *sockaddr) {
-  struct sockaddr *sa = (struct sockaddr *) sockaddr;
-  int len;
-
-  switch(sa->sa_family) {
-  case AF_INET:
-    len = sizeof(struct sockaddr_in);
-    break;
-  case AF_INET6:
-    len = sizeof(struct sockaddr_in6);
-    break;
-  case AF_UNIX:
-    len = sizeof(struct sockaddr_un);
-    break;
-  default:
-    len = 0;
-  }
-  return len;
-}
-
-
-int hip_sa_addr_len(void *sockaddr){
-  struct sockaddr *sa = (struct sockaddr *) sockaddr;
-  int len;
-
-  switch(sa->sa_family){
-  case AF_INET:
-    len = 4;
-    break;
-  case AF_INET6:
-    len = 16;
-    break;
-  default:
-    len = 0;
-  }
-  return len;
-}
-
+void *hip_cast_sa_addr(const struct sockaddr *sa)
+{
+    if (sa == NULL) {
+        return NULL;
+    }
+
+    switch (sa->sa_family) {
+    case AF_INET:
+        return &(((struct sockaddr_in *) sa)->sin_addr);
+    case AF_INET6:
+        return &(((struct sockaddr_in6 *) sa)->sin6_addr);
+    default:
+        return NULL;
+    }
+}
+
+int hip_sockaddr_is_v6_mapped(struct sockaddr *sa)
+{
+    int family = sa->sa_family;
+
+    HIP_ASSERT(family == AF_INET || family == AF_INET6);
+    if (family != AF_INET6) {
+        return 0;
+    } else {
+        return IN6_IS_ADDR_V4MAPPED((struct in6_addr *) hip_cast_sa_addr(sa));
+    }
+}
+
+int hip_sockaddr_len(const void *sockaddr)
+{
+    struct sockaddr *sa = (struct sockaddr *) sockaddr;
+    int len;
+
+    switch (sa->sa_family) {
+    case AF_INET:
+        len = sizeof(struct sockaddr_in);
+        break;
+    case AF_INET6:
+        len = sizeof(struct sockaddr_in6);
+        break;
+    case AF_UNIX:
+        len = sizeof(struct sockaddr_un);
+        break;
+    default:
+        len = 0;
+    }
+    return len;
+}
+
+int hip_sa_addr_len(void *sockaddr)
+{
+    struct sockaddr *sa = (struct sockaddr *) sockaddr;
+    int len;
+
+    switch (sa->sa_family) {
+    case AF_INET:
+        len = 4;
+        break;
+    case AF_INET6:
+        len = 16;
+        break;
+    default:
+        len = 0;
+    }
+    return len;
+}
 
 /* conversion function from in6_addr to sockaddr_storage
  *
  * NOTE: sockaddr too small to store sockaddr_in6 */
 void hip_addr_to_sockaddr(struct in6_addr *addr, struct sockaddr_storage *sa)
 {
-       memset(sa, 0, sizeof(struct sockaddr_storage));
-
-       if (IN6_IS_ADDR_V4MAPPED(addr)) {
-               struct sockaddr_in *in = (struct sockaddr_in *) sa;
-               in->sin_family = AF_INET;
-               IPV6_TO_IPV4_MAP(addr, &in->sin_addr);
-       } else {
-               struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) sa;
-               in6->sin6_family = AF_INET6;
-               ipv6_addr_copy(&in6->sin6_addr, addr);
-       }
-}
-
-
-int hip_remove_lock_file(char *filename){
-       return unlink(filename);
-}
-
-
-int hip_create_lock_file(char *filename, int killold) {
-
-       int err = 0, fd = 0, old_pid = 0, new_pid_str_len = 0;
-       char old_pid_str[64], new_pid_str[64];
-       int pid_set = 0; /* the pid was read successfully */
-       memset(old_pid_str, 0, sizeof(old_pid_str));
-       memset(new_pid_str, 0, sizeof(new_pid_str));
-
-       /* New pid */
-       snprintf(new_pid_str, sizeof(new_pid_str)-1, "%d\n", getpid());
-       new_pid_str_len = strlen(new_pid_str);
-       HIP_IFEL((new_pid_str_len <= 0), -1, "pID length error.\n");
-
-       /* Read old pid */
-       fd = HIP_CREATE_FILE(filename);
-       HIP_IFEL((fd <= 0), -1, "opening lock file failed\n");
-
-       /* FIXME: This is possibly unsafe: the pid is read from the file 
without checking
-        * file permissions and the process with the number is simply killed.
-        * THIS COULD BE USED TO ATTACK THE SYSTEM
-        */
-       pid_set = read(fd, old_pid_str, sizeof(old_pid_str) - 1);
-       old_pid = atoi(old_pid_str);
-
-       if (lockf(fd, F_TLOCK, 0) < 0)
-       {
-               HIP_IFEL(!killold, -12,
-                        "\nHIP daemon already running with pid %d\n"
-                        "Give: -k option to kill old daemon.\n", old_pid);
-
-               HIP_INFO("\nDaemon is already running with pid %d\n"
-                        "-k option given, terminating old one...\n", old_pid);
-               /* Erase the old lock file to avoid having multiple pids
-                  in the file */
-               if( lockf(fd, F_ULOCK, 0) == -1) {
-                       HIP_ERROR("Cannot unlock pid lock.");
-                       
-               }
-
-               close(fd);
-               HIP_IFEL(hip_remove_lock_file(filename), -1,
-                        "Removing lock file failed.\n");
-
-                /* fd = open(filename, O_RDWR | O_CREAT, 0644); */
-               fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
-
-                /* Don't close file descriptor because new started process is
-                  running. */
-               HIP_IFEL((fd <= 0), -1, "Opening lock file failed.\n");
-               HIP_IFEL(lockf(fd, F_TLOCK, 0), -1, "Lock attempt failed.\n");
-               if (pid_set){
-                       err = kill(old_pid, SIGKILL);
-               }
-               if (err != 0) {
-                       HIP_ERROR("\nError when trying to send signal SIGKILL "\
-                                 "process identified by process identifier "\
-                                 "%d.\n", old_pid);
-                       HIP_PERROR("errno after kill() is: ");
-               }
-       }
-       /* else if (killold)
-          {
-          lseek(fd,0,SEEK_SET);
-          write(fd, new_pid_str, new_pid_str_len);
-          system("NEW_PID=$(sudo awk NR==1 /var/lock/hipd.lock)");
-          system("OLD_PID=$(/bin/pidof -o $NEW_PID hipd)");
-          system("kill -9 $OLD_PID");
-          } */
-
-       lseek(fd, 0, SEEK_SET);
-
-       HIP_IFEL((write(fd, new_pid_str, new_pid_str_len) != new_pid_str_len),
-                -1, "Writing new process identifier failed.\n");
-
- out_err:
-       if (err == -12) {
-               exit(0);
-       }
-
-       return err;
+    memset(sa, 0, sizeof(struct sockaddr_storage));
+
+    if (IN6_IS_ADDR_V4MAPPED(addr)) {
+        struct sockaddr_in *in = (struct sockaddr_in *) sa;
+        in->sin_family = AF_INET;
+        IPV6_TO_IPV4_MAP(addr, &in->sin_addr);
+    } else {
+        struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) sa;
+        in6->sin6_family = AF_INET6;
+        ipv6_addr_copy(&in6->sin6_addr, addr);
+    }
+}
+
+int hip_remove_lock_file(char *filename)
+{
+    return unlink(filename);
+}
+
+int hip_create_lock_file(char *filename, int killold)
+{
+    int err     = 0, fd = 0, old_pid = 0, new_pid_str_len = 0;
+    char old_pid_str[64], new_pid_str[64];
+    int pid_set = 0;     /* the pid was read successfully */
+    memset(old_pid_str, 0, sizeof(old_pid_str));
+    memset(new_pid_str, 0, sizeof(new_pid_str));
+
+    /* New pid */
+    snprintf(new_pid_str, sizeof(new_pid_str) - 1, "%d\n", getpid());
+    new_pid_str_len = strlen(new_pid_str);
+    HIP_IFEL((new_pid_str_len <= 0), -1, "pID length error.\n");
+
+    /* Read old pid */
+    fd              = HIP_CREATE_FILE(filename);
+    HIP_IFEL((fd <= 0), -1, "opening lock file failed\n");
+
+    /* FIXME: This is possibly unsafe: the pid is read from the file without 
checking
+     * file permissions and the process with the number is simply killed.
+     * THIS COULD BE USED TO ATTACK THE SYSTEM
+     */
+    pid_set         = read(fd, old_pid_str, sizeof(old_pid_str) - 1);
+    old_pid         = atoi(old_pid_str);
+
+    if (lockf(fd, F_TLOCK, 0) < 0) {
+        HIP_IFEL(!killold, -12,
+                 "\nHIP daemon already running with pid %d\n"
+                 "Give: -k option to kill old daemon.\n", old_pid);
+
+        HIP_INFO("\nDaemon is already running with pid %d\n"
+                 "-k option given, terminating old one...\n", old_pid);
+        /* Erase the old lock file to avoid having multiple pids
+         * in the file */
+        if (lockf(fd, F_ULOCK, 0) == -1) {
+            HIP_ERROR("Cannot unlock pid lock.");
+        }
+
+        close(fd);
+        HIP_IFEL(hip_remove_lock_file(filename), -1,
+                 "Removing lock file failed.\n");
+
+        /* fd = open(filename, O_RDWR | O_CREAT, 0644); */
+        fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
+
+        /* Don't close file descriptor because new started process is
+         * running. */
+        HIP_IFEL((fd <= 0), -1, "Opening lock file failed.\n");
+        HIP_IFEL(lockf(fd, F_TLOCK, 0), -1, "Lock attempt failed.\n");
+        if (pid_set) {
+            err = kill(old_pid, SIGKILL);
+        }
+        if (err != 0) {
+            HIP_ERROR("\nError when trying to send signal SIGKILL " \
+                      "process identified by process identifier " \
+                      "%d.\n", old_pid);
+            HIP_PERROR("errno after kill() is: ");
+        }
+    }
+    /* else if (killold)
+     * {
+     * lseek(fd,0,SEEK_SET);
+     * write(fd, new_pid_str, new_pid_str_len);
+     * system("NEW_PID=$(sudo awk NR==1 /var/lock/hipd.lock)");
+     * system("OLD_PID=$(/bin/pidof -o $NEW_PID hipd)");
+     * system("kill -9 $OLD_PID");
+     * } */
+
+    lseek(fd, 0, SEEK_SET);
+
+    HIP_IFEL((write(fd, new_pid_str, new_pid_str_len) != new_pid_str_len),
+             -1, "Writing new process identifier failed.\n");
+
+out_err:
+    if (err == -12) {
+        exit(0);
+    }
+
+    return err;
 }
 
 /**
@@ -1781,143 +1807,145 @@
  * odds are 1/2^64 to try 0, I don't see the point in improving this now.
  */
 uint64_t hip_solve_puzzle(void *puzzle_or_solution,
-                         struct hip_common *hdr,
-                         int mode){
-       uint64_t mask = 0;
-       uint64_t randval = 0;
-       uint64_t maxtries = 0;
-       uint64_t digest = 0;
-       u8 cookie[48];
-       int err = 0;
-       union {
-               struct hip_puzzle pz;
-               struct hip_solution sl;
-       } *u;
-
-       HIP_HEXDUMP("puzzle", puzzle_or_solution,
-                   (mode == HIP_VERIFY_PUZZLE ? sizeof(struct hip_solution) : 
sizeof(struct hip_puzzle)));
-
-       _HIP_DEBUG("\n");
-       /* pre-create cookie */
-       u = puzzle_or_solution;
-
-       _HIP_DEBUG("current hip_cookie_max_k_r1=%d\n", max_k);
-       HIP_IFEL(u->pz.K > HIP_PUZZLE_MAX_K, 0,
-                "Cookie K %u is higher than we are willing to calculate"
-                " (current max K=%d)\n", u->pz.K, HIP_PUZZLE_MAX_K);
-
-       mask = hton64((1ULL << u->pz.K) - 1);
-       memcpy(cookie, (u8 *)&(u->pz.I), sizeof(uint64_t));
-
-       HIP_DEBUG("(u->pz.I: 0x%llx\n", u->pz.I);
-
-       if (mode == HIP_VERIFY_PUZZLE) {
-               ipv6_addr_copy((hip_hit_t *)(cookie+8), &hdr->hits);
-               ipv6_addr_copy((hip_hit_t *)(cookie+24), &hdr->hitr);
-               //randval = ntoh64(u->sl.J);
-               randval = u->sl.J;
-               _HIP_DEBUG("u->sl.J: 0x%llx\n", randval);
-               maxtries = 1;
-       } else if (mode == HIP_SOLVE_PUZZLE) {
-               ipv6_addr_copy((hip_hit_t *)(cookie+8), &hdr->hitr);
-               ipv6_addr_copy((hip_hit_t *)(cookie+24), &hdr->hits);
-               maxtries = 1ULL << (u->pz.K + 3);
-               get_random_bytes(&randval, sizeof(u_int64_t));
-       } else {
-               HIP_IFEL(1, 0, "Unknown mode: %d\n", mode);
-       }
-
-       HIP_DEBUG("K=%u, maxtries (with k+2)=%llu\n", u->pz.K, maxtries);
-       /* while loops should work even if the maxtries is unsigned
-        * if maxtries = 1 ---> while(1 > 0) [maxtries == 0 now]...
-        * the next round while (0 > 0) [maxtries > 0 now]
-        */
-       while(maxtries-- > 0) {
-               u8 sha_digest[HIP_AH_SHA_LEN];
-
-               /* must be 8 */
-               memcpy(cookie + 40, (u8*) &randval, sizeof(uint64_t));
-
-               hip_build_digest(HIP_DIGEST_SHA1, cookie, 48, sha_digest);
-
-                /* copy the last 8 bytes for checking */
-               memcpy(&digest, sha_digest + 12, sizeof(uint64_t));
-
-               /* now, in order to be able to do correctly the bitwise
-                * AND-operation we have to remember that little endian
-                * processors will interpret the digest and mask reversely.
-                * digest is the last 64 bits of the sha1-digest.. how that is
-                * ordered in processors registers etc.. does not matter to us.
-                * If the last 64 bits of the sha1-digest is
-                * 0x12345678DEADBEEF, whether we have 0xEFBEADDE78563412
-                * doesn't matter because the mask matters... if the mask is
-                * 0x000000000000FFFF (or in other endianness
-                * 0xFFFF000000000000). Either ways... the result is
-                * 0x000000000000BEEF or 0xEFBE000000000000, which the cpu
-                * interprets as 0xBEEF. The mask is converted to network byte
-                * order (above).
-                */
-               if ((digest & mask) == 0) {
-                       _HIP_DEBUG("*** Puzzle solved ***: 0x%llx\n",randval);
-                       _HIP_HEXDUMP("digest", sha_digest, HIP_AH_SHA_LEN);
-                       _HIP_HEXDUMP("cookie", cookie, sizeof(cookie));
-                       return randval;
-               }
-
-               /* It seems like the puzzle was not correctly solved */
-               HIP_IFEL(mode == HIP_VERIFY_PUZZLE, 0, "Puzzle incorrect\n");
-               randval++;
-       }
-
-       HIP_ERROR("Could not solve the puzzle, no solution found\n");
- out_err:
-       return err;
+                          struct hip_common *hdr,
+                          int mode)
+{
+    uint64_t mask     = 0;
+    uint64_t randval  = 0;
+    uint64_t maxtries = 0;
+    uint64_t digest   = 0;
+    u8 cookie[48];
+    int err           = 0;
+    union {
+        struct hip_puzzle   pz;
+        struct hip_solution sl;
+    } *u;
+
+    HIP_HEXDUMP("puzzle", puzzle_or_solution,
+                (mode == HIP_VERIFY_PUZZLE ? sizeof(struct hip_solution) :
+                                             sizeof(struct hip_puzzle)));
+
+    _HIP_DEBUG("\n");
+    /* pre-create cookie */
+    u = puzzle_or_solution;
+
+    _HIP_DEBUG("current hip_cookie_max_k_r1=%d\n", max_k);
+    HIP_IFEL(u->pz.K > HIP_PUZZLE_MAX_K, 0,
+             "Cookie K %u is higher than we are willing to calculate"
+             " (current max K=%d)\n", u->pz.K, HIP_PUZZLE_MAX_K);
+
+    mask = hton64((1ULL << u->pz.K) - 1);
+    memcpy(cookie, (u8 *) &(u->pz.I), sizeof(uint64_t));
+
+    HIP_DEBUG("(u->pz.I: 0x%llx\n", u->pz.I);
+
+    if (mode == HIP_VERIFY_PUZZLE) {
+        ipv6_addr_copy((hip_hit_t *) (cookie + 8), &hdr->hits);
+        ipv6_addr_copy((hip_hit_t *) (cookie + 24), &hdr->hitr);
+        //randval = ntoh64(u->sl.J);
+        randval  = u->sl.J;
+        _HIP_DEBUG("u->sl.J: 0x%llx\n", randval);
+        maxtries = 1;
+    } else if (mode == HIP_SOLVE_PUZZLE) {
+        ipv6_addr_copy((hip_hit_t *) (cookie + 8), &hdr->hitr);
+        ipv6_addr_copy((hip_hit_t *) (cookie + 24), &hdr->hits);
+        maxtries = 1ULL << (u->pz.K + 3);
+        get_random_bytes(&randval, sizeof(u_int64_t));
+    } else {
+        HIP_IFEL(1, 0, "Unknown mode: %d\n", mode);
+    }
+
+    HIP_DEBUG("K=%u, maxtries (with k+2)=%llu\n", u->pz.K, maxtries);
+    /* while loops should work even if the maxtries is unsigned
+     * if maxtries = 1 ---> while(1 > 0) [maxtries == 0 now]...
+     * the next round while (0 > 0) [maxtries > 0 now]
+     */
+    while (maxtries-- > 0) {
+        u8 sha_digest[HIP_AH_SHA_LEN];
+
+        /* must be 8 */
+        memcpy(cookie + 40, (u8 *) &randval, sizeof(uint64_t));
+
+        hip_build_digest(HIP_DIGEST_SHA1, cookie, 48, sha_digest);
+
+        /* copy the last 8 bytes for checking */
+        memcpy(&digest, sha_digest + 12, sizeof(uint64_t));
+
+        /* now, in order to be able to do correctly the bitwise
+         * AND-operation we have to remember that little endian
+         * processors will interpret the digest and mask reversely.
+         * digest is the last 64 bits of the sha1-digest.. how that is
+         * ordered in processors registers etc.. does not matter to us.
+         * If the last 64 bits of the sha1-digest is
+         * 0x12345678DEADBEEF, whether we have 0xEFBEADDE78563412
+         * doesn't matter because the mask matters... if the mask is
+         * 0x000000000000FFFF (or in other endianness
+         * 0xFFFF000000000000). Either ways... the result is
+         * 0x000000000000BEEF or 0xEFBE000000000000, which the cpu
+         * interprets as 0xBEEF. The mask is converted to network byte
+         * order (above).
+         */
+        if ((digest & mask) == 0) {
+            _HIP_DEBUG("*** Puzzle solved ***: 0x%llx\n", randval);
+            _HIP_HEXDUMP("digest", sha_digest, HIP_AH_SHA_LEN);
+            _HIP_HEXDUMP("cookie", cookie, sizeof(cookie));
+            return randval;
+        }
+
+        /* It seems like the puzzle was not correctly solved */
+        HIP_IFEL(mode == HIP_VERIFY_PUZZLE, 0, "Puzzle incorrect\n");
+        randval++;
+    }
+
+    HIP_ERROR("Could not solve the puzzle, no solution found\n");
+out_err:
+    return err;
 }
 
 #ifdef CONFIG_HIP_MIDAUTH
-int hip_solve_puzzle_m(struct hip_common *out, struct hip_common *in, hip_ha_t 
*entry)
+int hip_solve_puzzle_m(struct hip_common *out,
+                       struct hip_common *in,
+                       hip_ha_t *entry)
 {
-       struct hip_challenge_request *pz;
-       struct hip_puzzle tmp;
-       uint64_t solution;
-       int err = 0;
-       uint8_t digist[HIP_AH_SHA_LEN];
-
-
-       pz = hip_get_param(in, HIP_PARAM_CHALLENGE_REQUEST);
-       while (pz) {
-               if (hip_get_param_type(pz) != HIP_PARAM_CHALLENGE_REQUEST)
-                       break;
-
-               HIP_IFEL(hip_build_digest(HIP_DIGEST_SHA1, pz->opaque, 24, 
digist) < 0,
-                                        -1, "Building of SHA1 Random seed I 
failed\n");
-               tmp.type = pz->type;
-               tmp.length = pz->length;
-               tmp.K = pz->K;
-               tmp.lifetime = pz->lifetime;
-               tmp.opaque[0] = tmp.opaque[1] = 0;
-               tmp.I = *digist & 0x40; //truncate I to 8 byte length
-
-               HIP_IFEL((solution = entry->hadb_misc_func->hip_solve_puzzle(
-                        &tmp, in, HIP_SOLVE_PUZZLE)) == 0,
-                        -EINVAL, "Solving of puzzle failed\n");
-
-               HIP_IFEL(hip_build_param_challenge_response(out, pz, 
ntoh64(solution)) < 0, -1, "Error while creating solution_m reply parameter\n");
-               pz = (struct hip_challenge_request *) hip_get_next_param(in,
-                      (struct hip_tlv_common *) pz);
-       }
+    struct hip_challenge_request *pz;
+    struct hip_puzzle tmp;
+    uint64_t solution;
+    int err = 0;
+    uint8_t digist[HIP_AH_SHA_LEN];
+
+
+    pz = hip_get_param(in, HIP_PARAM_CHALLENGE_REQUEST);
+    while (pz) {
+        if (hip_get_param_type(pz) != HIP_PARAM_CHALLENGE_REQUEST) {
+            break;
+        }
+
+        HIP_IFEL(hip_build_digest(HIP_DIGEST_SHA1, pz->opaque, 24, digist) < 0,
+                 -1, "Building of SHA1 Random seed I failed\n");
+        tmp.type      = pz->type;
+        tmp.length    = pz->length;
+        tmp.K         = pz->K;
+        tmp.lifetime  = pz->lifetime;
+        tmp.opaque[0] = tmp.opaque[1] = 0;
+        tmp.I         = *digist & 0x40; //truncate I to 8 byte length
+
+        HIP_IFEL((solution = entry->hadb_misc_func->hip_solve_puzzle(
+                      &tmp, in, HIP_SOLVE_PUZZLE)) == 0,
+                 -EINVAL, "Solving of puzzle failed\n");
+
+        HIP_IFEL(hip_build_param_challenge_response(out, pz, ntoh64(solution)) 
< 0,
+                 -1,
+                 "Error while creating solution_m reply parameter\n");
+        pz = (struct hip_challenge_request *) hip_get_next_param(in,
+                                                                 (struct 
hip_tlv_common *) pz);
+    }
 
 out_err:
-       return err;
+    return err;
 }
+
 #endif
 
-
-
-
-
-
-
 /**
  * Gets the state of the bex for a pair of ip addresses.
  * @param *src_ip      input for finding the correct entries
@@ -1931,154 +1959,151 @@
  *                     otherwise returns -1
  */
 int hip_get_bex_state_from_LSIs(hip_lsi_t       *src_lsi,
-                               hip_lsi_t       *dst_lsi,
-                               struct in6_addr *src_ip,
-                               struct in6_addr *dst_ip,
-                               struct in6_addr *src_hit,
-                               struct in6_addr *dst_hit){
-       int err = 0, res = -1;
-       struct hip_tlv_common *current_param = NULL;
-       struct hip_common *msg = NULL;
-       struct hip_hadb_user_info_state *ha;
-
-       HIP_ASSERT(src_ip != NULL && dst_ip != NULL);
-
-       HIP_IFEL(!(msg = hip_msg_alloc()), -1, "malloc failed\n");
-       hip_msg_init(msg);
-       HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
-                       -1, "Building of daemon header failed\n");
-       HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send recv daemon 
info\n");
-
-       while((current_param = hip_get_next_param(msg, current_param)) != NULL) 
{
-               ha = hip_get_param_contents_direct(current_param);
-
-               if( (ipv4_addr_cmp(dst_lsi, &ha->lsi_our) == 0)  &&
-                   (ipv4_addr_cmp(src_lsi, &ha->lsi_peer) == 0)    ){
-                       *src_hit = ha->hit_peer;
-                       *dst_hit = ha->hit_our;
-                       *src_ip = ha->ip_peer;
-                       *dst_ip = ha->ip_our;
-                       res = ha->state;
-                       break;
-               }else if( (ipv4_addr_cmp(src_lsi, &ha->lsi_our) == 0)  &&
-                         (ipv4_addr_cmp(dst_lsi, &ha->lsi_peer) == 0)    ){
-                       *src_hit = ha->hit_our;
-                       *dst_hit = ha->hit_peer;
-                       *src_ip = ha->ip_our;
-                       *dst_ip = ha->ip_peer;
-                       res = ha->state;
-                       break;
-               }
-       }
-
- out_err:
-        if(msg)
-                HIP_FREE(msg);
-        return res;
-
+                                hip_lsi_t       *dst_lsi,
+                                struct in6_addr *src_ip,
+                                struct in6_addr *dst_ip,
+                                struct in6_addr *src_hit,
+                                struct in6_addr *dst_hit)
+{
+    int err = 0, res = -1;
+    struct hip_tlv_common *current_param = NULL;
+    struct hip_common *msg               = NULL;
+    struct hip_hadb_user_info_state *ha;
+
+    HIP_ASSERT(src_ip != NULL && dst_ip != NULL);
+
+    HIP_IFEL(!(msg = hip_msg_alloc()), -1, "malloc failed\n");
+    hip_msg_init(msg);
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
+             -1, "Building of daemon header failed\n");
+    HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send recv daemon 
info\n");
+
+    while ((current_param = hip_get_next_param(msg, current_param)) != NULL) {
+        ha = hip_get_param_contents_direct(current_param);
+
+        if ((ipv4_addr_cmp(dst_lsi, &ha->lsi_our) == 0)  &&
+            (ipv4_addr_cmp(src_lsi, &ha->lsi_peer) == 0)) {
+            *src_hit = ha->hit_peer;
+            *dst_hit = ha->hit_our;
+            *src_ip  = ha->ip_peer;
+            *dst_ip  = ha->ip_our;
+            res      = ha->state;
+            break;
+        } else if ((ipv4_addr_cmp(src_lsi, &ha->lsi_our) == 0)  &&
+                   (ipv4_addr_cmp(dst_lsi, &ha->lsi_peer) == 0)) {
+            *src_hit = ha->hit_our;
+            *dst_hit = ha->hit_peer;
+            *src_ip  = ha->ip_our;
+            *dst_ip  = ha->ip_peer;
+            res      = ha->state;
+            break;
+        }
+    }
+
+out_err:
+    if (msg) {
+        HIP_FREE(msg);
+    }
+    return res;
 }
 
 /**
  * Obtains the information needed by the dns proxy, based on the ip addr
- * 
+ *
  * @param *ip_addr     input, the ip address to look for
  * @param *hit         output, the corresponding hit
- * @param *lsi         output, the corresponding lsi   
- * 
+ * @param *lsi         output, the corresponding lsi
+ *
  * @return             1 - if a corresponding entry is found
- *                     0 - is returned if there is no entry
+ *          0 - is returned if there is no entry
  */
 /*int hip_get_info_for_dnsproxy_from_ip(
-                               struct in6_addr *ip_addr,
-                               struct in6_addr *hit,
-                               hip_lsi_t       *lsi){
-       int err = 0, res = 0;
-       hip_lsi_t src_ip4, dst_ip4;
-       struct hip_tlv_common *current_param = NULL;
-       struct hip_common *msg = NULL;
-       struct hip_hadb_user_info_state *ha;
-  
-       HIP_ASSERT(ip_addr != NULL);
-
-       HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, "malloc failed\n");
-       hip_msg_init(msg);
-       HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
-                               -1, "Building of daemon header failed\n");
-       HIP_IFEL(hip_send_recv_daemon_info(msg), -1, "send recv daemon info\n");
-
-       while((current_param = hip_get_next_param(msg, current_param)) != NULL){
-               ha = hip_get_param_contents_direct(current_param);
-               if(ipv6_addr_cmp(ip_addr, &ha->ip_our) == 0){
-                       *hit = ha->hit_our;
-                       *lsi = ha->lsi_our;
-                       res = 1;
-                       break;
-               }
-               else if(ipv6_addr_cmp(ip_addr, &ha->ip_peer) == 0){
-                       *hit = ha->hit_peer;
-                       *lsi = ha->lsi_peer;
-                       res = 1;
-                       break;
-               }
-       }
-out_err:
-        if(msg)
-                HIP_FREE(msg);  
-        return res;
-}
-*/
+ *                              struct in6_addr *ip_addr,
+ *                              struct in6_addr *hit,
+ *                              hip_lsi_t       *lsi){
+ *      int err = 0, res = 0;
+ *      hip_lsi_t src_ip4, dst_ip4;
+ *      struct hip_tlv_common *current_param = NULL;
+ *      struct hip_common *msg = NULL;
+ *      struct hip_hadb_user_info_state *ha;
+ *
+ *      HIP_ASSERT(ip_addr != NULL);
+ *
+ *      HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, "malloc failed\n");
+ *      hip_msg_init(msg);
+ *      HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
+ *                              -1, "Building of daemon header failed\n");
+ *      HIP_IFEL(hip_send_recv_daemon_info(msg), -1, "send recv daemon 
info\n");
+ *
+ *      while((current_param = hip_get_next_param(msg, current_param)) != 
NULL){
+ *              ha = hip_get_param_contents_direct(current_param);
+ *              if(ipv6_addr_cmp(ip_addr, &ha->ip_our) == 0){
+ *hit = ha->hit_our;
+ *lsi = ha->lsi_our;
+ *                      res = 1;
+ *                      break;
+ *              }
+ *              else if(ipv6_addr_cmp(ip_addr, &ha->ip_peer) == 0){
+ *hit = ha->hit_peer;
+ *lsi = ha->lsi_peer;
+ *                      res = 1;
+ *                      break;
+ *              }
+ *      }
+ * out_err:
+ *      if(msg)
+ *              HIP_FREE(msg);
+ *      return res;
+ * }
+ */
 
 /**
  * Obtains the information needed by the dns proxy, based on the hostname
- * 
+ *
  * @param *hostname    input, the ip address to look for
  * @param *hit         output, the corresponding hit
- * @param *lsi         output, the corresponding lsi   
- * 
+ * @param *lsi         output, the corresponding lsi
+ *
  * @return             1 - if a corresponding entry is found
- *                     0 - is returned if there is no entry
+ *          0 - is returned if there is no entry
  */
 /*int hip_get_info_for_dnsproxy_from_hostname(
-                               const char      *hostname,
-                               struct in6_addr *ip,
-                               struct in6_addr *hit,
-                               hip_lsi_t       *lsi){
-       int err = 0, res = 0;
-       hip_lsi_t src_ip4, dst_ip4;
-       struct hip_tlv_common *current_param = NULL;
-       struct hip_common *msg = NULL;
-       struct hip_hadb_user_info_state *ha;
-  
-       HIP_ASSERT(hostname != NULL);
-
-       HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, "malloc failed\n");
-       hip_msg_init(msg);
-       HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
-                               -1, "Building of daemon header failed\n");
-       HIP_IFEL(hip_send_recv_daemon_info(msg), -1, "send recv daemon info\n");
-
-       while((current_param = hip_get_next_param(msg, current_param)) != NULL){
-               ha = hip_get_param_contents_direct(current_param);
-
-               if(strcmp(hostname, &ha->peer_hostname) == 0){
-                       *ip =  ha->ip_peer;
-                       *hit = ha->hit_peer;
-                       *lsi = ha->lsi_peer;
-                       res = 1;
-                       break;
-               }
-       }
-
-out_err:
-        if(msg)
-                HIP_FREE(msg);  
-        return res;
-}
-*/
-
-
-
-
+ *                              const char      *hostname,
+ *                              struct in6_addr *ip,
+ *                              struct in6_addr *hit,
+ *                              hip_lsi_t       *lsi){
+ *      int err = 0, res = 0;
+ *      hip_lsi_t src_ip4, dst_ip4;
+ *      struct hip_tlv_common *current_param = NULL;
+ *      struct hip_common *msg = NULL;
+ *      struct hip_hadb_user_info_state *ha;
+ *
+ *      HIP_ASSERT(hostname != NULL);
+ *
+ *      HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1, "malloc failed\n");
+ *      hip_msg_init(msg);
+ *      HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_GET_HA_INFO, 0),
+ *                              -1, "Building of daemon header failed\n");
+ *      HIP_IFEL(hip_send_recv_daemon_info(msg), -1, "send recv daemon 
info\n");
+ *
+ *      while((current_param = hip_get_next_param(msg, current_param)) != 
NULL){
+ *              ha = hip_get_param_contents_direct(current_param);
+ *
+ *              if(strcmp(hostname, &ha->peer_hostname) == 0){
+ *ip =  ha->ip_peer;
+ *hit = ha->hit_peer;
+ *lsi = ha->lsi_peer;
+ *                      res = 1;
+ *                      break;
+ *              }
+ *      }
+ *
+ * out_err:
+ *      if(msg)
+ *              HIP_FREE(msg);
+ *      return res;
+ * }
+ */
 
 /* This builds a msg which will be sent to the HIPd in order to trigger
  * a BEX there.
@@ -2087,123 +2112,130 @@
  *         No, because this function is called by hip_fw_handle_outgoing_lsi 
too.
  *
  * NOTE: Either destination HIT or IP (for opportunistic BEX) has to be 
provided */
-int hip_trigger_bex(const struct in6_addr *src_hit, const struct in6_addr 
*dst_hit,
-                   struct in6_addr *src_lsi, struct in6_addr *dst_lsi,
-                   struct in6_addr *src_ip,  struct in6_addr *dst_ip){
-        struct hip_common *msg = NULL;
-        int err = 0;
-        HIP_IFE(!(msg = hip_msg_alloc()), -1);
-        HIP_IFEL(!dst_hit && !dst_ip, -1,
-                "neither destination hit nor ip provided\n");
-
-        /* NOTE: we need this sequence in order to process the incoming
-          message correctly */
-
-        /* build the message header */
-        HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_TRIGGER_BEX, 0),
-                                       -1, "build hdr failed\n");
-
-        // destination HIT is obligatory or opportunistic BEX
-        if(dst_hit) {
-               HIP_DEBUG_HIT("dst_hit: ", dst_hit);
-               HIP_IFEL(hip_build_param_contents(msg, (void *)(dst_hit),
-                                                  HIP_PARAM_HIT,
-                                                 sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_HIT failed\n");
-       }
-
-        // source HIT is optional
-        if(src_hit) {
-               HIP_DEBUG_HIT("src_hit: ", src_hit);
-               HIP_IFEL(hip_build_param_contents(msg, (void *)(src_hit),
-                                                 HIP_PARAM_HIT,
-                                                 sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_HIT failed\n");
-       }
-
-        // destination LSI is obligatory
-        if(dst_lsi) {
-               HIP_DEBUG_IN6ADDR("dst lsi: ", dst_lsi);
-                HIP_IFEL(hip_build_param_contents(msg, (void *)(dst_lsi),
-                                                  HIP_PARAM_LSI,
-                                                  sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_LSI failed\n");
-       }
-
-        // source LSI is optional
-        if(src_lsi) {
-               HIP_DEBUG_IN6ADDR("src lsi: ", src_lsi);
-               HIP_IFEL(hip_build_param_contents(msg, (void *)(src_lsi),
-                                                 HIP_PARAM_LSI,
-                                                 sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_LSI failed\n");
-       }
-
-        // if no destination HIT is provided this has to be there
-        if(dst_ip) {
-               HIP_DEBUG_IN6ADDR("dst_ip: ", dst_ip);
-                HIP_IFEL(hip_build_param_contents(msg, (void *)(dst_ip),
-                                                  HIP_PARAM_IPV6_ADDR,
-                                                  sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_IPV6_ADDR failed\n");
-       }
-
-        // this again is optional
-        if (src_ip) {
-               HIP_DEBUG_IN6ADDR("src_ip: ", src_ip);
-               HIP_IFEL(hip_build_param_contents(msg, (void *)(src_ip),
-                                                 HIP_PARAM_IPV6_ADDR,
-                                                 sizeof(struct in6_addr)),
-                               -1, "build param HIP_PARAM_IPV6_ADDR failed\n");
-       }
-
-        HIP_DUMP_MSG(msg);
-
-        /* send msg to hipd and receive corresponding reply */
-        HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send_recv msg 
failed\n");
-
-        /* check error value */
-        HIP_IFEL(hip_get_msg_err(msg), -1, "hipd returned error message!\n");
-        HIP_DEBUG("Send_recv msg succeed \n");
-
- out_err:
-        if (msg)
-                HIP_FREE(msg);
-        return err;
+int hip_trigger_bex(const struct in6_addr *src_hit,
+                    const struct in6_addr *dst_hit,
+                    struct in6_addr *src_lsi,
+                    struct in6_addr *dst_lsi,
+                    struct in6_addr *src_ip,
+                    struct in6_addr *dst_ip)
+{
+    struct hip_common *msg = NULL;
+    int err                = 0;
+    HIP_IFE(!(msg = hip_msg_alloc()), -1);
+    HIP_IFEL(!dst_hit && !dst_ip, -1,
+             "neither destination hit nor ip provided\n");
+
+    /* NOTE: we need this sequence in order to process the incoming
+     * message correctly */
+
+    /* build the message header */
+    HIP_IFEL(hip_build_user_hdr(msg, SO_HIP_TRIGGER_BEX, 0),
+             -1, "build hdr failed\n");
+
+    // destination HIT is obligatory or opportunistic BEX
+    if (dst_hit) {
+        HIP_DEBUG_HIT("dst_hit: ", dst_hit);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (dst_hit),
+                                          HIP_PARAM_HIT,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_HIT failed\n");
+    }
+
+    // source HIT is optional
+    if (src_hit) {
+        HIP_DEBUG_HIT("src_hit: ", src_hit);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (src_hit),
+                                          HIP_PARAM_HIT,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_HIT failed\n");
+    }
+
+    // destination LSI is obligatory
+    if (dst_lsi) {
+        HIP_DEBUG_IN6ADDR("dst lsi: ", dst_lsi);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (dst_lsi),
+                                          HIP_PARAM_LSI,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_LSI failed\n");
+    }
+
+    // source LSI is optional
+    if (src_lsi) {
+        HIP_DEBUG_IN6ADDR("src lsi: ", src_lsi);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (src_lsi),
+                                          HIP_PARAM_LSI,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_LSI failed\n");
+    }
+
+    // if no destination HIT is provided this has to be there
+    if (dst_ip) {
+        HIP_DEBUG_IN6ADDR("dst_ip: ", dst_ip);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (dst_ip),
+                                          HIP_PARAM_IPV6_ADDR,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_IPV6_ADDR failed\n");
+    }
+
+    // this again is optional
+    if (src_ip) {
+        HIP_DEBUG_IN6ADDR("src_ip: ", src_ip);
+        HIP_IFEL(hip_build_param_contents(msg, (void *) (src_ip),
+                                          HIP_PARAM_IPV6_ADDR,
+                                          sizeof(struct in6_addr)),
+                 -1, "build param HIP_PARAM_IPV6_ADDR failed\n");
+    }
+
+    HIP_DUMP_MSG(msg);
+
+    /* send msg to hipd and receive corresponding reply */
+    HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send_recv msg 
failed\n");
+
+    /* check error value */
+    HIP_IFEL(hip_get_msg_err(msg), -1, "hipd returned error message!\n");
+    HIP_DEBUG("Send_recv msg succeed \n");
+
+out_err:
+    if (msg) {
+        HIP_FREE(msg);
+    }
+    return err;
 }
+
 //Added by Prabhu to get the Data Packet header from Daemon
 
 int hip_get_data_packet_header(const struct in6_addr *src_hit,
-               const struct in6_addr *dst_hit, int payload, struct hip_common 
*msg)
+                               const struct in6_addr *dst_hit,
+                               int payload,
+                               struct hip_common *msg)
 {
-       int err = 0;
-       
-        hip_build_network_hdr(msg,HIP_DATA,0,src_hit,dst_hit);
-        msg->payload_proto = payload;
-
-        HIP_DEBUG("PAYLOAD_PROTO in HIP DATA HEADER = %d  ", payload );
-
-       /* @todo: this will assert  */
-        HIP_IFEL(hip_build_user_hdr(msg, 
SO_HIP_BUILD_HOST_ID_SIGNATURE_DATAPACKET, 0),
-                                       -1, "build hdr failed\n");
-        _HIP_DUMP_MSG(msg);
-
-        /* send msg to hipd and receive corresponding reply */
-        HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send_recv msg 
failed\n");
-
-        /* check error value */
-        HIP_IFEL(hip_get_msg_err(msg), -1, "hipd returned error message!\n");
-        HIP_DEBUG("Send_recv msg succeed \n");
+    int err = 0;
+
+    hip_build_network_hdr(msg, HIP_DATA, 0, src_hit, dst_hit);
+    msg->payload_proto = payload;
+
+    HIP_DEBUG("PAYLOAD_PROTO in HIP DATA HEADER = %d  ", payload );
+
+    /* @todo: this will assert  */
+    HIP_IFEL(hip_build_user_hdr(msg, 
SO_HIP_BUILD_HOST_ID_SIGNATURE_DATAPACKET, 0),
+             -1, "build hdr failed\n");
+    _HIP_DUMP_MSG(msg);
+
+    /* send msg to hipd and receive corresponding reply */
+    HIP_IFEL(hip_send_recv_daemon_info(msg, 0, 0), -1, "send_recv msg 
failed\n");
+
+    /* check error value */
+    HIP_IFEL(hip_get_msg_err(msg), -1, "hipd returned error message!\n");
+    HIP_DEBUG("Send_recv msg succeed \n");
 
 out_err:
-       msg->type_hdr = HIP_DATA;
-       msg->payload_proto = payload;        // this was overwritten by some 
mischief.. So reseting it 
+    msg->type_hdr      = HIP_DATA;
+    /* this was overwritten by some mischief.. So reseting it */
+    msg->payload_proto = payload;
 
-       return err;
+    return err;
 }
 
-
-
 /**
  * Checks whether there is a local ipv6 socket that is:
  *   connected to a particular port
@@ -2213,600 +2245,630 @@
  * @param *proto       protocol type
  *
  * @return             1 if it finds the required socket
- *                     0 otherwise
+ *          0 otherwise
  */
-int hip_get_proto_info(in_port_t port_dest, char *proto) {
-        FILE *fd = NULL;
-        char line[500], sub_string_addr_hex[8], path[11+sizeof(proto)];
-        char *fqdn_str = NULL, *separator = NULL, *sub_string_port_hex = NULL;
-       int lineno = 0, index_addr_port = 0, exists = 0, result;
-        uint32_t result_addr;
-       struct in_addr addr;
-        List list;
-
-       if (!proto)
-               return 0;
-
-       if (!strcmp(proto, "tcp6") || !strcmp(proto, "tcp"))
-               index_addr_port = 15;
-       else if (!strcmp(proto, "udp6") || !strcmp(proto,"udp"))
-               index_addr_port = 10;
-       else
-               return 0;
-
-       strcpy(path,"/proc/net/"); 
-       strcat(path, proto);
-        fd = fopen(path, "r");         
-        
-       initlist(&list);
-        while (fd && getwithoutnewline(line, 500, fd) != NULL && !exists) {
-               lineno++;
-
-               destroy(&list);
-               initlist(&list);
-               
-               if (lineno == 1 || strlen(line) <=1)
-                       continue;
-
-               extractsubstrings(line, &list); 
-
-               fqdn_str = getitem(&list, index_addr_port);
-               if (fqdn_str)
-                       separator = strrchr(fqdn_str, ':');
-
-               if (!separator)
-                       continue;
-
-               sub_string_port_hex = strtok(separator, ":");
-               //sprintf(port_dest_hex, "%x", port_dest);
-               //HIP_DEBUG("sub_string_port_hex %s\n",sub_string_port_hex);
-               sscanf(sub_string_port_hex,"%X", &result);
-               HIP_DEBUG("Result %i\n", result);
-               HIP_DEBUG("port dest %i\n", port_dest);
-               if (result == port_dest) {
-                       strncpy(sub_string_addr_hex, fqdn_str, 8);
-                       sscanf(sub_string_addr_hex, "%X", &result_addr);
-                       addr.s_addr = result_addr;
-                       if (IS_LSI32(addr.s_addr)) {
-                               exists = 2;
-                               break;
-                       } else {
-                               exists = 1;
-                               break;
-                       }
-               }
-       } /* end of while */
-               if (fd)
-                       fclose(fd);
-               destroy(&list);
-
-        return exists;
+int hip_get_proto_info(in_port_t port_dest, char *proto)
+{
+    FILE *fd       = NULL;
+    char line[500], sub_string_addr_hex[8], path[11 + sizeof(proto)];
+    char *fqdn_str = NULL, *separator = NULL, *sub_string_port_hex = NULL;
+    int lineno     = 0, index_addr_port = 0, exists = 0, result;
+    uint32_t result_addr;
+    struct in_addr addr;
+    List list;
+
+    if (!proto) {
+        return 0;
+    }
+
+    if (!strcmp(proto, "tcp6") || !strcmp(proto, "tcp")) {
+        index_addr_port = 15;
+    } else if (!strcmp(proto, "udp6") || !strcmp(proto, "udp")) {
+        index_addr_port = 10;
+    } else {
+        return 0;
+    }
+
+    strcpy(path, "/proc/net/");
+    strcat(path, proto);
+    fd = fopen(path, "r");
+
+    initlist(&list);
+    while (fd && getwithoutnewline(line, 500, fd) != NULL && !exists) {
+        lineno++;
+
+        destroy(&list);
+        initlist(&list);
+
+        if (lineno == 1 || strlen(line) <= 1) {
+            continue;
+        }
+
+        extractsubstrings(line, &list);
+
+        fqdn_str = getitem(&list, index_addr_port);
+        if (fqdn_str) {
+            separator = strrchr(fqdn_str, ':');
+        }
+
+        if (!separator) {
+            continue;
+        }
+
+        sub_string_port_hex = strtok(separator, ":");
+        //sprintf(port_dest_hex, "%x", port_dest);
+        //HIP_DEBUG("sub_string_port_hex %s\n",sub_string_port_hex);
+        sscanf(sub_string_port_hex, "%X", &result);
+        HIP_DEBUG("Result %i\n", result);
+        HIP_DEBUG("port dest %i\n", port_dest);
+        if (result == port_dest) {
+            strncpy(sub_string_addr_hex, fqdn_str, 8);
+            sscanf(sub_string_addr_hex, "%X", &result_addr);
+            addr.s_addr = result_addr;
+            if (IS_LSI32(addr.s_addr)) {
+                exists = 2;
+                break;
+            } else {
+                exists = 1;
+                break;
+            }
+        }
+    }     /* end of while */
+    if (fd) {
+        fclose(fd);
+    }
+    destroy(&list);
+
+    return exists;
 }
 
-void hip_get_rsa_keylen(const struct hip_host_id_priv *host_id, 
-                       struct hip_rsa_keylen *ret,
-                       int is_priv){
-       int bytes;
-       u8 *tmp = (u8 *) host_id->key;
-       int offset = 0;
-       int e_len = tmp[offset++];
-
-       /* Check for public exponent longer than 255 bytes (see RFC 3110) */
-       if (e_len == 0) {
-               e_len = ntohs((u16)tmp[offset]);
-               offset += 2;
-       }
-
-       /*
-        hi_length is the total length of:
-        rdata struct (4 bytes), length of e (1 byte for e < 255 bytes, 3 bytes 
otherwise),
-        e (normally 3 bytes), followed by public n, private d, p, q, dmp1, 
dmq1, iqmp
-        n_len == d_len == 2 * p_len == 2 * q_len == dmp1_len == dmq1_len == 
iqmp_len
-        for 9/2 * n_len
-       */
-       if (is_priv)
-               bytes = (ntohs(host_id->hi_length) - sizeof(struct 
hip_host_id_key_rdata) -
-                               offset - e_len) * 2 / 9;
-       else
-               bytes = (ntohs(host_id->hi_length) - sizeof(struct 
hip_host_id_key_rdata) -
-                               offset - e_len);
-
-       ret->e_len = offset;
-       ret->e = e_len;
-       ret->n = bytes;
+void hip_get_rsa_keylen(const struct hip_host_id_priv *host_id,
+                        struct hip_rsa_keylen *ret,
+                        int is_priv)
+{
+    int bytes;
+    u8 *tmp    = (u8 *) host_id->key;
+    int offset = 0;
+    int e_len  = tmp[offset++];
+
+    /* Check for public exponent longer than 255 bytes (see RFC 3110) */
+    if (e_len == 0) {
+        e_len   = ntohs((u16) tmp[offset]);
+        offset += 2;
+    }
+
+    /*
+     * hi_length is the total length of:
+     * rdata struct (4 bytes), length of e (1 byte for e < 255 bytes, 3 bytes 
otherwise),
+     * e (normally 3 bytes), followed by public n, private d, p, q, dmp1, 
dmq1, iqmp
+     * n_len == d_len == 2 * p_len == 2 * q_len == dmp1_len == dmq1_len == 
iqmp_len
+     * for 9/2 * n_len
+     */
+    if (is_priv) {
+        bytes = (ntohs(host_id->hi_length) - sizeof(struct 
hip_host_id_key_rdata) -
+                 offset - e_len) * 2 / 9;
+    } else {
+        bytes = (ntohs(host_id->hi_length) - sizeof(struct 
hip_host_id_key_rdata) -
+                 offset - e_len);
+    }
+
+    ret->e_len = offset;
+    ret->e     = e_len;
+    ret->n     = bytes;
 }
 
 #ifndef __KERNEL__
-RSA *hip_key_rr_to_rsa(const struct hip_host_id_priv *host_id, int is_priv) {
-       int offset;
-       struct hip_rsa_keylen keylen;
-       RSA *rsa = NULL;
-
-       hip_get_rsa_keylen(host_id, &keylen, is_priv);
-
-       rsa = RSA_new();
-       if (!rsa) {
-               HIP_ERROR("Failed to allocate RSA\n");
-               return NULL;
-       }
-
-       offset = keylen.e_len;
-       rsa->e = BN_bin2bn(&host_id->key[offset], keylen.e, 0);
-       offset += keylen.e;
-       rsa->n = BN_bin2bn(&host_id->key[offset], keylen.n, 0);
-       
-       if (is_priv) {
-               offset += keylen.n;
-               rsa->d = BN_bin2bn(&host_id->key[offset], keylen.n, 0);
-               offset += keylen.n;
-               rsa->p = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
-               offset += keylen.n / 2;
-               rsa->q = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
-               offset += keylen.n / 2;
-               rsa->dmp1 = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
-               offset += keylen.n / 2;
-               rsa->dmq1 = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
-               offset += keylen.n / 2;
-               rsa->iqmp = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
-       }
-
-       return rsa;
-}
-
-DSA *hip_key_rr_to_dsa(const struct hip_host_id_priv *host_id, int is_priv) {
-       int offset = 0;
-       DSA *dsa = NULL;
-       u8 t = host_id->key[offset++];
-       int key_len = 64 + (t * 8);
-
-       dsa = DSA_new();
-       if (!dsa) {
-               HIP_ERROR("Failed to allocate DSA\n");
-               return NULL;
-       }
-
-       dsa->q = BN_bin2bn(&host_id->key[offset], DSA_PRIV, 0);
-       offset += DSA_PRIV;
-       dsa->p = BN_bin2bn(&host_id->key[offset], key_len, 0);
-       offset += key_len;
-       dsa->g = BN_bin2bn(&host_id->key[offset], key_len, 0);
-       offset += key_len;
-       dsa->pub_key = BN_bin2bn(&host_id->key[offset], key_len, 0);
-
-       if (is_priv) {
-               offset += key_len;
-               dsa->priv_key = BN_bin2bn(&host_id->key[offset], DSA_PRIV, 0);
-
-               /* Precompute values for faster signing */
-               DSA_sign_setup(dsa, NULL, &dsa->kinv, &dsa->r);
-       }
-
-       return dsa;
-}
+RSA *hip_key_rr_to_rsa(const struct hip_host_id_priv *host_id, int is_priv)
+{
+    int offset;
+    struct hip_rsa_keylen keylen;
+    RSA *rsa = NULL;
+
+    hip_get_rsa_keylen(host_id, &keylen, is_priv);
+
+    rsa = RSA_new();
+    if (!rsa) {
+        HIP_ERROR("Failed to allocate RSA\n");
+        return NULL;
+    }
+
+    offset  = keylen.e_len;
+    rsa->e  = BN_bin2bn(&host_id->key[offset], keylen.e, 0);
+    offset += keylen.e;
+    rsa->n  = BN_bin2bn(&host_id->key[offset], keylen.n, 0);
+
+    if (is_priv) {
+        offset   += keylen.n;
+        rsa->d    = BN_bin2bn(&host_id->key[offset], keylen.n, 0);
+        offset   += keylen.n;
+        rsa->p    = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
+        offset   += keylen.n / 2;
+        rsa->q    = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
+        offset   += keylen.n / 2;
+        rsa->dmp1 = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
+        offset   += keylen.n / 2;
+        rsa->dmq1 = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
+        offset   += keylen.n / 2;
+        rsa->iqmp = BN_bin2bn(&host_id->key[offset], keylen.n / 2, 0);
+    }
+
+    return rsa;
+}
+
+DSA *hip_key_rr_to_dsa(const struct hip_host_id_priv *host_id, int is_priv)
+{
+    int offset  = 0;
+    DSA *dsa    = NULL;
+    u8 t        = host_id->key[offset++];
+    int key_len = 64 + (t * 8);
+
+    dsa = DSA_new();
+    if (!dsa) {
+        HIP_ERROR("Failed to allocate DSA\n");
+        return NULL;
+    }
+
+    dsa->q       = BN_bin2bn(&host_id->key[offset], DSA_PRIV, 0);
+    offset      += DSA_PRIV;
+    dsa->p       = BN_bin2bn(&host_id->key[offset], key_len, 0);
+    offset      += key_len;
+    dsa->g       = BN_bin2bn(&host_id->key[offset], key_len, 0);
+    offset      += key_len;
+    dsa->pub_key = BN_bin2bn(&host_id->key[offset], key_len, 0);
+
+    if (is_priv) {
+        offset       += key_len;
+        dsa->priv_key = BN_bin2bn(&host_id->key[offset], DSA_PRIV, 0);
+
+        /* Precompute values for faster signing */
+        DSA_sign_setup(dsa, NULL, &dsa->kinv, &dsa->r);
+    }
+
+    return dsa;
+}
+
 #endif /* !__KERNEL__ */
 
-int hip_string_to_lowercase(char *to, const char *from, cons