Merge lp:~hipl-core/hipl/libhip into lp:hipl

[Xin]

Mar 15, 2012 Fixed issues based on Christof and Stefan's review.

Feb 20, 2012 Code revisd based on Diego's second review and Christof's review
New APIs also have been changed to start with 'hipl_' prefix

Feb 10, 2012 code revised based on Diego's review

=============================================

Libhip merge proposal:

The libhip branch mainly aims to provide a convenient way for system test of HIPL without full installation and configuration. In addition to this purpose, it also provides a socket API alike library approach for application to use HIP. Last by not least, since vanilla Linux TCP does not yet support long periods of disconnectivity [1] , libhip can be a solution in this condition.

In the libhip branch, we build a library version of HIP for upper applications, which only exposes traditional socket like API. when using the libhip, hip control messages are transmitted over TCP or UDP, which is similar to TLS/DTLS but we have a unified protocol to handle both datagram and streaming traffic[2]. Compared to TLS/DTLS, this is a big advantage and it may be better use case for HIP[3].

In the libhip, most of code of hipd has been moved to lib/hipdaemon which then becomes a library for both hipd and libhip. By this way, the libhip can reuse the code of hipd to the max extend. This is also the reason why libhip can be a system test approach for hipd, especially in the process of base exchange, the libhip and hipd share the same code base. Meanwhile, the hip daemon, and other functionalities previous exist in the trunk, are kept unchanged and functioning after this merge.

We also implement a sample application called hipnetcat, which is a client-server style application on top of libhip and these 2 sides establish HIP association via BEX before actual data communication. The hipnetcat is integrated into our automatically test framework (check_hipnetcat). In check_hipnetcat, 2 hipnetcat processes try to establish BEX on loopback address on top of TCP/UDP, therefore, the execution of this test suite will check the functionality of base exchange in a system level.

Currently the libhip is still at an eary stage, there are several features waiting for implementation. First there is no support in the firewall; Second, although the control plane base exchange functions well, the data plane security is not implemented yet. We plan to introduce libsrtp for this purpose; Third, the libhip is not thread save yet, because the socket descriptors we use now are global variables; Last, the support of long period disconnectivity we mention in the first paragraph is not included in this merge, there will be another merge request for this feature.

[1] Schutz et al,. Protocol enhancements for intermittently connected hosts, 2005
[2] Komu et al, Technical report: Sockets and Beyond Assessing the Source Code of Network Applications, 2012
[3] Levä et al, Adoption of General-purpose Communication Protocols: the Case of Host Identity Protocol, unpublished manuscript, 2012

[Christof Mroz (christof-mroz)]

> === modified file 'lib/core/hostid.c'
> --- lib/core/hostid.c 2011-11-10 10:35:47 +0000
> +++ lib/core/hostid.c 2012-02-20 08:33:22 +0000
> @@ -743,11 +744,17 @@
> goto out_err;
> }
> } else if (!use_default) {
> + char hi_file_dup[strlen(hi_file) + 1];
> + strcpy(hi_file_dup, hi_file);
> + if ((err = check_and_create_dir(dirname(hi_file_dup), HIP_DIR_MODE))) {
> + HIP_ERROR("Could not create direcory for path: %s\n", hi_file);
> + goto out_err;
> + }

I investigated a bit and seems like PATH_MAX is 4096 chars on linux, which is probably OK even for stacks on embedded devices, but strdup() would be safer nevertheless.
My apologies for advising you to use the stack for that in the last mail (see also further below).

Probably unrelated: should this handle recursive mkdir()? check_and_create_dir() currently does not, as far as I see.

> === modified file 'lib/core/linkedlist.c'
> --- lib/core/linkedlist.c 2011-08-15 14:11:56 +0000
> +++ lib/core/linkedlist.c 2012-02-20 08:33:22 +0000
> @@ -298,6 +298,51 @@
> /**
> + * Deletes the first node from list which has the same ptr given.
> + * If there is no match, does nothing.
> + *
> + * @param linkedlist list to remoe an element from
> + * @param ptr pointer by which to identify the node
> + * @param free_element a function pointer to a function for freeing the memory
> + * allocated for an element at a node or NULL if the element
> + * itself is not to be freed.
> + */
> +void hip_ll_del_by_ptr(struct hip_ll *linkedlist, void *ptr,
> + free_elem_fn free_element)
> +{
> + struct hip_ll_node *curr;
> + struct hip_ll_node *tmp;
> +
> + /* match first list node */
> + if (linkedlist != NULL && linkedlist->element_count > 0
> + && linkedlist->head->ptr == ptr) {
> + tmp = linkedlist->head;
> + linkedlist->head = tmp->next;
> + linkedlist->element_count--;
> + if (free_element != NULL) {
> + free_element(tmp->ptr);
> + }
> + free(tmp);
> + return;
> + }
> +
> + /* match the rest list */
> + tmp = linkedlist->head;
> + for (curr = tmp->next; curr != NULL; curr = curr->next) {
> + if (curr->ptr == ptr) {
> + tmp->next = curr->next;
> + linkedlist->element_count--;
> + if (free_element != NULL) {
> + free_element(curr->ptr);
> + }
> + free(curr);
> + return;
> + }
> + tmp = tmp->next;
> + }
> +}

Looks like both loops can be merged, at first glance (untested):

if(!linkedlist || linkedlist->element_count == 0) {
 return;
}

struct hip_ll_node **storage = &linkedlist->head;
struct hip_ll_node *node = linkedlist->head;

while(node) {
 if(node->ptr == ptr) {
  *storage = node->next;
  free(node);
  node = *storage;

  linkedlist->elementcount -= 1;
  // could return here for micro optimization
 } else {
  storage = &node->next;
  node = node->next;
 }
}

> === renamed file 'hipd/init.c' => 'lib/hipdaemon/init....

review: Needs Fixing

[Christof Mroz (christof-mroz)]

On 20.02.2012 21:03, Christof Mroz wrote:
> struct hip_ll_node **storage = &linkedlist->head;
> struct hip_ll_node *node = linkedlist->head;
>
> while(node) {
> if(node->ptr == ptr) {
> *storage = node->next;
> free(node);
> node = *storage;
>
> linkedlist->elementcount -= 1;
> // could return here for micro optimization
> } else {
> storage = &node->next;
> node = node->next;
> }
> }

Just realized this can be compacted some more:

struct hip_ll_node **storage = &linkedlist->head;

while(*storage) {
     struct hip_ll_node *const node = *storage;

     if(node->ptr == ptr) {
         linkedlist->elementcount -= 1;
         *storage = node->next;

         free(node);
         // could return here for micro optimization
     } else {
         storage = &node->next;
     }
}

[Xin (eric-nevup)]

Hi,

On 20/02/12 22:03, Christof Mroz wrote:
> Review: Needs Fixing
>
>> === modified file 'lib/core/hostid.c'
>> --- lib/core/hostid.c 2011-11-10 10:35:47 +0000
>> +++ lib/core/hostid.c 2012-02-20 08:33:22 +0000
>> @@ -743,11 +744,17 @@
>> goto out_err;
>> }
>> } else if (!use_default) {
>> + char hi_file_dup[strlen(hi_file) + 1];
>> + strcpy(hi_file_dup, hi_file);
>> + if ((err = check_and_create_dir(dirname(hi_file_dup), HIP_DIR_MODE))) {
>> + HIP_ERROR("Could not create direcory for path: %s\n", hi_file);
>> + goto out_err;
>> + }
> I investigated a bit and seems like PATH_MAX is 4096 chars on linux, which is probably OK even for stacks on embedded devices, but strdup() would be safer nevertheless.
> My apologies for advising you to use the stack for that in the last mail (see also further below).
>
> Probably unrelated: should this handle recursive mkdir()? check_and_create_dir() currently does not, as far as I see.

Related stack memory usages have been reverted to malloc.

Regarding to check_and_create_dir(), in libhipl, using it is save,
because the parent directory (user's home folder) should exist.

Nice hints for linkedlist, it greatly shorten the lines of code :)

Xin

[Diego Biurrun (diego-biurrun)]

On Tue, Feb 21, 2012 at 05:36:57PM +0200, Xin Gu wrote:
> On 20/02/12 22:03, Christof Mroz wrote:
> >Review: Needs Fixing
> >
> >>=== modified file 'lib/core/hostid.c'
> >>--- lib/core/hostid.c 2011-11-10 10:35:47 +0000
> >>+++ lib/core/hostid.c 2012-02-20 08:33:22 +0000
> >>@@ -743,11 +744,17 @@
> >
> >Probably unrelated: should this handle recursive mkdir()? check_and_create_dir() currently does not, as far as I see.
>
> Regarding to check_and_create_dir(), in libhipl, using it is save,
> because the parent directory (user's home folder) should exist.

What happens if it does not exist?

Diego

[Xin (eric-nevup)]

On 21/02/12 21:21, Diego Biurrun wrote:
> On Tue, Feb 21, 2012 at 05:36:57PM +0200, Xin Gu wrote:
>> On 20/02/12 22:03, Christof Mroz wrote:
>>> Review: Needs Fixing
>>>
>>>> === modified file 'lib/core/hostid.c'
>>>> --- lib/core/hostid.c 2011-11-10 10:35:47 +0000
>>>> +++ lib/core/hostid.c 2012-02-20 08:33:22 +0000
>>>> @@ -743,11 +744,17 @@
>>> Probably unrelated: should this handle recursive mkdir()? check_and_create_dir() currently does not, as far as I see.
>> Regarding to check_and_create_dir(), in libhipl, using it is save,
>> because the parent directory (user's home folder) should exist.
> What happens if it does not exist?
>
>

Then the initialization process (loading the keys) will fail, program
exits with error.

Xin

[Christof Mroz (christof-mroz)]

Unless there's more to come (as you didn't request another review yet), I'm fine with the proposal.

Note that the early return in the linked list deletion routine is wrong if an item could be present multiple times.
In this case, in DEBUG configuration it could still be useful to trigger a HIP_ASSERT if an item is present multiple times but wasn't expected to (of course, you must always search the complete list then). This not directly related to this branch though.

If you commit the current version, remember to add bug tracker items concerning
- the non-recursive mkdir(): either always create the directory or never, but the current solution is something inbetween,
- the forking unit test: Even though forking is the simplest solution, tests should ideally not rely on their execution environment. Using mock functions you could also simulate dropped or corrupted packets for hipnetcat, etc.

review: Approve

[Miika Komu (miika-iki)]

Diego, I believe Xin has addressed the main issues, can we proceed to merge? We will continue to polish the library but we'd like to a get a more stable base for further work.

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

 review needs-fixing

Sorry, Stefan the bean counter is back...
> /**
> + * Deletes the first node from list which has the same ptr given.

well, maybe "which contains the payload pointer ptr"?

> + * If there is no match, does nothing.
> + *
> + * @param linkedlist list to remoe an element from

remo[v]e

> + * @param ptr pointer by which to identify the node
> + * @param free_element a function pointer to a function for freeing the memory
> + * allocated for an element at a node or NULL if the element
> + * itself is not to be freed.
> + */
> +void hip_ll_del_by_ptr(struct hip_ll *linkedlist, void *ptr,
> + free_elem_fn free_element)

const correctness: struct hip_ll *const linkedlist, const void *const ptr

To separate memory management from list management, I would find it a cleaner
API to not pass in a free function pointer but to return a void* pointer. If ptr
was found in the list and removed, the function should then return ptr itself.
If ptr was not found in the list, the function should return NULL. In any case,
the caller can free the memory for ptr (if they intend to do so) by calling
free(hip_ll_del_by_ptr(list, ptr)); This separates concerns and is still very
easy to use.

> +{
> + struct hip_ll_node *curr;
> + struct hip_ll_node *tmp;
> +
> + /* match first list node */
> + if (linkedlist != NULL && linkedlist->element_count > 0

the check for linkedlist != NULL should also cover the second part of this
function. I'd suggest adding an assertion for it.

> + && linkedlist->head->ptr == ptr) {
> + tmp = linkedlist->head;
> + linkedlist->head = tmp->next;
> + linkedlist->element_count--;
> + if (free_element != NULL) {
> + free_element(tmp->ptr);
> + }
> + free(tmp);
> + return;
> + }
> +
> + /* match the rest list */

rest [of ]the list?

> + tmp = linkedlist->head;
> + for (curr = tmp->next; curr != NULL; curr = curr->next) {
> + if (curr->ptr == ptr) {
> + tmp->next = curr->next;
> + linkedlist->element_count--;
> + if (free_element != NULL) {
> + free_element(curr->ptr);
> + }
> + free(curr);
> + return;
> + }
> + tmp = tmp->next;
> + }
> +}

Why not go with Christof's version? It looked much simpler to me.

> +void hip_ll_del_by_ptr(struct hip_ll *linkedlist, void *ptr,
> + free_elem_fn free_element);

const correctness

> /**
> + * Read a control message over TCP socket.

What exactly does this function do? What happens after the message is read? Is
it returned to the caller? Sent to another processing function? /dev/null? The
CIA? Paradise?

> + * @param sockfd a socket file descriptor
> + * @param ctx a pointer to the packet context
> + * @return -1 in case of an error, 0 otherwise.
> + */
> +int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *ctx)

const correctness

> +int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *ctx);

const correctness

> --- h...

review: Needs Fixing

[Christof Mroz (christof-mroz)]

On 26.02.2012 09:25, Stefan Götz wrote:
> To separate memory management from list management, I would find it a cleaner
> API to not pass in a free function pointer but to return a void* pointer. If ptr
> was found in the list and removed, the function should then return ptr itself.
> If ptr was not found in the list, the function should return NULL. In any case,
> the caller can free the memory for ptr (if they intend to do so) by calling
> free(hip_ll_del_by_ptr(list, ptr)); This separates concerns and is still very
> easy to use.

I'd rather vote for someone to pick up and finish your existing linked
list branch instead (one day), so we have a single implementation for
both hipd and hipfw.

I agree that passing the free function every time is stupid. Note though
that we could go the other extreme and store alloc/free function
pointers in the list head instead, to avoid this duplication altogether.
But ultimately your solution would wreak the least havoc, because there
is nothing unexpected going on behind the scenes (easier to comprehend
for new contributors) and we're unlikely to refactor this aspect.

