Merge lp:~stefan.goetz-deactivatedaccount/hipl/lib-core-fixes into lp:hipl

[Stefan Götz]

This branch fixes the files lib/core/hit.c and lib/core/straddr.c so that they 1) no longer fail the unit tests in the unittests branch and 2) are generally saner and easier to work, including much improved documentation.

This branch complements the branch lp:~stefan.goetz/hipl/unittests

[Stefan Götz (stefan.goetz-deactivatedaccount)]

Hi Diego!

Thanks for taking the time to review!

> This [the branch] looks like it could be split into two parts, one for the
> fixes and one for the unit tests...

Technically, it could. Logically however, the intention is to start the 'don't commit things that break the unit tests' policy.

>> --- lib/core/hit.c 2010-10-18 17:44:31 +0000
>> +++ lib/core/hit.c 2010-10-19 12:14:42 +0000
>> @@ -42,71 +42,48 @@
>>
>> + if (hit != NULL && hit_str != NULL) {
>> + if (hip_in6_ntop(hit, hit_str) != NULL) {
>
> I don't think the '!= NULL' expressions aid readability.

As opposed to writing "if (hit && hit_str)"? In that case I agree and I would change the code accordingly. Please let me know if it is a different alternative you are suggesting.

> In any case these two if clauses can be combined.

Technically, they could. Logically, there are two different checks here. First, I check my input (i.e. hit and hit_str), then I do the work (hip_in6_ntop()). In my eyes, these two steps are worth separating 1) for comprehensibility and 2) if changes become necessary. I concede that this is a purely philosophical point :)

>> --- test/lib/core/hit.c 2010-10-19 12:14:42 +0000
>> +++ test/lib/core/hit.c 2010-10-19 12:14:42 +0000
>
> This is a separate thing.

True. This is reflected by the fact that on this branch, one commit contains the changes in straddr.c and a different commit those in hit.c.

I hope these explanations adequately address your concerns.

Stefan

[lp:~stefan.goetz-deactivatedaccount/hipl/lib-core-fixes]

5003. By Stefan Götz on 2010-10-19

In response to https://code.launchpad.net/~stefan.goetz/hipl/lib-core-fixes/+merge/38825/comments/87700:
Removed NULL constants from validity checks as they were felt as being unnecessarily verbose.

5004. By Stefan Götz on 2010-10-19

Pulled lp:~stefan.goetz/hipl/unittests for mergeability

[Stefan Götz (stefan.goetz-deactivatedaccount)]

Revision 5003 addresses the concerns about NULL pointer checks raised by Diego. It should thus fix out all outstanding merge blockers. Revision 5004 ensures mergeability on top of lp:~stefan.goetz/hipl/unittests. The branch merges cleanly into the current trunk revision 5028. Unless there are further issues, I herewith re-request this branch to be merged into trunk :-)

[lp:~stefan.goetz-deactivatedaccount/hipl/lib-core-fixes]

5005. By Stefan Götz on 2010-10-19

Removed unnecessarily included header files from lib/core/straddr.c

5006. By Stefan Götz on 2010-10-19

Removed unnecessarily included header files from lib/core/hit.c

5007. By Stefan Götz on 2010-10-20

Pulled lp:~stefan.goetz/hipl/unittests for mergeability

[Diego Biurrun (diego-biurrun)]

On Tue, Oct 19, 2010 at 04:26:03PM +0000, Stefan Götz wrote:
>
> > This [the branch] looks like it could be split into two parts, one for the
> > fixes and one for the unit tests...
>
> Technically, it could. Logically however, the intention is to start
> the 'don't commit things that break the unit tests' policy.

Let that policy take effect one commit later. I'm sure nobody will be
able to slip a mickey into HIPL between REV_FIXES and REV_FIXES + 1.

> >> --- lib/core/hit.c 2010-10-18 17:44:31 +0000
> >> +++ lib/core/hit.c 2010-10-19 12:14:42 +0000
> >> @@ -42,71 +42,48 @@
> >>
> >> + if (hit != NULL && hit_str != NULL) {
> >> + if (hip_in6_ntop(hit, hit_str) != NULL) {
> >
> > I don't think the '!= NULL' expressions aid readability.
>
> As opposed to writing "if (hit && hit_str)"?

Yes.

> > In any case these two if clauses can be combined.
>
> Technically, they could. Logically, there are two different checks
> here. First, I check my input (i.e. hit and hit_str), then I do
> the work (hip_in6_ntop()). In my eyes, these two steps are worth
> separating 1) for comprehensibility and 2) if changes become
> necessary. I concede that this is a purely philosophical point :)

Whatever you prefer.

Notice that I always consider my review comments suggestions to be
followed or ignored at the coder's discretion. Unless I'm pointing
out bugs of course :)

Diego

=== modified file 'hipd/cert.c'
--- hipd/cert.c	2010-10-15 15:29:14 +0000
+++ hipd/cert.c	2010-10-20 08:51:06 +0000
@@ -194,11 +194,11 @@
     /* clearing signature field just to be sure */
     memset(cert->signature, '\0', sizeof(cert->signature));
 