>> +{
>> + struct hip_ll_node *curr;
>> + struct hip_ll_node *tmp;
>> +
>> + /* match first list node */
>> + if (linkedlist != NULL&& linkedlist->element_count> 0
>
> the check for linkedlist != NULL should also cover the second part of this
> function. I'd suggest adding an assertion for it.

Passing NULL to free()-like functions is usually a no-op (by
convention), so I disagree.

[Miika Komu (miika-iki)]

Hi,

On 02/26/2012 01:50 PM, Christof Mroz wrote:
>>> +{
>>> + struct hip_ll_node *curr;
>>> + struct hip_ll_node *tmp;
>>> +
>>> + /* match first list node */
>>> + if (linkedlist != NULL&& linkedlist->element_count> 0
>>
>> the check for linkedlist != NULL should also cover the second part of
>> this
>> function. I'd suggest adding an assertion for it.
>
> Passing NULL to free()-like functions is usually a no-op (by
> convention), so I disagree.

don't know if this applies here but, in general, we have agreed that
calling free(NULL) in the context of e.g. HIP_IFEL() is fine as
indicated by doc/HACKING:

   int f(void)
   {
       char *mem = NULL;
       HIP_IFEL(!(mem = HIP_ALLOC(256, 0)), -1, "alloc\n");

   out_err:
       free(mem);
       return err;
   }

This keeps the line count at minimum.

[Diego Biurrun (diego-biurrun)]

On Sat, Feb 25, 2012 at 09:52:17AM +0000, Miika Komu wrote:
> Diego, I believe Xin has addressed the main issues, can we proceed to
> merge? We will continue to polish the library but we'd like to a get a
> more stable base for further work.

No, the branch still has pending needs-fixing reviews and central issues
like the naming remain undecided.

Diego

[Xin (eric-nevup)]

Hi,

On 26/02/12 10:25, Stefan Götz wrote:
>> + * @param ptr pointer by which to identify the node
>> + * @param free_element a function pointer to a function for freeing the memory
>> + * allocated for an element at a node or NULL if the element
>> + * itself is not to be freed.
>> + */
>> +void hip_ll_del_by_ptr(struct hip_ll *linkedlist, void *ptr,
>> + free_elem_fn free_element)
> const correctness: struct hip_ll *const linkedlist, const void *const ptr

I was wondering if we can just use "const void *ptr"? I haven't figured
out why we need the second const.

If I understand correctly, you also suggest to change "struct
hip_packet_context *ctx" to "struct hip_packet_context *const ctx" for
the following function. Then I have the same question related to const
after asterisk.

int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *ctx)

> Why not go with Christof's version? It looked much simpler to me.

Current version is already based on Christof's advice. It seems that
somehow you receive an old version. I don't know why...

>> --- hipd/hadb.c 2012-02-17 10:45:47 +0000
>> +++ lib/hipdaemon/hadb.c 2012-02-20 08:33:22 +0000
>> @@ -616,7 +616,12 @@
>>
>> if (hip_select_source_address(&peer_map.our_addr,&peer_map.peer_addr)) {
>> HIP_ERROR("Cannot find source address\n");
>> - return -1;
>> + if (hipl_is_libhip_mode()) {
>> + memset(&peer_map.our_addr, 0, sizeof(peer_map.our_addr));
> How about 'peer_map.our_addr = INVALID_ADDR' with a suitable definition (and
> probably a better name for) INVALID_ADDR? It would reveal the intention of this
> code more clearly
>
>> + HIP_DEBUG("Using ANY for source address\n");
>> + } else {
>> + return -1;
>> + }

Hmm, what about add a comment? I add a comment and also rearrange this
part a bit, hope it is more clear.

> I couldn't finish reviewing, maybe later. In any case, const correctness for all
> further functions, please :)
>

I revised other code related to const correctness. Thanks for the review :)

https://code.launchpad.net/~hipl-core/hipl/libhip The diff in the
"Branch merges" section of this page is up-to-date.

Xin

[Xin (eric-nevup)]

Hi,

On 26/02/12 16:34, Diego Biurrun wrote:
> On Sat, Feb 25, 2012 at 09:52:17AM +0000, Miika Komu wrote:
>> Diego, I believe Xin has addressed the main issues, can we proceed to
>> merge? We will continue to polish the library but we'd like to a get a
>> more stable base for further work.
> No, the branch still has pending needs-fixing reviews and central issues
> like the naming remain undecided.
>
>

What is your opinion related to this naming issue? Previous we propose
to call it libhipl instead of libhipdaemon.
Since it will requires some efforts to change this, I hope we can agree
on a new name soon.

Xin

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

> I was wondering if we can just use "const void *ptr"? I haven't figured
> out why we need the second const.

http://www.parashift.com/c++-faq-lite/const-correctness.html

In short, 'const int *ptr' makes '*ptr = 7' illegal. 'int *const ptr' makes 'ptr
= NULL' illegal.

> If I understand correctly, you also suggest to change "struct
> hip_packet_context *ctx" to "struct hip_packet_context *const ctx" for
> the following function. Then I have the same question related to const
> after asterisk.
>
> int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *ctx)

Actually: const int sockfd, struct hip_packet_context *const ctx

Makes assignments to sockfd and ctx illegal because such assignments are not
necessary, anyway.

>> Why not go with Christof's version? It looked much simpler to me.
>
> Current version is already based on Christof's advice. It seems that
> somehow you receive an old version. I don't know why...

Ah, ok. No worries then.

>>> --- hipd/hadb.c 2012-02-17 10:45:47 +0000
>>> +++ lib/hipdaemon/hadb.c 2012-02-20 08:33:22 +0000
>>> @@ -616,7 +616,12 @@
>>>
>>> if (hip_select_source_address(&peer_map.our_addr,&peer_map.peer_addr)) {
>>> HIP_ERROR("Cannot find source address\n");
>>> - return -1;
>>> + if (hipl_is_libhip_mode()) {
>>> + memset(&peer_map.our_addr, 0, sizeof(peer_map.our_addr));
>> How about 'peer_map.our_addr = INVALID_ADDR' with a suitable definition (and
>> probably a better name for) INVALID_ADDR? It would reveal the intention of this
>> code more clearly
>>
>>> + HIP_DEBUG("Using ANY for source address\n");
>>> + } else {
>>> + return -1;
>>> + }
>
> Hmm, what about add a comment? I add a comment and also rearrange this
> part a bit, hope it is more clear.

Ok

Stefan

[Miika Komu (miika-iki)]

Hi,

> Hi,
>
> On 26/02/12 16:34, Diego Biurrun wrote:
> > On Sat, Feb 25, 2012 at 09:52:17AM +0000, Miika Komu wrote:
> >> Diego, I believe Xin has addressed the main issues, can we proceed to
> >> merge? We will continue to polish the library but we'd like to a get a
> >> more stable base for further work.
> > No, the branch still has pending needs-fixing reviews and central issues
> > like the naming remain undecided.
> >
> >
>
> What is your opinion related to this naming issue? Previous we propose
> to call it libhipl instead of libhipdaemon.
> Since it will requires some efforts to change this, I hope we can agree
> on a new name soon.

I suggested earlier:
* lib/hipl for the directory hierarchy
* libhipl.{so.a} for the resulting binary

Diego, what say ye?

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

> /**
> + * Read a control message over TCP socket and save it to @c hip_packet_context
> + * for future processing.

Ideally, this would also describe at least the most important checks that this code performs, how it handles socket errors, etc.

> +int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *const ctx)

const sockfd

> + is_ipv4 = (src_addr.sa_family == AF_INET);
> + if (is_ipv4) {
> + saddr4 = (struct sockaddr_in *) &src_addr;
> + IPV4_TO_IPV6_MAP(&saddr4->sin_addr, &ctx->src_addr);
> + ctx->msg_ports.src_port = ntohs(saddr4->sin_port);
> + } else {
> + saddr6 = (struct sockaddr_in6 *) &src_addr;
> + memcpy(&ctx->dst_addr, &saddr6->sin6_addr, sizeof(struct in6_addr));

a plain assignment instead of memcpy is easier to read in such cases, but that is a matter of taste.

> + ctx->msg_ports.src_port = ntohs(saddr6->sin6_port);
> + }

Some of the socket_wrapper functions fit in very well here.

> + HIP_DEBUG_IN6ADDR("src", &ctx->src_addr);
> + HIP_DEBUG_IN6ADDR("dst", &ctx->dst_addr);

Maybe more information than that? Such as 'received packet from TCP socket, src..., dst...'?

> +static int hipd_library_mode = 0;

Why not a boolean type?

> === added file 'lib/hipdaemon/socket_wrapper.c'
> --- lib/hipdaemon/socket_wrapper.c 1970-01-01 00:00:00 +0000
> +++ lib/hipdaemon/socket_wrapper.c 2012-02-26 19:08:21 +0000

It would be extremely good to have more documentation in this file. Why is the struct hipl_fd_info necessary, for example? I don't mean what information in contains - that is obvious - but what is its purpose? Why was it necessary?

All of the functions in this file need to be updated with stricter const correctness.

> +static struct hip_ll socket_list;

What kind of socket is stored in this list? It's struct hipl_fd_info objects, right?

Are there many such objects? If not it may be simpler to just use a fixed size array than a dynamic list that tends to be awkward to use (==read).

> +static struct in6_addr default_hit;

> +/**
> + * Get information on a HIP socket by its file descritor.

descri[p]tor

Please use an editor with a spell checker and respect its suggestions :)

> +/**
> + * Add peer's hit-to-addr mapping to hadb.
> + * @param peer_hit peer's hit
> + * @param peer_addr peer's addr, v4 addr should be mapped.
> + * @return 0 on success, -1 otherwise.
> + */
> +int hipl_add_peer_info(const hip_hit_t *peer_hit,
> + const struct in6_addr *peer_addr)
> +{
> + return hip_hadb_add_peer_info(peer_hit, peer_addr, NULL, NULL);
> +}

What's the point? Why not call hip_hadb_add_peer_info() in the first place?

More to come

Stefan

[Diego Biurrun (diego-biurrun)]

On Mon, Feb 27, 2012 at 07:25:23AM +0000, Miika Komu wrote:
> > On 26/02/12 16:34, Diego Biurrun wrote:
> > > On Sat, Feb 25, 2012 at 09:52:17AM +0000, Miika Komu wrote:
> > >> Diego, I believe Xin has addressed the main issues, can we proceed to
> > >> merge? We will continue to polish the library but we'd like to a get a
> > >> more stable base for further work.
> > > No, the branch still has pending needs-fixing reviews and central issues
> > > like the naming remain undecided.
> >
> > What is your opinion related to this naming issue? Previous we propose
> > to call it libhipl instead of libhipdaemon.
> > Since it will requires some efforts to change this, I hope we can agree
> > on a new name soon.
>
> I suggested earlier:
> * lib/hipl for the directory hierarchy

I don't think grouping all of that stuff together below lib/ is a bad
idea, just put it in its separate directory.

I previously said I wanted to move lib/core and lib/tool together, I
would still like to.

> * libhipl.{so.a} for the resulting binary

Fine with me.

Diego

[David Martin (martin-lp)]

Hi,

On Mon, Feb 27, 2012 at 9:04 AM, Stefan Götz <email address hidden> wrote:

>> +    is_ipv4 = (src_addr.sa_family == AF_INET);
>> +    if (is_ipv4) {
>> +        saddr4 = (struct sockaddr_in *) &src_addr;
>> +        IPV4_TO_IPV6_MAP(&saddr4->sin_addr, &ctx->src_addr);
>> +        ctx->msg_ports.src_port = ntohs(saddr4->sin_port);
>> +    } else {
>> +        saddr6 = (struct sockaddr_in6 *) &src_addr;
>> +        memcpy(&ctx->dst_addr, &saddr6->sin6_addr, sizeof(struct in6_addr));
>
> a plain assignment instead of memcpy is easier to read in such cases, but that is a matter of taste.

Either way there's a wrapper function for this purpose in
lib/core/prefix.c: ipv6_addr_copy(). Not sure if assignments are a
good idea but the wrapper should definitely be used instead of the
manual memcpy() with sizeof(). :)

[Diego Biurrun (diego-biurrun)]

On Mon, Feb 27, 2012 at 08:04:22AM +0000, Stefan Götz wrote:
> > + is_ipv4 = (src_addr.sa_family == AF_INET);
> > + if (is_ipv4) {
> > + saddr4 = (struct sockaddr_in *) &src_addr;
> > + IPV4_TO_IPV6_MAP(&saddr4->sin_addr, &ctx->src_addr);
> > + ctx->msg_ports.src_port = ntohs(saddr4->sin_port);
> > + } else {
> > + saddr6 = (struct sockaddr_in6 *) &src_addr;
> > + memcpy(&ctx->dst_addr, &saddr6->sin6_addr, sizeof(struct in6_addr));
>
> a plain assignment instead of memcpy is easier to read in such cases,
> but that is a matter of taste.

I'd disagree with the taste part - just use assignments.

Diego

[Xin (eric-nevup)]

Hi,

On 26/02/12 22:34, Stefan Götz wrote:
>> I was wondering if we can just use "const void *ptr"? I haven't figured
>> out why we need the second const.
> http://www.parashift.com/c++-faq-lite/const-correctness.html
>
> In short, 'const int *ptr' makes '*ptr = 7' illegal. 'int *const ptr' makes 'ptr
> = NULL' illegal.
>
>> If I understand correctly, you also suggest to change "struct
>> hip_packet_context *ctx" to "struct hip_packet_context *const ctx" for
>> the following function. Then I have the same question related to const
>> after asterisk.
>>
>> int hip_read_control_msg_tcp(int sockfd, struct hip_packet_context *ctx)
> Actually: const int sockfd, struct hip_packet_context *const ctx
>
> Makes assignments to sockfd and ctx illegal because such assignments are not
> necessary, anyway.
>
>

I understand the syntax of const, but from the caller's point of view,
it has no difference if the function parameters are "const int sockfd,
struct hip_packet_context *const ctx" or "int sockfd, struct
hip_packet_context *ctx". Because both integer and pointer are
pass-by-value, and callee changing those parameters or not won't affect
caller.

That's why I am wondering if it is really necessary to add const under
those situations, if we have a look at some other C libraries, it is
also rare to see them using const in this way. For example, socket(int,
int, int) not socket(const int, const int, const int).

Of course, a const pointer like "const char *ptr" is necessary, which
means the function will not alter the data this ptr points to. My commit
last night fixed the const missing for this case.

Xin

[Miika Komu (miika-iki)]

Hi,

On 02/27/2012 10:23 AM, Diego Biurrun wrote:
> On Mon, Feb 27, 2012 at 07:25:23AM +0000, Miika Komu wrote:
>>> On 26/02/12 16:34, Diego Biurrun wrote:
>>>> On Sat, Feb 25, 2012 at 09:52:17AM +0000, Miika Komu wrote:
>>>>> Diego, I believe Xin has addressed the main issues, can we proceed to
>>>>> merge? We will continue to polish the library but we'd like to a get a
>>>>> more stable base for further work.
>>>> No, the branch still has pending needs-fixing reviews and central issues
>>>> like the naming remain undecided.
>>>
>>> What is your opinion related to this naming issue? Previous we propose
>>> to call it libhipl instead of libhipdaemon.
>>> Since it will requires some efforts to change this, I hope we can agree
>>> on a new name soon.
>>
>> I suggested earlier:
>> * lib/hipl for the directory hierarchy
>
> I don't think grouping all of that stuff together below lib/ is a bad
> idea, just put it in its separate directory.
>
> I previously said I wanted to move lib/core and lib/tool together, I
> would still like to.

I believe this request is unrelated to the merge proposal?

Anyway, we have decided earlier that lib/core contains MIT-licensed code
and lib/tool GPL-licensed code. Now that I think about this separation,
I think the copyright already states clearly the difference. So, I don't
really object against merging the two directories.

[Miika Komu (miika-iki)]

Hi,

On 02/27/2012 11:27 AM, Xin Gu wrote:
> That's why I am wondering if it is really necessary to add const under
> those situations, if we have a look at some other C libraries, it is
> also rare to see them using const in this way. For example, socket(int,
> int, int) not socket(const int, const int, const int).

the Sockets API is a bit sloppy and we're trying to be more strict in HIPL.

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

Hi Xin,

your understanding is quite correct. It is simply project policy to make all data as 'const' as possible because it helps to detect bugs. For example:

void foo(list_t *list) {
  if (list = NULL) {
    return;
  } else {
    // do stuff with list
  }
}

cannot go unnoticed when foo is declared as 'void foo(list_t *const list)'

So you're right: such const qualifiers are not *necessary*. But the hipl team still considers them a very good idea.

Cheers,
 Stefan

[Xin (eric-nevup)]

On 27/02/12 11:46, Stefan Götz wrote:
> Hi Xin,
>
> your understanding is quite correct. It is simply project policy to make all data as 'const' as possible because it helps to detect bugs. For example:
>
> void foo(list_t *list) {
> if (list = NULL) {
> return;
> } else {
> // do stuff with list
> }
> }
>
> cannot go unnoticed when foo is declared as 'void foo(list_t *const list)'
>
> So you're right: such const qualifiers are not *necessary*. But the hipl team still considers them a very good idea.
>
> Cheers,
> Stefan
>
>

Hi Stefan,

Thanks for this explanation, so we are using const in this case for the
function author to avoid potential bugs and it is also helpful for
others to understand the code. It is a good practice, I will follow this
style.

I have one suggestion: for the function declaration in the header file,
I suggest that we can eliminate this kind of const because it makes no
sense for the API caller. For instance:

In linkedlist.h
void hip_ll_del_by_ptr(struct hip_ll *linkedlist, const void *ptr,
                        free_elem_fn free_element);

In linkedlist.c
void hip_ll_del_by_ptr(struct hip_ll *const linkedlist, const void
*const ptr,
                        free_elem_fn free_element) {
     ... ....
}

Compiler will treat them as the same function. I am also thinking if
there is any compiler option to enforce this const by default, then
perhaps we don't need to type it everywhere :)

Xin

[Xin (eric-nevup)]

On 27/02/12 10:04, Stefan Götz wrote:
>
>> + ctx->msg_ports.src_port = ntohs(saddr6->sin6_port);
>> + }
> Some of the socket_wrapper functions fit in very well here.

Didn't get your point, which function?

>
>> +static struct hip_ll socket_list;
> What kind of socket is stored in this list? It's struct hipl_fd_info objects, right?
>
> Are there many such objects? If not it may be simpler to just use a fixed size array than a dynamic list that tends to be awkward to use (==read).

Added comments about this field.

Yes, it is a list of hipl_fd_info. Since the number of open HIPL sockets
is determined by the user, I think it is difficult to make it as a fixed
size array.

>
>> +/**
>> + * Add peer's hit-to-addr mapping to hadb.
>> + * @param peer_hit peer's hit
>> + * @param peer_addr peer's addr, v4 addr should be mapped.
>> + * @return 0 on success, -1 otherwise.
>> + */
>> +int hipl_add_peer_info(const hip_hit_t *peer_hit,
>> + const struct in6_addr *peer_addr)
>> +{
>> + return hip_hadb_add_peer_info(peer_hit, peer_addr, NULL, NULL);
>> +}
> What's the point? Why not call hip_hadb_add_peer_info() in the first place?
>

This is an API for LIBHIPL user. We don't want user to directly handle hadb.

The const correctness is applied to all functions.

Xin

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

>>
>>> + ctx->msg_ports.src_port = ntohs(saddr6->sin6_port);
>>> + }
>> Some of the socket_wrapper functions fit in very well here.
>
> Didn't get your point, which function?

I meant get_port_from_saddr()

[Xin (eric-nevup)]

On 28/02/12 09:28, Stefan Götz wrote:
> I meant get_port_from_saddr()
>
>

This get_port_from_saddr() function is used when you don't know the
saddr is AF_INET or AF_INET6, and it is a static function, but in
currently condition we already know it is IPv4 or v6, because except
port number, we also extract the IP address from it.

Xin

[Xin (eric-nevup)]

On 27/02/12 14:35, Diego Biurrun wrote:
> On Mon, Feb 27, 2012 at 11:31:45AM +0200, Miika Komu wrote:
>> On 02/27/2012 10:23 AM, Diego Biurrun wrote:
>> I believe this request is unrelated to the merge proposal?
> What to do with lib/core and lib/tool is, yes, but what to do with
> libhipl is not.
>
>
In libhip branch, I have changed libhipdaemon to libhipl, and renamed
folder from lib/hipdaemon to lib/hipl

Xin

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

Sorry, no time for more reviews :-(

review: Abstain

[Miika Komu (miika-iki)]

Unless somebody objects by Friday, I would suggest Xin to merge the code then.

[Diego Biurrun (diego-biurrun)]

 review needs-fixing

On Tue, Mar 13, 2012 at 09:51:23AM +0000, Miika Komu wrote:
> Unless somebody objects by Friday, I would suggest Xin to merge the code then.

I object. This merge request had many comments and questions that I did
not see addressed. I would expect a fresh merge request at least.

Diego

review: Needs Fixing

[Xin (eric-nevup)]

Hi,

On 13/03/12 17:58, Diego Biurrun wrote:
> I object. This merge request had many comments and questions that I did
> not see addressed. I would expect a fresh merge request at least.
>
Since all the reviewers approve this merge request, I don't know where
is the open comments and questions you said. If I miss something, could
you show them so I can fix accordingly?

Xin

[Diego Biurrun (diego-biurrun)]

On Wed, Mar 14, 2012 at 01:51:56PM +0200, Xin Gu wrote:
> On 13/03/12 17:58, Diego Biurrun wrote:
> >I object. This merge request had many comments and questions that I did
> >not see addressed. I would expect a fresh merge request at least.
> >
> Since all the reviewers approve this merge request,

I don't approve it and I set my review to needs-fixing.

> I don't know where is the open comments and questions you said. If I
> miss something, could you show them so I can fix accordingly?

As I said, I am expecting a fresh merge request; this one had far too
many comments.

Diego

[Christof Mroz (christof-mroz)]

> === modified file 'doc/HOWTO.xml.in'
> --- doc/HOWTO.xml.in 2012-01-25 10:44:48 +0000
> +++ doc/HOWTO.xml.in 2012-03-15 08:58:36 +0000
> @@ -2584,6 +2658,68 @@
> + <para>
> + Libhipl API set is mainly located in
> + <emphasis>"socket_wrapper.h"</emphasis>. The initialization function:
> + <emphasis>libhipd_init(void)</emphasis> is declared in
> + <emphasis>"init.h"</emphasis>
> + </para>

A <code> tag looks more appropriate than <emphasis> (also in other places throught the file)
http://www.docbook.org/tdg/en/html/code.html

> === added file 'lib/hipl/socket_wrapper.c'
> --- lib/hipl/socket_wrapper.c 1970-01-01 00:00:00 +0000
> +++ lib/hipl/socket_wrapper.c 2012-03-15 08:58:36 +0000
> @@ -0,0 +1,827 @@
> + do {
> + if (fd_info->proto == IPPROTO_TCP) {
> + if (!hip_read_control_msg_tcp(fd, &ctx)) {
> + hip_receive_control_packet(&ctx);
> + }
> + } else if (fd_info->family == AF_INET) {
> + if (!hip_read_control_msg_v4(fd, &ctx, HIP_UDP_ZERO_BYTES_LEN)) {
> + hip_receive_control_packet(&ctx);
> + }
> + } else {
> + if (!hip_read_control_msg_v6(fd, &ctx, HIP_UDP_ZERO_BYTES_LEN)) {
> + hip_receive_control_packet(&ctx);
> + }
> + }
> + } while (fd_info->ha->state != HIP_STATE_ESTABLISHED);

Looks like a lot of this dispatching throughout the patch could be avoided by introducing a generic hip_read_control_msg() function that takes an extra fd_info parameter and runs a switch() through it.
Sorry if this has been mentioned before, but I couldn't find it in the archives right away.

> + if (domain == AF_INET) {
> + setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
> + setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &on, sizeof(on));
> + setsockopt(sock, IPPROTO_IP, IP_RECVERR, &off, sizeof(off));
> + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
> + } else {
> + setsockopt(sock, IPPROTO_IPV6, IPV6_RECVERR, &off, sizeof(off));
> + setsockopt(sock, IPPROTO_IPV6, IPV6_2292PKTINFO, &on, sizeof(on));
> + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
> + }

Since this is a library function (i.e., "user-friendly"), this should error out if neither AF_INET nor AF_INET6 are given.

> + /* Drop the packet if it doesn't come from the address associated
> + * with the correct peer. */
> + if (fd_info->proto == IPPROTO_UDP) {
> + if (addr->sa_family == AF_INET) {

Since this is a library function, you should check that addr is indeed non-NULL for UDP.
But better yet: don't use the caller's buffer in the first place but provide your own.

> + peer_addr4 = &((struct sockaddr_in *) addr)->sin_addr;
> + IPV4_TO_IPV6_MAP(peer_addr4, &peer_addr);
> + peer_addr6 = &peer_addr;
> + } else {

peer_addr is probably a useless indirection.

> === added file 'lib/hipl/socket_wrapper.h'
> --- lib/hipl/socket_wrapper.h 1970-01-01 00:00:00 +0000
> +++ lib/hipl/socket_wrapper.h 2012-03-15 08:58:36 +0000
> @@ -0,0 +1,52 @@
> +int hipl...

review: Needs Information

[René Hummen (rene-hummen)]

We are currently wrapping up the changes to the HIPL codebase for our project in Aachen. To this end, we are testing the HIPL code thoroughly on the certificate-exchange branch (which is in close sync with trunk). You may have noticed some bug fixes during the last couple of days. Once, we are confident that the certificate-related code is working correctly, we will merge it to trunk.

In order to have a stable HIPL version at the end of our project, I would very much appreciate if you could delay your merge until the end of the month. This will give us enough time to fix remaining issues that we run into. Merging your branch will again result in hugh changes that may result in new bugs and additional effort towards a stabile version of HIPL.

I suggest to make a new HIPL release after the certificate code has been merged. A few people have asked for this functionality. So a release might be helpful for them. The next release may then consist of the librarized version of HIPL.

review: Disapprove

[Miika Komu (miika-iki)]

The code is actually supposed to improve testing but I do understand your concern. As a compromise, would it be ok to do an intermediate merge proposal where we just change the directory structure to reflect the upcoming changes with the library? This would ease our pain as well.

Regarding to the release, we can do a release from any version in the code base and there's no real reason why the release schedule should stall progress.

[Diego Biurrun (diego-biurrun)]

 review needs-fixing

On Thu, Mar 15, 2012 at 08:59:19AM +0000, Xin wrote:
> Xin has proposed merging lp:~hipl-core/hipl/libhip into lp:hipl.

This merge request is huge and not easy to review. Please split it.

> +++ Makefile.am 2012-03-15 08:58:36 +0000
> @@ -34,7 +34,7 @@
> EXTRA_DIST += $(wildcard $(addprefix $(srcdir)/hipfw/,*.cfg))
> EXTRA_DIST += $(HIPL_HEADER_LIST)
> -EXTRA_DIST += hipd/pisa.c hipfw/pisa.c hipfw/pisa_cert.c
> +EXTRA_DIST += lib/hipl/pisa.c hipfw/pisa.c hipfw/pisa_cert.c

This conflicts with the certificate branch, which just landed on trunk.
You will have to merge trunk soon.

> @@ -48,6 +48,7 @@
>
> ### test programs ###
> noinst_PROGRAMS = test/certteststub \
> + test/hipnetcat \
> test/performance/auth_performance \

I think tools/ would be a better place for this.

> @@ -59,15 +60,19 @@
>
> ### libraries ###
> lib_LTLIBRARIES = lib/core/libhipcore.la
> +lib_LTLIBRARIES += lib/hipl/libhipl.la

Align the = please. Better yet, just put it on one line or continue
with a backslash, there is no need to split it like you did.

> @@ -85,46 +91,7 @@
>
> @@ -199,6 +166,48 @@
>
> +lib_hipl_libhipl_la_sources = lib/hipl/accessor.c \
> + lib/hipl/cert.c \
> + modules/heartbeat/hipd/heartbeat.c \
> + modules/heartbeat_update/hipd/hb_update.c \
> + modules/update/hipd/update.c \
> + modules/update/hipd/update_builder.c \
> + modules/update/hipd/update_locator.c \
> + modules/update/hipd/update_param_handling.c
> +
> +lib_hipl_libhipl_la_SOURCES = $(lib_hipl_libhipl_la_sources) \
> + modules/midauth/hipd/midauth.c

This looks like a merging error to me. I just made this indirection
unnecessary on trunk, midauth.c is just a normal source file.

> +lib_hipl_libhipl_la_LIBADD = lib/core/libhipcore.la

Place this together with the other lib dependencies.

> @@ -216,10 +225,13 @@
> test_check_lib_core_SOURCES = test/check_lib_core.c \
> test/lib/core/crypto.c \
> test/lib/core/hit.c \
> test/lib/core/hostid.c \
> + test/lib/core/linkedlist.c \

This whole linkedlist business could be split out into a separate merge request.

> --- doc/HOWTO.xml.in 2012-01-25 10:44:48 +0000
> +++ doc/HOWTO.xml.in 2012-03-15 08:58:36 +0000
> @@ -764,6 +764,80 @@
> </para>
> </section> <!-- handover -->
>
> + <section id="ch_hipnetcat">
> + <title>Test HIPL with the hipnetcat program</title>
> + <para>
> + Hipnetcat can be used to test the base exchange functionality of HIPL.
> + This section explains its usage in detail.
> + </para>
> +...

review: Needs Fixing

[lp:~hipl-core/hipl/libhip]

4889. By Xin on 2012-03-20

Check HIP firewall status before sending RESET message when closing HIP SA.

The "fail and retry" mechanism makes closing time unnecessary long when there
is no HIP firewall. In this case, we should simply skip this process.

4890. By Xin on 2012-03-20

Fix bug in hipnetcat test programming which causes longger testing time.

Previously, the break statement only exits the inner loop, but its purpose is
to exit the outer loop also.

4891. By Xin on 2012-03-20

Sync: trunk 6344

4892. By Xin on 2012-03-20

Eliminate redundant code in control message receiving and handling.

4893. By Xin on 2012-03-20

Fix issues in doc raised during review.

4894. By Xin on 2012-03-21

Sync: trunk 6360

4895. By Xin on 2012-03-22

Remove useless indirection.

[Xin (eric-nevup)]

Hi,

On 15/03/12 13:41, Christof Mroz wrote:
> Review: Needs Information
>
> A<code> tag looks more appropriate than<emphasis> (also in other places throught the file)
> http://www.docbook.org/tdg/en/html/code.html

Although from the link you provided, <code> tag can be the child of
<para>, I found that changing to <code> tag causes XML validation
failure. Now I still using <emphasis> tag.

> Since this is a library function (i.e., "user-friendly"), this should error out if neither AF_INET nor AF_INET6 are given.
>
> Since this is a library function, you should check that addr is indeed non-NULL for UDP.
> But better yet: don't use the caller's buffer in the first place but provide your own.
>
>
> Would a corresponding remove function make sense?

Next version of libhipl (which is what I am working on now) will contain
argument check and other functionalities you mentioned.

Other two issues: code redundancy and useless indirection are fixed.

Sorry for my delayed response. Thanks.

Xin

[Diego Biurrun (diego-biurrun)]

On Thu, Mar 22, 2012 at 02:49:47PM +0200, Xin Gu wrote:
> On 15/03/12 13:41, Christof Mroz wrote:
> >Review: Needs Information
> >
> >A<code> tag looks more appropriate than<emphasis> (also in other places throught the file)
> >http://www.docbook.org/tdg/en/html/code.html
>
> Although from the link you provided, <code> tag can be the child of
> <para>, I found that changing to <code> tag causes XML validation
> failure. Now I still using <emphasis> tag.

That is not the right solution. Look around in the file for better markup
suggestions.

Diego

[lp:~hipl-core/hipl/libhip]

4896. By Xin on 2012-03-27

sync: libhipl-mobility 4899

4897. By Xin on 2012-03-27

change the type of hipl_socket identifier from int to type hipl_sock_id

4898. By Xin on 2012-04-16

Sync: libhipl-mobility 4911.

4899. By Xin on 2012-04-16

Sync: trunk 6364

4900. By Xin on 2012-04-16

Fix document style and missing header.

4901. By Xin on 2012-04-17

Improve code style and doxygen documentation.

4902. By Xin on 2012-04-17

sync: trunk 6370

4903. By Xin on 2012-04-17

Remove unnecessary changes.

4904. By Xin on 2012-04-17

Change memcpy to assignments

4905. By Xin on 2012-04-17

Remove hipnetcat

[Xin (eric-nevup)]

Hi,

On 19/03/12 16:59, Diego Biurrun wrote:
> review needs-fixing
>
>
>> --- lib/core/hostid.c 2012-03-01 14:26:43 +0000
>> +++ lib/core/hostid.c 2012-03-15 08:58:36 +0000
>> @@ -678,6 +679,7 @@
>> int dsa_pub_key_rr_len = 0, rsa_pub_key_rr_len = 0;
>> hip_hdr numeric_action = 0;
>> + char *hi_file_dup = NULL;
>> char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
>> @@ -743,11 +745,16 @@
>> goto out_err;
>> }
>> } else if (!use_default) {
>> + hi_file_dup = strdup(hi_file);
>> + if ((err = check_and_create_dir(dirname(hi_file_dup), HIP_DIR_MODE))) {
>> + HIP_ERROR("Could not create direcory for path: %s\n", hi_file);
>> + goto out_err;
> You strup - why?

the function dirname() might modify the parameter, so I copy it.

>
> unrelated: I'm slightly suspicious of HIP_DIR_MODE, which is 0755.
> Is it really safe to make this world-readable?
>

It seems to be problematic, what should be a safe DIR_MODE?

>
>> @@ -523,6 +551,208 @@
>> +static int libhip_init_handle_functions(void)
>> +{
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_I2, HIP_STATE_NONE,&hip_setup_ipsec_sa, 30500);
>> + //hip_register_handle_function(HIP_R2, HIP_STATE_I2_SENT,&hip_setup_ipsec_sa, 30500);
> Why are all these commented-out?

Because kernel-based IPSec functions cannot be used in libhipl. Now I
delete those lines instead of commenting out.

All other issues are fixed.
Although hipnetcat and its test cases are not included in the merge
proposal this time, I fixed those issues you mentioned. You will see
them when I merge the hipnetcat.

Thanks for the review.

Xin

[Christof Mroz (christof-mroz)]

On 17.04.2012 18:16, Xin wrote:
> On 19/03/12 16:59, Diego Biurrun wrote:
>> > review needs-fixing
>> >
>> >
>>> >> --- lib/core/hostid.c 2012-03-01 14:26:43 +0000
>>> >> +++ lib/core/hostid.c 2012-03-15 08:58:36 +0000
>>> >> @@ -678,6 +679,7 @@
>>> >> int dsa_pub_key_rr_len = 0, rsa_pub_key_rr_len = 0;
>>> >> hip_hdr numeric_action = 0;
>>> >> + char *hi_file_dup = NULL;
>>> >> char hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
>>> >> @@ -743,11 +745,16 @@
>>> >> goto out_err;
>>> >> }
>>> >> } else if (!use_default) {
>>> >> + hi_file_dup = strdup(hi_file);
>>> >> + if ((err = check_and_create_dir(dirname(hi_file_dup), HIP_DIR_MODE))) {
>>> >> + HIP_ERROR("Could not create direcory for path: %s\n", hi_file);
>>> >> + goto out_err;
>> > You strup - why?
> the function dirname() might modify the parameter, so I copy it.
>

This is ok now, but tucking the strdup() and dirname() away into
check_and_create_dir() could be less distracting and reusable. I'm not sure.

Unmerged revisions

=== modified file 'Makefile.am'
--- Makefile.am	2012-03-13 15:27:06 +0000
+++ Makefile.am	2012-04-17 15:16:21 +0000
@@ -58,17 +58,21 @@
 
 
 ### libraries ###
-lib_LTLIBRARIES = lib/core/libhipcore.la
+lib_LTLIBRARIES = lib/core/libhipcore.la                                \
+                  lib/hipl/libhipl.la
 
 
 ### tests ###
 if HIP_UNITTESTS
 TESTS           = test/check_hipd                                       \
                   test/check_hipfw                                      \
-                  test/check_lib_core
+                  test/check_lib_core                                   \
+                  test/check_libhipl
+
 check_PROGRAMS  = test/check_hipd                                       \
                   test/check_hipfw                                      \
-                  test/check_lib_core
+                  test/check_lib_core                                   \
+                  test/check_libhipl
 endif
 
 
@@ -85,47 +89,7 @@
 
 tools_hipconf_SOURCES  = tools/hipconf.c
 
-hipd_hipd_sources = hipd/accessor.c                                     \
-                    hipd/cert.c                                         \
-                    hipd/close.c                                        \
-                    hipd/configfilereader.c                             \
-                    hipd/cookie.c                                       \
-                    hipd/dh.c                                           \
-                    hipd/esp_prot_anchordb.c                            \
-                    hipd/esp_prot_hipd_msg.c                            \
-                    hipd/esp_prot_light_update.c                        \
-                    hipd/hadb.c                                         \
-                    hipd/hidb.c                                         \
-                    hipd/hip_socket.c                                   \
-                    hipd/hipd.c                                         \
-                    hipd/hiprelay.c                                     \
-                    hipd/hit_to_ip.c                                    \
-                    hipd/init.c                                         \
-                    hipd/input.c                                        \
-                    hipd/keymat.c                                       \
-                    hipd/lsidb.c                                        \
-                    hipd/maintenance.c                                  \
-                    hipd/nat.c                                          \
-                    hipd/netdev.c                                       \
-                    hipd/nsupdate.c                                     \
-                    hipd/opp_mode.c                                     \
-                    hipd/output.c                                       \
-                    hipd/pkt_handling.c                                 \
-                    hipd/registration.c                                 \
-                    hipd/user.c                                         \
-                    hipd/user_ipsec_hipd_msg.c                          \
-                    hipd/user_ipsec_sadb_api.c                          \
-                    modules/heartbeat/hipd/heartbeat.c                  \
-                    modules/heartbeat_update/hipd/hb_update.c           \
-                    modules/cert/hipd/cert.c                            \
-                    modules/update/hipd/update.c                        \
-                    modules/update/hipd/update_builder.c                \
-                    modules/update/hipd/update_locator.c                \
-                    modules/update/hipd/update_param_handling.c
-
-hipd_hipd_SOURCES = $(hipd_hipd_sources)                                \
-                    modules/midauth/hipd/midauth.c                      \
-                    hipd/main.c
+hipd_hipd_SOURCES = hipd/main.c
 
 dist_sysconf_DATA = hipd/hipd.conf                                      \
                     hipd/hosts                                          \
@@ -202,6 +166,47 @@
 lib_core_libhipcore_la_SOURCES += lib/core/performance.c
 endif
 
+lib_hipl_libhipl_la_SOURCES = lib/hipl/accessor.c                         \
+                              lib/hipl/cert.c                             \
+                              lib/hipl/close.c                            \
+                              lib/hipl/configfilereader.c                 \
+                              lib/hipl/cookie.c                           \
+                              lib/hipl/dh.c                               \
+                              lib/hipl/esp_prot_anchordb.c                \
+                              lib/hipl/esp_prot_hipd_msg.c                \
+                              lib/hipl/esp_prot_light_update.c            \
+                              lib/hipl/hadb.c                             \
+                              lib/hipl/hidb.c                             \
+                              lib/hipl/hip_socket.c                       \
+                              lib/hipl/hipd.c                             \
+                              lib/hipl/hiprelay.c                         \
+                              lib/hipl/hit_to_ip.c                        \
+                              lib/hipl/init.c                             \
+                              lib/hipl/input.c                            \
+                              lib/hipl/keymat.c                           \
+                              lib/hipl/lhipl.c                            \
+                              lib/hipl/lhipl_sock.c                       \
+                              lib/hipl/lhipl_operations.c                 \
+                              lib/hipl/lsidb.c                            \
+                              lib/hipl/maintenance.c                      \
+                              lib/hipl/nat.c                              \
+                              lib/hipl/netdev.c                           \
+                              lib/hipl/nsupdate.c                         \
+                              lib/hipl/opp_mode.c                         \
+                              lib/hipl/output.c                           \
+                              lib/hipl/pkt_handling.c                     \
+                              lib/hipl/registration.c                     \
+                              lib/hipl/user.c                             \
+                              lib/hipl/user_ipsec_hipd_msg.c              \
+                              lib/hipl/user_ipsec_sadb_api.c              \
+                              modules/cert/hipd/cert.c                    \
+                              modules/heartbeat/hipd/heartbeat.c          \
+                              modules/heartbeat_update/hipd/hb_update.c   \
+                              modules/midauth/hipd/midauth.c              \
+                              modules/update/hipd/update.c                \
+                              modules/update/hipd/update_builder.c        \
+                              modules/update/hipd/update_locator.c        \
+                              modules/update/hipd/update_param_handling.c
 
 test_check_hipd_SOURCES = test/check_hipd.c                             \
                           test/hipd/lsidb.c                             \
@@ -230,14 +235,18 @@
                               test/lib/core/gpl/pk.c                    \
                               test/lib/core/modules/midauth_builder.c
 
+test_check_libhipl_SOURCES = test/check_libhipl.c
+
 
 ### static library dependencies ###
 
-hipd_hipd_LDADD                          = lib/core/libhipcore.la
+hipd_hipd_LDADD                          = lib/hipl/libhipl.la
 hipfw_hipfw_LDADD                        = lib/core/libhipcore.la
-test_check_hipd_LDADD                    = lib/core/libhipcore.la
+lib_hipl_libhipl_la_LIBADD               = lib/core/libhipcore.la
+test_check_hipd_LDADD                    = lib/hipl/libhipl.la
 test_check_hipfw_LDADD                   = lib/core/libhipcore.la
 test_check_lib_core_LDADD                = lib/core/libhipcore.la
+test_check_libhipl_LDADD                 = lib/hipl/libhipl.la
 test_certteststub_LDADD                  = lib/core/libhipcore.la
 test_performance_auth_performance_LDADD  = lib/core/libhipcore.la
 test_performance_dh_performance_LDADD    = lib/core/libhipcore.la

=== modified file 'doc/HOWTO.xml.in'
--- doc/HOWTO.xml.in	2012-02-28 18:38:18 +0000
+++ doc/HOWTO.xml.in	2012-04-17 15:16:21 +0000
@@ -2659,6 +2659,112 @@
 
   </section>
 
+  <section id="ch_libhipl_usage">
+    <title>The Libhipl Extension</title>
+
+    <para>
+      Libhipl provides HIP functionality as a library for upper layer
+      applications and it does not require the presence of the HIPL daemon.
+      Instead, the HIP control messages are transmitted on top of TCP/UDP.
+      From the applications' point of view, there is an API similar to the
+      normal socket API. This section describes the libhipl API.
+    </para>
+
+    <para>
+      Libhipl API set is located in <emphasis>"lhipl.h"</emphasis>. Refer to
+      its API documentation for detail information of each function.
+    </para>
+
+    <formalpara>
+      <title>Libhipl initialization</title>
+      <para>
+      Libhipl requires initialization before calling any other related
+      functions. The function: <emphasis>hipl_lib_init_all()</emphasis>
+      serves this purpose and different debug levels can be set as its
+      parameters to track problems inside the library.
+      </para>
+    </formalpara>
+
+    <formalpara>
+      <title>Name-based API</title>
+      <para>
+      Compared to standard socket API, one apparent difference in Libhipl is
+      that a peer is specified by given a peer name and a port number instead
+      of a sockaddr data structure. The peer name is a string representation of
+      the peer. Currently, Libhipl only support HIT string as peer name.
+      </para>
+    </formalpara>
+
+    <formalpara>
+      <title>Libhipl socket creation</title>
+      <para>
+      The function hipl_socket() creates a new libhipl socket. An ID is
+      assigned to each created libhipl socket and returned by this function,
+      then caller can pass this ID to other libhipl functions to operates on
+      this libhipl socket. NOTE: there is NO relation between libhipl socket
+      ID and normal socket file descriptor, and the result of using
+      this ID as file descriptor is undefined.
+      </para>
+    </formalpara>
+
+    <formalpara><title>Setup TCP connection</title><para>
+      When using libhipl in TCP mode, TCP connection setup is the first task.
+      similar to the normal socket syntax, libhipl provides:
+      <emphasis>hipl_connect()</emphasis>, <emphasis>hipl_listen()</emphasis>
+      and <emphasis>hipl_accept()</emphasis> for this goal. Those functions
+      process the 3-way handshake and establish a TCP connection.
+    </para></formalpara>
+
+    <formalpara>
+      <title>libhipl Base Exchange (BEX) and user data transmission</title>
+      <para>
+      Data transmission is handled by <emphasis>hipl_sendto()</emphasis> and
+      <emphasis>hipl_recvfrom()</emphasis>.
+      In libhipl, The first sending data call triggers BEX and the first
+      receiving call waits for incoming BEX message. Once BEX succeeds,
+      the pending user data is transmitted to the peer side. This BEX process
+      is handled by libhipl automatically by default. Meanwhile, we also
+      provide an advanced way to handle BEX step by step, which we will
+      explain bellow.
+      </para>
+    </formalpara>
+
+    <formalpara>
+      <title>libhipl assistant API</title>
+      <para>
+        <itemizedlist>
+          <listitem>
+            <para>
+              <emphasis>hipl_add_peer_info()</emphasis> adds peer's HIT and IP
+              address mappings to the database of libhipl. The library can use
+              this information to look up peer's locator when a peer name is
+              given.
+            </para>
+          </listitem>
+
+          <listitem>
+            <para>
+              <emphasis>hipl_lib_set_bex_feedback()</emphasis>: This function
+              turns on/off the step-by-step process of BEX. By default, BEX
+              feedback is off. When it is on, sending/receiving functions only
+              process one BEX messages at a time, and give different return
+              values to notify the progress of BEX.
+            </para>
+          </listitem>
+        </itemizedlist>
+      </para>
+    </formalpara>
+
+    <formalpara>
+      <title>Libhipl sample program</title>
+      <para>
+        For a libhipl usage example, refer to the
+        <emphasis>check_libhipl</emphasis> program in the
+        <emphasis>test</emphasis> directory.
+      </para>
+    </formalpara>
+
+  </section> <!-- ch_libhipl_usage -->
 </chapter> <!-- ch_exp_extensions -->
 
 </book>

=== modified file 'hipd/main.c'
--- hipd/main.c	2011-11-03 09:21:12 +0000
+++ hipd/main.c	2012-04-17 15:16:21 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010-2011 Aalto University and RWTH Aachen University.
+ * Copyright (c) 2010-2012 Aalto University and RWTH Aachen University.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -32,10 +32,9 @@
 #include <unistd.h>
 #include <sys/types.h>
 
-
-#include "hipd/hipd.h"
-#include "init.h"
 #include "lib/core/debug.h"
+#include "lib/hipl/hipd.h"
+#include "lib/hipl/init.h"
 
 
 /**

=== modified file 'hipfw/hipfw.c'
--- hipfw/hipfw.c	2012-04-16 14:55:53 +0000
+++ hipfw/hipfw.c	2012-04-17 15:16:21 +0000
@@ -75,7 +75,7 @@
 #include "lib/core/performance.h"
 #include "lib/core/prefix.h"
 #include "lib/core/util.h"
-#include "hipd/hipd.h"
+#include "lib/hipl/hipd.h"
 #include "config.h"
 #include "cache.h"
 #include "cert.h"

=== modified file 'lib/core/hostid.c'
--- lib/core/hostid.c	2012-03-01 14:26:43 +0000
+++ lib/core/hostid.c	2012-04-17 15:16:21 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010-2011 Aalto University and RWTH Aachen University.
+ * Copyright (c) 2010-2012 Aalto University and RWTH Aachen University.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -29,6 +29,7 @@
  */
 
 #include <errno.h>
+#include <libgen.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -678,6 +679,7 @@
     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                  numeric_action     = 0;
+    char                    *hi_file_dup        = NULL;
     char                     hostname[HIP_HOST_ID_HOSTNAME_LEN_MAX];
     const char              *rsa_filenamebase     = DEFAULT_HOST_RSA_KEY_FILE_BASE DEFAULT_ANON_HI_FILE_NAME_SUFFIX;
     const char              *dsa_filenamebase     = DEFAULT_HOST_DSA_KEY_FILE_BASE DEFAULT_ANON_HI_FILE_NAME_SUFFIX;
@@ -743,11 +745,16 @@
                 goto out_err;
             }
         } else if (!use_default) {
+            hi_file_dup = strdup(hi_file);
+            if ((err = check_and_create_dir(dirname(hi_file_dup), HIP_DIR_MODE))) {
+                HIP_ERROR("Could not create directory for path: %s\n", hi_file);
+                goto out_err;
+            }
             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))) {
+                if ((err = save_dsa_private_key(hi_file, dsa_key))) {
                     HIP_ERROR("Saving of DSA key failed.\n");
                     goto out_err;
                 }
@@ -756,7 +763,7 @@
                 ecdsa_key = create_ecdsa_key(ecdsa_nid);
                 HIP_IFEL(!ecdsa_key, -EINVAL,
                          "Creation of ECDSA key failed.\n");
-                if ((err = save_ecdsa_private_key(ecdsa_filenamebase, ecdsa_key))) {
+                if ((err = save_ecdsa_private_key(hi_file, ecdsa_key))) {
                     HIP_ERROR("Saving of ECDSA key failed.\n");
                     goto out_err;
                 }
@@ -765,7 +772,7 @@
                 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))) {
+                if ((err = save_rsa_private_key(hi_file, rsa_key))) {
                     HIP_ERROR("Saving of RSA key failed.\n");
                     goto out_err;
                 }
@@ -1093,6 +1100,7 @@
         change_key_file_perms(rsa_filenamebase_pub);
     }
 
+    free(hi_file_dup);
     free(dsa_host_id);
     free(dsa_pub_host_id);
     free(rsa_host_id);

=== added directory 'lib/hipl'
=== renamed file 'hipd/accessor.c' => 'lib/hipl/accessor.c'
=== renamed file 'hipd/accessor.h' => 'lib/hipl/accessor.h'
=== renamed file 'hipd/cert.c' => 'lib/hipl/cert.c'
=== renamed file 'hipd/cert.h' => 'lib/hipl/cert.h'
=== renamed file 'hipd/close.c' => 'lib/hipl/close.c'
=== renamed file 'hipd/close.h' => 'lib/hipl/close.h'
=== renamed file 'hipd/configfilereader.c' => 'lib/hipl/configfilereader.c'
=== renamed file 'hipd/configfilereader.h' => 'lib/hipl/configfilereader.h'
=== renamed file 'hipd/cookie.c' => 'lib/hipl/cookie.c'
=== renamed file 'hipd/cookie.h' => 'lib/hipl/cookie.h'
=== renamed file 'hipd/dh.c' => 'lib/hipl/dh.c'
=== renamed file 'hipd/dh.h' => 'lib/hipl/dh.h'
=== renamed file 'hipd/esp_prot_anchordb.c' => 'lib/hipl/esp_prot_anchordb.c'
=== renamed file 'hipd/esp_prot_anchordb.h' => 'lib/hipl/esp_prot_anchordb.h'
=== renamed file 'hipd/esp_prot_hipd_msg.c' => 'lib/hipl/esp_prot_hipd_msg.c'
=== renamed file 'hipd/esp_prot_hipd_msg.h' => 'lib/hipl/esp_prot_hipd_msg.h'
=== renamed file 'hipd/esp_prot_light_update.c' => 'lib/hipl/esp_prot_light_update.c'
=== renamed file 'hipd/esp_prot_light_update.h' => 'lib/hipl/esp_prot_light_update.h'
=== renamed file 'hipd/hadb.c' => 'lib/hipl/hadb.c'
--- hipd/hadb.c	2012-03-20 13:08:56 +0000
+++ lib/hipl/hadb.c	2012-04-17 15:16:21 +0000
@@ -608,9 +608,15 @@
                HIP_HOST_ID_HOSTNAME_LEN_MAX - 1);
     }
 