-    HIP_IFEL(!(digest_b64 = base64_encode((unsigned char *) sha_digest,
-                                          (unsigned int) sizeof(sha_digest))),
+    HIP_IFEL(EVP_EncodeBlock(digest_b64, (unsigned char *) sha_digest,
+                             (unsigned int) sizeof(sha_digest)) > 0,
              -1, "Failed to encode digest_b64\n");
-    HIP_IFEL(!(signature_b64 = base64_encode((unsigned char *) signature,
-                                             (unsigned int) sig_len)),
+    HIP_IFEL(EVP_EncodeBlock(signature_b64, (unsigned char *) signature,
+                             (unsigned int) sig_len) > 0,
              -1, "Failed to encode signature_b64\n");
     /* create (signature (hash sha1 |digest|)|signature|) */
     sprintf(cert->signature, "(signature (hash sha1 |%s|)|%s|)",
@@ -218,7 +218,7 @@
                  -1,
                  "Error in converting public exponent from BN to bin\n");
 
-        HIP_IFEL(!(n_b64 = base64_encode((unsigned char *) n_bin, RSA_size(rsa))),
+        HIP_IFEL(EVP_EncodeBlock(n_b64, (unsigned char *) n_bin, RSA_size(rsa)) > 0,
                  -1,
                  "Failed to encode n_b64\n");
 
@@ -244,26 +244,22 @@
          */
         HIP_IFEL(!(BN_bn2bin(dsa->p, p_bin)), -1,
                  "Error in converting public exponent from BN to bin\n");
-        HIP_IFEL(!(p_b64 = base64_encode((unsigned char *) p_bin,
-                                         BN_num_bytes(dsa->p))),
+        HIP_IFEL(EVP_EncodeBlock(p_b64, (unsigned char *) p_bin, BN_num_bytes(dsa->p)) > 0,
                  -1, "Failed to encode p_b64\n");
 
         HIP_IFEL(!(BN_bn2bin(dsa->q, q_bin)), -1,
                  "Error in converting public exponent from BN to bin\n");
-        HIP_IFEL(!(q_b64 = base64_encode((unsigned char *) q_bin,
-                                         BN_num_bytes(dsa->q))),
+        HIP_IFEL(EVP_EncodeBlock(q_b64, (unsigned char *) q_bin, BN_num_bytes(dsa->q)) > 0,
                  -1, "Failed to encode q_64");
 
         HIP_IFEL(!(BN_bn2bin(dsa->g, g_bin)), -1,
                  "Error in converting public exponent from BN to bin\n");
-        HIP_IFEL(!(g_b64 = base64_encode((unsigned char *) g_bin,
-                                         BN_num_bytes(dsa->g))),
+        HIP_IFEL(EVP_EncodeBlock(g_b64, (unsigned char *) g_bin, BN_num_bytes(dsa->g)) > 0,
                  -1, "Failed to encode g_b64\n");
 
         HIP_IFEL(!(BN_bn2bin(dsa->pub_key, y_bin)), -1,
                  "Error in converting public exponent from BN to bin\n");
-        HIP_IFEL(!(y_b64 = base64_encode((unsigned char *) y_bin,
-                                         BN_num_bytes(dsa->pub_key))),
+        HIP_IFEL(EVP_EncodeBlock(y_b64, (unsigned char *) y_bin, BN_num_bytes(dsa->pub_key)) > 0,
                  -1, "Failed to encode y_b64\n");
 
         sprintf(cert->public_key, "(public_key (dsa-pkcs1-sha1 (p |%s|)(q |%s|)"

=== modified file 'hipd/hidb.c'
--- hipd/hidb.c	2010-10-15 15:29:14 +0000
+++ hipd/hidb.c	2010-10-20 08:51:06 +0000
@@ -355,7 +355,7 @@
 
     list_for_each(item, hip_local_hostid_db, c) {
         id_entry = (struct hip_host_id_entry *) list_entry(item);
-        if (hip_hit_are_equal(&id_entry->lhi.hit, our)) {
+        if (memcmp(&id_entry->lhi.hit, our, sizeof(*our)) == 0) {
             memcpy(our_lsi, &id_entry->lsi, sizeof(hip_lsi_t));
             return 0;
         }

=== modified file 'lib/core/conf.c'
--- lib/core/conf.c	2010-10-20 03:38:26 +0000
+++ lib/core/conf.c	2010-10-20 08:51:06 +0000
@@ -872,7 +872,6 @@
     int index_of_hit = 0, index_of_ip = 0, opp_mode = 0;;
     uint8_t lifetime             = 0, *reg_types = NULL;
     time_t seconds_from_lifetime = 0;
-    char lowercase[30];
 
     memset(&hit, 0, sizeof(hit));
     memset(&ipv6, 0, sizeof(ipv6));
@@ -883,6 +882,8 @@
         err = -1;
         goto out_err;
     } else if (action == ACTION_ADD) {
+        char *tail_ptr = NULL;
+
         if (optc < 4) {
             if (optc < 3) {
                 HIP_ERROR("Missing arguments.\n");
@@ -903,20 +904,12 @@
             index_of_ip        = optc - 2;
         }
 
-        HIP_IFEL(hip_string_is_digit(opt[optc - 1]), -1,
+        seconds = strtoul(opt[optc - 1], &tail_ptr, 10);
+        HIP_IFEL(*tail_ptr == '\0' && seconds > 0 && seconds <= 15384774, -1,
                  "Invalid lifetime value \"%s\" given.\n"       \
                  "Please give a lifetime value between 1 and "  \
                  "15384774 seconds.\n", opt[optc - 1]);
 
-        seconds = atoi(opt[optc - 1]);
-
-        if (seconds <= 0 || seconds > 15384774) {
-            HIP_ERROR("Invalid lifetime value \"%s\" given.\n"    \
-                      "Please give a lifetime value between 1 and " \
-                      "15384774 seconds.\n", opt[optc - 1]);
-            goto out_err;
-        }
-
         HIP_IFEL(hip_get_lifetime_value(seconds, &lifetime), -1,
                  "Unable to convert seconds to a lifetime value.\n");
 
@@ -994,19 +987,18 @@
             goto out_err;
         }
 
-        hip_string_to_lowercase(lowercase, opt[i], strlen(opt[i]) + 1);
-        if (strcmp("rvs", lowercase) == 0) {
+        if (strcasecmp("rvs", opt[i]) == 0) {
             reg_types[i] = HIP_SERVICE_RENDEZVOUS;
-        } else if (strcmp("relay", lowercase) == 0) {
+        } else if (strcasecmp("relay", opt[i]) == 0) {
             reg_types[i] = HIP_SERVICE_RELAY;
-        } else if (strcmp("full-relay", lowercase) == 0)  {
+        } else if (strcasecmp("full-relay", opt[i]) == 0)  {
             reg_types[i] = HIP_SERVICE_FULLRELAY;
         }         /* To cope with the atoi() error value we handle the 'zero'
                    * case here. */
-        else if (strcmp("0", lowercase) == 0) {
+        else if (strcasecmp("0", opt[i]) == 0) {
             reg_types[i] = 0;
         } else {
-            reg_type = atoi(lowercase);
+            reg_type = atoi(opt[i]);
             if (reg_type <= 0 || reg_type > 255) {
                 HIP_ERROR("'%s' is not a valid service name " \
                           "or service number.\n", opt[i]);
@@ -1207,13 +1199,13 @@
 
     HIP_IFEL((optc != 2 && optc != 3), -1, "Missing arguments\n");
 
-    HIP_IFEL(convert_string_to_address(opt[0], &hit), -1,
-             "string to address conversion failed\n");
-
-    HIP_IFEL((err = convert_string_to_address(opt[1], &ip6)), -1,
-             "string to address conversion failed\n");
-
-    if ((err && !convert_string_to_address_v4(opt[1], &aux))) {
+    HIP_IFEL(hip_convert_string_to_address(opt[0], &hit), -1,
+             "string to address conversion failed\n");
+
+    HIP_IFEL((err = hip_convert_string_to_address(opt[1], &ip6)), -1,
+             "string to address conversion failed\n");
+
+    if ((err && inet_pton(AF_INET, opt[1], &aux) != 1)) {
         HIP_IFEL(IS_LSI32(aux.s_addr), -1, "Missing ip address before lsi\n");
     }
 
@@ -1243,7 +1235,7 @@
              "build param hit failed\n");
 
     if (optc == 3) {
-        HIP_IFEL(convert_string_to_address_v4(opt[2], &lsi), -1,
+        HIP_IFEL(inet_pton(AF_INET, opt[2], &lsi) == 1, -1,
                  "string to address conversion failed\n");
         HIP_IFEL(!IS_LSI32(lsi.s_addr), -1, "Wrong LSI value\n");
         HIP_IFEL(hip_build_param_contents(msg, &lsi,
@@ -2011,7 +2003,7 @@
         if (!strcmp("all", opt[0])) {
             hip_conf_print_info_ha(ha);
         } else {
-            HIP_IFE(convert_string_to_address(opt[0], &hit1), -1);
+            HIP_IFE(hip_convert_string_to_address(opt[0], &hit1), -1);
 
             if ((ipv6_addr_cmp(&hit1, &ha->hit_our) == 0) ||
                 (ipv6_addr_cmp(&hit1, &ha->hit_peer) == 0))

=== modified file 'lib/core/hit.c'
--- lib/core/hit.c	2010-10-18 17:44:31 +0000
+++ lib/core/hit.c	2010-10-20 08:51:06 +0000
@@ -30,83 +30,56 @@
  * @author Miika Komu <[e-mail]>
  */
 
-#include <stdint.h>
-#include <string.h>
+#include <string.h>     // strcpy()
 
-#include "config.h"
-#include "builder.h"
-#include "debug.h"
-#include "prefix.h"
-#include "protodefs.h"
-#include "straddr.h"
+#include "debug.h"      // HIP_ASSERT()
+#include "prefix.h"     // ipv6_addr_cmp()
+#include "straddr.h"    // hip_in6_ntop()
 #include "hit.h"
 
 /**
- * convert a binary HIT into a string
+ * Convert a binary HIT to a hexadecimal string representation of the form
+ * 0011:2233:4455:6677:8899:AABB:CCDD:EEFF terminated by a null character.
  *
- * @param hit a binary HIT
- * @param prefix an optional HIT prefix as a string
- * @param hit_str the HIT as a string with the given prefix
- * @return zero on success and negative on error
+ * @param hit a pointer to a binary HIT.
+ * @param suffix an optional null-terminated string suffix to be appended to
+ *  the HIT. If suffix is NULL or the empty string, no suffix is appended. If
+ *  suffix is not null-terminated, the result is undefined.
+ * @param hit_str a pointer to a buffer to write the HIT and the suffix to. The
+ *  result of passing a buffer that is too short to hold the string
+ *  representation plus the suffix is undefined.
+ * @return 0 if the HIT was successfully converted. Returns a negative value if
+ *  hit is NULL or hit_str is NULL.
  */
-int hip_convert_hit_to_str(const hip_hit_t *hit,
-                           const char *prefix,
-                           char *hit_str)
+int hip_convert_hit_to_str(const hip_hit_t *const hit,
+                           const char *const suffix,
+                           char *const 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));
+    if (hit && hit_str) {
+        if (hip_in6_ntop(hit, hit_str)) {
+            if (suffix && *suffix != '\0') {
+                strcpy(hit_str + strlen(hit_str), suffix);
+            }
+            return 0;
+        }
     }
 
-    return err;
-}
-/**
- * compare two HITs to check which HIT is "bigger"
- *
- * @param hit1 the first HIT to be compared
- * @param hit2 the second HIT to be compared
- *
- * @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;
-}
-
-/**
- * compare two HITs to check which if they are equal
- *
- * @param hit1 the first HIT to be compared
- * @param hit2 the second HIT to be compared
- *
- * @return 1 if the HITs were equal and zero otherwise
- */
-int hip_hit_are_equal(const struct in6_addr *hit1,
-                      const struct in6_addr *hit2)
-{
-    return ipv6_addr_cmp(hit1, hit2) == 0;
-}
-
-/**
- * calculate a hash from a HIT
- *
- * @param ptr pointer to a HIT
- *
- * 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, (const uint8_t *)ptr + sizeof(uint16_t),
-                     7 * sizeof(uint16_t), hash);
-
-    return *((unsigned long *) hash);
+    return -1;
+}
+
+/**
+ * Determine whether a HIT is numerically greater than another.
+ *
+ * @param hit_gt    a pointer to a HIT. When passing a NULL pointer, the result
+ *  of this function is undefined.
+ * @param hit_le    a pointer to a HIT. When passing a NULL pointer, the result
+ *  of this function is undefined.
+ * @return 1 if hit_gt is greater than hit_le, otherwise 0.
+ */
+int hip_hit_is_bigger(const struct in6_addr *const hit_gt,
+                      const struct in6_addr *const hit_le)
+{
+    HIP_ASSERT(hit_gt);
+    HIP_ASSERT(hit_le);
+    return ipv6_addr_cmp(hit_gt, hit_le) > 0;
 }

=== modified file 'lib/core/hit.h'
--- lib/core/hit.h	2010-10-15 15:29:14 +0000
+++ lib/core/hit.h	2010-10-20 08:51:06 +0000
@@ -30,11 +30,8 @@
 
 #include "protodefs.h"
 
-int hip_convert_hit_to_str(const hip_hit_t *hit, const char *prefix, char *str);
-int hip_hit_is_bigger(const struct in6_addr *hit1,
-                      const struct in6_addr *hit2);
-int hip_hit_are_equal(const struct in6_addr *hit1,
-                      const struct in6_addr *hit2);
-unsigned long hip_hash_hit(const void *hit);
+int hip_convert_hit_to_str(const hip_hit_t *const hit, const char *const suffix, char *const str);
+int hip_hit_is_bigger(const struct in6_addr *const hit_gt,
+                      const struct in6_addr *const hit_le);
 
 #endif /* HIP_LIB_CORE_HIT_H */

=== modified file 'lib/core/straddr.c'
--- lib/core/straddr.c	2010-10-18 17:44:31 +0000
+++ lib/core/straddr.c	2010-10-20 08:51:06 +0000
@@ -32,30 +32,28 @@
 
 #define _BSD_SOURCE
 
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <openssl/evp.h>
+#include <stdio.h>      // sprintf()
+#include <arpa/inet.h>  // inet_pton()
 
-#include "config.h"
-#include "debug.h"
-#include "ife.h"
-#include "prefix.h"
+#include "debug.h"      // HIP_DEBUG()
+#include "prefix.h"     // IPV4_TO_IPV6_MAP()
 #include "straddr.h"
 
 /**
- * convert a binary IPv6 address to a string
+ * Convert a binary IPv6 address to a hexadecimal string representation of the
+ * form 0011:2233:4455:6677:8899:AABB:CCDD:EEFF terminated by a null character.
  *
- * @param in6 the IPv6 address to convert
- * @param buf a preallocated buffer where the string will be stored
- * @return a pointer to the buf
+ * @param in6 a pointer to a binary IPv6 address.
+ * @param buf a pointer to a buffer to write the string representation to. The
+ *  result of passing a buffer that is too short to hold the string
+ *  representation is undefined.
+ * @return The function returns a pointer to the output buffer buf if the
+ *  address is successfully converted. It returns a negative value if in6 is
+ *  NULL or buf is NULL.
  */
-char *hip_in6_ntop(const struct in6_addr *in6, char *buf)
+char *hip_in6_ntop(const struct in6_addr *const in6, char *const buf)
 {
-    if (!buf) {
+    if (!in6 || !buf) {
         return NULL;
     }
     sprintf(buf,
@@ -68,137 +66,37 @@
 }
 
 /**
- * convert a string into a binary IPv4 address (a wrapper for inet_pton())
- *
- * @param str the string to convert
- * @param ip an output argument that will contain a binary IPv4 calculated
- *        from the @c str
- * @return zero on success and negative on error
- */
-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;
-}
-
-/**
- * Convert a string to an IPv6 address. This function can handle
- * also IPv6 mapped addresses.
- *
- * @param str the string to convert
- * @param ip6 An output argument that will contain a binary IPv4 calculated
- *        from the @c str. Possibly in IPv6 mapped format.
- * @return zero on success or negative on error
- */
-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 */
-        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;
-}
-
-/**
- * convert a string containing upper case characters to lower case
- *
- * @param to the result of the conversion (minimum length @c count)
- * @param from a string possibly containing upper case characters
- * @param count count
- * @return zero on success or negative on failure
- */
-int hip_string_to_lowercase(char *to, const char *from, const size_t count)
-{
-    unsigned i;
-
-    if (to == NULL || from == NULL || count == 0) {
-        return -1;
-    }
-
-    for (i = 0; i < count; i++) {
-        if (isalpha(from[i])) {
-            to[i] = tolower(from[i]);
+ * Convert a string representation of an IPv6 or IPv4 address to a struct
+ * in6_addr.
+ * If the string contains an IPv4 address, it is converted to its
+ * IPv6-compatible mapping.
+ *
+ * @param str points to the string to convert.
+ * @param ip6 points to a buffer where the function stores the binary address
+ *  if it could be converted.
+ * @return The return value is 0 if the conversion succeeds. It is a
+ *  negative value if str or ip6 are NULL or if str contains neither a
+ *  parseable IPv6 or IPv4 address.
+ */
+int hip_convert_string_to_address(const char *const str,
+                                  struct in6_addr *const ip6)
+{
+    if (str && ip6) {
+        if (inet_pton(AF_INET6, str, ip6) == 1) {
+            /* IPv6 address conversion was ok */
+            return 0;
         } else {
-            to[i] = from[i];
-        }
-    }
-    return 0;
-}
-
-/**
- * test if a given string contains a positive integer
- *
- * @param string the string to test
- * @return zero if the string is digit or negative otherwise
- */
-int hip_string_is_digit(const char *string)
-{
-    if (string == NULL) {
-        return -1;
-    }
-
-    int i = 0;
-
-    while (string[i] != '\0') {
-        if (!isdigit(string[i])) {
-            return -1;
-        }
-        i++;
-    }
-    return 0;
-}
-
-
-/**
- * encode the given content to Base64
- *
- * @param buf Pointer to contents to be encoded
- * @param len How long is the first parameter in bytes
- *
- * @return Returns a pointer to encoded content or NULL on error
- */
-unsigned char *base64_encode(unsigned char *buf, unsigned int len)
-{
-    unsigned char *ret;
-    unsigned int b64_len;
-
-    b64_len = (((len + 2) / 3) * 4) + 1;
-    ret     = malloc(b64_len);
-    if (ret == NULL) {
-        goto out_err;
-    }
-    EVP_EncodeBlock(ret, buf, len);
-    return ret;
-out_err:
-    if (ret) {
-        free(ret);
-    }
-    return NULL;
-}
-
+            struct in_addr ip4;
+
+            /* Might be an ipv4 address (ret == 0). Lets catch it here. */
+            if (inet_pton(AF_INET, str, &ip4) == 1) {
+                IPV4_TO_IPV6_MAP(&ip4, ip6);
+                HIP_DEBUG("Mapped v4 to v6.\n");
+                HIP_DEBUG_IN6ADDR("mapped v6", ip6);
+                return 0;
+            }
+        }
+    }
+
+    return -1;
+}

=== modified file 'lib/core/straddr.h'
--- lib/core/straddr.h	2010-10-15 15:29:14 +0000
+++ lib/core/straddr.h	2010-10-20 08:51:06 +0000
@@ -29,11 +29,8 @@
 #include <sys/types.h>
 #include <netinet/in.h>
 
-int convert_string_to_address_v4(const char *str, struct in_addr *ip);
-int convert_string_to_address(const char *str, struct in6_addr *ip6);
-char *hip_in6_ntop(const struct in6_addr *in6, char *buf);
-int hip_string_to_lowercase(char *to, const char *from, const size_t count);
-int hip_string_is_digit(const char *string);
-unsigned char *base64_encode(unsigned char *, unsigned int);
+char *hip_in6_ntop(const struct in6_addr *const in6, char *const buf);
+int hip_convert_string_to_address(const char *const str,
+                                  struct in6_addr *const ip6);
 
 #endif /* HIP_LIB_CORE_STRADDR_H */

=== modified file 'test/lib/core/hit.c'
--- test/lib/core/hit.c	2010-10-20 08:51:06 +0000
+++ test/lib/core/hit.c	2010-10-20 08:51:06 +0000
@@ -44,18 +44,18 @@
 START_TEST(test_hip_convert_hit_to_str_null_hit)
 {
     char buf[64];
-    hip_convert_hit_to_str(NULL, "", buf);
+    fail_unless(hip_convert_hit_to_str(NULL, "", buf) < 0, NULL);
 }
 END_TEST
 
 START_TEST(test_hip_convert_hit_to_str_null_buf)
 {
     hip_hit_t hit;
-    fail_unless(hip_convert_hit_to_str(&hit, "", NULL) == 1, NULL);
+    fail_unless(hip_convert_hit_to_str(&hit, "", NULL) < 0, NULL);
 }
 END_TEST
 
-START_TEST(test_hip_convert_hit_to_str_null_prefix)
+START_TEST(test_hip_convert_hit_to_str_null_suffix)
 {
     char buf[64];
     hip_hit_t hit;
@@ -70,9 +70,12 @@
     const unsigned int HIT_LEN = 39; // 16 bytes -> 32 hex chars + 7 ':'s
     const unsigned int SUFFIX_LEN = sizeof(suffix); // includes null char
     const unsigned int AFTER_LEN = 30;
-    char buf[BEFORE_LEN + HIT_LEN + SUFFIX_LEN + AFTER_LEN] = { 1 };
-    char ones[BEFORE_LEN + HIT_LEN + SUFFIX_LEN + AFTER_LEN] = { 1 };
+    char buf[BEFORE_LEN + HIT_LEN + SUFFIX_LEN + AFTER_LEN];
+    char ones[BEFORE_LEN + HIT_LEN + SUFFIX_LEN + AFTER_LEN];
     hip_hit_t hit;
+
+    memset(buf, '1', sizeof(buf));
+    memset(ones, '1', sizeof(ones));
     memset(&hit.s6_addr, 0x22, sizeof(hit.s6_addr));
 
     // write the HIT string into the middle of the buffer
@@ -107,6 +110,20 @@
 }
 END_TEST
 
+START_TEST(test_hip_hit_is_bigger_null_first)
+{
+    const hip_hit_t hit = IN6ADDR_LOOPBACK_INIT;
+    hip_hit_is_bigger(NULL, &hit);
+}
+END_TEST
+
+START_TEST(test_hip_hit_is_bigger_null_second)
+{
+    const hip_hit_t hit = IN6ADDR_LOOPBACK_INIT;
+    hip_hit_is_bigger(&hit, NULL);
+}
+END_TEST
+
 START_TEST(test_hip_hit_is_bigger_first_null)
 {
     hip_hit_t hit;
@@ -121,49 +138,6 @@
 }
 END_TEST
 
-START_TEST(test_hip_hit_are_equal_equality)
-{
-    const hip_hit_t hit1 = IN6ADDR_LOOPBACK_INIT;
-    const hip_hit_t hit2 = IN6ADDR_LOOPBACK_INIT;
-    fail_unless(hip_hit_are_equal(&hit1, &hit2) == 1, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_hit_are_equal_inequality)
-{
-    const hip_hit_t bigger = IN6ADDR_LOOPBACK_INIT;
-    const hip_hit_t smaller = IN6ADDR_ANY_INIT;
-    fail_unless(hip_hit_are_equal(&bigger, &smaller) == 1, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_hit_are_equal_first_null)
-{
-    hip_hit_t hit;
-    hip_hit_are_equal(NULL, &hit);
-}
-END_TEST
-
-START_TEST(test_hip_hit_are_equal_second_null)
-{
-    hip_hit_t hit;
-    hip_hit_are_equal(&hit, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_hash_hit_valid)
-{
-    const hip_hit_t hit = IN6ADDR_ANY_INIT;
-    hip_hash_hit(&hit);
-}
-END_TEST
-
-START_TEST(test_hip_hash_hit_null)
-{
-    hip_hash_hit(NULL);
-}
-END_TEST
-
 // For unknown reasons, this file does not compile with the following,
 // seemingly useless forward declaration
 Suite *lib_core_hit(void);
@@ -174,20 +148,16 @@
 
     TCase *tc_core = tcase_create("Core");
     tcase_add_test(tc_core, test_hip_convert_hit_to_str_valid);
-    tcase_add_exit_test(tc_core, test_hip_convert_hit_to_str_null_hit, 1);
+    tcase_add_test(tc_core, test_hip_convert_hit_to_str_null_hit);
     tcase_add_test(tc_core, test_hip_convert_hit_to_str_null_buf);
-    tcase_add_test(tc_core, test_hip_convert_hit_to_str_null_prefix);
+    tcase_add_test(tc_core, test_hip_convert_hit_to_str_null_suffix);
     tcase_add_test(tc_core, test_hip_convert_hit_to_str_bounds);
     tcase_add_test(tc_core, test_hip_hit_is_bigger_bigger);
     tcase_add_test(tc_core, test_hip_hit_is_bigger_equal_smaller);
+    tcase_add_exit_test(tc_core, test_hip_hit_is_bigger_null_first, 1);
+    tcase_add_exit_test(tc_core, test_hip_hit_is_bigger_null_second, 1);
     tcase_add_exit_test(tc_core, test_hip_hit_is_bigger_first_null, 1);
     tcase_add_exit_test(tc_core, test_hip_hit_is_bigger_second_null, 1);
-    tcase_add_test(tc_core, test_hip_hit_are_equal_equality);
-    tcase_add_test(tc_core, test_hip_hit_are_equal_inequality);
-    tcase_add_exit_test(tc_core, test_hip_hit_are_equal_first_null, 1);
-    tcase_add_exit_test(tc_core, test_hip_hit_are_equal_second_null, 1);
-    tcase_add_test(tc_core, test_hip_hash_hit_valid);
-    tcase_add_exit_test(tc_core, test_hip_hash_hit_null, 1);
     suite_add_tcase(s, tc_core);
 
     return s;

=== modified file 'test/lib/core/straddr.c'
--- test/lib/core/straddr.c	2010-10-20 08:51:06 +0000
+++ test/lib/core/straddr.c	2010-10-20 08:51:06 +0000
@@ -31,137 +31,83 @@
 #include <stdlib.h> // free()
 #include "lib/core/straddr.h"
 
-START_TEST(test_convert_string_to_address_v4_valid)
-{
-    const char *str = "127.0.0.1";
-    struct in_addr ip;
-
-    fail_unless(convert_string_to_address_v4(str, &ip) == 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_v4_null_str)
-{
-    struct in_addr ip;
-
-    fail_unless(convert_string_to_address_v4(NULL, &ip) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_v4_null_addr)
-{
-    const char *str = "127.0.0.1";
-
-    fail_unless(convert_string_to_address_v4(str, NULL) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_v4_invalid)
-{
-    const char *str = " 127.0.0.1";
-    struct in_addr ip;
-
-    fail_unless(convert_string_to_address_v4(str, &ip) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_valid)
-{
-    const char *str = "fe80::215:58ff:fe29:9c36";
-    struct in6_addr ip;
-
-    fail_unless(convert_string_to_address(str, &ip) == 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_null_str)
-{
-    struct in6_addr ip;
-
-    fail_unless(convert_string_to_address(NULL, &ip) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_null_addr)
-{
-    const char *str = "fe80::215:58ff:fe29:9c36";
-
-    fail_unless(convert_string_to_address(str, NULL) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_convert_string_to_address_invalid)
+START_TEST(test_hip_in6_ntop_valid)
+{
+    const int GUARD_SIZE = 32;      // arbitrary
+    struct buf_test {
+        char before[GUARD_SIZE];
+        char addr[39];              // 16 IPv6 bytes -> 32 hex chars + 7 ':'s
+        char null[1];               // terminating null character
+        char after[GUARD_SIZE];
+    } buf;
+    char ones[GUARD_SIZE];
+    struct in6_addr in6;
+
+    memset(&buf, '1', sizeof(buf));
+    memset(ones, '1', sizeof(ones));
+    memset(&in6.s6_addr, 0x22, sizeof(in6.s6_addr));
+
+    fail_unless(hip_in6_ntop(&in6, buf.addr) == buf.addr, NULL);
+    // is the buffer before the address untouched?
+    fail_unless(memcmp(buf.before, ones, GUARD_SIZE) == 0, NULL);
+    // is the first part of the address correct?
+    fail_unless(buf.addr[0] == '2', NULL);
+    // is the last part of the address correct?
+    fail_unless(buf.addr[sizeof(buf.addr) - 1] == '2', NULL);
+    // is there a terminating null character?
+    fail_unless(buf.null[0] == '\0', NULL);
+    // is the buffer after the address untouched?
+    fail_unless(memcmp(buf.after, ones, GUARD_SIZE) == 0, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_in6_ntop_null_addr)
+{
+    char buf[64];
+
+    fail_unless(hip_in6_ntop(NULL, buf) == NULL, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_in6_ntop_null_buf)
+{
+    struct in6_addr in6 = IN6ADDR_LOOPBACK_INIT;
+
+    fail_unless(hip_in6_ntop(&in6, NULL) == NULL, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_convert_string_to_address_valid)
+{
+    const char *str = "fe80::215:58ff:fe29:9c36";
+    struct in6_addr ip;
+
+    fail_unless(hip_convert_string_to_address(str, &ip) == 0, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_convert_string_to_address_null_str)
+{
+    struct in6_addr ip;
+
+    fail_unless(hip_convert_string_to_address(NULL, &ip) < 0, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_convert_string_to_address_null_addr)
+{
+    const char *str = "fe80::215:58ff:fe29:9c36";
+
+    fail_unless(hip_convert_string_to_address(str, NULL) < 0, NULL);
+}
+END_TEST
+
+START_TEST(test_hip_convert_string_to_address_invalid)
 {
     const char *str = " fe80::215:58ff:fe29:9c36";
     struct in6_addr ip;
 
-    fail_unless(convert_string_to_address(str, &ip) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_string_to_lowercase_valid)
-{
-    char to[128] = { 1 };
-    char ones[128] = { 1 };
-    const char from[] = "TesT";
-    const size_t count = sizeof(from) - 1;
-    const unsigned int offset = 32;
-
-    fail_unless(hip_string_to_lowercase(to + offset, from, count) == 0, NULL);
-    // was from correctly converted to lower case?
-    fail_unless(memcmp(to + offset, "test", count) == 0, NULL);
-    // is the beginning of to still intact?
-    fail_unless(memcmp(to, ones, offset) == 0, NULL);
-    // is the rest of to still intact?
-    fail_unless(memcmp(to + offset + count, ones, offset) == 0, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_string_is_digit_valid)
-{
-    fail_unless(hip_string_is_digit("123456789") == 0, NULL);
-    fail_unless(hip_string_is_digit("abc") < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_string_is_digit_null)
-{
-    fail_unless(hip_string_is_digit(NULL) < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_hip_string_is_digit_empty)
-{
-    fail_unless(hip_string_is_digit("") < 0, NULL);
-}
-END_TEST
-
-START_TEST(test_base64_encode_valid)
-{
-    const char b64[] = "VGVzdA==";
-    unsigned char buf[] = "Test";
-    unsigned int len = sizeof(buf) - 1; // do not include null character as per doc
-    unsigned char *result = NULL;
-
-    fail_unless((result = base64_encode(buf, len)) != NULL, NULL);
-    fail_unless(strcmp((char*)result, b64) == 0, NULL);
-    free(result); // note it's not documented that we need to free the returned memory
-}
-END_TEST
-
-START_TEST(test_base64_encode_null_buf)
-{
-    fail_unless(base64_encode(NULL, 42) == NULL, NULL);
-}
-END_TEST
-
-START_TEST(test_base64_encode_empty_buf)
-{
-    unsigned char buf[] = "";
-    unsigned char *result = NULL;
-
-    fail_unless((result = base64_encode(buf, 0)) != NULL, NULL);
-    fail_unless(strlen((char *)result) == 0, NULL);
+    fail_unless(hip_convert_string_to_address(str, &ip) < 0, NULL);
 }
 END_TEST
 
@@ -174,21 +120,13 @@
     Suite *s = suite_create("lib/core/straddr");
 
     TCase *tc_core = tcase_create("Core");
-    tcase_add_test(tc_core, test_convert_string_to_address_v4_valid);
-    tcase_add_test(tc_core, test_convert_string_to_address_v4_null_str);
-    tcase_add_test(tc_core, test_convert_string_to_address_v4_null_addr);
-    tcase_add_test(tc_core, test_convert_string_to_address_v4_invalid);
-    tcase_add_test(tc_core, test_convert_string_to_address_valid);
-    tcase_add_test(tc_core, test_convert_string_to_address_null_str);
-    tcase_add_test(tc_core, test_convert_string_to_address_null_addr);
-    tcase_add_test(tc_core, test_convert_string_to_address_invalid);
-    tcase_add_test(tc_core, test_hip_string_to_lowercase_valid);
-    tcase_add_test(tc_core, test_hip_string_is_digit_valid);
-    tcase_add_test(tc_core, test_hip_string_is_digit_null);
-    tcase_add_test(tc_core, test_hip_string_is_digit_empty);
-    tcase_add_test(tc_core, test_base64_encode_valid);
-    tcase_add_test(tc_core, test_base64_encode_null_buf);
-    tcase_add_test(tc_core, test_base64_encode_empty_buf);
+    tcase_add_test(tc_core, test_hip_in6_ntop_valid);
+    tcase_add_test(tc_core, test_hip_in6_ntop_null_addr);
+    tcase_add_test(tc_core, test_hip_in6_ntop_null_buf);
+    tcase_add_test(tc_core, test_hip_convert_string_to_address_valid);
+    tcase_add_test(tc_core, test_hip_convert_string_to_address_null_str);
+    tcase_add_test(tc_core, test_hip_convert_string_to_address_null_addr);
+    tcase_add_test(tc_core, test_hip_convert_string_to_address_invalid);
     suite_add_tcase(s, tc_core);
 
     return s;