-    if (hip_select_source_address(&peer_map.our_addr, &peer_map.peer_addr)) {
+    /* hip_select_source_address() is incompatible with libhipl, therefore we skip
+     * this function and set the source address in peer_map to the ANY source
+     * address.*/
+    if (!hipl_is_libhip_mode()
+        && hip_select_source_address(&peer_map.our_addr, &peer_map.peer_addr)) {
         HIP_ERROR("Cannot find source address\n");
         return -1;
+    } else if (hipl_is_libhip_mode()) {
+        memset(&peer_map.our_addr, 0, sizeof(peer_map.our_addr));
     }
 
     if (hip_for_each_hi(hadb_add_peer_info_wrapper, &peer_map)) {
@@ -1451,6 +1457,10 @@
  */
 void hip_delete_security_associations_and_sp(struct hip_hadb_state *const ha)
 {
+    if (hipl_is_libhip_mode()) {
+        return;
+    }
+
     // Delete previous security policies
     hip_delete_hit_sp_pair(&ha->hit_our, &ha->hit_peer, 1);
     hip_delete_hit_sp_pair(&ha->hit_peer, &ha->hit_our, 1);
@@ -1520,6 +1530,11 @@
                         ha),
              -1, "Error while changing outbound security association\n");
 
+    if (hipl_is_libhip_mode()) {
+        HIP_DEBUG("No SP set up in library mode\n");
+        goto out_err;
+    }
+
     // Create a new security policy pointing to SAs after SA setup
     HIP_IFEL(hip_setup_hit_sp_pair(&ha->hit_peer,
                                    &ha->hit_our,

=== renamed file 'hipd/hadb.h' => 'lib/hipl/hadb.h'
=== renamed file 'hipd/hidb.c' => 'lib/hipl/hidb.c'
--- hipd/hidb.c	2012-04-17 11:20:20 +0000
+++ lib/hipl/hidb.c	2012-04-17 15:16:21 +0000
@@ -596,13 +596,15 @@
         hip_add_iface_local_route(&in6_lsi);
 
         /* Adding HITs and LSIs to the interface */
-        if (hip_add_iface_local_hit(&hit)) {
-            HIP_ERROR("Failed to add HIT to the device\n");
-            return -1;
-        }
-        if (hip_add_iface_local_hit(&in6_lsi)) {
-            HIP_ERROR("Failed to add LSI to the device\n");
-            return -1;
+        if (!hipl_is_libhip_mode()) {
+            if (hip_add_iface_local_hit(&hit)) {
+                HIP_ERROR("Failed to add HIT to the device\n");
+                return -1;
+            }
+            if (hip_add_iface_local_hit(&in6_lsi)) {
+                HIP_ERROR("Failed to add LSI to the device\n");
+                return -1;
+            }
         }
     }
 

=== renamed file 'hipd/hidb.h' => 'lib/hipl/hidb.h'
=== renamed file 'hipd/hip_socket.c' => 'lib/hipl/hip_socket.c'
=== renamed file 'hipd/hip_socket.h' => 'lib/hipl/hip_socket.h'
=== renamed file 'hipd/hipd.c' => 'lib/hipl/hipd.c'
=== renamed file 'hipd/hipd.h' => 'lib/hipl/hipd.h'
--- hipd/hipd.h	2012-03-20 21:45:03 +0000
+++ lib/hipl/hipd.h	2012-04-17 15:16:21 +0000
@@ -27,6 +27,7 @@
 #define HIPL_HIPD_HIPD_H
 
 #include <netdb.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <netinet/in.h>
 #include <sys/types.h>
@@ -80,4 +81,8 @@
 int hipd_parse_cmdline_opts(int argc, char *argv[], uint64_t * flags);
 int hipd_main(uint64_t flags);
 
+/* libhip_mode accessor */
+bool hipl_is_libhip_mode(void);
+void hipl_set_libhip_mode(void);
+
 #endif /* HIPL_HIPD_HIPD_H */

=== renamed file 'hipd/hiprelay.c' => 'lib/hipl/hiprelay.c'
=== renamed file 'hipd/hiprelay.h' => 'lib/hipl/hiprelay.h'
=== renamed file 'hipd/hit_to_ip.c' => 'lib/hipl/hit_to_ip.c'
=== renamed file 'hipd/hit_to_ip.h' => 'lib/hipl/hit_to_ip.h'
=== renamed file 'hipd/init.c' => 'lib/hipl/init.c'
--- hipd/init.c	2012-04-16 14:47:42 +0000
+++ lib/hipl/init.c	2012-04-17 15:16:21 +0000
@@ -34,7 +34,9 @@
 
 #include <errno.h>
 #include <limits.h>
+#include <pwd.h>
 #include <signal.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -118,6 +120,34 @@
 #endif
 /** end ICMPV6_FILTER related stuff */
 
+#define HIPL_USER_DIR ".hipl"
+#define HIPL_USER_RSA_KEY_NAME "hipl_lib_rsa_key"
+
+/* Flag to show if hipl is running in libhip mode (=1) or normal mode (=0).
+ *
+ * This variable should NOT be accessed directly. Always use the accessor
+ * functions instead.
+ */
+static bool hipd_library_mode = false;
+
+/**
+ * Test if the library mode is on.
+ *
+ * @return true if the library mode is on, false otherwise.
+ */
+bool hipl_is_libhip_mode(void)
+{
+    return hipd_library_mode;
+}
+
+/**
+ * Turn on library mode.
+ */
+void hipl_set_libhip_mode(void)
+{
+    hipd_library_mode = true;
+}
+
 /* Startup flags of the HIPD. Keep the around, for they will be used at exit */
 static uint64_t sflags;
 
@@ -523,6 +553,199 @@
     lmod_register_packet_type(HIP_LUPDATE,   "HIP_LUPDATE");
 }
 
+static int libhip_init_handle_functions(void)
+{
+    HIP_DEBUG("Initialize handle functions for libhip.\n");
+
+    hip_register_handle_function(HIP_I1, HIP_STATE_UNASSOCIATED, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_UNASSOCIATED, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_UNASSOCIATED, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_UNASSOCIATED, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I1_SENT, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I1_SENT, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I1_SENT, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I1_SENT, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I2_SENT, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I2_SENT, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I2_SENT, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_I2_SENT, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_R2_SENT, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_R2_SENT, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_R2_SENT, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_R2_SENT, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_ESTABLISHED, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_ESTABLISHED, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_ESTABLISHED, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_ESTABLISHED, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSING, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSING, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSING, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSING, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSED, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSED, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSED, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_CLOSED, &hip_send_r1,   40000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_NONE, &hip_check_i1,  20000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_NONE, &hip_handle_i1, 30000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_NONE, &hip_update_retransmissions, 35000);
+    hip_register_handle_function(HIP_I1, HIP_STATE_NONE, &hip_send_r1,   40000);
+
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_UNASSOCIATED, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I1_SENT, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_check_i2,             20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_handle_i2_in_i2_sent, 21000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_handle_i2,            30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_I2_SENT, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_R2_SENT, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_ESTABLISHED, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSING, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_CLOSED, &hip_send_r2, 50000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_check_i2,  20000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_handle_i2, 30000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_update_retransmissions, 30250);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_create_r2, 40000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_add_rvs_reg_from, 41000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_hmac2_and_sign, 42000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_add_rvs_relay_to, 43000);
+    hip_register_handle_function(HIP_I2, HIP_STATE_NONE, &hip_send_r2, 50000);
+
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_check_r1,  20000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_handle_r1, 30000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_update_retransmissions, 30500);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_build_esp_info, 31000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_build_solution, 32000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_handle_diffie_hellman, 33000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &esp_prot_r1_handle_transforms, 34000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_create_i2, 40000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_add_signed_echo_response, 41000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_mac_and_sign_handler, 42000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_add_unsigned_echo_response, 43000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I1_SENT, &hip_send_i2,   50000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_check_r1,  20000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_handle_r1, 30000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_update_retransmissions, 30500);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_build_esp_info, 31000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_build_solution, 32000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_handle_diffie_hellman, 33000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &esp_prot_r1_handle_transforms, 34000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_create_i2, 40000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_add_signed_echo_response, 41000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_mac_and_sign_handler, 42000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_add_unsigned_echo_response, 43000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_I2_SENT, &hip_send_i2,   50000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_check_r1,  20000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_handle_r1, 30000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_update_retransmissions, 30500);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_build_esp_info, 31000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_build_solution, 32000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_handle_diffie_hellman, 33000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &esp_prot_r1_handle_transforms, 34000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_create_i2, 40000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_add_signed_echo_response, 41000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_mac_and_sign_handler, 42000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_add_unsigned_echo_response, 43000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSING, &hip_send_i2,   50000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_check_r1,  20000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_handle_r1, 30000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_update_retransmissions, 30500);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_build_esp_info, 31000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_build_solution, 32000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_handle_diffie_hellman, 33000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &esp_prot_r1_handle_transforms, 34000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_create_i2, 40000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_add_signed_echo_response, 41000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_mac_and_sign_handler, 42000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_add_unsigned_echo_response, 43000);
+    hip_register_handle_function(HIP_R1, HIP_STATE_CLOSED, &hip_send_i2, 50000);
+
+    hip_register_handle_function(HIP_R2, HIP_STATE_I2_SENT, &hip_check_r2,  20000);
+    hip_register_handle_function(HIP_R2, HIP_STATE_I2_SENT, &hip_handle_r2, 30000);
+    hip_register_handle_function(HIP_R2, HIP_STATE_I2_SENT, &hip_update_retransmissions, 30250);
+
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_I1_SENT, &hip_check_notify,  20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_I1_SENT, &hip_handle_notify, 30000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_I2_SENT, &hip_check_notify,  20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_I2_SENT, &hip_handle_notify, 30000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_R2_SENT, &hip_check_notify,  20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_R2_SENT, &hip_handle_notify, 30000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_ESTABLISHED, &hip_check_notify, 20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_ESTABLISHED, &hip_handle_notify, 30000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_CLOSING, &hip_check_notify,  20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_CLOSING, &hip_handle_notify, 30000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_CLOSED, &hip_check_notify,  20000);
+    hip_register_handle_function(HIP_NOTIFY, HIP_STATE_CLOSED, &hip_handle_notify, 30000);
+
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_ESTABLISHED,  &hip_close_check_packet,     20000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_ESTABLISHED,  &hip_update_retransmissions, 25000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_ESTABLISHED,  &hip_close_create_response,  30000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_ESTABLISHED,  &hip_close_send_response,    40000);
+
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_CLOSING,  &hip_close_check_packet,     20000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_CLOSING,  &hip_update_retransmissions, 25000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_CLOSING,  &hip_close_create_response,  30000);
+    hip_register_handle_function(HIP_CLOSE, HIP_STATE_CLOSING,  &hip_close_send_response,    40000);
+
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSING, &hip_close_ack_check_packet,  20000);
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSING, &hip_update_retransmissions,  25000);
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSING, &hip_close_ack_handle_packet, 30000);
+
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSED,  &hip_close_ack_check_packet,  20000);
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSED,  &hip_update_retransmissions,  25000);
+    hip_register_handle_function(HIP_CLOSE_ACK, HIP_STATE_CLOSED,  &hip_close_ack_handle_packet, 30000);
+
+    hip_register_handle_function(HIP_LUPDATE, HIP_STATE_ESTABLISHED, &esp_prot_handle_light_update, 20000);
+    hip_register_handle_function(HIP_LUPDATE, HIP_STATE_R2_SENT,     &esp_prot_handle_light_update, 20000);
+
+    return 0;
+}
+
 static int init_handle_functions(void)
 {
     int err = 0;
@@ -1090,6 +1313,80 @@
 }
 
 /**
+ * Initialization function for libhipl.
+ *
+ * @param debug_level debug level for log output.
+ * @return            0 on success, negative number on errors.
+ */
+int hipl_lib_init(enum logdebug debug_level)
+{
+    int                err         = 0;
+    int                keypath_len = 0;
+    char              *key_path    = NULL;
+    struct hip_common *msg         = NULL;
+    struct passwd     *pwd;
+
+    hipl_set_libhip_mode();
+    hip_nat_status = 1;
+
+    /* disable hip_firewall */
+    lsi_status = HIP_MSG_LSI_OFF;
+
+    /* set the initial verbosity level */
+    hip_set_logdebug(debug_level);
+
+    hip_init_hadb();
+    hip_init_hostid_db();
+    hip_netdev_init_addresses();
+    libhip_init_handle_functions();
+
+    /* Load default key from ~/.hipl/ */
+    if ((pwd = getpwuid(getuid())) == NULL) {
+        return -1;
+    }
+
+    /* +3 because we need 2 slashes and a NULL for termination */
+    keypath_len = strlen(pwd->pw_dir) +
+                  strlen(HIPL_USER_DIR) +
+                  strlen(HIPL_USER_RSA_KEY_NAME) +
+                  strlen(DEFAULT_PUB_HI_FILE_NAME_SUFFIX) + 3;
+    if ((key_path = malloc(keypath_len)) == NULL) {
+        HIP_ERROR("malloc() failed\n");
+        return -ENOMEM;
+    }
+
+    HIP_IFEL(snprintf(key_path, keypath_len, "%s/%s/%s%s", pwd->pw_dir,
+                      HIPL_USER_DIR,
+                      HIPL_USER_RSA_KEY_NAME,
+                      DEFAULT_PUB_HI_FILE_NAME_SUFFIX) < 0,
+             -1, "snprintf() failed");
+
+    HIP_DEBUG("Using key: %s\n", key_path);
+    HIP_IFEL(!(msg = hip_msg_alloc()), -ENOMEM, "hip_msg_alloc()");
+    if (hip_serialize_host_id_action(msg, ACTION_ADD, 0, 0, "rsa",
+                                     key_path, 0, 0, 0)) {
+        free(msg);
+        HIP_IFEL(!(msg = hip_msg_alloc()), -ENOMEM, "hip_msg_alloc()");
+        HIP_IFEL(hip_serialize_host_id_action(msg, ACTION_NEW, 0, 0, "rsa",
+                                              key_path, RSA_KEY_DEFAULT_BITS,
+                                              DSA_KEY_DEFAULT_BITS,
+                                              ECDSA_DEFAULT_CURVE), -1,
+                 "Fail to create local key at %s.", key_path);
+        free(msg);
+        HIP_IFE(!(msg = hip_msg_alloc()), -ENOMEM);
+        HIP_IFEL(hip_serialize_host_id_action(msg, ACTION_ADD, 0, 0, "rsa",
+                                              key_path, 0, 0, 0), -1,
+                 "Fail to load local key at %s.", key_path);
+    }
+    HIP_IFE(hip_handle_add_local_hi(msg), -1);
+
+out_err:
+    free(msg);
+    free(key_path);
+    return err;
+}
+
+/**
  * create a socket to handle UDP encapsulation of HIP control
  * packets
  *

=== renamed file 'hipd/init.h' => 'lib/hipl/init.h'
--- hipd/init.h	2011-11-25 17:56:24 +0000
+++ lib/hipl/init.h	2012-04-17 15:16:21 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 Aalto University and RWTH Aachen University.
+ * Copyright (c) 2010-2012 Aalto University and RWTH Aachen University.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -29,6 +29,8 @@
 #include <stdint.h>
 #include <netinet/in.h>
 
+#include "lib/core/debug.h"
+
 
 /* startup flags options to be configured via the command line */
 #define HIPD_START_FOREGROUND               (1 << 0)
@@ -60,4 +62,6 @@
                             int is_output);
 void hip_exit(void);
 
+int hipl_lib_init(enum logdebug);
+
 #endif /* HIPL_HIPD_INIT_H */

=== renamed file 'hipd/input.c' => 'lib/hipl/input.c'
--- hipd/input.c	2012-04-17 11:20:20 +0000
+++ lib/hipl/input.c	2012-04-17 15:16:21 +0000
@@ -707,6 +707,11 @@
                                &ctx->src_addr);
     }
 
+    if (hipl_is_libhip_mode()) {
+        ctx->msg_ports.src_port = ctx->hadb_entry->peer_udp_port;
+        ctx->msg_ports.dst_port = ctx->hadb_entry->local_udp_port;
+    }
+
     hip_relay_add_rvs_to_ha(ctx->input_msg, ctx->hadb_entry);
 
 #ifdef CONFIG_HIP_RVS

=== renamed file 'hipd/input.h' => 'lib/hipl/input.h'
=== renamed file 'hipd/keymat.c' => 'lib/hipl/keymat.c'
=== renamed file 'hipd/keymat.h' => 'lib/hipl/keymat.h'
=== added file 'lib/hipl/lhipl.c'
--- lib/hipl/lhipl.c	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl.c	2012-04-17 15:16:21 +0000
@@ -0,0 +1,536 @@
+/*
+ * Copyright (c) 2010-2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * This file contains the implementation of the libhipl public APIs.
+ */
+
+#define _BSD_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "lib/core/builder.h"
+#include "lib/core/ife.h"
+#include "lib/core/prefix.h"
+#include "close.h"
+#include "hadb.h"
+#include "init.h"
+#include "lhipl_sock.h"
+#include "lhipl_operations.h"
+#include "netdev.h"
+#include "output.h"
+#include "lhipl.h"
+
+
+/* A switch to turn off/on BEX feedback.
+ *
+ * If it is on, when the BEX process is conducted during "recvmsg" and "sendmsg",
+ * the intermediate result is returned to the caller.
+ * If it is off, "recvmsg" and "sendmsg" will only return after the message gets
+ * sent or received.
+ */
+static bool libhipl_bex_feedback;
+
+/**
+ * build a @c sockaddr_in6 address to store peer's HIT and port number from a
+ * string-based peer name and a port number.
+ *
+ * @param peername the string representation of a peer, only support HIT string
+ *                 currently.
+ * @param port     the port of the peer.
+ * @param peer     the @c sockaddr_in6 to hold peer's HIT and port number.
+ * @return         0 on success, -1 on error.
+ */
+static int build_peer_hit(const char *peername, const uint16_t port,
+                          struct sockaddr_in6 *peer)
+{
+    if (!peername || !peer) {
+        HIP_ERROR("Invalid input\n");
+        return -1;
+    }
+
+    if (inet_pton(AF_INET6, peername, &peer->sin6_addr) != 1) {
+        HIP_ERROR("Failed to translate %s into HIT\n", peername);
+    }
+    peer->sin6_port   = htons(port);
+    peer->sin6_family = AF_INET6;
+    return 0;
+}
+
+/**
+ * Initialize libhipl library.
+ *
+ * This function should be called before using libhipl.
+ *
+ * @param debug_level the debug level of the libhipl library.
+ * @return            0 on success, negative number on error.
+ */
+int hipl_lib_init_all(enum hipl_lib_loglv debug_level)
+{
+    hipl_hsock_init();
+    switch (debug_level) {
+    case HIPL_LIB_LOG_DEBUG:
+        return hipl_lib_init(LOGDEBUG_ALL);
+    case HIPL_LIB_LOG_INFO:
+        return hipl_lib_init(LOGDEBUG_MEDIUM);
+    case HIPL_LIB_LOG_ERROR:
+        return hipl_lib_init(LOGDEBUG_LOW);
+    case HIPL_LIB_LOG_NONE:
+        return hipl_lib_init(LOGDEBUG_NONE);
+    }
+
+    return -1;
+}
+
+/**
+ * Check the current state of the BEX feedback switch.
+ *
+ * @return true if the switch is on, false if it is off.
+ */
+bool hipl_lib_bex_feedback(void)
+{
+    return libhipl_bex_feedback;
+}
+
+/**
+ * Turn off/on the BEX feedback switch.
+ *
+ * @param val true to turn the switch on, false to turn it off.
+ */
+void hipl_lib_set_bex_feedback(bool val)
+{
+    libhipl_bex_feedback = val;
+}
+
+/**
+ * Turn on/off non-blocking feature for a libhipl socket.
+ *
+ * @param hsock_id ID of the libhipl socket.
+ * @param on       true to turn on non-blocking, false otherwise.
+ * @return         0 on success, negative number on error.
+ */
+int hipl_lib_set_nonblock(const hipl_sock_id hsock_id, bool on)
+{
+    int               flags;
+    struct hipl_sock *hsock = NULL;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket\n", hsock_id);
+        return -EBADF;
+    }
+
+    flags = fcntl(hsock->sock_fd, F_GETFL, 0);
+    if (on && !(flags & O_NONBLOCK)) {
+        fcntl(hsock->sock_fd, F_SETFL, flags | O_NONBLOCK);
+    } else if (!on && (flags & O_NONBLOCK)) {
+        fcntl(hsock->sock_fd, F_SETFL, flags & ~O_NONBLOCK);
+    }
+    return 0;
+}
+
+/**
+ * Return the corresponding socket file descriptor of a libhipl socket.
+ *
+ * @param hsock_id the ID of the libhipl socket
+ * @return         socket file descriptor on success, -1 on error.
+ */
+int hipl_lib_get_sockfd(const hipl_sock_id hsock_id)
+{
+    struct hipl_sock *hsock = NULL;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket\n", hsock_id);
+        return -1;
+    }
+
+    return hsock->sock_fd;
+}
+
+/**
+ * Save peer's HIT-to-IP mapping.
+ *
+ * @param hit  peer's hit.
+ * @param addr peer's IP address.
+ * @return     0 on success, -1 otherwise.
+ */
+int hipl_add_peer_info(const char *const hit, const char *const addr)
+{
+    struct in6_addr peer_hit, peer_addr6;
+    struct in_addr  peer_addr4;
+
+    if (!hit || !addr) {
+        HIP_ERROR("Invalid argument\n");
+        return -1;
+    }
+    if (inet_pton(AF_INET6, hit, &peer_hit) != 1) {
+        HIP_ERROR("Invalid hit: %s\n", hit);
+        return -1;
+    }
+    if (!ipv6_addr_is_hit(&peer_hit)) {
+        HIP_ERROR("Invalid hit: %s\n", hit);
+        return -1;
+    }
+    if (inet_pton(AF_INET6, addr, &peer_addr6) != 1) {
+        if (inet_pton(AF_INET, addr, &peer_addr4) != 1) {
+            HIP_ERROR("Invalid address: %s\n", addr);
+            return -1;
+        }
+        IPV4_TO_IPV6_MAP(&peer_addr4, &peer_addr6);
+    }
+
+    return hip_hadb_add_peer_info(&peer_hit, &peer_addr6, NULL, NULL);
+}
+
+/**
+ * Create a libhipl socket.
+ *
+ * @param domain    the domain of the libhipl socket (AF_INET / AF_INET6).
+ * @param type      the type of the libhipl socket (SOCK_DGRAM / SOCK_STREAM).
+ * @param protocol  the protocol (IPPROTO_UDP / IPPROTO_TCP).
+ * @return          the ID of the new libhipl socket on success, negative
+ *                  number on error.
+ */
+int hipl_socket(const int domain, const int type, const int protocol)
+{
+    if (domain != AF_INET && domain != AF_INET6) {
+        HIP_ERROR("Invalid domain: %d\n", domain);
+        return -EINVAL;
+    }
+    if (type != SOCK_DGRAM && type != SOCK_STREAM) {
+        HIP_ERROR("Invalid type: %d\n", type);
+        return -EINVAL;
+    }
+    if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) {
+        HIP_ERROR("Invalid protocol: %d\n", protocol);
+        return -EINVAL;
+    }
+
+    return hipl_socket_internal(domain, type, protocol);
+}
+
+/**
+ * Close a socket.
+ *
+ * Send HIP CLOSE message to the associated peer and deletes the libhipl
+ * socket information.
+ *
+ * @param hsock_id the ID of the libhipl socket to be closed.
+ * @return         0 on success, negative number on error.
+ */
+int hipl_close(const hipl_sock_id hsock_id)
+{
+    int                ret   = 0;
+    struct hip_common *msg   = NULL;
+    struct hipl_sock  *hsock = NULL;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket\n", hsock_id);
+        return -1;
+    }
+    if (!hsock->ha || hsock->ha->state == HIP_STATE_CLOSED) {
+        HIP_DEBUG("Not sending CLOSE.\n");
+        goto skip_close_msg;
+    }
+
+    /* Build HIP_CLOSE message and send it to the peer */
+    if ((msg = hip_msg_alloc()) == NULL) {
+        HIP_ERROR("hip_msg_alloc() failed");
+        ret = -ENOMEM;
+        goto skip_close_msg;
+    }
+    if ((ret = hip_build_param_contents(msg, &hsock->peer_hit,
+                                        HIP_PARAM_HIT,
+                                        sizeof(hsock->peer_hit))) < 0) {
+        HIP_ERROR("hip_build_param_contents() failed\n");
+        goto skip_close_msg;
+    }
+    if ((ret = hip_send_close(msg, 1)) < 0) {
+        HIP_ERROR("hip_send_close() failed\n");
+    }
+
+skip_close_msg:
+    if (hsock) {
+        close(hsock->sock_fd);
+        hipl_hsock_delete_and_free(hsock);
+    }
+    free(msg);
+    return ret;
+}
+
+/**
+ * Bind a libhipl socket to a local IP address.
+ *
+ * @param hsock_id      the ID of the libhipl socket.
+ * @param address       the IP address to be bound.
+ * @param address_len   the length of the @c address.
+ * @return              0 on success, negative number on error.
+ */
+int hipl_bind(const hipl_sock_id hsock_id, const struct sockaddr *const address,
+              const socklen_t address_len)
+{
+    struct hipl_sock *hsock;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket\n", hsock_id);
+        return -1;
+    }
+
+    return hipl_bind_internal(hsock, address, address_len);
+}
+
+/**
+ * Switch a libhipl socket to listening mode.
+ *
+ * @param hsock_id the ID of the libhipl socket.
+ * @param backlog  the max length of the queue for pending connections.
+ * @return         zero on success, negative number on error.
+ */
+int hipl_listen(const hipl_sock_id hsock_id, const int backlog)
+{
+    struct hipl_sock *hsock;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket.\n", hsock_id);
+        return -1;
+    }
+
+    return listen(hsock->sock_fd, backlog);
+}
+
+/**
+ * Send data to a peer.
+ *
+ * Triggers base exchange if no HIP association exists.
+ * @note Data is currently sent unencrypted.
+ *
+ * @param hsock_id  the ID of the libhipl socket for sending data.
+ * @param msg       data to send.
+ * @param len       size of the data.
+ * @param flags     the flags of the socket function @c sendto().
+ * @param peername  the string representation of the peer.
+ * @param port      peer's port number.
+ * @return          number of bytes sent on success, negative number on error.
+ */
+int hipl_sendto(const hipl_sock_id hsock_id, const void *const msg,
+                const size_t len, const int flags,
+                const char *const peername, uint16_t port)
+{
+    struct hipl_sock   *hsock;
+    struct sockaddr_in6 peer;
+    struct msghdr       params = { 0 };
+    struct iovec        iov;
+    char               *buf = NULL;
+    int                 err = 0;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket.\n", hsock_id);
+        return -1;
+    }
+    if (hsock->sock_proto == IPPROTO_UDP
+        && (peername == NULL || build_peer_hit(peername, port, &peer) < 0)) {
+        HIP_ERROR("Invalid argument: peername\n");
+        return -EINVAL;
+    }
+    if (hsock->sock_proto == IPPROTO_TCP
+        && hsock->peer_locator.ss_family == 0) {
+        HIP_ERROR("Not connected!\n");
+        return -ENOTCONN;
+    }
+    if (msg == NULL) {
+        HIP_ERROR("Invalid argument: msg\n");
+        return -EINVAL;
+    }
+
+    struct sockaddr_storage dst;
+    struct sockaddr_in6    *p6;
+    if (hsock->sock_proto == IPPROTO_UDP) {
+        hipl_build_addrstorage(&peer.sin6_addr, ntohs(peer.sin6_port), &dst);
+    } else {
+        dst             = hsock->peer_locator;
+        p6              = (struct sockaddr_in6 *) &dst;
+        p6->sin6_addr   = hsock->peer_hit;
+        p6->sin6_family = AF_INET6;
+    }
+    if ((buf = malloc(len)) == NULL) {
+        return -ENOMEM;
+    }
+    memcpy(buf, msg, len);
+    iov.iov_base       = buf;
+    iov.iov_len        = len;
+    params.msg_name    = &dst;
+    params.msg_namelen = sizeof(dst);
+    params.msg_iovlen  = 1;
+    params.msg_iov     = &iov;
+
+    if (hipl_lib_bex_feedback()) {
+        err = hipl_sendmsg_internal(hsock, &params, flags);
+    } else {
+        fd_set fdset;
+        if (hipl_hsock_ha_state(hsock) == HIP_STATE_UNASSOCIATED) {
+            HIP_DEBUG("Sending via hsock %d, Triggering BEX.\n", hsock->sid);
+            err = hipl_sendmsg_internal(hsock, &params, flags);
+            HIP_IFEL(err != -EWAITBEX, -1, "hipl_sendmsg_internal() failed\n");
+        }
+        if (hipl_hsock_ha_state(hsock) == HIP_STATE_ESTABLISHED) {
+            HIP_DEBUG("Sending via hsock %d, HA established.\n", hsock->sid);
+            err = hipl_sendmsg_internal(hsock, &params, flags);
+        } else {
+            while (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED) {
+                FD_ZERO(&fdset);
+                FD_SET(hsock->sock_fd, &fdset);
+                HIP_DEBUG("Sending via hsock %d, Waiting BEX.\n", hsock->sid);
+                err = select(hsock->sock_fd + 1, &fdset, NULL, NULL, NULL);
+                HIP_IFEL(err < 0, -1, "select(): %s\n", strerror(errno));
+                err = hipl_sendmsg_internal(hsock, &params, flags);
+                HIP_IFEL(err < 0 && err != -EWAITBEX && err != -EBEXESTABLISHED,
+                         -1, "hipl_sendmsg_internal() failed\n");
+            }
+            err = hipl_sendmsg_internal(hsock, &params, flags);
+        }
+    }
+
+out_err:
+    free(buf);
+    return err;
+}
+
+/**
+ * Receive data from a peer.
+ *
+ * Wait for base exchange if no host association exists.
+ * @note Data is currently sent unencrypted.
+ *
+ * @param hsock_id  the ID of the libhipl socket for receiving data.
+ * @param buf       buffer for received data.
+ * @param len       the size of the @c buf.
+ * @param flags     the flags of the socket function @c recvfrom().
+ * @param peername  buffer for the HIT of the associated peer, the size of
+ *                  this buffer should be at least @c HIPL_MAX_PEERNAME.
+ * @param port      buffer for the port of the associated peer.
+ * @return          number of bytes received on success,
+ *                  negative number on error,
+ *                  0 on end-of-file.
+ */
+int hipl_recvfrom(const hipl_sock_id hsock_id, void *const buf,
+                  const size_t len, const int flags,
+                  char *const peername, uint16_t *const port)
+{
+    struct hipl_sock   *hsock  = NULL;
+    struct msghdr       params = { 0 };
+    struct iovec        iov;
+    struct sockaddr_in6 hit;
+    int                 ret;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket.\n", hsock_id);
+        return -1;
+    }
+    if (hsock->sock_proto == IPPROTO_TCP
+        && hsock->peer_locator.ss_family == 0) {
+        HIP_ERROR("Not connected!\n");
+        return -ENOTCONN;
+    }
+
+    iov.iov_base       = buf;
+    iov.iov_len        = len;
+    params.msg_name    = &hit;
+    params.msg_namelen = sizeof(hit);
+    params.msg_iovlen  = 1;
+    params.msg_iov     = &iov;
+
+    if (!hipl_lib_bex_feedback()) {
+        fd_set fdset;
+        while (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED) {
+            FD_ZERO(&fdset);
+            FD_SET(hsock->sock_fd, &fdset);
+            if (select(hsock->sock_fd + 1, &fdset, NULL, NULL, NULL) < 0) {
+                HIP_PERROR("select()");
+            }
+            ret = hipl_recvmsg_internal(hsock, &params, flags);
+            if (ret < 0 && ret != -EWAITBEX && ret != -EBEXESTABLISHED) {
+                HIP_ERROR("hipl_recvmsg_internal() failed()\n");
+                return ret;
+            }
+        }
+    }
+    ret = hipl_recvmsg_internal(hsock, &params, flags);
+
+    if (peername) {
+        inet_ntop(AF_INET6, &hit.sin6_addr, peername, HIPL_MAX_PEERNAME);
+    }
+    if (port) {
+        *port = ntohs(hit.sin6_port);
+    }
+    return ret;
+}
+
+/**
+ * Initiate a connection to a peer.
+ *
+ * @param hsock_id   the ID of the libhipl socket to initiate a connection.
+ * @param peername   the string representation of the peer.
+ * @param port       the port number of the peer.
+ * @return           0 on success, negative number on error.
+ */
+int hipl_connect(const hipl_sock_id hsock_id, const char *peername,
+                 const uint16_t port)
+{
+    struct hipl_sock   *hsock = NULL;
+    struct sockaddr_in6 peer;
+
+    if (peername == NULL || build_peer_hit(peername, port, &peer) < 0) {
+        HIP_ERROR("Invalid argument: peername\n");
+        return -EINVAL;
+    }
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket.\n", hsock_id);
+        return -1;
+    }
+
+    return hipl_connect_internal(hsock, &peer);
+}
+
+/**
+ * Wait for an incoming connection.
+ *
+ * @param hsock_id the ID of the libhipl socket for waiting connections.
+ * @return         the ID of the accepted libhipl socket, negative number
+ *                 on error.
+ */
+int hipl_accept(const hipl_sock_id hsock_id)
+{
+    struct hipl_sock *hsock = NULL;
+
+    if ((hsock = hipl_hsock_find(hsock_id)) == NULL) {
+        HIP_ERROR("ID %d is not a libhipl socket.\n", hsock_id);
+        return -1;
+    }
+
+    return hipl_accept_internal(hsock);
+}

=== added file 'lib/hipl/lhipl.h'
--- lib/hipl/lhipl.h	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl.h	2012-04-17 15:16:21 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2010-2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef HIPL_LIB_HIPL_LHIPL_H
+#define HIPL_LIB_HIPL_LHIPL_H
+
+#include <sys/socket.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+
+#define EWAITBEX        139000
+#define EBEXESTABLISHED 139001
+
+#define HIPL_MAX_PEERNAME 128
+
+enum hipl_lib_loglv { HIPL_LIB_LOG_DEBUG, HIPL_LIB_LOG_INFO,
+                      HIPL_LIB_LOG_ERROR, HIPL_LIB_LOG_NONE };
+
+typedef uint16_t hipl_sock_id;
+
+int hipl_lib_init_all(enum hipl_lib_loglv);
+
+void hipl_lib_set_bex_feedback(bool val);
+bool hipl_lib_bex_feedback(void);
+
+int hipl_lib_set_nonblock(const hipl_sock_id hsock_id, bool on);
+int hipl_lib_get_sockfd(const hipl_sock_id hsock_id);
+
+int hipl_add_peer_info(const char *const hit, const char *const addr);
+
+int hipl_socket(const int domain, const int type, const int protocol);
+
+int hipl_close(const hipl_sock_id hsock_id);
+
+int hipl_listen(const hipl_sock_id hsock_id, const int backlog);
+
+int hipl_bind(const hipl_sock_id hsock_id, const struct sockaddr *const address,
+              const socklen_t address_len);
+
+int hipl_sendto(const hipl_sock_id hsock_id, const void *const msg,
+                const size_t len, const int flags,
+                const char *const peername, const uint16_t port);
+
+int hipl_recvfrom(const hipl_sock_id hsock_id, void *const buf,
+                  const size_t len, const int flags,
+                  char *const peername, uint16_t *const port);
+
+int hipl_connect(const hipl_sock_id hsock_id, const char *const peername,
+                 const uint16_t port);
+
+int hipl_accept(const hipl_sock_id hsock_id);
+
+#endif /* HIPL_LIB_HIPL_LHIPL_H */

=== added file 'lib/hipl/lhipl_operations.c'
--- lib/hipl/lhipl_operations.c	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl_operations.c	2012-04-17 15:16:21 +0000
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) 2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * This file contains the internal implementation of the libhipl socket
+ * related operations.
+ */
+
+#define _BSD_SOURCE
+
+#include <sys/socket.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "lib/core/builder.h"
+#include "lib/core/hip_udp.h"
+#include "lib/core/ife.h"
+#include "lib/core/prefix.h"
+#include "lhipl.h"
+#include "lhipl_sock.h"
+#include "hadb.h"
+#include "hidb.h"
+#include "input.h"
+#include "netdev.h"
+#include "output.h"
+#include "lhipl_operations.h"
+
+
+/**
+ * Automatically bind to a port for a libhipl socket.
+ *
+ * @param hsock the libhipl socket for port binding.
+ * @return      0 on success, -1 on error.
+ */
+static int auto_bind(struct hipl_sock *const hsock)
+{
+    struct sockaddr_storage ss = { 0 };
+    struct sockaddr_in     *addr4;
+    struct sockaddr_in6    *addr6;
+
+    if (hsock->src_port != 0) {
+        HIP_DEBUG("A bound port exists, auto_bind stops\n");
+        return 0;
+    }
+
+    if (hsock->sock_family == AF_INET) {
+        ss.ss_family    = AF_INET;
+        addr4           = (struct sockaddr_in *) &ss;
+        addr4->sin_port = 0;
+        return hipl_bind_internal(hsock, (struct sockaddr *) addr4,
+                                  sizeof(ss));
+    } else {
+        ss.ss_family     = AF_INET6;
+        addr6            = (struct sockaddr_in6 *) &ss;
+        addr6->sin6_port = 0;
+        return hipl_bind_internal(hsock, (struct sockaddr *) addr6,
+                                  sizeof(ss));
+    }
+}
+
+static uint16_t get_port_from_saddr(const struct sockaddr *const addr)
+{
+    const struct sockaddr_in  *addr4 = (const struct sockaddr_in *) addr;
+    const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *) addr;
+
+    if (addr->sa_family == AF_INET) {
+        return addr4->sin_port;
+    } else {
+        return addr6->sin6_port;
+    }
+}
+
+/**
+ * Set global variables in order to inter-operate with libhipdeamon.
+ *
+ * @param sock_fd     the socket file descriptor for sending message.
+ * @param local_port  the local port for sending message.
+ * @param remote_port the remote port for receiving message.
+ */
+static void set_hip_connection_parameters(const int sock_fd,
+                                          const int local_port,
+                                          const int remote_port)
+{
+    HIP_DEBUG("Set connection params: fd = %d, lport = %d, rport= %d\n",
+              sock_fd, local_port, remote_port);
+    hip_nat_sock_output_udp = sock_fd;
+    hip_raw_sock_output_v4  = sock_fd;
+    hip_raw_sock_output_v6  = sock_fd;
+    hip_set_local_nat_udp_port(local_port);
+    hip_set_peer_nat_udp_port(remote_port);
+}
+
+/**
+ * Check whether a received packet is a HIP control packet.
+ *
+ * @param buf   buffer containing the received packet.
+ * @param len   size of the @c buf.
+ * @param hsock the libhipl socket receiving the packet.
+ * @return      1 on a control message, 0 on a user message,
+ *              negative number on error.
+ */
+static int hipl_is_control_msg(char *const buf, unsigned int len,
+                               struct hipl_sock *const hsock)
+{
+    char                    udp_pad[HIP_UDP_ZERO_BYTES_LEN] = { 0 };
+    struct hip_common      *msg;
+    struct sockaddr_storage src    = { 0 };
+    socklen_t               srclen = sizeof(src);
+
+    if (len < sizeof(struct hip_common)) {
+        return 0;
+    }
+
+    if (!memcmp(udp_pad, buf, HIP_UDP_ZERO_BYTES_LEN)) {
+        HIP_DEBUG("Message is padded\n");
+        msg  = (struct hip_common *) (buf + HIP_UDP_ZERO_BYTES_LEN);
+        len -= HIP_UDP_ZERO_BYTES_LEN;
+    } else {
+        msg = (struct hip_common *) buf;
+    }
+
+    if (getsockname(hsock->sock_fd, (struct sockaddr *) &src, &srclen) < 0) {
+        HIP_PERROR("getsockname()");
+        return true;
+    }
+
+    return !hip_verify_network_header(msg, (struct sockaddr *) &src,
+                                      (struct sockaddr *) &hsock->peer_locator,
+                                      len);
+}
+
+static void build_packet_context(struct hip_packet_context *const ctx,
+                                 struct sockaddr *ctx_dst, struct sockaddr *ctx_src)
+{
+    struct sockaddr_in  *s4;
+    struct sockaddr_in6 *s6;
+
+    if (ctx_dst->sa_family == AF_INET) {
+        s4 = (struct sockaddr_in *) ctx_dst;
+        IPV4_TO_IPV6_MAP(&s4->sin_addr, &ctx->dst_addr);
+        ctx->msg_ports.dst_port = ntohs(s4->sin_port);
+    } else if (ctx_dst->sa_family == AF_INET6) {
+        s6                      = (struct sockaddr_in6 *) ctx_dst;
+        ctx->dst_addr           = s6->sin6_addr;
+        ctx->msg_ports.dst_port = ntohs(s6->sin6_port);
+    }
+
+    if (ctx_src->sa_family == AF_INET) {
+        s4 = (struct sockaddr_in *) ctx_src;
+        IPV4_TO_IPV6_MAP(&s4->sin_addr, &ctx->src_addr);
+        ctx->msg_ports.src_port = ntohs(s4->sin_port);
+    } else if (ctx_src->sa_family == AF_INET6) {
+        s6                      = (struct sockaddr_in6 *) ctx_src;
+        ctx->src_addr           = s6->sin6_addr;
+        ctx->msg_ports.src_port = ntohs(s6->sin6_port);
+    }
+}
+
+/**
+ * Receive and pre-process an incoming message.
+ *
+ * This function discards UDP packet from an unknown peer, identifies
+ * user/control packet, eliminates zero padding in control packets and
+ * builds the packet context for handling control packets.
+ *
+ * @param hsock       the libhipl socket for receiving message.
+ * @param msg         buffer to hold the incoming message.
+ * @param flags       the flags of socket @c recvmsg().
+ * @param ctx         the HIP packet context to be built.
+ * @param is_user_msg true if the message is a user message, false otherwise.
+ * @return            negative number on errors, 0 on end-of-file, number of
+ *                    bytes received otherwise.
+ */
+static int recv_msg_wrapper(struct hipl_sock *const hsock,
+                            struct msghdr *const msg, const int flags,
+                            struct hip_packet_context *const ctx,
+                            bool *is_user_msg)
+{
+    int                     ret;
+    struct sockaddr_storage our_locator = { 0 };
+    socklen_t               sslen       = sizeof(our_locator);
+
+    *is_user_msg = true;
+    if ((ret = recvmsg(hsock->sock_fd, msg, flags)) < 0) {
+        HIP_PERROR("recvmsg()");
+        return -1;
+    }
+
+    //in UDP mode, we don't know the peer locator until we receive the
+    //first message from the peer. Once we get the peer locator, save it
+    //to 'hsock'. We should also fill the packet context for UDP.
+    if (hsock->sock_proto == IPPROTO_UDP) {
+        if (msg->msg_name != NULL && hsock->peer_locator.ss_family == 0) {
+            memcpy(&hsock->peer_locator, msg->msg_name,
+                   sizeof(hsock->peer_locator));
+        }
+        if (ctx != NULL) {
+            if (getsockname(hsock->sock_fd, (struct sockaddr *) &our_locator,
+                            &sslen) < 0) {
+                HIP_PERROR("getsockname()");
+                return -1;
+            }
+            build_packet_context(ctx, (struct sockaddr *) &our_locator,
+                                 (struct sockaddr *) &hsock->peer_locator);
+        }
+    }
+
+    char *buf = (char *) msg->msg_iov->iov_base;
+    if (hipl_is_control_msg(buf, ret, hsock)) {
+        memmove(buf, buf + HIP_UDP_ZERO_BYTES_LEN,
+                HIP_MAX_PACKET - HIP_UDP_ZERO_BYTES_LEN);
+        ret         -= HIP_UDP_ZERO_BYTES_LEN;
+        *is_user_msg = false;
+    }
+
+    return ret;
+}
+
+static int nonb_result_check(const int ret, const int err)
+{
+    if (ret < 0 && err != EWOULDBLOCK && err != EAGAIN) {
+        HIP_ERROR("BEX failed, errno = %d, errstr = %s\n", err,
+                  strerror(err));
+        return -1;
+    }
+    if (ret < 0 && (err == EWOULDBLOCK || err == EAGAIN)) {
+        HIP_DEBUG("BEX returns EWOULDBLOCK or EAGAIN\n");
+        return -EWAITBEX;
+    }
+
+    return 0;
+}
+
+/**
+ * Wait for a HIP I1 packet and continue performing base exchange.
+ *
+ * @param hsock     the libhipl socket waiting for the I1 packet.
+ * @param ctx       the HIP packet context for HIP packet processing.
+ * @return          0 on success, -1 on error, -EWAITBEX when BEX is pending
+ */
+static int nonb_await_bex(struct hipl_sock *const hsock,
+                          struct hip_packet_context *const ctx)
+{
+    struct msghdr           params = { 0 };
+    struct iovec            iov;
+    struct sockaddr_storage ss;
+    bool                    is_user_msg;
+    int                     ret = 0;
+    int                     flag;
+
+    params.msg_name    = &ss;
+    params.msg_namelen = sizeof(ss);
+    params.msg_iovlen  = 1;
+    iov.iov_base       = ctx->input_msg;
+    iov.iov_len        = HIP_MAX_PACKET;
+    params.msg_iov     = &iov;
+
+    flag = fcntl(hsock->sock_fd, F_GETFL, 0);
+    fcntl(hsock->sock_fd, F_SETFL, flag | O_NONBLOCK);
+
+    set_hip_connection_parameters(hsock->sock_fd, hsock->src_port, 0);
+    ret = recv_msg_wrapper(hsock, &params, 0, ctx, &is_user_msg);
+    if ((ret = nonb_result_check(ret, errno)) != 0) {
+        HIP_DEBUG("returns %d\n", ret);
+        goto out;
+    }
+
+    if (is_user_msg || hip_receive_control_packet(ctx) < 0) {
+        HIP_ERROR("hip_receive_control_packet() failed\n");
+        ret = -1;
+    }
+
+out:
+    fcntl(hsock->sock_fd, F_SETFL, flag);
+    return ret;
+}
+
+/**
+ * Trigger BEX in a non-blocking way.
+ *
+ * @param hsock    the libhipl socket to trigger BEX.
+ * @param src_hit  the source HIT for base exchange.
+ * @param dst_hit  the destination HIT for base exchange.
+ * @param dst_port the destination port.
+ * @return         -1 on error, -EWAITBEX when the BEX is pending, 0 if sending
+ *                 BEX trigger message successfully.
+ */
+static int nonb_trigger_bex(struct hipl_sock *hsock, const hip_hit_t *src_hit,
+                            const hip_hit_t *dst_hit, const int dst_port)
+{
+    struct in6_addr dst_addr;
+    int             err = 0, flag;
+
+    flag = fcntl(hsock->sock_fd, F_GETFL, 0);
+    fcntl(hsock->sock_fd, F_SETFL, flag | O_NONBLOCK);
+
+    err = hip_map_id_to_addr(dst_hit, NULL, &dst_addr);
+    HIP_IFEL(err < 0, -1, "failed to match hit to IP\n");
+    HIP_IFEL(ipv6_addr_any(&dst_addr), -1, "Couldn't map HIT to IP\n");
+
+    set_hip_connection_parameters(hsock->sock_fd, hsock->src_port, dst_port);
+    err = netdev_trigger_bex(src_hit, dst_hit, NULL, NULL, NULL, &dst_addr);
+    HIP_DEBUG("netdev_trigger_bex returns %d, errno = %d\n", err, errno);
+    err = nonb_result_check(err, errno);
+    if (err == 0) {
+        hsock->ha = hip_hadb_find_byhits(src_hit, dst_hit);
+    }
+
+out_err:
+    fcntl(hsock->sock_fd, F_SETFL, flag);
+    return err;
+}
+
+/**
+ * Handle BEX for a libhipl socket.
+ *
+ * If param @c peer_hit is given, current libhipl socket will be the initiator
+ * and trigger the BEX. otherwise, it acts as a responder and waits for an I1
+ * message.
+ *
+ * @param hsock    the libhipl socket to handle BEX.
+ * @param peer_hit the peer's hit and port.
+ * @return         -1 on error, -EWAITBEX when the BEX is pending, and
+ *                 -EBEXESTABLISHED when BEX finishes.
+ */
+static int handle_bex(struct hipl_sock *hsock, struct sockaddr_in6 *peer_hit)
+{
+    int                       err = 0;
+    struct hip_packet_context ctx = { 0 };
+
+    // We are the initiator, send I1
+    if (hipl_hsock_ha_state(hsock) == HIP_STATE_UNASSOCIATED && peer_hit) {
+        hsock->peer_hit = peer_hit->sin6_addr;
+
+        err = nonb_trigger_bex(hsock, &hsock->src_hit, &peer_hit->sin6_addr,
+                               ntohs(peer_hit->sin6_port));
+        // send I1 successfully, return -EWAITBEX.
+        if (err == 0) {
+            err = -EWAITBEX;
+        }
+        return err;
+    }
+
+    // waiting for and handle control messages
+    hsock->ha = hip_hadb_find_byhits(&hsock->src_hit, &hsock->peer_hit);
+    if (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED) {
+        ctx.input_msg  = hip_msg_alloc();
+        ctx.output_msg = hip_msg_alloc();
+        HIP_IFEL(!ctx.input_msg || !ctx.output_msg, -ENOMEM,
+                 "hip_msg_alloc() failed\n");
+
+        err = nonb_await_bex(hsock, &ctx);
+        HIP_DEBUG("nonb_await_bex returns %d\n", err);
+        if (err < 0) { /* -1 or -EWAITBEX */
+            goto out_err;
+        }
+        hsock->peer_hit = ctx.input_msg->hit_sender;
+        hsock->ha       = hip_hadb_find_byhits(&hsock->src_hit, &hsock->peer_hit);
+    }
+
+    if (hipl_hsock_ha_state(hsock) == HIP_STATE_ESTABLISHED) {
+        err = -EBEXESTABLISHED;
+    } else {
+        err = -EWAITBEX;
+    }
+
+out_err:
+    free(ctx.input_msg);
+    free(ctx.output_msg);
+    return err;
+}
+
+static int validate_udp_peer_addr(const struct hipl_sock *const hsock,
+                                  const struct sockaddr_storage *const saddr)
+{
+    const struct in6_addr *paddr;
+    struct in6_addr        peer_addr;
+
+    if (hsock->sock_proto != IPPROTO_UDP) {
+        return 0;
+    }
+
+    switch (saddr->ss_family) {
+    case AF_INET:
+        IPV4_TO_IPV6_MAP(&((const struct sockaddr_in *) saddr)->sin_addr,
+                         &peer_addr);
+        paddr = &peer_addr;
+        break;
+
+    case AF_INET6:
+        paddr = &((const struct sockaddr_in6 *) saddr)->sin6_addr;
+        break;
+
+    default:
+        HIP_DEBUG("Unsupported family: %d\n", saddr->ss_family);
+        return -1;
+    }
+
+    if (ipv6_addr_cmp(&hsock->ha->peer_addr, paddr)) {
+        HIP_DEBUG("Packet not from associated address. Dropping.\n");
+        HIP_DEBUG_IN6ADDR("expected", &hsock->ha->peer_addr);
+        HIP_DEBUG_IN6ADDR("got", paddr);
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Build a @c sockaddr_storage from a given IPv6 address and a port number.
+ *
+ * If the address is V4MAPPED, the storage family will be @c AF_INET,
+ * otherwise the storage family will be @c AF_INET6.
+ *
+ * @param addr    a V6 address or a V4MAPPED address.
+ * @param port    the port number.
+ * @param ss      the @c sockaddr_storage to be filled.
+ */
+void hipl_build_addrstorage(const struct in6_addr *const addr,
+                            const uint16_t port,
+                            struct sockaddr_storage *const ss)
+{
+    HIP_ASSERT(addr && ss);
+    memset(ss, 0, sizeof(*ss));
+
+    if (IN6_IS_ADDR_V4MAPPED(addr)) {
+        struct sockaddr_in *const in = (struct sockaddr_in *) ss;
+        in->sin_family = AF_INET;
+        IPV6_TO_IPV4_MAP(addr, &in->sin_addr);
+        in->sin_port = htons(port);
+    } else {
+        struct sockaddr_in6 *const in6 = (struct sockaddr_in6 *) ss;
+        in6->sin6_family = AF_INET6;
+        ipv6_addr_copy(&in6->sin6_addr, addr);
+        in6->sin6_port = htons(port);
+    }
+}
+
+/**
+ * Create a libhipl socket.
+ *
+ * @param family    the communications domain of the libhipl socket
+ * @param type      the socket type of the libhipl socket
+ * @param protocol  the protocol of the libhipl socket
+ * @return          the ID of the new libhipl socket on success, negative
+ *                  number otherwise
+ */
+int hipl_socket_internal(const int family, const int type, const int protocol)
+{
+    int               sock;
+    int               on    = 1, off = 0;
+    struct hipl_sock *hsock = NULL;
+
+    //TODO support IPV6
+    if (family == AF_INET6) {
+        HIP_ERROR("No IPv6 support yet.\n");
+        return -ENOTSUP;
+    }
+
+    sock = socket(family, type, protocol);
+    if (family == AF_INET) {
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
+        setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &on, sizeof(on));
+        setsockopt(sock, IPPROTO_IP, IP_RECVERR, &off, sizeof(off));
+        setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+    } else {
+        setsockopt(sock, IPPROTO_IPV6, IPV6_RECVERR, &off, sizeof(off));
+        setsockopt(sock, IPPROTO_IPV6, IPV6_2292PKTINFO, &on, sizeof(on));
+        setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+    }
+    if ((hsock = hipl_hsock_new(family, type, protocol)) == NULL) {
+        HIP_ERROR("Failed to create libhipl socket.\n");
+        close(sock);
+        return -1;
+    }
+    hsock->sock_fd = sock;
+    hip_get_default_hit(&hsock->src_hit);
+
+    return hsock->sid;
+}
+
+/**
+ * Bind a libhipl socket to a local address.
+ *
+ * @param hsock         the libhipl socket for address binding.
+ * @param address       the IP address to be bound.
+ * @param address_len   the length of the @c address.
+ * @return              0 on success, -1 on error.
+ */
+int hipl_bind_internal(struct hipl_sock *const hsock,
+                       const struct sockaddr *const address,
+                       const socklen_t address_len)
+{
+    struct     sockaddr_storage laddr     = { 0 };
+    socklen_t                   laddr_len = sizeof(laddr);
+    uint16_t                    request_port;
+
+    request_port = get_port_from_saddr(address);
+    if (bind(hsock->sock_fd, address, address_len) < 0) {
+        HIP_PERROR("bind error:");
+        return -1;
+    }
+
+    /* Ask OS for the assigned port number */
+    if (request_port == 0) {
+        if (0 > getsockname(hsock->sock_fd, (struct sockaddr *) &laddr,
+                            &laddr_len)) {
+            HIP_PERROR("getsockname() error: ");
+            return -1;
+        }
+        request_port = get_port_from_saddr((struct sockaddr *) &laddr);
+    }
+
+    hsock->src_port = ntohs(request_port);
+    HIP_DEBUG("bind to port %d\n", hsock->src_port);
+
+    return 0;
+}
+
+/**
+ * Initiate a connection to a peer.
+ *
+ * @param hsock    the libhipl socket to initiate the connection.
+ * @param peer     the peer's HIT and port number.
+ * @return         0 on success, -1 on error.
+ */
+int hipl_connect_internal(struct hipl_sock *const hsock,
+                          const struct sockaddr_in6 *const peer)
+{
+    struct in6_addr         dst_addr = { { { 0 } } };
+    struct sockaddr_storage ss;
+
+    if (ipv6_addr_any(&peer->sin6_addr)) {
+        HIP_ERROR("Invalid argument: dst_hit.\n");
+        return -1;
+    }
+
+    if (hip_map_id_to_addr(&peer->sin6_addr, NULL, &dst_addr) < 0) {
+        return -1;
+    }
+    if (ipv6_addr_any(&dst_addr)) {
+        HIP_ERROR("Couldn't map HIT to IP\n");
+        return -1;
+    }
+
+    HIP_DEBUG_IN6ADDR("Dest locator is: ", &dst_addr);
+    HIP_DEBUG("Dest locator is V4MAPPED: %d\n", IN6_IS_ADDR_V4MAPPED(&dst_addr));
+    hipl_build_addrstorage(&dst_addr, ntohs(peer->sin6_port), &ss);
+
+    if (connect(hsock->sock_fd, (struct sockaddr *) &ss, sizeof(ss)) < 0) {
+        HIP_ERROR("connect(): %s\n", strerror(errno));
+        return -1;
+    }
+
+    /* Save related information into hsock */
+    hsock->peer_hit     = peer->sin6_addr;
+    hsock->peer_locator = ss;
+    if (hsock->src_port == 0) {
+        socklen_t taddr_len = sizeof(ss);
+
+        if (getsockname(hsock->sock_fd, (struct sockaddr *) &ss,
+                        &taddr_len) < 0) {
+            HIP_PERROR("getsockname() error: ");
+            return -1;
+        }
+        hsock->src_port = ntohs(get_port_from_saddr((struct sockaddr *) &ss));
+    }
+
+    return 0;
+}
+
+/**
+ * Wait for an incoming connection on a libhipl socket.
+ *
+ * @param hsock the libhipl socket waiting for the connection.
+ * @return      the ID of the accepted libhipl socket on success, -1 on error.
+ */
+int hipl_accept_internal(struct hipl_sock *const hsock)
+{
+    int                     new_fd;
+    struct hipl_sock       *hsock_new = NULL;
+    struct sockaddr_storage ss        = { 0 };
+    socklen_t               ss_len    = sizeof(ss);
+
+    new_fd = accept(hsock->sock_fd, (struct sockaddr *) &ss, &ss_len);
+    if (new_fd < 0) {
+        HIP_PERROR("accept(): ");
+        return -1;
+    }
+
+    hsock_new = hipl_hsock_new(hsock->sock_family, hsock->sock_type,
+                               hsock->sock_proto);
+    hsock_new->src_port     = hsock->src_port;
+    hsock_new->src_hit      = hsock->src_hit;
+    hsock_new->sock_fd      = new_fd;
+    hsock_new->peer_locator = ss;
+
+    return hsock_new->sid;
+}
+
+/**
+ * Receive data from a remote peer.
+ *
+ * Wait for base exchange if no host association exists.
+ * @note Data is currently sent unencrypted.
+ * @note Scatter read is not supported yet.
+ *
+ * @param hsock     the libhipl socket for receiving data.
+ * @param msg       the buffer to hold data and peer information.
+ * @param flags     the flags of the socket function @c recvmsg().
+ * @return          number of bytes received on success,
+ *                  0 on end-of-file,
+ *                  -EWAITBEX when the BEX is pending,
+ *                  -EBEXESTABLISHED when BEX finishes,
+ *                  other negative numbers on error.
+ */
+ssize_t hipl_recvmsg_internal(struct hipl_sock *const hsock,
+                              struct msghdr *const msg,
+                              const int flags)
+{
+    struct hip_packet_context ctx    = { 0 };
+    struct msghdr             params = { 0 };
+    struct iovec              iov;
+    struct sockaddr_storage   recv_remote_addr;
+    int                       err = 0;
+    bool                      is_user_msg;
+
+    if (msg->msg_iovlen != 1) {
+        HIP_ERROR("Invalid iovlen: %d, scatter read is not supported yet\n",
+                  msg->msg_iovlen);
+        return -ENOTSUP;
+    }
+
+    /* Bind to an ephemeral port if the src port hasn't been bound yet */
+    if (auto_bind(hsock)) {
+        HIP_ERROR("Fail to bind the hip socket.\n");
+        return -1;
+    }
+
+    /* Handle BEX if HA hasn't established */
+    if (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED
+        && hipl_hsock_ha_state(hsock) != HIP_STATE_CLOSING) {
+        return handle_bex(hsock, NULL);
+    }
+
+    ctx.input_msg  = hip_msg_alloc();
+    ctx.output_msg = hip_msg_alloc();
+    HIP_IFEL(!ctx.input_msg || !ctx.output_msg, -ENOMEM,
+             "hip_msg_alloc() failed\n");
+    params.msg_name    = &recv_remote_addr;
+    params.msg_namelen = sizeof(recv_remote_addr);
+    params.msg_iovlen  = 1;
+    iov.iov_base       = ctx.input_msg;
+    iov.iov_len        = HIP_MAX_PACKET;
+    params.msg_iov     = &iov;
+
+    err = recv_msg_wrapper(hsock, &params, flags, &ctx, &is_user_msg);
+    HIP_IFEL(err < 0, -1, "recv_msg_wrapper() failed\n");
+
+    if (validate_udp_peer_addr(hsock, &recv_remote_addr) < 0) {
+        HIP_IFEL(true, -EAGAIN,
+                 "Received a packet with invalid peer address, dropping.\n");
+    }
+    if (!is_user_msg) {
+        HIP_DEBUG("receive a hip control message.\n");
+        hip_receive_control_packet(&ctx);
+        if (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED) {
+            HIP_DEBUG("HA state change to %d, return 0.\n", hsock->ha->state);
+            return 0;
+        }
+    } else {
+        HIP_DEBUG("receive a user message.\n");
+        // TODO, if buffer size is too small, we should save it to a internal buffer
+        // and only return content with length specified by user's buffer (TCP).
+        // return error for UDP in this case.
+        struct iovec        *iovp;
+        struct sockaddr_in6 *hitp;
+        hitp = msg->msg_name;
+        iovp = msg->msg_iov;
+        HIP_IFEL(iovp->iov_len < (unsigned int) err, -1,
+                 "buffer size too small\n");
+        HIP_DEBUG_HIT("ha->hit_peer:", &hsock->ha->hit_peer);
+        hitp->sin6_family = AF_INET6;
+        hitp->sin6_port   = get_port_from_saddr((const struct sockaddr *) &hsock->peer_locator);
+        HIP_DEBUG("hitp port: %d\n", ntohs(hitp->sin6_port));
+        hitp->sin6_addr = hsock->ha->hit_peer;
+        memcpy(iovp->iov_base, ctx.input_msg, err);
+    }
+
+out_err:
+    free(ctx.input_msg);
+    free(ctx.output_msg);
+    return err;
+}
+
+/**
+ * Send data to a peer.
+ *
+ * Trigger base exchange if no host association exists.
+ * @note Data is currently sent unencrypted.
+ * @note Gather write is not supported yet.
+ *
+ * @param hsock     the libhipl socket for sending data.
+ * @param msg       containing data, and peer information.
+ * @param flags     the flags of the socket function @c sendmsg().
+ * @return          number of bytes sent on success,
+ *                  -EWAITBEX if the BEX is pending,
+ *                  -EBEXESTABLISHED if the BEX finishes,
+ *                  other negative number on error.
+ */
+ssize_t hipl_sendmsg_internal(struct hipl_sock *const hsock,
+                              struct msghdr *const msg,
+                              const int flags)
+{
+    int fd = hsock->sock_fd;
+
+    /* Gather write is not supported yet */
+    if (msg->msg_iovlen > 1) {
+        HIP_ERROR("Invalid iovlen: %d, gather write is not supported\n",
+                  msg->msg_iovlen);
+        return -ENOTSUP;
+    }
+
+    /* Bind to an ephemeral port if the src port hasn't been bound yet */
+    if (auto_bind(hsock)) {
+        HIP_ERROR("Fail to bind the hip socket.\n");
+        return -1;
+    }
+
+    /* Start BEX if HA hasn't established */
+    if (hipl_hsock_ha_state(hsock) != HIP_STATE_ESTABLISHED) {
+        return handle_bex(hsock, msg->msg_name);
+    }
+
+    /* Determine peer's locator and send out the message */
+    HIP_DEBUG("BEX ok, start to send user data\n");
+    if (hsock->peer_locator.ss_family == 0) {
+        hipl_build_addrstorage(&hsock->ha->peer_addr,
+                               hsock->ha->peer_udp_port,
+                               &hsock->peer_locator);
+    }
+    msg->msg_namelen = sizeof(hsock->peer_locator);
+    memcpy(msg->msg_name, &hsock->peer_locator, msg->msg_namelen);
+    return sendmsg(fd, msg, flags);
+}

=== added file 'lib/hipl/lhipl_operations.h'
--- lib/hipl/lhipl_operations.h	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl_operations.h	2012-04-17 15:16:21 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef HIPL_LIB_HIPL_LHIPL_OPERATIONS_H
+#define HIPL_LIB_HIPL_LHIPL_OPERATIONS_H
+
+#include "lib/hipl/lhipl_sock.h"
+
+
+int hipl_socket_internal(const int family, const int type, const int protocol);
+
+int hipl_bind_internal(struct hipl_sock *const hsock,
+                       const struct sockaddr *const address,
+                       const socklen_t address_len);
+
+int hipl_connect_internal(struct hipl_sock *const hsock,
+                          const struct sockaddr_in6 *const addr);
+
+int hipl_accept_internal(struct hipl_sock *const hsock);
+
+ssize_t hipl_recvmsg_internal(struct hipl_sock *const hsock,
+                              struct msghdr *const msg,
+                              const int flags);
+
+ssize_t hipl_sendmsg_internal(struct hipl_sock *const hsock,
+                              struct msghdr *const msg,
+                              const int flags);
+
+void hipl_build_addrstorage(const struct in6_addr *const addr,
+                            const uint16_t port,
+                            struct sockaddr_storage *const ss);
+
+#endif /* HIPL_LIB_HIPL_LHIPL_OPERATIONS_H */

=== added file 'lib/hipl/lhipl_sock.c'
--- lib/hipl/lhipl_sock.c	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl_sock.c	2012-04-17 15:16:21 +0000
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * This file contains functions for maintaining libhipl sockets.
+ */
+
+#define _BSD_SOURCE
+
+#include <sys/socket.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "lib/core/debug.h"
+#include "lib/core/hashtable.h"
+#include "lhipl_sock.h"
+
+
+/* A hashtable to record all opening libhipl sockets */
+static HIP_HASHTABLE *hsocks = NULL;
+
+static unsigned long hipl_sk_hash(const struct hipl_sock *hsock)
+{
+    return hsock->sid;
+}
+
+STATIC_IMPLEMENT_LHASH_HASH_FN(hipl_sk, struct hipl_sock)
+
+static int hipl_sk_cmp(const struct hipl_sock *hsock1,
+                       const struct hipl_sock *hsock2)
+{
+    return memcmp(&hsock1->sid, &hsock2->sid, sizeof(hsock1->sid));
+}
+
+STATIC_IMPLEMENT_LHASH_COMP_FN(hipl_sk, struct hipl_sock)
+
+static uint32_t hsock_generate_id(void)
+{
+    static uint32_t id_generator = HIPL_LIB_HSOCK_ID_MIN;
+
+    if (id_generator == HIPL_LIB_HSOCK_ID_MAX) {
+        id_generator = HIPL_LIB_HSOCK_ID_MIN;
+    } else {
+        id_generator += 1;
+    }
+
+    return id_generator;
+}
+
+/**
+ * Initialize the libhipl socket hashtable.
+ */
+void hipl_hsock_init(void)
+{
+    hsocks = hip_ht_init(LHASH_HASH_FN(hipl_sk), LHASH_COMP_FN(hipl_sk));
+}
+
+/**
+ * Create a new libhipl socket and save it to the libhipl socket hashtable.
+ *
+ * @param family      the address family of the libhipl socket (INET or INET6).
+ * @param type        the type of the protocol.
+ * @param protocol    the protocol of the libhipl socket (TCP or UDP).
+ * @return            pointer to the created libhipl socket on success, NULL on
+ *                    error.
+ */
+struct hipl_sock *hipl_hsock_new(const int family, const int type,
+                                 const int protocol)
+{
+    struct hipl_sock *hsock = NULL;
+
+    hsock = calloc(sizeof(struct hipl_sock), sizeof(uint8_t));
+    if (hsock == NULL) {
+        HIP_ERROR("calloc() failed.\n");
+        return NULL;
+    }
+
+    hsock->sid         = hsock_generate_id();
+    hsock->sock_family = family;
+    hsock->sock_type   = type;
+    hsock->sock_proto  = protocol;
+    hip_ht_add(hsocks, hsock);
+    return hsock;
+}
+
+/**
+ * Get a libhipl socket by its ID.
+ *
+ * @param hsock_id the ID of the libhipl socket.
+ * @return         pointer to the libhipl socket on success, or NULL if the
+ *                 given ID doesn't match any record.
+ */
+struct hipl_sock *hipl_hsock_find(const uint16_t hsock_id)
+{
+    struct hipl_sock hsock;
+
+    hsock.sid = hsock_id;
+    return hip_ht_find(hsocks, &hsock);
+}
+
+/**
+ * Delete a libhipl socket and free the memory it occupies.
+ *
+ * @param hsock pointer to the libhipl socket to be deleted.
+ */
+void hipl_hsock_delete_and_free(struct hipl_sock *const hsock)
+{
+    struct hipl_sock *deleted_item;
+
+    deleted_item = hip_ht_delete(hsocks, hsock);
+    free(deleted_item);
+}
+
+/**
+ * Get the HIP association state of a given libhipl socket.
+ *
+ * @param hsock the libhipl socket.
+ * @return      the HIP association state of the libhipl socket.
+ */
+enum hip_state hipl_hsock_ha_state(const struct hipl_sock *const hsock)
+{
+    if (!hsock->ha) {
+        return HIP_STATE_UNASSOCIATED;
+    } else {
+        return hsock->ha->state;
+    }
+}

=== added file 'lib/hipl/lhipl_sock.h'
--- lib/hipl/lhipl_sock.h	1970-01-01 00:00:00 +0000
+++ lib/hipl/lhipl_sock.h	2012-04-17 15:16:21 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef HIPL_LIB_HIPL_LHIPL_SOCK_H
+#define HIPL_LIB_HIPL_LHIPL_SOCK_H
+
+#include <limits.h>
+
+#include "lib/core/protodefs.h"
+#include "lib/core/state.h"
+
+
+#define HIPL_LIB_HSOCK_ID_MIN  1
+#define HIPL_LIB_HSOCK_ID_MAX  USHRT_MAX
+#define HIPL_LIB_HSOCK_MAX     1024
+
+/* This struct contains internal information about each libhipl socket.
+ *
+ * It is generated when a new libhipl socket is created.
+ */
+struct hipl_sock {
+    uint16_t                sid;           /* libhipl socket ID */
+    struct hip_hadb_state  *ha;
+    hip_hit_t               peer_hit;
+    struct sockaddr_storage peer_locator;
+    hip_hit_t               src_hit;       /* our HIT */
+    int                     src_port;      /* our port number */
+    int                     sock_fd;       /* underlying socket */
+    int                     sock_family;
+    int                     sock_type;
+    int                     sock_proto;
+};
+
+void hipl_hsock_init(void);
+
+enum hip_state hipl_hsock_ha_state(const struct hipl_sock *const hsock);
+
+struct hipl_sock *hipl_hsock_new(const int family, const int type,
+                                 const int protocol);
+
+struct hipl_sock *hipl_hsock_find(const uint16_t hsock_id);
+
+void hipl_hsock_delete_and_free(struct hipl_sock *const hsock);
+
+#endif /* HIPL_LIB_HIPL_LHIPL_SOCK_H */

=== renamed file 'hipd/lsidb.c' => 'lib/hipl/lsidb.c'
=== renamed file 'hipd/lsidb.h' => 'lib/hipl/lsidb.h'
=== renamed file 'hipd/maintenance.c' => 'lib/hipl/maintenance.c'
=== renamed file 'hipd/maintenance.h' => 'lib/hipl/maintenance.h'
=== renamed file 'hipd/nat.c' => 'lib/hipl/nat.c'
=== renamed file 'hipd/nat.h' => 'lib/hipl/nat.h'
=== renamed file 'hipd/netdev.c' => 'lib/hipl/netdev.c'
=== renamed file 'hipd/netdev.h' => 'lib/hipl/netdev.h'
=== renamed file 'hipd/nsupdate.c' => 'lib/hipl/nsupdate.c'
=== renamed file 'hipd/nsupdate.h' => 'lib/hipl/nsupdate.h'
=== renamed file 'hipd/opp_mode.c' => 'lib/hipl/opp_mode.c'
=== renamed file 'hipd/opp_mode.h' => 'lib/hipl/opp_mode.h'
=== renamed file 'hipd/output.c' => 'lib/hipl/output.c'
--- hipd/output.c	2012-04-16 14:47:42 +0000
+++ lib/hipl/output.c	2012-04-17 15:16:21 +0000
@@ -848,7 +848,8 @@
     HIP_ASSERT(!hit_is_opportunistic_hit(&ctx->input_msg->hit_receiver));
 
     /* Case: I ----->IPv4---> RVS ---IPv6---> R */
-    if (IN6_IS_ADDR_V4MAPPED(r1_src_addr) !=
+    if (!hipl_is_libhip_mode() &&
+        IN6_IS_ADDR_V4MAPPED(r1_src_addr) !=
         IN6_IS_ADDR_V4MAPPED(r1_dst_addr)) {
         HIP_DEBUG_IN6ADDR("r1_src_addr", r1_src_addr);
         HIP_DEBUG_IN6ADDR("r1_dst_addr", r1_dst_addr);
@@ -1217,6 +1218,9 @@
         goto out_err;
     }
 
+    if (hipl_is_libhip_mode()) {
+        udp = 1;
+    }
     dst_is_ipv4 = IN6_IS_ADDR_V4MAPPED(peer_addr);
     len         = hip_get_msg_total_len(msg);
 
@@ -1245,13 +1249,16 @@
     if (local_addr) {
         HIP_DEBUG("local address given\n");
         memcpy(&my_addr, local_addr, sizeof(struct in6_addr));
-    } else {
+    } else if (!hipl_is_libhip_mode()) {
         HIP_DEBUG("no local address, selecting one\n");
         HIP_IFEL(hip_select_source_address(&my_addr, peer_addr), -1,
                  "Cannot find source address\n");
+    } else {
+        memset(&my_addr, 0, sizeof(my_addr));
     }
 
-    src_is_ipv4 = IN6_IS_ADDR_V4MAPPED(&my_addr);
+    src_is_ipv4 = IN6_IS_ADDR_V4MAPPED(&my_addr) ||
+                  (dst_is_ipv4 && ipv6_addr_any(&my_addr));
 
     if (src_is_ipv4) {
         IPV6_TO_IPV4_MAP(&my_addr, &src4->sin_addr);
@@ -1305,9 +1312,10 @@
 
     /* Handover may cause e.g. on-link duplicate address detection
      * which may cause bind to fail. */
-
-    HIP_IFEL(bind(hip_raw_sock_output, (struct sockaddr *) &src, sa_size),
-             -1, "Binding to raw sock failed\n");
+    if (!hipl_is_libhip_mode()) {
+        HIP_IFEL(bind(hip_raw_sock_output, (struct sockaddr *) &src, sa_size),
+                 -1, "Binding to raw sock failed\n");
+    }
 
 #if (HIP_SIMULATE_PACKET_LOSS_PROBABILITY > 0)
     if (HIP_SIMULATE_PACKET_LOSS && HIP_SIMULATE_PACKET_IS_LOST()) {
@@ -1324,18 +1332,25 @@
     len = hip_get_msg_total_len(msg);
 
     if (udp) {
-        struct udphdr *uh = (struct udphdr *) msg;
-
-        /* Insert 32 bits of zero bytes between UDP and HIP */
-        memmove((char *) msg + HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr), msg, len);
-        memset(msg, 0, HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr));
-        len += HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr);
-
-        uh->source = htons(src_port);
-        uh->dest   = htons(dst_port);
-        uh->len    = htons(len);
-        uh->check  = 0;
-        memmoved   = 1;
+        if (!hipl_is_libhip_mode()) {
+            /* Insert 32 bits of zero bytes between UDP and HIP */
+            memmove((char *) msg + HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr), msg, len);
+            memset(msg, 0, HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr));
+            len += HIP_UDP_ZERO_BYTES_LEN + sizeof(struct udphdr);
+
+            struct udphdr *uh = (struct udphdr *) msg;
+            uh->source = htons(src_port);
+            uh->dest   = htons(dst_port);
+            uh->len    = htons(len);
+            uh->check  = 0;
+        } else {
+            memmove((char *) msg + HIP_UDP_ZERO_BYTES_LEN, msg, len);
+            memset(msg, 0, HIP_UDP_ZERO_BYTES_LEN);
+            len += HIP_UDP_ZERO_BYTES_LEN;
+
+            dst4->sin_port = htons(dst_port);
+        }
+        memmoved = 1;
     }
 
     sent = sendto(hip_raw_sock_output, msg, len, 0,

=== renamed file 'hipd/output.h' => 'lib/hipl/output.h'
=== renamed file 'hipd/pkt_handling.c' => 'lib/hipl/pkt_handling.c'
=== renamed file 'hipd/pkt_handling.h' => 'lib/hipl/pkt_handling.h'
=== renamed file 'hipd/registration.c' => 'lib/hipl/registration.c'
=== renamed file 'hipd/registration.h' => 'lib/hipl/registration.h'
=== renamed file 'hipd/user.c' => 'lib/hipl/user.c'
=== renamed file 'hipd/user.h' => 'lib/hipl/user.h'
=== renamed file 'hipd/user_ipsec_hipd_msg.c' => 'lib/hipl/user_ipsec_hipd_msg.c'
=== renamed file 'hipd/user_ipsec_hipd_msg.h' => 'lib/hipl/user_ipsec_hipd_msg.h'
=== renamed file 'hipd/user_ipsec_sadb_api.c' => 'lib/hipl/user_ipsec_sadb_api.c'
=== renamed file 'hipd/user_ipsec_sadb_api.h' => 'lib/hipl/user_ipsec_sadb_api.h'
=== modified file 'modules/cert/hipd/cert.c'
--- modules/cert/hipd/cert.c	2012-03-08 09:38:56 +0000
+++ modules/cert/hipd/cert.c	2012-04-17 15:16:21 +0000
@@ -33,13 +33,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "hipd/hipd.h"
-#include "hipd/pkt_handling.h"
 #include "lib/core/builder.h"
 #include "lib/core/cert.h"
 #include "lib/core/debug.h"
 #include "lib/core/ife.h"
 #include "lib/core/protodefs.h"
+#include "lib/hipl/hipd.h"
+#include "lib/hipl/pkt_handling.h"
 #include "modules/midauth/hipd/midauth.h"
 #include "modules/update/hipd/update.h"
 #include "cert.h"

=== modified file 'modules/heartbeat/hipd/heartbeat.c'
--- modules/heartbeat/hipd/heartbeat.c	2012-03-21 13:14:54 +0000
+++ modules/heartbeat/hipd/heartbeat.c	2012-04-17 15:16:21 +0000
@@ -65,15 +65,6 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
-#include "hipd/close.h"
-#include "hipd/hadb.h"
-#include "hipd/init.h"
-#include "hipd/hip_socket.h"
-#include "hipd/maintenance.h"
-#include "hipd/nat.h"
-#include "hipd/output.h"
-#include "hipd/pkt_handling.h"
-#include "hipd/user.h"
 #include "lib/core/common.h"
 #include "lib/core/debug.h"
 #include "lib/core/icomm.h"
@@ -84,6 +75,15 @@
 #include "lib/core/straddr.h"
 #include "lib/core/modularization.h"
 #include "lib/core/gpl/nlink.h"
+#include "lib/hipl/close.h"
+#include "lib/hipl/hadb.h"
+#include "lib/hipl/hip_socket.h"
+#include "lib/hipl/init.h"
+#include "lib/hipl/maintenance.h"
+#include "lib/hipl/nat.h"
+#include "lib/hipl/output.h"
+#include "lib/hipl/pkt_handling.h"
+#include "lib/hipl/user.h"
 #include "heartbeat.h"
 
 #define HIP_MAX_ICMP_PACKET 512

=== modified file 'modules/heartbeat_update/hipd/hb_update.c'
--- modules/heartbeat_update/hipd/hb_update.c	2012-03-21 13:14:54 +0000
+++ modules/heartbeat_update/hipd/hb_update.c	2012-04-17 15:16:21 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 Aalto University and RWTH Aachen University.
+ * Copyright (c) 2010, 2012 Aalto University and RWTH Aachen University.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -40,12 +40,12 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "hipd/hadb.h"
-#include "hipd/maintenance.h"
 #include "lib/core/builder.h"
 #include "lib/core/common.h"
 #include "lib/core/debug.h"
 #include "lib/core/protodefs.h"
+#include "lib/hipl/hadb.h"
+#include "lib/hipl/maintenance.h"
 #include "modules/update/hipd/update.h"
 #include "modules/update/hipd/update_locator.h"
 #include "hb_update.h"

=== modified file 'modules/midauth/hipd/midauth.c'
--- modules/midauth/hipd/midauth.c	2012-04-17 11:20:20 +0000
+++ modules/midauth/hipd/midauth.c	2012-04-17 15:16:21 +0000
@@ -33,8 +33,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "hipd/hidb.h"
-#include "hipd/pkt_handling.h"
 #include "lib/core/builder.h"
 #include "lib/core/common.h"
 #include "lib/core/ife.h"
@@ -42,6 +40,8 @@
 #include "lib/core/protodefs.h"
 #include "lib/core/solve.h"
 #include "lib/core/state.h"
+#include "lib/hipl/hidb.h"
+#include "lib/hipl/pkt_handling.h"
 #include "modules/midauth/lib/midauth_builder.h"
 #include "modules/update/hipd/update.h"
 #include "midauth.h"

=== modified file 'modules/update/hipd/update.c'
--- modules/update/hipd/update.c	2012-03-20 12:52:49 +0000
+++ modules/update/hipd/update.c	2012-04-17 15:16:21 +0000
@@ -37,17 +37,6 @@
 #include <string.h>
 
 #include "config.h"
-#include "hipd/cookie.h"
-#include "hipd/hadb.h"
-#include "hipd/hidb.h"
-#include "hipd/hipd.h"
-#include "hipd/input.h"
-#include "hipd/maintenance.h"
-#include "hipd/netdev.h"
-#include "hipd/nsupdate.h"
-#include "hipd/output.h"
-#include "hipd/pkt_handling.h"
-#include "hipd/user.h"
 #include "lib/core/builder.h"
 #include "lib/core/debug.h"
 #include "lib/core/hip_udp.h"
@@ -57,6 +46,17 @@
 #include "lib/core/prefix.h"
 #include "lib/core/state.h"
 #include "lib/core/performance.h"
+#include "lib/hipl/cookie.h"
+#include "lib/hipl/hadb.h"
+#include "lib/hipl/hidb.h"
+#include "lib/hipl/hipd.h"
+#include "lib/hipl/input.h"
+#include "lib/hipl/maintenance.h"
+#include "lib/hipl/netdev.h"
+#include "lib/hipl/nsupdate.h"
+#include "lib/hipl/output.h"
+#include "lib/hipl/pkt_handling.h"
+#include "lib/hipl/user.h"
 #include "update_builder.h"
 #include "update_locator.h"
 #include "update_param_handling.h"

=== modified file 'modules/update/hipd/update_builder.c'
--- modules/update/hipd/update_builder.c	2012-04-17 11:20:20 +0000
+++ modules/update/hipd/update_builder.c	2012-04-17 15:16:21 +0000
@@ -34,12 +34,12 @@
 #include <string.h>
 #include <errno.h>
 
-#include "hipd/hadb.h"
-#include "hipd/netdev.h"
 #include "lib/core/builder.h"
 #include "lib/core/ife.h"
 #include "lib/core/list.h"
 #include "lib/core/prefix.h"
+#include "lib/hipl/hadb.h"
+#include "lib/hipl/netdev.h"
 #include "update_builder.h"
 
 enum hip_locator_traffic_type {

=== modified file 'modules/update/hipd/update_locator.c'
--- modules/update/hipd/update_locator.c	2011-12-12 14:18:05 +0000
+++ modules/update/hipd/update_locator.c	2012-04-17 15:16:21 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 Aalto University and RWTH Aachen University.
+ * Copyright (c) 2010, 2012 Aalto University and RWTH Aachen University.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -34,11 +34,11 @@
 #include <string.h>
 #include <openssl/lhash.h>
 
-#include "hipd/maintenance.h"
 #include "lib/core/builder.h"
 #include "lib/core/debug.h"
 #include "lib/core/ife.h"
 #include "lib/core/protodefs.h"
+#include "lib/hipl/maintenance.h"
 #include "update_builder.h"
 #include "update.h"
 #include "update_locator.h"

=== added file 'test/check_libhipl.c'
--- test/check_libhipl.c	1970-01-01 00:00:00 +0000
+++ test/check_libhipl.c	2012-04-17 15:16:21 +0000
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2012 Aalto University and RWTH Aachen University.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * @brief Tests of libhipl on localhost (see doc/HACKING on unit tests).
+ */
+
+#include <arpa/inet.h>
+#include <check.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/select.h>
+#include <unistd.h>
+
+#include "lib/hipl/hidb.h"
+#include "lib/hipl/lhipl.h"
+
+#ifndef max
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+#define LO_IP    "127.0.0.1"
+#define TEST_MSG "Hello Sailor!"
+#define SEND_PORT 22345
+#define RECV_PORT 22300
+
+static struct in6_addr    lo_hit;
+static char               peername[HIPL_MAX_PEERNAME];
+static struct sockaddr_in send_addr;
+static struct sockaddr_in recv_addr;
+
+static int sender;
+static int receiver;
+
+static void test_libhipl_lo_init(int proto)
+{
+    if (hipl_lib_init_all(HIPL_LIB_LOG_NONE) < 0) {
+        fail("hipl_lib_init_all");
+    }
+
+    fail_if(hip_get_default_hit(&lo_hit) < 0, "Failed to load local hit");
+    inet_ntop(AF_INET6, &lo_hit, peername, HIPL_MAX_PEERNAME);
+    fail_if(hipl_add_peer_info(peername, LO_IP) < 0,
+            "Failed to insert peer info");
+
+    send_addr.sin_family = AF_INET;
+    inet_pton(AF_INET, LO_IP, &send_addr.sin_addr);
+    send_addr.sin_port   = htons(SEND_PORT);
+    recv_addr.sin_family = AF_INET;
+    inet_pton(AF_INET, LO_IP, &recv_addr.sin_addr);
+    recv_addr.sin_port = htons(RECV_PORT);
+
+    if (proto == IPPROTO_TCP) {
+        sender   = hipl_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        receiver = hipl_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    } else if (proto == IPPROTO_UDP) {
+        sender   = hipl_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        receiver = hipl_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    }
+    fail_if(sender <= 0 || receiver <= 0);
+
+    if (hipl_bind(sender, (struct sockaddr *) &send_addr,
+                  sizeof(send_addr)) < 0) {
+        fail("hipl_bind() for sender");
+    }
+    if (hipl_bind(receiver, (struct sockaddr *) &recv_addr,
+                  sizeof(recv_addr)) < 0) {
+        fail("hipl_bind() for receiver");
+    }
+
+    hipl_lib_set_bex_feedback(true);
+}
+
+static void test_libhipl_lo_main_loop(int send_hid, int recv_hid)
+{
+    char     peer[HIPL_MAX_PEERNAME];
+    uint16_t peer_port;
+    char     buf[1024];
+    fd_set   rset;
+    int      ret   = 0;
+    int      maxfd = max(hipl_lib_get_sockfd(send_hid),
+                         hipl_lib_get_sockfd(recv_hid));
+
+    //trigger BEX
+    ret = hipl_sendto(send_hid, TEST_MSG, strlen(TEST_MSG), 0,
+                      peername, RECV_PORT);
+    fail_if(ret != -EWAITBEX);
+
+    while (1) {
+        FD_ZERO(&rset);
+        FD_SET(hipl_lib_get_sockfd(send_hid), &rset);
+        FD_SET(hipl_lib_get_sockfd(recv_hid), &rset);
+        fail_if(select(maxfd + 1, &rset, NULL, NULL, NULL) < 0);
+
+        if (FD_ISSET(hipl_lib_get_sockfd(recv_hid), &rset)) {
+            ret = hipl_recvfrom(recv_hid, buf, 1024, 0, peer, &peer_port);
+            fail_if(ret < 0 && ret != -EWAITBEX && ret != -EBEXESTABLISHED);
+            fail_if(ret > 0 && ret != strlen(TEST_MSG));
+
+            if (ret == strlen(TEST_MSG)) {
+                buf[ret] = '\0';
+                fail_if(strcmp(buf, TEST_MSG) != 0);
+                fail_if(strcmp(peername, peer) != 0);
+                fail_if(peer_port != SEND_PORT);
+                return;
+            }
+        }
+        if (FD_ISSET(hipl_lib_get_sockfd(send_hid), &rset)) {
+            ret = hipl_sendto(send_hid, TEST_MSG, strlen(TEST_MSG), 0,
+                              peername, RECV_PORT);
+            fail_if(ret < 0 && ret != -EWAITBEX && ret != -EBEXESTABLISHED);
+            fail_if(ret > 0 && ret != strlen(TEST_MSG));
+        }
+    }
+}
+
+START_TEST(test_libhipl_lo_tcp)
+{
+    fd_set wset, rset;
+    int    maxfd, recv_slave = 0;
+
+    test_libhipl_lo_init(IPPROTO_TCP);
+
+    // Setup TCP connection
+    maxfd = max(hipl_lib_get_sockfd(sender), hipl_lib_get_sockfd(receiver));
+    if (hipl_listen(receiver, 5) < 0) {
+        fail("hipl_listen()");
+    }
+    fail_if(hipl_lib_set_nonblock(sender, true) < 0);
+    fail_if(hipl_lib_set_nonblock(receiver, true) < 0);
+    hipl_accept(receiver);
+    hipl_connect(sender, peername, RECV_PORT);
+    while (recv_slave <= 0) {
+        FD_ZERO(&wset);
+        FD_ZERO(&rset);
+        FD_SET(hipl_lib_get_sockfd(sender), &wset);
+        FD_SET(hipl_lib_get_sockfd(receiver), &rset);
+        fail_if(select(maxfd + 1, &rset, &wset, NULL, NULL) < 0);
+        if (FD_ISSET(hipl_lib_get_sockfd(receiver), &rset)) {
+            if ((recv_slave = hipl_accept(receiver)) < 0) {
+                fail("hipl_accept(), %s", strerror(errno));
+            }
+        }
+        if (FD_ISSET(hipl_lib_get_sockfd(sender), &wset)) {
+            if (hipl_connect(sender, peername, RECV_PORT) < 0
+                && errno != EINPROGRESS && errno != EISCONN) {
+                fail("hipl_connect() %s", strerror(errno));
+            }
+        }
+    }
+    fail_if(hipl_connect(sender, peername, RECV_PORT) < 0 && errno != EISCONN);
+    fail_if(hipl_lib_set_nonblock(sender, false) < 0);
+
+    // Process base exchange and user data
+    test_libhipl_lo_main_loop(sender, recv_slave);
+}
+END_TEST
+
+START_TEST(test_libhipl_lo_udp)
+{
+    test_libhipl_lo_init(IPPROTO_UDP);
+    test_libhipl_lo_main_loop(sender, receiver);
+}
+END_TEST
+
+static Suite *hipnc_suite(void)
+{
+    Suite *s = suite_create("libhipl");
+
+    TCase *tc_libhipl_lo = tcase_create("libhipl_lo");
+    tcase_add_test(tc_libhipl_lo, test_libhipl_lo_udp);
+    tcase_add_test(tc_libhipl_lo, test_libhipl_lo_tcp);
+    suite_add_tcase(s, tc_libhipl_lo);
+
+    return s;
+}
+
+int main(void)
+{
+    int      number_failed;
+    Suite   *s  = hipnc_suite();
+    SRunner *sr = srunner_create(NULL);
+
+    srunner_add_suite(sr, s);
+    srunner_run_all(sr, CK_NORMAL);
+
+    number_failed = srunner_ntests_failed(sr);
+    srunner_free(sr);
+
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}

=== modified file 'test/hipd/lsidb.c'
--- test/hipd/lsidb.c	2012-01-18 21:09:47 +0000
+++ test/hipd/lsidb.c	2012-04-17 15:16:21 +0000
@@ -26,7 +26,7 @@
 #include <check.h>
 #include <stdlib.h>
 
-#include "hipd/lsidb.c"
+#include "lib/hipl/lsidb.c"
 #include "test_suites.h"
 
 START_TEST(test_lsidb_allocate_lsi_valid)