Imported Upstream version 0.9.3upstream/0.9.3

48 files changed, 3611 insertions, 361 deletions

diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index afe4ecb..34a879f 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -51,7 +51,9 @@ gnunetinclude_HEADERS = \
   gnunet_hello_lib.h \
   gnunet_helper_lib.h \
   gnunet_load_lib.h \
+  gnunet_lockmanager_service.h \
   gnunet_mesh_service.h \
+  gnunet_mysql_lib.h \
   gnunet_namestore_plugin.h \
   gnunet_namestore_service.h \
   gnunet_nat_lib.h \
@@ -61,10 +63,12 @@ gnunetinclude_HEADERS = \
   gnunet_peer_lib.h \
   gnunet_peerinfo_service.h \
   gnunet_plugin_lib.h \
+  gnunet_postgres_lib.h \
   gnunet_program_lib.h \
   gnunet_protocols.h \
   gnunet_pseudonym_lib.h \
   gnunet_resolver_service.h \
+  gnunet_regex_lib.h \
   gnunet_scheduler_lib.h \
   gnunet_server_lib.h \
   gnunet_service_lib.h \
@@ -73,7 +77,9 @@ gnunetinclude_HEADERS = \
   gnunet_statistics_service.h \
   gnunet_stream_lib.h \
   gnunet_strings_lib.h \
+  gnunet_testbed_service.h \
   gnunet_testing_lib.h \
+  gnunet_testing_lib-new.h \
   gnunet_time_lib.h \
   gnunet_transport_service.h \
   gnunet_transport_plugin.h \
diff --git a/src/include/Makefile.in b/src/include/Makefile.in
index ce91bd7..ac6b874 100644
--- a/src/include/Makefile.in
+++ b/src/include/Makefile.in
@@ -87,18 +87,22 @@ am__gnunetinclude_HEADERS_DIST = gauger.h gettext.h platform.h plibc.h \
 	gnunet_dv_service.h gnunet_fragmentation_lib.h \
 	gnunet_fs_service.h gnunet_getopt_lib.h gnunet_gns_service.h \
 	gnunet_hello_lib.h gnunet_helper_lib.h gnunet_load_lib.h \
-	gnunet_mesh_service.h gnunet_namestore_plugin.h \
+	gnunet_lockmanager_service.h gnunet_mesh_service.h \
+	gnunet_mysql_lib.h gnunet_namestore_plugin.h \
 	gnunet_namestore_service.h gnunet_nat_lib.h \
 	gnunet_network_lib.h gnunet_nse_service.h gnunet_os_lib.h \
 	gnunet_peer_lib.h gnunet_peerinfo_service.h \
-	gnunet_plugin_lib.h gnunet_program_lib.h gnunet_protocols.h \
-	gnunet_pseudonym_lib.h gnunet_resolver_service.h \
+	gnunet_plugin_lib.h gnunet_postgres_lib.h gnunet_program_lib.h \
+	gnunet_protocols.h gnunet_pseudonym_lib.h \
+	gnunet_resolver_service.h gnunet_regex_lib.h \
 	gnunet_scheduler_lib.h gnunet_server_lib.h \
 	gnunet_service_lib.h gnunet_signal_lib.h gnunet_signatures.h \
 	gnunet_statistics_service.h gnunet_stream_lib.h \
-	gnunet_strings_lib.h gnunet_testing_lib.h gnunet_time_lib.h \
-	gnunet_transport_service.h gnunet_transport_plugin.h \
-	gnunet_tun_lib.h gnunet_util_lib.h gnunet_vpn_service.h
+	gnunet_strings_lib.h gnunet_testbed_service.h \
+	gnunet_testing_lib.h gnunet_testing_lib-new.h \
+	gnunet_time_lib.h gnunet_transport_service.h \
+	gnunet_transport_plugin.h gnunet_tun_lib.h gnunet_util_lib.h \
+	gnunet_vpn_service.h
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
@@ -212,6 +216,7 @@ INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 INTLLIBS = @INTLLIBS@
 INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@
+JAVAPORT = @JAVAPORT@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBADD_DL = @LIBADD_DL@
@@ -245,6 +250,7 @@ LT_DLLOADERS = @LT_DLLOADERS@
 LT_DLPREOPEN = @LT_DLPREOPEN@
 MAKEINFO = @MAKEINFO@
 MKDIR_P = @MKDIR_P@
+MONKEYPREFIX = @MONKEYPREFIX@
 MSGFMT = @MSGFMT@
 MSGFMT_015 = @MSGFMT_015@
 MSGMERGE = @MSGMERGE@
@@ -409,7 +415,9 @@ gnunetinclude_HEADERS = \
   gnunet_hello_lib.h \
   gnunet_helper_lib.h \
   gnunet_load_lib.h \
+  gnunet_lockmanager_service.h \
   gnunet_mesh_service.h \
+  gnunet_mysql_lib.h \
   gnunet_namestore_plugin.h \
   gnunet_namestore_service.h \
   gnunet_nat_lib.h \
@@ -419,10 +427,12 @@ gnunetinclude_HEADERS = \
   gnunet_peer_lib.h \
   gnunet_peerinfo_service.h \
   gnunet_plugin_lib.h \
+  gnunet_postgres_lib.h \
   gnunet_program_lib.h \
   gnunet_protocols.h \
   gnunet_pseudonym_lib.h \
   gnunet_resolver_service.h \
+  gnunet_regex_lib.h \
   gnunet_scheduler_lib.h \
   gnunet_server_lib.h \
   gnunet_service_lib.h \
@@ -431,7 +441,9 @@ gnunetinclude_HEADERS = \
   gnunet_statistics_service.h \
   gnunet_stream_lib.h \
   gnunet_strings_lib.h \
+  gnunet_testbed_service.h \
   gnunet_testing_lib.h \
+  gnunet_testing_lib-new.h \
   gnunet_time_lib.h \
   gnunet_transport_service.h \
   gnunet_transport_plugin.h \
diff --git a/src/include/block_dns.h b/src/include/block_dns.h
index 4c2f1a3..e047779 100644
--- a/src/include/block_dns.h
+++ b/src/include/block_dns.h
@@ -64,7 +64,7 @@ struct GNUNET_DNS_Record
    * The descriptor for the service
    * (a peer may provide more than one service)
    */
-  GNUNET_HashCode service_descriptor GNUNET_PACKED;
+  GNUNET_HashCode service_descriptor;
 
   /**
    * When does this record expire?
diff --git a/src/include/block_gns.h b/src/include/block_gns.h
index 4514acf..ffdb294 100644
--- a/src/include/block_gns.h
+++ b/src/include/block_gns.h
@@ -65,19 +65,14 @@ struct GNSNameRecordBlock
 {
 
   /**
-   * GNUNET_RSA_Signature using RSA-key generated from the records.
-   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
-
-  /**
-   * What is being signed and why?
+   * The public key of the authority
    */
-  struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
 
   /**
-   * The public key of the authority
+   * GNUNET_RSA_Signature using RSA-key generated from the records.
    */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+  struct GNUNET_CRYPTO_RsaSignature signature;
 
   /* number of records that follow */
   uint32_t rd_count GNUNET_PACKED;
@@ -86,7 +81,6 @@ struct GNSNameRecordBlock
 
   /* variable-size GNSRecordBlocks follows here */
 
-
 };
 
 GNUNET_NETWORK_STRUCT_END
diff --git a/src/include/gnunet_arm_service.h b/src/include/gnunet_arm_service.h
index af1c8cd..116bfc5 100644
--- a/src/include/gnunet_arm_service.h
+++ b/src/include/gnunet_arm_service.h
@@ -111,6 +111,19 @@ enum GNUNET_ARM_ProcessStatus
 typedef void (*GNUNET_ARM_Callback) (void *cls, 
 				     enum GNUNET_ARM_ProcessStatus result);
 
+/**
+ * Callback function invoked when list operation is complete.
+ *
+ * @param cls closure
+ * @param result outcome of the operation (GNUNET_YES if successful)
+ * @param count number of strings in the list
+ * @param list list of running services
+ */
+typedef void (*GNUNET_ARM_List_Callback) (void *cls, 
+                                          int result,
+                                          unsigned int count,
+                                          const char *const *list);
+
 
 /**
  * Handle for interacting with ARM.
@@ -183,6 +196,18 @@ GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h, const char *service_name,
                          GNUNET_ARM_Callback cb, void *cb_cls);
 
 
+/**
+ * List all running services.
+ * 
+ * @param h handle to ARM
+ * @param timeout how long to wait before failing for good
+ * @param cb callback to invoke when service is ready
+ * @param cb_cls closure for callback
+ */
+void
+GNUNET_ARM_list_running_services (struct GNUNET_ARM_Handle *h,
+                                  struct GNUNET_TIME_Relative timeout,
+                                  GNUNET_ARM_List_Callback cb, void *cb_cls);
 
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
diff --git a/src/include/gnunet_ats_service.h b/src/include/gnunet_ats_service.h
index 858ae1d..aa7a089 100644
--- a/src/include/gnunet_ats_service.h
+++ b/src/include/gnunet_ats_service.h
@@ -523,6 +523,17 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh);
 
 
 /**
+ * We would like to reset the address suggestion block time for this
+ * peer
+ *
+ * @param sh handle
+ * @param peer identity of the peer we want to reset
+ */
+void
+GNUNET_ATS_reset_backoff (struct GNUNET_ATS_SchedulingHandle *sh,
+                          const struct GNUNET_PeerIdentity *peer);
+
+/**
  * We would like to establish a new connection with a peer.  ATS
  * should suggest a good address to begin with.
  *
@@ -552,7 +563,7 @@ GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
  * @param addrlen address length
  * @return location as GNUNET_ATS_Information
  */
-const struct GNUNET_ATS_Information
+struct GNUNET_ATS_Information
 GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle *sh,
                              const struct sockaddr * addr,
                              socklen_t addrlen);
@@ -594,6 +605,7 @@ GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
                            const struct GNUNET_HELLO_Address *address,
                            struct Session *session, int in_use);
 
+
 /**
  * A session got destroyed, stop including it as a valid address.
  *
diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index 60fa938..51da46d 100644
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -69,13 +69,10 @@ GNUNET_CLIENT_connect (const char *service_name,
  * destroyed (unless, of course, there is an error with the server in
  * which case the message may still be lost).
  *
- * @param sock handle to the service connection
- * @param finish_pending_write should a transmission already passed to the
- *          handle be completed?
+ * @param client handle to the service connection
  */
 void
-GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock,
-                          int finish_pending_write);
+GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *client);
 
 
 /**
@@ -106,13 +103,13 @@ typedef void (*GNUNET_CLIENT_ShutdownTask) (void *cls, int reason);
 /**
  * Read from the service.
  *
- * @param sock the service
+ * @param client connection to the service
  * @param handler function to call with the message
  * @param handler_cls closure for handler
  * @param timeout how long to wait until timing out
  */
 void
-GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
+GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *client,
                        GNUNET_CLIENT_MessageHandler handler, void *handler_cls,
                        struct GNUNET_TIME_Relative timeout);
 
@@ -128,7 +125,7 @@ struct GNUNET_CLIENT_TransmitHandle;
  * are free in the transmission buffer.  May call the notify
  * method immediately if enough space is available.
  *
- * @param sock connection to the service
+ * @param client connection to the service
  * @param size number of bytes to send
  * @param timeout after how long should we give up (and call
  *        notify with buf NULL and size 0)?
@@ -144,7 +141,7 @@ struct GNUNET_CLIENT_TransmitHandle;
  *         using GNUNET_CONNECTION_notify_transmit_ready_cancel)
  */
 struct GNUNET_CLIENT_TransmitHandle *
-GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
+GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *client,
                                      size_t size,
                                      struct GNUNET_TIME_Relative timeout,
                                      int auto_retry,
@@ -169,7 +166,7 @@ GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
  * will be called with a "NULL" response (in which
  * case the connection should probably be destroyed).
  *
- * @param sock connection to use
+ * @param client connection to use
  * @param hdr message to transmit
  * @param timeout when to give up (for both transmission
  *         and for waiting for a response)
@@ -184,7 +181,7 @@ GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
  *         is already pending
  */
 int
-GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
+GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client,
                                          const struct GNUNET_MessageHeader *hdr,
                                          struct GNUNET_TIME_Relative timeout,
                                          int auto_retry,
diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index a1ef4ee..9f77658 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -141,6 +141,26 @@
 #define GNUNET_PACKED __attribute__((packed))
 
 /**
+ * gcc-ism to get gcc bitfield layout when compiling with -mms-bitfields
+ */
+#if MINGW
+#define GNUNET_GCC_STRUCT_LAYOUT __attribute__((gcc_struct))
+#else
+#define GNUNET_GCC_STRUCT_LAYOUT
+#endif
+
+/**
+ * gcc-ism to force alignment; we use this to align char-arrays
+ * that may then be cast to 'struct's.  See also gcc
+ * bug #33594.
+ */
+#ifdef __BIGGEST_ALIGNMENT__
+#define GNUNET_ALIGN __attribute__((aligned (__BIGGEST_ALIGNMENT__)))
+#else
+#define GNUNET_ALIGN __attribute__((aligned (8)))
+#endif
+
+/**
  * gcc-ism to document unused arguments
  */
 #define GNUNET_UNUSED __attribute__((unused))
@@ -199,27 +219,25 @@ struct GNUNET_MessageHeader
   uint16_t type GNUNET_PACKED;
 
 };
-GNUNET_NETWORK_STRUCT_END
+
 
 /**
  * @brief 512-bit hashcode
  */
-typedef struct
+typedef struct GNUNET_HashCode
 {
   uint32_t bits[512 / 8 / sizeof (uint32_t)];   /* = 16 */
 }
 GNUNET_HashCode;
 
 
-GNUNET_NETWORK_STRUCT_BEGIN
-
 /**
  * The identity of the host (basically the SHA-512 hashcode of
  * it's public key).
  */
 struct GNUNET_PeerIdentity
 {
-  GNUNET_HashCode hashPubKey GNUNET_PACKED;
+  GNUNET_HashCode hashPubKey;
 };
 GNUNET_NETWORK_STRUCT_END
 
diff --git a/src/include/gnunet_configuration_lib.h b/src/include/gnunet_configuration_lib.h
index f8f302a..0fcb4e0 100644
--- a/src/include/gnunet_configuration_lib.h
+++ b/src/include/gnunet_configuration_lib.h
@@ -87,6 +87,19 @@ GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
+ * Load default configuration.  This function will parse the
+ * defaults from the given defaults_d directory.
+ *
+ * @param cfg configuration to update
+ * @param defaults_d directory with the defaults
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle *cfg,
+				const char *defaults_d);
+
+
+/**
  * Parse a configuration file, add all of the options in the
  * file to the configuration environment.
  *
diff --git a/src/include/gnunet_connection_lib.h b/src/include/gnunet_connection_lib.h
index 3e48d32..5ee4635 100644
--- a/src/include/gnunet_connection_lib.h
+++ b/src/include/gnunet_connection_lib.h
@@ -109,10 +109,10 @@ typedef void (*GNUNET_CONNECTION_Receiver) (void *cls, const void *buf,
  * that the underlying socket or fd should never really be closed.
  * Used for indicating process death.
  *
- * @param sock the connection to set persistent
+ * @param connection the connection to set persistent
  */
 void
-GNUNET_CONNECTION_persist_ (struct GNUNET_CONNECTION_Handle *sock);
+GNUNET_CONNECTION_persist_ (struct GNUNET_CONNECTION_Handle *connection);
 
 /**
  * Disable the "CORK" feature for communication with the given socket,
@@ -122,17 +122,17 @@ GNUNET_CONNECTION_persist_ (struct GNUNET_CONNECTION_Handle *sock);
  * Used to make sure that the last messages sent through the connection
  * reach the other side before the process is terminated.
  *
- * @param sock the connection to make flushing and blocking
+ * @param connection the connection to make flushing and blocking
  * @return GNUNET_OK on success
  */
 int
-GNUNET_CONNECTION_disable_corking (struct GNUNET_CONNECTION_Handle *sock);
+GNUNET_CONNECTION_disable_corking (struct GNUNET_CONNECTION_Handle *connection);
 
 
 /**
- * Create a socket handle by boxing an existing OS socket.  The OS
+ * Create a connection handle by boxing an existing OS socket.  The OS
  * socket should henceforth be no longer used directly.
- * GNUNET_socket_destroy will close it.
+ * GNUNET_CONNECTION_destroy will close it.
  *
  * @param osSocket existing socket to box
  * @return the boxed socket handle
@@ -142,13 +142,13 @@ GNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle *osSocket);
 
 
 /**
- * Create a socket handle by accepting on a listen socket.  This
+ * Create a connection handle by accepting on a listen socket.  This
  * function may block if the listen socket has no connection ready.
  *
  * @param access function to use to check if access is allowed
  * @param access_cls closure for access
  * @param lsock listen socket
- * @return the socket handle, NULL on error (for example, access refused)
+ * @return the connection handle, NULL on error (for example, access refused)
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
@@ -157,14 +157,14 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
 
 
 /**
- * Create a socket handle by (asynchronously) connecting to a host.
+ * Create a connection handle by (asynchronously) connecting to a host.
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates TCP connections.
  *
  * @param cfg configuration to use
  * @param hostname name of the host to connect to
  * @param port port to connect to
- * @return the socket handle
+ * @return the connection handle
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle
@@ -173,13 +173,13 @@ GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle
 
 
 /**
- * Create a socket handle by connecting to a UNIX domain service.
+ * Create a connection handle by connecting to a UNIX domain service.
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates UNIX connections.
  *
  * @param cfg configuration to use
  * @param unixpath path to connect to)
- * @return the socket handle, NULL on systems without UNIX support
+ * @return the connection handle, NULL on systems without UNIX support
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
@@ -190,14 +190,14 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
 
 
 /**
- * Create a socket handle by (asynchronously) connecting to a host.
+ * Create a connection handle by (asynchronously) connecting to a host.
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates TCP connections.
  *
  * @param af_family address family to use
  * @param serv_addr server address
  * @param addrlen length of server address
- * @return the socket handle
+ * @return the connection handle
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_sockaddr (int af_family,
@@ -205,84 +205,77 @@ GNUNET_CONNECTION_create_from_sockaddr (int af_family,
                                         socklen_t addrlen);
 
 /**
- * Check if socket is valid (no fatal errors have happened so far).
- * Note that a socket that is still trying to connect is considered
+ * Check if connection is valid (no fatal errors have happened so far).
+ * Note that a connection that is still trying to connect is considered
  * valid.
  *
- * @param sock socket to check
+ * @param connection handle to check
  * @return GNUNET_YES if valid, GNUNET_NO otherwise
  */
 int
-GNUNET_CONNECTION_check (struct GNUNET_CONNECTION_Handle *sock);
+GNUNET_CONNECTION_check (struct GNUNET_CONNECTION_Handle *connection);
 
 
 /**
  * Obtain the network address of the other party.
  *
- * @param sock the client to get the address for
+ * @param connection the client to get the address for
  * @param addr where to store the address
  * @param addrlen where to store the length of the address
  * @return GNUNET_OK on success
  */
 int
-GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *sock,
+GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *connection,
                                void **addr, size_t * addrlen);
 
 
 /**
- * Close the socket and free associated resources. Pending
- * transmissions may be completed or dropped depending on the
- * arguments.   If a receive call is pending and should
- * NOT be completed, 'GNUNET_CONNECTION_receive_cancel'
- * should be called explicitly first.
+ * Close the connection and free associated resources.  There must
+ * not be any pending requests for reading or writing to the
+ * connection at this time.
  *
- * @param sock socket to destroy
- * @param finish_pending_write should pending writes be completed or aborted?
- *        (this applies to transmissions where the data has already been
- *        read from the application; all other transmissions should be
- *        aborted using 'GNUNET_CONNECTION_notify_transmit_ready_cancel').
+ * @param connection connection to destroy
  */
 void
-GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *sock,
-                           int finish_pending_write);
+GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection);
 
 
 /**
- * Receive data from the given socket.  Note that this function will
+ * Receive data from the given connection.  Note that this function will
  * call "receiver" asynchronously using the scheduler.  It will
  * "immediately" return.  Note that there MUST only be one active
- * receive call per socket at any given point in time (so do not
+ * receive call per connection at any given point in time (so do not
  * call receive again until the receiver callback has been invoked).
  *
- * @param sock socket handle
+ * @param connection connection handle
  * @param max maximum number of bytes to read
  * @param timeout maximum amount of time to wait
  * @param receiver function to call with received data
  * @param receiver_cls closure for receiver
  */
 void
-GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *sock, size_t max,
+GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *connection, size_t max,
                            struct GNUNET_TIME_Relative timeout,
                            GNUNET_CONNECTION_Receiver receiver,
                            void *receiver_cls);
 
 
 /**
- * Cancel receive job on the given socket.  Note that the
+ * Cancel receive job on the given connection.  Note that the
  * receiver callback must not have been called yet in order
  * for the cancellation to be valid.
  *
- * @param sock socket handle
+ * @param connection connection handle
  * @return closure of the original receiver callback closure
  */
 void *
-GNUNET_CONNECTION_receive_cancel (struct GNUNET_CONNECTION_Handle *sock);
+GNUNET_CONNECTION_receive_cancel (struct GNUNET_CONNECTION_Handle *connection);
 
 
 /**
- * Function called to notify a client about the socket
+ * Function called to notify a client about the connection
  * begin ready to queue more data.  "buf" will be
- * NULL and "size" zero if the socket was closed for
+ * NULL and "size" zero if the connection was closed for
  * writing in the meantime.
  *
  * @param cls closure
@@ -301,17 +294,17 @@ typedef size_t (*GNUNET_CONNECTION_TransmitReadyNotify) (void *cls, size_t size,
 struct GNUNET_CONNECTION_TransmitHandle;
 
 /**
- * Ask the socket to call us once the specified number of bytes
+ * Ask the connection to call us once the specified number of bytes
  * are free in the transmission buffer.  May call the notify
  * method immediately if enough space is available.  Note that
  * this function will abort if "size" is greater than
  * GNUNET_SERVER_MAX_MESSAGE_SIZE.
  *
  * Note that "notify" will be called either when enough
- * buffer space is available OR when the socket is destroyed.
+ * buffer space is available OR when the connection is destroyed.
  * The size parameter given to notify is guaranteed to be
  * larger or equal to size if the buffer is ready, or zero
- * if the socket was destroyed (or at least closed for
+ * if the connection was destroyed (or at least closed for
  * writing).  Finally, any time before 'notify' is called, a
  * client may call "notify_transmit_ready_cancel" to cancel
  * the transmission request.
@@ -320,7 +313,7 @@ struct GNUNET_CONNECTION_TransmitHandle;
  * time.  Notify will be run with the same scheduler priority
  * as that of the caller.
  *
- * @param sock socket
+ * @param connection connection
  * @param size number of bytes to send
  * @param timeout after how long should we give up (and call
  *        notify with buf NULL and size 0)?
@@ -330,7 +323,7 @@ struct GNUNET_CONNECTION_TransmitHandle;
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_CONNECTION_TransmitHandle *
-GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *sock,
+GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *connection,
                                          size_t size,
                                          struct GNUNET_TIME_Relative timeout,
                                          GNUNET_CONNECTION_TransmitReadyNotify
@@ -349,16 +342,6 @@ GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
                                                 *th);
 
 
-/**
- * Configure this connection to ignore shutdown signals.
- *
- * @param sock socket handle
- * @param do_ignore GNUNET_YES to ignore, GNUNET_NO to restore default
- */
-void
-GNUNET_CONNECTION_ignore_shutdown (struct GNUNET_CONNECTION_Handle *sock,
-                                   int do_ignore);
-
 
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
diff --git a/src/include/gnunet_container_lib.h b/src/include/gnunet_container_lib.h
index 75443b6..a78d8cc 100644
--- a/src/include/gnunet_container_lib.h
+++ b/src/include/gnunet_container_lib.h
@@ -70,7 +70,8 @@ typedef int (*GNUNET_HashCodeIterator) (void *cls, GNUNET_HashCode * next);
  *
  * @param filename the name of the file (or the prefix)
  * @param size the size of the bloom-filter (number of
- *        bytes of storage space to use)
+ *        bytes of storage space to use); will be rounded up
+ *        to next power of 2
  * @param k the number of GNUNET_CRYPTO_hash-functions to apply per
  *        element (number of bits set per element in the set)
  * @return the bloomfilter
@@ -1152,12 +1153,28 @@ GNUNET_CONTAINER_slist_clear (struct GNUNET_CONTAINER_SList *l);
  * @param l list
  * @param buf payload buffer to find
  * @param len length of the payload (number of bytes in buf)
+ *
+ * @return GNUNET_YES if found, GNUNET_NO otherwise
  */
 int
 GNUNET_CONTAINER_slist_contains (const struct GNUNET_CONTAINER_SList *l,
                                  const void *buf, size_t len);
 
-
+/**
+ * Check if a list contains a certain element using 'compare' function
+ *
+ * @param l list
+ * @param buf payload buffer to find
+ * @param len length of the payload (number of bytes in buf)
+ * @param compare comparison function
+ *
+ * @return NULL if the 'buf' could not be found, pointer to the
+ *         list element, if found
+ */
+void *
+GNUNET_CONTAINER_slist_contains2 (const struct GNUNET_CONTAINER_SList *l,
+                                  const void *buf, size_t len,
+                                  int (*compare)(const void *, const size_t, const void *, const size_t));
 /**
  * Count the elements of a list
  * @param l list
diff --git a/src/include/gnunet_core_service.h b/src/include/gnunet_core_service.h
index 1f6c0f3..cb48f41 100644
--- a/src/include/gnunet_core_service.h
+++ b/src/include/gnunet_core_service.h
@@ -157,8 +157,8 @@ typedef void (*GNUNET_CORE_StartupCallback) (void *cls,
  * @param cfg configuration to use
  * @param queue_size size of the per-peer message queue
  * @param cls closure for the various callbacks that follow (including handlers in the handlers array)
- * @param init callback to call on timeout or once we have successfully
- *        connected to the core service; note that timeout is only meaningful if init is not NULL
+ * @param init callback to call once we have successfully
+ *        connected to the core service
  * @param connects function to call on peer connect, can be NULL
  * @param disconnects function to call on peer disconnect / timeout, can be NULL
  * @param inbound_notify function to call for all inbound messages, can be NULL
@@ -229,8 +229,7 @@ struct GNUNET_CORE_TransmitHandle;
  * @param cork is corking allowed for this transmission?
  * @param priority how important is the message?
  * @param maxdelay how long can the message wait?
- * @param target who should receive the message,
- *        use NULL for this peer (loopback)
+ * @param target who should receive the message, never NULL (can be this peer's identity for loopback)
  * @param notify_size how many bytes of buffer space does notify want?
  * @param notify function to call when buffer space is available;
  *        will be called with NULL on timeout or if the overall queue
@@ -293,6 +292,12 @@ GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
+ * Handle to cancel 'is_peer_connected' test.
+ */
+struct GNUNET_CORE_ConnectTestHandle;
+
+
+/**
  * Check if the given peer is currently connected and return information
  * about the session if so.  This function is for special cirumstances
  * (GNUNET_TESTING uses it), normal users of the CORE API are
@@ -300,22 +305,28 @@ GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * connect/disconnect callbacks from GNUNET_CORE_connect.  This
  * function is NOT part of the 'versioned', 'official' API.
  *
- * FIXME: we should probably make it possible to 'cancel' the
- * operation...
- *
  * @param cfg configuration to use
  * @param peer the specific peer to check for
  * @param peer_cb function to call with the peer information
  * @param cb_cls closure for peer_cb
- * @return GNUNET_OK if iterating, GNUNET_SYSERR on error
+ * @return handle to cancel the operation
  */
-int
+struct GNUNET_CORE_ConnectTestHandle *
 GNUNET_CORE_is_peer_connected (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                               struct GNUNET_PeerIdentity *peer,
+                               const struct GNUNET_PeerIdentity *peer,
                                GNUNET_CORE_ConnectEventHandler peer_cb,
                                void *cb_cls);
 
 
+/**
+ * Abort 'is_connected' test operation.
+ *
+ * @param cth handle for operation to cancel
+ */
+void
+GNUNET_CORE_is_peer_connected_cancel (struct GNUNET_CORE_ConnectTestHandle *cth);
+
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index 6e37266..777ddd9 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2012 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -86,7 +86,7 @@ enum GNUNET_CRYPTO_Quality
 
 
 /**
- * Length of an RSA KEY (d,e,len), 2048 bit (=256 octests) key d, 2 byte e
+ * Length of an RSA KEY (n,e,len), 2048 bit (=256 octests) key n, 2 byte e
  */
 #define GNUNET_CRYPTO_RSA_KEY_LENGTH 258
 
@@ -101,6 +101,32 @@ enum GNUNET_CRYPTO_Quality
  */
 struct GNUNET_CRYPTO_RsaPrivateKey;
 
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * GNUnet mandates a certain format for the encoding
+ * of private RSA key information that is provided
+ * by the RSA implementations.  This format is used
+ * to serialize a private RSA key (typically when
+ * writing it to disk).
+ */
+struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded
+{
+  /**
+   * Total size of the structure, in bytes, in big-endian!
+   */
+  uint16_t len GNUNET_PACKED;
+  uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sized GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
+  uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
+  /* followed by the actual values */
+};
+GNUNET_NETWORK_STRUCT_END
+
 
 /**
  * @brief 0-terminated ASCII encoding of a GNUNET_HashCode.
@@ -112,6 +138,26 @@ struct GNUNET_CRYPTO_HashAsciiEncoded
 
 
 
+
+/**
+ * @brief 256-bit hashcode
+ */
+struct GNUNET_CRYPTO_ShortHashCode
+{
+  uint32_t bits[256 / 8 / sizeof (uint32_t)];   /* = 8 */
+};
+
+
+/**
+ * @brief 0-terminated ASCII encoding of a 'struct GNUNET_ShortHashCode'.
+ */
+struct GNUNET_CRYPTO_ShortHashAsciiEncoded
+{
+  unsigned char short_encoding[53];
+};
+
+
+
 /**
  * @brief an RSA signature
  */
@@ -320,6 +366,7 @@ GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n);
 void
 GNUNET_CRYPTO_aes_create_session_key (struct GNUNET_CRYPTO_AesSessionKey *key);
 
+
 /**
  * Check that a new session key is well-formed.
  *
@@ -406,7 +453,19 @@ GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block,
 
 
 /**
- * Convert ASCII encoding back to GNUNET_CRYPTO_hash
+ * Convert short hash to ASCII encoding.
+ *
+ * @param block the hash code
+ * @param result where to store the encoding (struct GNUNET_CRYPTO_ShortHashAsciiEncoded can be
+ *  safely cast to char*, a '\\0' termination is set).
+ */
+void
+GNUNET_CRYPTO_short_hash_to_enc (const struct GNUNET_CRYPTO_ShortHashCode * block,
+				 struct GNUNET_CRYPTO_ShortHashAsciiEncoded *result);
+
+
+/**
+ * Convert ASCII encoding back to a 'GNUNET_HashCode'
  *
  * @param enc the encoding
  * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
@@ -419,16 +478,53 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen,
 
 
 /**
- * Convert ASCII encoding back to GNUNET_CRYPTO_hash
+ * Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash'
+ *
  * @param enc the encoding
+ * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
  * @param result where to store the GNUNET_CRYPTO_hash code
  * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
  */
+int
+GNUNET_CRYPTO_short_hash_from_string2 (const char *enc, size_t enclen,
+				       struct GNUNET_CRYPTO_ShortHashCode * result);
+
+
+/**
+ * Convert ASCII encoding back to GNUNET_HashCode
+ *
+ * @param enc the encoding
+ * @param result where to store the hash code
+ * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
+ */
 #define GNUNET_CRYPTO_hash_from_string(enc, result) \
   GNUNET_CRYPTO_hash_from_string2 (enc, strlen(enc), result)
 
 
 /**
+ * Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash'
+ *
+ * @param enc the encoding
+ * @param result where to store the GNUNET_CRYPTO_ShortHash 
+ * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
+ */
+#define GNUNET_CRYPTO_short_hash_from_string(enc, result) \
+  GNUNET_CRYPTO_short_hash_from_string2 (enc, strlen(enc), result)
+
+
+/**
+ * Compare function for ShortHashCodes, producing a total ordering
+ * of all hashcodes.
+ *
+ * @param h1 some hash code
+ * @param h2 some hash code
+ * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
+ */
+int
+GNUNET_CRYPTO_short_hash_cmp (const struct GNUNET_CRYPTO_ShortHashCode * h1,
+                              const struct GNUNET_CRYPTO_ShortHashCode * h2);
+
+/**
  * Compute the distance between 2 hashcodes.
  * The computation must be fast, not involve
  * a.a or a.e (they're used elsewhere), and
@@ -456,6 +552,42 @@ GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret);
 
 
 /**
+ * Compute short (256-bit) hash of a given block.
+ *
+ * @param block the data to hash
+ * @param size size of the block
+ * @param ret pointer to where to write the hashcode
+ */
+void
+GNUNET_CRYPTO_short_hash (const void *block, size_t size, 
+			  struct GNUNET_CRYPTO_ShortHashCode * ret);
+
+
+/**
+ * Double short (256-bit) hash to create a long hash.
+ *
+ * @param sh short hash to double
+ * @param dh where to store the (doubled) long hash (not really a hash)
+ */
+void
+GNUNET_CRYPTO_short_hash_double (const struct GNUNET_CRYPTO_ShortHashCode *sh,
+				 struct GNUNET_HashCode *dh);
+
+
+/**
+ * Truncate doubled short hash back to a short hash.
+ *
+ * @param dh doubled short hash to reduce again
+ * @param sh where to store the short hash
+ * @return GNUNET_OK on success, GNUNET_SYSERR if this was not a
+ *         doubled short hash
+ */
+int
+GNUNET_CRYPTO_short_hash_from_truncation (const struct GNUNET_HashCode *dh,
+					  struct GNUNET_CRYPTO_ShortHashCode *sh);
+
+
+/**
  * Calculate HMAC of a message (RFC 2104)
  *
  * @param key secret key
@@ -735,6 +867,40 @@ GNUNET_CRYPTO_kdf (void *result, size_t out_len, const void *xts,
 struct GNUNET_CRYPTO_RsaPrivateKey *
 GNUNET_CRYPTO_rsa_key_create (void);
 
+
+/**
+ * Convert a public key to a string.
+ *
+ * @param pub key to convert
+ * @return string representing  'pub'
+ */
+char *
+GNUNET_CRYPTO_rsa_public_key_to_string (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub);
+
+
+/**
+ * Convert a string representing a public key to a public key.
+ *
+ * @param enc encoded public key
+ * @param enclen number of bytes in enc (without 0-terminator)
+ * @param pub where to store the public key
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_CRYPTO_rsa_public_key_from_string (const char *enc, 
+					  size_t enclen,
+					  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub);
+
+
+/**
+ * Encode the private key in a format suitable for
+ * storing it into a file.
+ * @returns encoding of the private key.
+ *    The first 4 bytes give the size of the array, as usual.
+ */
+struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *
+GNUNET_CRYPTO_rsa_encode_key (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey);
+
 /**
  * Decode the private key from the data-format back
  * to the "normal", internal format.
@@ -764,6 +930,18 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename);
 
 
 /**
+ * Setup a hostkey file for a peer given the name of the
+ * configuration file (!).  This function is used so that
+ * at a later point code can be certain that reading a
+ * hostkey is fast (for example in time-dependent testcases).
+ *
+ * @param cfg_name name of the configuration file to use
+ */
+void
+GNUNET_CRYPTO_setup_hostkey (const char *cfg_name);
+
+
+/**
  * Deterministically (!) create a private key using only the
  * given HashCode as input to the PRNG.
  *
@@ -869,6 +1047,7 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
 void
 GNUNET_CRYPTO_random_disable_entropy_gathering (void);
 
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_datastore_service.h b/src/include/gnunet_datastore_service.h
index b4af0e6..2950832 100644
--- a/src/include/gnunet_datastore_service.h
+++ b/src/include/gnunet_datastore_service.h
@@ -292,8 +292,8 @@ typedef void (*GNUNET_DATASTORE_DatumProcessor) (void *cls,
  * @param max_queue_size at what queue size should this request be dropped
  *        (if other requests of higher priority are in the queue)
  * @param timeout how long to wait at most for a response
- * @param proc function to call on each matching value;
- *        will be called once with a NULL value at the end
+ * @param proc function to call on a matching value;
+ *        or with a NULL value if no datum matches
  * @param proc_cls closure for proc
  * @return NULL if the entry was not queued, otherwise a handle that can be used to
  *         cancel
diff --git a/src/include/gnunet_dht_service.h b/src/include/gnunet_dht_service.h
index e533ef2..6606acb 100644
--- a/src/include/gnunet_dht_service.h
+++ b/src/include/gnunet_dht_service.h
@@ -121,6 +121,28 @@ GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle);
 
 /* *************** Standard API: get and put ******************* */
 
+
+/**
+ * Opaque handle to cancel a PUT operation.
+ */
+struct GNUNET_DHT_PutHandle;
+
+
+/**
+ * Type of a PUT continuation.  You must not call
+ * "GNUNET_DHT_disconnect" in this continuation.
+ *
+ * @param cls closure
+ * @param success GNUNET_OK if the PUT was transmitted,
+ *                GNUNET_NO on timeout,
+ *                GNUNET_SYSERR on disconnect from service
+ *                after the PUT message was transmitted
+ *                (so we don't know if it was received or not)
+ */
+typedef void (*GNUNET_DHT_PutContinuation)(void *cls,
+					   int success);
+
+
 /**
  * Perform a PUT operation storing data in the DHT.
  *
@@ -135,19 +157,38 @@ GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle);
  * @param exp desired expiration time for the value
  * @param timeout how long to wait for transmission of this request
  * @param cont continuation to call when done (transmitting request to service)
+ *        You must not call "GNUNET_DHT_disconnect" in this continuation
  * @param cont_cls closure for cont
+ * @return handle to cancel the "PUT" operation, NULL on error
+ *        (size too big)
  */
-void
+struct GNUNET_DHT_PutHandle *
 GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, const GNUNET_HashCode * key,
                 uint32_t desired_replication_level,
                 enum GNUNET_DHT_RouteOption options,
                 enum GNUNET_BLOCK_Type type, size_t size, const char *data,
                 struct GNUNET_TIME_Absolute exp,
-                struct GNUNET_TIME_Relative timeout, GNUNET_SCHEDULER_Task cont,
+                struct GNUNET_TIME_Relative timeout,
+		GNUNET_DHT_PutContinuation cont,
                 void *cont_cls);
 
 
 /**
+ * Cancels a DHT PUT operation.  Note that the PUT request may still
+ * go out over the network (we can't stop that); However, if the PUT
+ * has not yet been sent to the service, cancelling the PUT will stop
+ * this from happening (but there is no way for the user of this API
+ * to tell if that is the case).  The only use for this API is to 
+ * prevent a later call to 'cont' from "GNUNET_DHT_put" (i.e. because
+ * the system is shutting down).
+ *
+ * @param ph put operation to cancel ('cont' will no longer be called)
+ */
+void
+GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph);
+
+
+/**
  * Iterator called on each result obtained for a DHT
  * operation that expects a reply
  *
@@ -179,7 +220,6 @@ typedef void (*GNUNET_DHT_GetIterator) (void *cls,
  * also "GNUNET_BLOCK_evaluate".
  *
  * @param handle handle to the DHT service
- * @param timeout how long to wait for transmission of this request to the service
  * @param type expected type of the response object
  * @param key the key to look up
  * @param desired_replication_level estimate of how many
@@ -194,7 +234,6 @@ typedef void (*GNUNET_DHT_GetIterator) (void *cls,
  */
 struct GNUNET_DHT_GetHandle *
 GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
-                      struct GNUNET_TIME_Relative timeout,
                       enum GNUNET_BLOCK_Type type, const GNUNET_HashCode * key,
                       uint32_t desired_replication_level,
                       enum GNUNET_DHT_RouteOption options, const void *xquery,
@@ -216,37 +255,85 @@ GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle);
 
 /* *************** Extended API: monitor ******************* */
 
+/**
+ * Handle to monitor requests
+ */
 struct GNUNET_DHT_MonitorHandle;
 
 /**
- * Callback called on each request going through the DHT.
+ * Callback called on each GET request going through the DHT.
+ *
+ * @param cls Closure.
+ * @param options Options, for instance RecordRoute, DemultiplexEverywhere.
+ * @param type The type of data in the request.
+ * @param hop_count Hop count so far.
+ * @param path_length number of entries in path (or 0 if not recorded).
+ * @param path peers on the GET path (or NULL if not recorded).
+ * @param desired_replication_level Desired replication level.
+ * @param key Key of the requested data.
+ */
+typedef void (*GNUNET_DHT_MonitorGetCB) (void *cls,
+                                         enum GNUNET_DHT_RouteOption options,
+                                         enum GNUNET_BLOCK_Type type,
+                                         uint32_t hop_count,
+                                         uint32_t desired_replication_level, 
+                                         unsigned int path_length,
+                                         const struct GNUNET_PeerIdentity *path,
+                                         const GNUNET_HashCode * key);
+
+/**
+ * Callback called on each GET reply going through the DHT.
  *
  * @param cls Closure.
- * @param mtype Type of the DHT message monitored.
- * @param exp When will this value expire.
- * @param key Key of the result/request.
- * @param get_path Peers on reply path (or NULL if not recorded).
+ * @param type The type of data in the result.
+ * @param get_path Peers on GET path (or NULL if not recorded).
  * @param get_path_length number of entries in get_path.
  * @param put_path peers on the PUT path (or NULL if not recorded).
  * @param put_path_length number of entries in get_path.
- * @param desired_replication_level Desired replication level.
- * @param type Type of the result/request.
+ * @param exp Expiration time of the data.
+ * @param key Key of the data.
  * @param data Pointer to the result data.
  * @param size Number of bytes in data.
  */
-typedef void (*GNUNET_DHT_MonitorCB) (void *cls,
-                                      uint16_t mtype,
-                                      struct GNUNET_TIME_Absolute exp,
-                                      const GNUNET_HashCode * key,
-                                      const struct GNUNET_PeerIdentity *
-                                      get_path, unsigned int get_path_length,
-                                      const struct GNUNET_PeerIdentity *
-                                      put_path, unsigned int put_path_length,
-                                      uint32_t desired_replication_level, 
-                                      enum GNUNET_DHT_RouteOption options,
-                                      enum GNUNET_BLOCK_Type type,
-                                      const void *data,
-                                      size_t size);
+typedef void (*GNUNET_DHT_MonitorGetRespCB) (void *cls,
+                                             enum GNUNET_BLOCK_Type type,
+                                             const struct GNUNET_PeerIdentity
+                                             *get_path,
+                                             unsigned int get_path_length,
+                                             const struct GNUNET_PeerIdentity
+                                             * put_path,
+                                             unsigned int put_path_length,
+                                             struct GNUNET_TIME_Absolute exp,
+                                             const GNUNET_HashCode * key,
+                                             const void *data,
+                                             size_t size);
+
+/**
+ * Callback called on each PUT request going through the DHT.
+ *
+ * @param cls Closure.
+ * @param options Options, for instance RecordRoute, DemultiplexEverywhere.
+ * @param type The type of data in the request.
+ * @param hop_count Hop count so far.
+ * @param path_length number of entries in path (or 0 if not recorded).
+ * @param path peers on the PUT path (or NULL if not recorded).
+ * @param desired_replication_level Desired replication level.
+ * @param exp Expiration time of the data.
+ * @param key Key under which data is to be stored.
+ * @param data Pointer to the data carried.
+ * @param size Number of bytes in data.
+ */
+typedef void (*GNUNET_DHT_MonitorPutCB) (void *cls,
+                                         enum GNUNET_DHT_RouteOption options,
+                                         enum GNUNET_BLOCK_Type type,
+                                         uint32_t hop_count,
+                                         uint32_t desired_replication_level, 
+                                         unsigned int path_length,
+                                         const struct GNUNET_PeerIdentity *path,
+                                         struct GNUNET_TIME_Absolute exp,
+                                         const GNUNET_HashCode * key,
+                                         const void *data,
+                                         size_t size);
 
 /**
  * Start monitoring the local DHT service.
@@ -254,7 +341,9 @@ typedef void (*GNUNET_DHT_MonitorCB) (void *cls,
  * @param handle Handle to the DHT service.
  * @param type Type of blocks that are of interest.
  * @param key Key of data of interest, NULL for all.
- * @param cb Callback to process all monitored data.
+ * @param get_cb Callback to process monitored get messages.
+ * @param get_resp_cb Callback to process monitored get response messages.
+ * @param put_cb Callback to process monitored put messages.
  * @param cb_cls Closure for cb.
  *
  * @return Handle to stop monitoring.
@@ -263,7 +352,9 @@ struct GNUNET_DHT_MonitorHandle *
 GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle,
                           enum GNUNET_BLOCK_Type type,
                           const GNUNET_HashCode *key,
-                          GNUNET_DHT_MonitorCB cb,
+                          GNUNET_DHT_MonitorGetCB get_cb,
+                          GNUNET_DHT_MonitorGetRespCB get_resp_cb,
+                          GNUNET_DHT_MonitorPutCB put_cb,
                           void *cb_cls);
 
 
diff --git a/src/include/gnunet_disk_lib.h b/src/include/gnunet_disk_lib.h
index 18f5535..d6ec0fe 100644
--- a/src/include/gnunet_disk_lib.h
+++ b/src/include/gnunet_disk_lib.h
@@ -302,8 +302,8 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, OFF_T offset,
 
 
 /**
- * Get the size of the file (or directory)
- * of the given file (in bytes).
+ * Get the size of the file (or directory) of the given file (in
+ * bytes).
  *
  * @param filename name of the file or directory
  * @param size set to the size of the file (or,
@@ -311,11 +311,13 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, OFF_T offset,
  *             of all sizes of files in the directory)
  * @param includeSymLinks should symbolic links be
  *        included?
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @param singleFileMode GNUNET_YES to only get size of one file
+ *        and return GNUNET_SYSERR for directories.
+ * @return GNUNET_SYSERR on error, GNUNET_OK on success
  */
 int
 GNUNET_DISK_file_size (const char *filename, uint64_t * size,
-                       int includeSymLinks);
+                       int includeSymLinks, int singleFileMode);
 
 
 /**
diff --git a/src/include/gnunet_dnsparser_lib.h b/src/include/gnunet_dnsparser_lib.h
index 0c310ba..28cc4c0 100644
--- a/src/include/gnunet_dnsparser_lib.h
+++ b/src/include/gnunet_dnsparser_lib.h
@@ -128,7 +128,7 @@ struct GNUNET_DNSPARSER_Flags
    */
   unsigned int recursion_available  : 1 GNUNET_PACKED; 
   
-};
+} GNUNET_GCC_STRUCT_LAYOUT;
 
 
 /**
diff --git a/src/include/gnunet_fs_service.h b/src/include/gnunet_fs_service.h
index 3eb5892..1f1e60f 100644
--- a/src/include/gnunet_fs_service.h
+++ b/src/include/gnunet_fs_service.h
@@ -1820,7 +1820,11 @@ GNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h,
  * @param cls closure
  * @param offset offset to read from; it is possible
  *            that the caller might need to go backwards
- *            a bit at times
+ *            a bit at times; set to UINT64_MAX to tell
+ *            the reader that we won't be reading for a while
+ *            (used to close the file descriptor but NOT fully
+ *             clean up the reader's state); in this case,
+ *            a value of '0' for max should be ignored
  * @param max maximum number of bytes that should be
  *            copied to buf; readers are not allowed
  *            to provide less data unless there is an error;
diff --git a/src/include/gnunet_gns_service.h b/src/include/gnunet_gns_service.h
index 2422178..4e040f7 100644
--- a/src/include/gnunet_gns_service.h
+++ b/src/include/gnunet_gns_service.h
@@ -34,6 +34,7 @@
 #define GNUNET_GNS_SERVICE_H
 
 #include "gnunet_util_lib.h"
+#include "gnunet_dnsparser_lib.h"
 #include "gnunet_namestore_service.h"
 
 #ifdef __cplusplus
@@ -56,36 +57,40 @@ struct GNUNET_GNS_Handle;
 struct GNUNET_GNS_LookupHandle;
 
 /**
+ * Handle to control a shorten operation
+ */
+
+/**
  * Record types
  * Based on GNUNET_DNSPARSER_TYPEs (standard DNS)
  */
 enum GNUNET_GNS_RecordType
 {
   /* Standard DNS */
-  GNUNET_GNS_RECORD_TYPE_A = 1,
-  GNUNET_GNS_RECORD_TYPE_NS = 2,
-  GNUNET_GNS_RECORD_TYPE_CNAME = 5,
-  GNUNET_GNS_RECORD_TYPE_SOA = 6,
-  GNUNET_GNS_RECORD_TYPE_PTR = 12,
-  GNUNET_GNS_RECORD_MX = 15,
-  GNUNET_GNS_RECORD_TXT = 16,
-  GNUNET_GNS_RECORD_AAAA = 28,
+  GNUNET_GNS_RECORD_TYPE_A = GNUNET_DNSPARSER_TYPE_A,
+  GNUNET_GNS_RECORD_TYPE_NS = GNUNET_DNSPARSER_TYPE_NS,
+  GNUNET_GNS_RECORD_TYPE_CNAME = GNUNET_DNSPARSER_TYPE_CNAME,
+  GNUNET_GNS_RECORD_TYPE_SOA = GNUNET_DNSPARSER_TYPE_SOA,
+  GNUNET_GNS_RECORD_TYPE_PTR = GNUNET_DNSPARSER_TYPE_PTR,
+  GNUNET_GNS_RECORD_MX = GNUNET_DNSPARSER_TYPE_MX,
+  GNUNET_GNS_RECORD_TXT = GNUNET_DNSPARSER_TYPE_TXT,
+  GNUNET_GNS_RECORD_AAAA = GNUNET_DNSPARSER_TYPE_AAAA,
 
   /* GNS specific */
-  GNUNET_GNS_RECORD_PKEY = 256
+  GNUNET_GNS_RECORD_PKEY = GNUNET_NAMESTORE_TYPE_PKEY,
+  GNUNET_GNS_RECORD_PSEU = GNUNET_NAMESTORE_TYPE_PSEU,
+  GNUNET_GNS_RECORD_ANY  = GNUNET_NAMESTORE_TYPE_ANY
 };
 
 /**
  * Initialize the connection with the GNS service.
- * FIXME: Do we need the ht_len?
  *
  * @param cfg configuration to use
- * @param ht_len size of the internal hash table to use for parallel lookups
- * @return NULL on error
+ *
+ * @return handle to the GNS service, or NULL on error
  */
 struct GNUNET_GNS_Handle *
-GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                    unsigned int ht_len);
+GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
 /**
@@ -100,56 +105,135 @@ GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle);
 /* *************** Standard API: lookup ******************* */
 
 /**
- * Iterator called on each result obtained for a GNS
+ * Iterator called on obtained result for a GNS
  * lookup
  *
  * @param cls closure
  * @param name "name" of the original lookup
- * @param record the records in reply
- * @param num_records the number of records in reply
+ * @param rd_count number of records
+ * @param rd the records in reply
  */
-typedef void (*GNUNET_GNS_LookupIterator) (void *cls,
-                                        const char * name,
-                                        const struct GNUNET_NAMESTORE_RecordData *record,
-                                        unsigned int num_records);
+typedef void (*GNUNET_GNS_LookupResultProcessor) (void *cls,
+                                 uint32_t rd_count,
+                                 const struct GNUNET_NAMESTORE_RecordData *rd);
 
 
 
 /**
- * Perform an asynchronous lookup operation on the GNS.
+ * Perform an asynchronous lookup operation on the GNS
+ * in the default zone.
  *
  * @param handle handle to the GNS service
- * @param timeout how long to wait for transmission of this request to the service
- * // FIXME: what happens afterwards?
+ * @param name the name to look up
+ * @param type the GNUNET_GNS_RecordType to look for
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ *
+ * @return handle to the queued request
+ */
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
+                         const char * name,
+                         enum GNUNET_GNS_RecordType type,
+                         GNUNET_GNS_LookupResultProcessor proc,
+                         void *proc_cls);
+
+/**
+ * Perform an asynchronous lookup operation on the GNS
+ * in the zone specified by 'zone'.
+ *
  * @param handle handle to the GNS service
- * @param timeout timeout of request
  * @param name the name to look up
+ * @param zone the zone to start the resolution in
  * @param type the GNUNET_GNS_RecordType to look for
- * @param iter function to call on each result
- * @param iter_cls closure for iter
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
  *
- * @return handle to stop the async lookup
+ * @return handle to the queued request
  */
-struct GNUNET_GNS_LookupHandle *
-GNUNET_GNS_lookup_start (struct GNUNET_GNS_Handle *handle,
-                         struct GNUNET_TIME_Relative timeout,
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
                          const char * name,
+                         struct GNUNET_CRYPTO_ShortHashCode *zone,
                          enum GNUNET_GNS_RecordType type,
-                         GNUNET_GNS_LookupIterator iter,
-                         void *iter_cls);
+                         GNUNET_GNS_LookupResultProcessor proc,
+                         void *proc_cls);
+
+/* *************** Standard API: shorten ******************* */
 
 
 /**
- * Stop async GNS lookup.  Frees associated resources.
+ * Processor called on for a name shortening result
+ * called only once
  *
- * @param lookup_handle lookup operation to stop.
+ * @param cls closure
+ * @param short_name the shortened name or NULL if no result
+ */
+typedef void (*GNUNET_GNS_ShortenResultProcessor) (void *cls,
+                                        const char* short_name);
+
+
+/**
+ * Perform a name shortening operation on the GNS.
  *
- * On return lookup_handle will no longer be valid, caller
- * must not use again!!!
+ * @param handle handle to the GNS service
+ * @param name the name to look up
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the operation
  */
-void
-GNUNET_GNS_lookup_stop (struct GNUNET_GNS_LookupHandle *lookup_handle);
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle,
+                    const char * name,
+                    GNUNET_GNS_ShortenResultProcessor proc,
+                    void *proc_cls);
+
+
+/**
+ * Perform a name shortening operation on the GNS.
+ *
+ * @param handle handle to the GNS service
+ * @param name the name to look up
+ * @param zone the zone to start the resolution in
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the operation
+ */
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle,
+                    const char * name,
+                    struct GNUNET_CRYPTO_ShortHashCode *zone,
+                    GNUNET_GNS_ShortenResultProcessor proc,
+                    void *proc_cls);
+
+/* *************** Standard API: get authority ******************* */
+
 
+/**
+ * Processor called on for a name shortening result
+ * called only once
+ *
+ * @param cls closure
+ * @param auth_name the name of the auhtority or NULL
+ */
+typedef void (*GNUNET_GNS_GetAuthResultProcessor) (void *cls,
+                                        const char* short_name);
+
+
+/**
+ * Perform an authority lookup for a given name.
+ *
+ * @param handle handle to the GNS service
+ * @param name the name to look up authority for
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the operation
+ */
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle,
+                    const char * name,
+                    GNUNET_GNS_GetAuthResultProcessor proc,
+                    void *proc_cls);
 
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
diff --git a/src/include/gnunet_helper_lib.h b/src/include/gnunet_helper_lib.h
index 7115748..9c1bc21 100644
--- a/src/include/gnunet_helper_lib.h
+++ b/src/include/gnunet_helper_lib.h
@@ -75,6 +75,12 @@ typedef void (*GNUNET_HELPER_Continuation)(void *cls,
 
 
 /**
+ * Handle to cancel 'send'
+ */
+struct GNUNET_HELPER_SendHandle;
+
+
+/**
  * Send an message to the helper.
  *
  * @param h helper to send message to
@@ -82,10 +88,11 @@ typedef void (*GNUNET_HELPER_Continuation)(void *cls,
  * @param can_drop can the message be dropped if there is already one in the queue?
  * @param cont continuation to run once the message is out
  * @param cont_cls closure for 'cont'
- * @return GNUNET_YES if the message will be sent
- *         GNUNET_NO if the message was dropped
+ * @return NULL if the message was dropped, 
+ *         otherwise handle to cancel *cont* (actual transmission may
+ *         not be abortable)
  */
-int
+struct GNUNET_HELPER_SendHandle *
 GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h, 
 		    const struct GNUNET_MessageHeader *msg,
 		    int can_drop,
@@ -93,4 +100,14 @@ GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h,
 		    void *cont_cls);
 
 
+/**
+ * Cancel a 'send' operation.  If possible, transmitting the
+ * message is also aborted, but at least 'cont' won't be
+ * called.
+ *
+ * @param sh operation to cancel
+ */
+void
+GNUNET_HELPER_send_cancel (struct GNUNET_HELPER_SendHandle *sh);
+
 #endif /* end of include guard: GNUNET_HELPER_LIB_H */
diff --git a/src/include/gnunet_lockmanager_service.h b/src/include/gnunet_lockmanager_service.h
new file mode 100644
index 0000000..570cce5
--- /dev/null
+++ b/src/include/gnunet_lockmanager_service.h
@@ -0,0 +1,165 @@
+/*
+     This file is part of GNUnet.
+     (C) 2012 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/gnunet_lockmanager_service.h
+ * @brief API for the lockmanger service
+ * @author Sree Harsha Totakura
+ */
+
+#ifndef GNUNET_LOCKMANAGER_SERVICE_H
+#define GNUNET_LOCKMANAGER_SERVICE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include "gnunet_configuration_lib.h"
+
+/**
+ * Opaque handle for the lockmanager service
+ */
+struct GNUNET_LOCKMANAGER_Handle;
+
+
+/**
+ * Connect to the lockmanager service
+ *
+ * @param cfg the configuration to use
+ *
+ * @return upon success the handle to the service; NULL upon error
+ */
+struct GNUNET_LOCKMANAGER_Handle *
+GNUNET_LOCKMANAGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Disconnect from the lockmanager service
+ *
+ * @param handle the handle to the lockmanager service
+ */
+void
+GNUNET_LOCKMANAGER_disconnect (struct GNUNET_LOCKMANAGER_Handle *handle);
+
+
+/**
+ * Enumeration for status
+ */
+enum GNUNET_LOCKMANAGER_Status
+  {
+    /**
+     * Signifies a successful operation
+     */
+    GNUNET_LOCKMANAGER_SUCCESS = 1,
+
+    /**
+     * Used to signal that a lock is no longer valid. It must then be released
+     */
+    GNUNET_LOCKMANAGER_RELEASE
+  };
+
+
+/**
+ * This callback will be called when a lock has been successfully acquired or
+ * when an acquired lock has been lost (happens when the lockmanager service
+ * crashes/restarts).
+ *
+ * @param cls the closure from GNUNET_LOCKMANAGER_lock call
+ *
+ * @param domain_name the locking domain of the lock 
+ *
+ * @param lock the lock for which this status is relevant
+ *
+ * @param status GNUNET_LOCKMANAGER_SUCCESS if the lock has been successfully
+ *          acquired; GNUNET_LOCKMANAGER_RELEASE when the acquired lock is lost
+ */
+typedef void 
+(*GNUNET_LOCKMANAGER_StatusCallback) (void *cls,
+                                      const char *domain_name,
+                                      uint32_t lock,
+                                      enum GNUNET_LOCKMANAGER_Status 
+                                      status);
+
+
+/**
+ * Opaque handle to locking request
+ */
+struct GNUNET_LOCKMANAGER_LockingRequest;
+
+
+/**
+ * Tries to acquire the given lock(even if the lock has been lost) until the
+ * request is called. If the lock is available the status_cb will be
+ * called. If the lock is busy then the request is queued and status_cb
+ * will be called when the lock has been made available and acquired by us.
+ *
+ * @param handle the handle to the lockmanager service
+ *
+ * @param domain_name name of the locking domain. Clients who want to share
+ *          locks must use the same name for the locking domain. Also the
+ *          domain_name should be selected with the prefix
+ *          "GNUNET_<PROGRAM_NAME>_" to avoid domain name collisions.
+ *
+ *
+ * @param lock which lock to lock
+ *
+ * @param status_cb the callback for signalling when the lock is acquired and
+ *          when it is lost
+ *
+ * @param status_cb_cls the closure to the above callback
+ *
+ * @return the locking request handle for this request
+ */
+struct GNUNET_LOCKMANAGER_LockingRequest *
+GNUNET_LOCKMANAGER_acquire_lock (struct GNUNET_LOCKMANAGER_Handle *handle,
+                                 const char *domain_name,
+                                 uint32_t lock,
+                                 GNUNET_LOCKMANAGER_StatusCallback
+                                 status_cb,
+                                 void *status_cb_cls);
+
+
+/**
+ * Function to cancel the locking request generated by
+ * GNUNET_LOCKMANAGER_acquire_lock. If the lock is acquired us then the lock is
+ * released. GNUNET_LOCKMANAGER_StatusCallback will not be called upon any
+ * status changes resulting due to this call.
+ *
+ * @param request the LockingRequest to cancel
+ */
+void
+GNUNET_LOCKMANAGER_cancel_request (struct GNUNET_LOCKMANAGER_LockingRequest
+                                   *request);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* ifndef GNUNET_LOCKMANAGER_SERVICE_H */
+#endif
+/* end of gnunet_lockmanager_service.h */
diff --git a/src/include/gnunet_mysql_lib.h b/src/include/gnunet_mysql_lib.h
new file mode 100644
index 0000000..c61bdca
--- /dev/null
+++ b/src/include/gnunet_mysql_lib.h
@@ -0,0 +1,214 @@
+/*
+     This file is part of GNUnet
+     (C) 2012 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file include/gnunet_mysql_lib.h
+ * @brief library to help with access to a MySQL database
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_MYSQL_LIB_H
+#define GNUNET_MYSQL_LIB_H
+
+#include "gnunet_util_lib.h"
+#include <mysql/mysql.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * Mysql context.
+ */
+struct GNUNET_MYSQL_Context;
+
+
+/**
+ * Handle for a prepared statement.
+ */
+struct GNUNET_MYSQL_StatementHandle;
+
+
+/**
+ * Type of a callback that will be called for each
+ * data set returned from MySQL.
+ *
+ * @param cls user-defined argument
+ * @param num_values number of elements in values
+ * @param values values returned by MySQL
+ * @return GNUNET_OK to continue iterating, GNUNET_SYSERR to abort
+ */
+typedef int (*GNUNET_MYSQL_DataProcessor) (void *cls, unsigned int num_values,
+					   MYSQL_BIND * values);
+
+
+/**
+ * Create a mysql context.
+ *
+ * @param cfg configuration
+ * @param section configuration section to use to get MySQL configuration options
+ * @return the mysql context
+ */
+struct GNUNET_MYSQL_Context *
+GNUNET_MYSQL_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+			     const char *section);
+
+
+/**
+ * Destroy a mysql context.  Also frees all associated prepared statements.
+ * 
+ * @param mc context to destroy
+ */
+void
+GNUNET_MYSQL_context_destroy (struct GNUNET_MYSQL_Context *mc);
+
+
+/**
+ * Close database connection and all prepared statements (we got a DB
+ * error).  The connection will automatically be re-opened and
+ * statements will be re-prepared if they are needed again later.
+ *
+ * @param mc mysql context
+ */
+void
+GNUNET_MYSQL_statements_invalidate (struct GNUNET_MYSQL_Context *mc);
+
+
+/**
+ * Get internal handle for a prepared statement.  This function should rarely
+ * be used, and if, with caution!  On failures during the interaction with
+ * the handle, you must call 'GNUNET_MYSQL_statements_invalidate'!
+ *
+ * @param mc mysql context
+ * @param sh prepared statement to introspect
+ * @return MySQL statement handle, NULL on error
+ */
+MYSQL_STMT *
+GNUNET_MYSQL_statement_get_stmt (struct GNUNET_MYSQL_Context *mc,
+				 struct GNUNET_MYSQL_StatementHandle *sh);
+
+
+/**
+ * Prepare a statement.  Prepared statements are automatically discarded
+ * when the MySQL context is destroyed.
+ *
+ * @param mc mysql context
+ * @param query query text
+ * @return prepared statement, NULL on error
+ */
+struct GNUNET_MYSQL_StatementHandle *
+GNUNET_MYSQL_statement_prepare (struct GNUNET_MYSQL_Context *mc,
+				const char *query);
+
+
+/**
+ * Run a SQL statement.
+ *
+ * @param mc mysql context
+ * @param sql SQL statement to run
+ * @return GNUNET_OK on success
+ *         GNUNET_SYSERR if there was a problem
+ */
+int
+GNUNET_MYSQL_statement_run (struct GNUNET_MYSQL_Context *mc,
+			    const char *sql);
+
+
+/**
+ * Run a prepared SELECT statement.
+ *
+ * @param mc mysql context
+ * @param sh handle to SELECT statment
+ * @param result_size number of elements in results array
+ * @param results pointer to already initialized MYSQL_BIND
+ *        array (of sufficient size) for passing results
+ * @param processor function to call on each result
+ * @param processor_cls extra argument to processor
+ * @param ... pairs and triplets of "MYSQL_TYPE_XXX" keys and their respective
+ *        values (size + buffer-reference for pointers); terminated
+ *        with "-1"
+ * @return GNUNET_SYSERR on error, otherwise
+ *         the number of successfully affected (or queried) rows
+ */
+int
+GNUNET_MYSQL_statement_run_prepared_select (struct GNUNET_MYSQL_Context *mc,
+					    struct GNUNET_MYSQL_StatementHandle *sh,
+					    unsigned int result_size, MYSQL_BIND * results,
+					    GNUNET_MYSQL_DataProcessor processor,
+					    void *processor_cls, ...);
+
+
+/**
+ * Run a prepared SELECT statement.
+ *
+ * @param mc mysql context
+ * @param s statement to run
+ * @param result_size number of elements in results array
+ * @param results pointer to already initialized MYSQL_BIND
+ *        array (of sufficient size) for passing results
+ * @param processor function to call on each result
+ * @param processor_cls extra argument to processor
+ * @param ap pairs and triplets of "MYSQL_TYPE_XXX" keys and their respective
+ *        values (size + buffer-reference for pointers); terminated
+ *        with "-1"
+ * @return GNUNET_SYSERR on error, otherwise
+ *         the number of successfully affected (or queried) rows
+ */
+int
+GNUNET_MYSQL_statement_run_prepared_select_va (struct GNUNET_MYSQL_Context *mc,
+					       struct GNUNET_MYSQL_StatementHandle *s,
+					       unsigned int result_size,
+					       MYSQL_BIND * results,
+					       GNUNET_MYSQL_DataProcessor processor,
+					       void *processor_cls,
+					       va_list ap);
+
+
+/**
+ * Run a prepared statement that does NOT produce results.
+ *
+ * @param mc mysql context
+ * @param sh handle to statment
+ * @param insert_id NULL or address where to store the row ID of whatever
+ *        was inserted (only for INSERT statements!)
+ * @param ... pairs and triplets of "MYSQL_TYPE_XXX" keys and their respective
+ *        values (size + buffer-reference for pointers); terminated
+ *        with "-1"
+ * @return GNUNET_SYSERR on error, otherwise
+ *         the number of successfully affected rows
+ */
+int
+GNUNET_MYSQL_statement_run_prepared (struct GNUNET_MYSQL_Context *mc,
+				     struct GNUNET_MYSQL_StatementHandle *sh,
+				     unsigned long long *insert_id, ...);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* end of gnunet_mysql_lib.h */
+#endif
diff --git a/src/include/gnunet_namestore_plugin.h b/src/include/gnunet_namestore_plugin.h
index 5468513..b27867f 100644
--- a/src/include/gnunet_namestore_plugin.h
+++ b/src/include/gnunet_namestore_plugin.h
@@ -56,7 +56,7 @@ typedef void (*GNUNET_NAMESTORE_RecordIterator) (void *cls,
 						 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 						 struct GNUNET_TIME_Absolute expire,
 						 const char *name,
-						 unsigned int rd_count,
+						 unsigned int rd_len,
 						 const struct GNUNET_NAMESTORE_RecordData *rd,
 						 const struct GNUNET_CRYPTO_RsaSignature *signature);
 
@@ -85,13 +85,13 @@ struct GNUNET_NAMESTORE_PluginFunctions
    * @param rd array of records with data to store
    * @param signature signature of the record block, NULL if signature is unavailable (i.e. 
    *        because the user queried for a particular record type only)
-   * @return GNUNET_OK on success
+   * @return GNUNET_OK on success, else GNUNET_SYSERR
    */
   int (*put_records) (void *cls, 
 		      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 		      struct GNUNET_TIME_Absolute expire,
 		      const char *name,
-		      unsigned int rd_count,
+		      unsigned int rd_len,
 		      const struct GNUNET_NAMESTORE_RecordData *rd,
 		      const struct GNUNET_CRYPTO_RsaSignature *signature);
 
@@ -105,7 +105,7 @@ struct GNUNET_NAMESTORE_PluginFunctions
    * @return GNUNET_OK on success
    */
   int (*remove_records) (void *cls, 
-			 const GNUNET_HashCode *zone,
+			 const struct GNUNET_CRYPTO_ShortHashCode *zone,
 			 const char *name);
 
 
@@ -115,27 +115,44 @@ struct GNUNET_NAMESTORE_PluginFunctions
    *
    * @param cls closure (internal context for the plugin)
    * @param zone hash of public key of the zone, NULL to iterate over all zones
-   * @param name_hash hash of name, NULL to iterate over all records of the zone
+   * @param name name as '\0' terminated string, NULL to iterate over all records of the zone
    * @param offset offset in the list of all matching records
    * @param iter function to call with the result
    * @param iter_cls closure for iter
    * @return GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error
    */
   int (*iterate_records) (void *cls, 
-			  const GNUNET_HashCode *zone,
-			  const GNUNET_HashCode *name_hash,
+			  const struct GNUNET_CRYPTO_ShortHashCode *zone,
+			  const char *name,
 			  uint64_t offset,
 			  GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls);
 
 
   /**
+   * Look for an existing PKEY delegation record for a given public key.
+   * Returns at most one result to the iterator.
+   *
+   * @param cls closure (internal context for the plugin)
+   * @param zone hash of public key of the zone to look up in, never NULL
+   * @param value_zone hash of the public key of the target zone (value), never NULL
+   * @param iter function to call with the result
+   * @param iter_cls closure for iter
+   * @return GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error
+   */
+  int (*zone_to_name) (void *cls, 
+		       const struct GNUNET_CRYPTO_ShortHashCode *zone,
+		       const struct GNUNET_CRYPTO_ShortHashCode *value_zone,
+		       GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls);
+
+
+  /**
    * Delete an entire zone (all records).  Not used in normal operation.
    *
    * @param cls closure (internal context for the plugin)
    * @param zone zone to delete
    */
   void (*delete_zone) (void *cls,
-		       const GNUNET_HashCode *zone);
+		       const struct GNUNET_CRYPTO_ShortHashCode *zone);
 
 
 };
diff --git a/src/include/gnunet_namestore_service.h b/src/include/gnunet_namestore_service.h
index 8ab2ce8..a484601 100644
--- a/src/include/gnunet_namestore_service.h
+++ b/src/include/gnunet_namestore_service.h
@@ -44,6 +44,26 @@ extern "C"
 #endif
 
 /**
+ * Record type indicating any record/'*'
+ */
+#define GNUNET_NAMESTORE_TYPE_ANY 0
+
+/**
+ * Record type for GNS zone transfer ("PKEY").
+ */
+#define GNUNET_NAMESTORE_TYPE_PKEY 65536
+
+/**
+ * Record type for GNS zone transfer ("PSEU").
+ */
+#define GNUNET_NAMESTORE_TYPE_PSEU 65537
+
+/**
+ * Record type for GNS legacy hostnames ("LEHO").
+ */
+#define GNUNET_NAMESTORE_TYPE_LEHO 65538
+
+/**
  * Entry in the queue.
  */
 struct GNUNET_NAMESTORE_QueueEntry;
@@ -63,6 +83,8 @@ struct GNUNET_NAMESTORE_ZoneIterator;
  */
 #define GNUNET_NAMESTORE_MAX_VALUE_SIZE (63 * 1024)
 
+
+
 /**
  * Connect to the namestore service.
  *
@@ -90,7 +112,7 @@ GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h, int drop);
  *
  * @param cls closure
  * @param success GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate)
- *                GNUNET_NO if content was already there
+ *                GNUNET_NO if content was already there or not found
  *                GNUNET_YES (or other positive value) on success
  * @param emsg NULL on success, otherwise an error message
  */
@@ -121,7 +143,13 @@ enum GNUNET_NAMESTORE_RecordFlags
    * This is a private record of this peer and it should
    * thus not be handed out to other peers.
    */
-  GNUNET_NAMESTORE_RF_PRIVATE = 2
+  GNUNET_NAMESTORE_RF_PRIVATE = 2,
+
+  /**
+   * This record was added by the system
+   * and is pending user confimation
+   */
+  GNUNET_NAMESTORE_RF_PENDING = 4
 
 };
 
@@ -168,7 +196,7 @@ struct GNUNET_NAMESTORE_RecordData
  * @param h handle to the namestore
  * @param zone_key public key of the zone
  * @param name name that is being mapped (at most 255 characters long)
- * @param expire when does the corresponding block in the DHT expire (until
+ * @param freshness when does the corresponding block in the DHT expire (until
  *               when should we never do a DHT lookup for the same name again)?
  * @param rd_count number of entries in 'rd' array
  * @param rd array of records with data to store
@@ -181,7 +209,7 @@ struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
 			     const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 			     const char *name,
-			     struct GNUNET_TIME_Absolute expire,
+			     struct GNUNET_TIME_Absolute freshness,
 			     unsigned int rd_count,
 			     const struct GNUNET_NAMESTORE_RecordData *rd,
 			     const struct GNUNET_CRYPTO_RsaSignature *signature,
@@ -194,6 +222,7 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
  * to validate signatures received from the network.
  *
  * @param public_key public key of the zone
+ * @param expire block expiration
  * @param name name that is being mapped (at most 255 characters long)
  * @param rd_count number of entries in 'rd' array
  * @param rd array of records with data to store
@@ -202,10 +231,11 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
  */
 int
 GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
-				   const char *name,
-				   unsigned int rd_count,
-				   const struct GNUNET_NAMESTORE_RecordData *rd,
-				   const struct GNUNET_CRYPTO_RsaSignature *signature);
+                                   const struct GNUNET_TIME_Absolute freshness,
+                                   const char *name,
+                                   unsigned int rd_count,
+                                   const struct GNUNET_NAMESTORE_RecordData *rd,
+                                   const struct GNUNET_CRYPTO_RsaSignature *signature);
 
 
 /**
@@ -223,11 +253,11 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary
  */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
-				const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
-				const char *name,
-				const struct GNUNET_NAMESTORE_RecordData *rd,
-				GNUNET_NAMESTORE_ContinuationWithStatus cont,
-				void *cont_cls);
+                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
+                                const char *name,
+                                const struct GNUNET_NAMESTORE_RecordData *rd,
+                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
+                                void *cont_cls);
 
 
 /**
@@ -240,7 +270,7 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
  * @param h handle to the namestore
  * @param pkey private key of the zone
  * @param name name that is being mapped (at most 255 characters long)
- * @param rd record data
+ * @param rd record data, remove specific record,  NULL to remove the name and all records
  * @param cont continuation to call when done
  * @param cont_cls closure for cont
  * @return handle to abort the request
@@ -272,9 +302,9 @@ GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
  */
 typedef void (*GNUNET_NAMESTORE_RecordProcessor) (void *cls,
 						  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
-						  struct GNUNET_TIME_Absolute expire,			    
+						  struct GNUNET_TIME_Absolute freshness,			    
 						  const char *name,
-						  unsigned int rd_count,
+						  unsigned int rd_len,
 						  const struct GNUNET_NAMESTORE_RecordData *rd,
 						  const struct GNUNET_CRYPTO_RsaSignature *signature);
 
@@ -295,17 +325,36 @@ typedef void (*GNUNET_NAMESTORE_RecordProcessor) (void *cls,
  */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_lookup_record (struct GNUNET_NAMESTORE_Handle *h, 
-			      const GNUNET_HashCode *zone,
+			      const struct GNUNET_CRYPTO_ShortHashCode *zone,
 			      const char *name,
 			      uint32_t record_type,
 			      GNUNET_NAMESTORE_RecordProcessor proc, void *proc_cls);
 
 
 /**
+ * Look for an existing PKEY delegation record for a given public key.
+ * Returns at most one result to the processor.
+ *
+ * @param h handle to the namestore
+ * @param zone hash of public key of the zone to look up in, never NULL
+ * @param value_zone hash of the public key of the target zone (value), never NULL
+ * @param proc function to call on the matching records, or with
+ *        NULL (rd_count == 0) if there are no matching records
+ * @param proc_cls closure for proc
+ * @return a handle that can be used to
+ *         cancel
+ */
+struct GNUNET_NAMESTORE_QueueEntry *
+GNUNET_NAMESTORE_zone_to_name (struct GNUNET_NAMESTORE_Handle *h, 
+			       const struct GNUNET_CRYPTO_ShortHashCode *zone,
+			       const struct GNUNET_CRYPTO_ShortHashCode *value_zone,
+			       GNUNET_NAMESTORE_RecordProcessor proc, void *proc_cls);
+
+
+
+/**
  * Starts a new zone iteration (used to periodically PUT all of our
- * records into our DHT). This MUST lock the GNUNET_NAMESTORE_Handle
- * for any other calls than GNUNET_NAMESTORE_zone_iterator_next and
- * GNUNET_NAMESTORE_zone_iteration_stop.  "proc" will be called once
+ * records into our DHT). "proc" will be called once
  * immediately, and then again after
  * "GNUNET_NAMESTORE_zone_iterator_next" is invoked.
  *
@@ -321,7 +370,7 @@ GNUNET_NAMESTORE_lookup_record (struct GNUNET_NAMESTORE_Handle *h,
  */
 struct GNUNET_NAMESTORE_ZoneIterator *
 GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
-				       const GNUNET_HashCode *zone,
+				       const struct GNUNET_CRYPTO_ShortHashCode *zone,
 				       enum GNUNET_NAMESTORE_RecordFlags must_have_flags,
 				       enum GNUNET_NAMESTORE_RecordFlags must_not_have_flags,
 				       GNUNET_NAMESTORE_RecordProcessor proc,
@@ -357,6 +406,117 @@ void
 GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe);
 
 
+
+/* convenience APIs for serializing / deserializing GNS records */
+
+/**
+ * Calculate how many bytes we will need to serialize the given
+ * records.
+ *
+ * @param rd_count number of records in the rd array
+ * @param rd array of GNUNET_NAMESTORE_RecordData with rd_count elements
+ *
+ * @return the required size to serialize
+ *
+ */
+size_t
+GNUNET_NAMESTORE_records_get_size (unsigned int rd_count,
+				   const struct GNUNET_NAMESTORE_RecordData *rd);
+
+/**
+ * Serialize the given records to the given destination buffer.
+ *
+ * @param rd_count number of records in the rd array
+ * @param rd array of GNUNET_NAMESTORE_RecordData with rd_count elements
+ * @param dest_size size of the destination array
+ * @param dest where to write the result
+ *
+ * @return the size of serialized records
+ */
+ssize_t
+GNUNET_NAMESTORE_records_serialize (unsigned int rd_count,
+				    const struct GNUNET_NAMESTORE_RecordData *rd,
+				    size_t dest_size,
+				    char *dest);
+
+
+/**
+ * Deserialize the given records to the given destination.
+ *
+ * @param len size of the serialized record data
+ * @param src the serialized record data
+ * @param rd_count number of records in the rd array
+ * @param dest where to put the data
+ *
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_NAMESTORE_records_deserialize (size_t len,
+				      const char *src,
+				      unsigned int rd_count,
+				      struct GNUNET_NAMESTORE_RecordData *dest);
+
+
+/**
+ * Checks if a name is wellformed
+ *
+ * @param name the name to check
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_NAMESTORE_check_name (const char * name);
+
+/**
+ * Convert the 'value' of a record to a string.
+ *
+ * @param type type of the record
+ * @param data value in binary encoding
+ * @param data_size number of bytes in data
+ * @return NULL on error, otherwise human-readable representation of the value
+ */
+char *
+GNUNET_NAMESTORE_value_to_string (uint32_t type,
+				  const void *data,
+				  size_t data_size);
+
+
+/**
+ * Convert human-readable version of a 'value' of a record to the binary
+ * representation.
+ *
+ * @param type type of the record
+ * @param s human-readable string
+ * @param data set to value in binary encoding (will be allocated)
+ * @param data_size set to number of bytes in data
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_NAMESTORE_string_to_value (uint32_t type,
+				  const char *s,
+				  void **data,
+				  size_t *data_size);
+
+
+/**
+ * Convert a type name (i.e. "AAAA") to the corresponding number.
+ *
+ * @param typename name to convert
+ * @return corresponding number, UINT32_MAX on error
+ */
+uint32_t
+GNUNET_NAMESTORE_typename_to_number (const char *typename);
+
+
+/**
+ * Convert a type number (i.e. 1) to the corresponding type string (i.e. "A")
+ *
+ * @param type number of a type to convert
+ * @return corresponding typestring, NULL on error
+ */
+const char *
+GNUNET_NAMESTORE_number_to_typename (uint32_t type);
+
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_nat_lib.h b/src/include/gnunet_nat_lib.h
index 6c1db80..3a1e9a6 100644
--- a/src/include/gnunet_nat_lib.h
+++ b/src/include/gnunet_nat_lib.h
@@ -117,8 +117,11 @@ GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h, const void *addr,
  *
  * @param h handle (used for configuration)
  * @param sa the address of the peer (IPv4-only)
+ *
+ * @return GNUNET_SYSERR on error, GNUNET_NO if nat client is disabled,
+ *         GNUNET_OK otherwise
  */
-void
+int
 GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
                        const struct sockaddr_in *sa);
 
diff --git a/src/include/gnunet_network_lib.h b/src/include/gnunet_network_lib.h
index a14d5f0..085845a 100644
--- a/src/include/gnunet_network_lib.h
+++ b/src/include/gnunet_network_lib.h
@@ -374,6 +374,26 @@ GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc);
 
 
 /**
+ * Return the sockaddr for this network handle
+ *
+ * @param desc wrapper to process
+ * @return POSIX file descriptor
+ */
+struct sockaddr*
+GNUNET_NETWORK_get_addr (struct GNUNET_NETWORK_Handle *desc);
+
+
+/**
+ * Return sockaddr length for this network handle
+ *
+ * @param desc wrapper to process
+ * @return socklen_t for sockaddr
+ */
+socklen_t
+GNUNET_NETWORK_get_addrlen (struct GNUNET_NETWORK_Handle *desc);
+
+
+/**
  * Copy a native fd set
  * @param to destination
  * @param from native source set
diff --git a/src/include/gnunet_os_lib.h b/src/include/gnunet_os_lib.h
index e9e484f..67b6cce 100644
--- a/src/include/gnunet_os_lib.h
+++ b/src/include/gnunet_os_lib.h
@@ -227,7 +227,7 @@ GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig);
  * @param proc pointer to process structure
  */
 void
-GNUNET_OS_process_close (struct GNUNET_OS_Process *proc);
+GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc);
 
 
 /**
@@ -364,7 +364,8 @@ GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
 
 
 /**
- * Retrieve the status of a process.  Nonblocking version.
+ * Retrieve the status of a process, waiting on him if dead.
+ * Nonblocking version.
  *
  * @param proc pointer to process structure
  * @param type status type
diff --git a/src/include/gnunet_peerinfo_service.h b/src/include/gnunet_peerinfo_service.h
index 12264fb..49ba916 100644
--- a/src/include/gnunet_peerinfo_service.h
+++ b/src/include/gnunet_peerinfo_service.h
@@ -58,7 +58,6 @@ struct GNUNET_PEERINFO_Handle *
 GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
-
 /**
  * Disconnect from the peerinfo service.  Note that all iterators must
  * have completed or have been cancelled by the time this function is
@@ -73,6 +72,22 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h);
 
 
 /**
+ * Continuation called with a status result.
+ * 
+ * @param cls closure
+ * @param emsg error message, NULL on success
+ */
+typedef void (*GNUNET_PEERINFO_Continuation)(void *cls,
+					     const char *emsg);
+
+
+/**
+ * Opaque handle to cancel 'add' operation.
+ */
+struct GNUNET_PEERINFO_AddContext;
+
+
+/**
  * Add a host to the persistent list.  This method operates in
  * semi-reliable mode: if the transmission is not completed by
  * the time 'GNUNET_PEERINFO_disconnect' is called, it will be
@@ -82,10 +97,29 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h);
  *
  * @param h handle to the peerinfo service
  * @param hello the verified (!) HELLO message
+ * @param cont continuation to call when done, NULL is allowed
+ * @param cont_cls closure for 'cont'
+ * @return handle to cancel add operation; all pending
+ *         'add' operations will be cancelled automatically
+ *        on disconnect, so it is not necessary to keep this
+ *        handle (unless 'cont' is NULL and at some point
+ *        calling 'cont' must be prevented)
  */
-void
+struct GNUNET_PEERINFO_AddContext *
 GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,
-                          const struct GNUNET_HELLO_Message *hello);
+                          const struct GNUNET_HELLO_Message *hello,
+			  GNUNET_PEERINFO_Continuation cont,
+			  void *cont_cls);
+
+
+/**
+ * Cancel pending 'add' operation.  Must only be called before
+ * either 'cont' or 'GNUNET_PEERINFO_disconnect' are invoked.
+ *
+ * @param ac handle for the add operation to cancel
+ */
+void
+GNUNET_PEERINFO_add_peer_cancel (struct GNUNET_PEERINFO_AddContext *ac);
 
 
 /**
diff --git a/src/include/gnunet_postgres_lib.h b/src/include/gnunet_postgres_lib.h
new file mode 100644
index 0000000..559793d
--- /dev/null
+++ b/src/include/gnunet_postgres_lib.h
@@ -0,0 +1,163 @@
+/*
+     This file is part of GNUnet
+     (C) 2012 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file include/gnunet_postgres_lib.h
+ * @brief library to help with access to a Postgres database
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_POSTGRES_LIB_H
+#define GNUNET_POSTGRES_LIB_H
+
+#include "gnunet_util_lib.h"
+#include <postgresql/libpq-fe.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * Check if the result obtained from Postgres has
+ * the desired status code.  If not, log an error, clear the
+ * result and return GNUNET_SYSERR.
+ *
+ * @param dbh database handle
+ * @param ret return value from database operation to check
+ * @param expected_status desired status
+ * @param command description of the command that was run
+ * @param args arguments given to the command 
+ * @param filename name of the source file where the command was run
+ * @param line line number in the source file
+ * @return GNUNET_OK if the result is acceptable
+ */
+int
+GNUNET_POSTGRES_check_result_ (PGconn *dbh, PGresult * ret, int expected_status,
+			       const char *command, const char *args,
+			       const char *filename, int line);
+
+
+/**
+ * Check if the result obtained from Postgres has
+ * the desired status code.  If not, log an error, clear the
+ * result and return GNUNET_SYSERR.
+ *
+ * @param dbh database handle
+ * @param ret return value from database operation to check
+ * @param expected_status desired status
+ * @param command description of the command that was run
+ * @param args arguments given to the command 
+ * @return GNUNET_OK if the result is acceptable
+ */
+#define GNUNET_POSTGRES_check_result(dbh,ret,expected_status,command,args) GNUNET_POSTGRES_check_result_(dbh,ret,expected_status,command,args,__FILE__,__LINE__)
+
+
+/**
+ * Run simple SQL statement (without results).
+ *
+ * @param dbh database handle
+ * @param sql statement to run
+ * @param filename filename for error reporting
+ * @param line code line for error reporting 
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_POSTGRES_exec_ (PGconn *dbh, const char *sql, const char *filename, int line);
+
+
+/**
+ * Run simple SQL statement (without results).
+ *
+ * @param dbh database handle
+ * @param sql statement to run
+ * @return GNUNET_OK on success
+ */
+#define GNUNET_POSTGRES_exec(dbh,sql) GNUNET_POSTGRES_exec_(dbh,sql,__FILE__,__LINE__)
+
+
+/**
+ * Prepare SQL statement.
+ *
+ * @param dbh database handle
+ * @param name name for the prepared SQL statement
+ * @param sql SQL code to prepare
+ * @param nparms number of parameters in sql
+ * @param filename filename for error reporting
+ * @param line code line for error reporting
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_POSTGRES_prepare_ (PGconn *dbh, const char *name, const char *sql,
+			  int nparms,
+			  const char *filename, int line);
+
+
+/**
+ * Prepare SQL statement.
+ *
+ * @param dbh database handle
+ * @param name name for the prepared SQL statement
+ * @param sql SQL code to prepare
+ * @param nparams number of parameters in sql
+ * @return GNUNET_OK on success
+ */
+#define GNUNET_POSTGRES_prepare(dbh,name,sql,nparams) GNUNET_POSTGRES_prepare_(dbh,name,sql,nparams,__FILE__,__LINE__)
+
+
+/**
+ * Connect to a postgres database
+ *
+ * @param cfg configuration
+ * @param section configuration section to use to get Postgres configuration options
+ * @return the postgres handle
+ */
+PGconn *
+GNUNET_POSTGRES_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+			 const char *section);
+
+
+/**
+ * Delete the row identified by the given rowid (qid
+ * in postgres).
+ *
+ * @param dbh database handle
+ * @param stmt name of the prepared statement
+ * @param rowid which row to delete
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_POSTGRES_delete_by_rowid (PGconn *dbh,
+				 const char *stmt,
+				 uint32_t rowid);
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* end of gnunet_postgres_lib.h */
+#endif
diff --git a/src/include/gnunet_program_lib.h b/src/include/gnunet_program_lib.h
index 48d5280..fa96ecf 100644
--- a/src/include/gnunet_program_lib.h
+++ b/src/include/gnunet_program_lib.h
@@ -60,6 +60,28 @@ typedef void (*GNUNET_PROGRAM_Main) (void *cls, char *const *args,
  * @param argc number of command line arguments
  * @param argv command line arguments
  * @param binaryName our expected name
+ * @param binaryHelp help text for the program
+ * @param options command line options
+ * @param task main function to run
+ * @param task_cls closure for task
+ * @param run_without_scheduler GNUNET_NO start the scheduler, GNUNET_YES do not
+ *        start the scheduler just run the main task
+ * @return GNUNET_SYSERR on error, GNUNET_OK on success
+ */
+int
+GNUNET_PROGRAM_run2 (int argc, char *const *argv, const char *binaryName,
+                    const char *binaryHelp,
+                    const struct GNUNET_GETOPT_CommandLineOption *options,
+                    GNUNET_PROGRAM_Main task, void *task_cls,
+                    int run_without_scheduler);
+
+/**
+ * Run a standard GNUnet command startup sequence (initialize loggers
+ * and configuration, parse options).
+ *
+ * @param argc number of command line arguments
+ * @param argv command line arguments
+ * @param binaryName our expected name
  * @param binaryHelp helptext for "-h" option (about the app)
  * @param options command line options
  * @param task main function to run
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index dd7c7fe..b655f08 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -87,6 +87,15 @@ extern "C"
  */
 #define GNUNET_MESSAGE_TYPE_ARM_RESULT 11
 
+/**
+ * Request to ARM to list all currently running services
+ */
+#define GNUNET_MESSAGE_TYPE_ARM_LIST 12
+
+/**
+ * Response from ARM for listing currently running services
+ */
+#define GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT 13
 
 /*******************************************************************************
  * HELLO message types
@@ -119,15 +128,18 @@ extern "C"
  ******************************************************************************/
 
 /**
- * Type of messages between the gnunet-wlan-helper and the daemon
- *
+ * Type of data messages from the plugin to the gnunet-wlan-helper 
  */
-#define GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA 40
+#define GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER 39
 
 /**
- * Control messages between the gnunet-wlan-helper and the daemon
+ * Type of data messages from the gnunet-wlan-helper to the plugin
  */
+#define GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER 40
 
+/**
+ * Control message between the gnunet-wlan-helper and the daemon (with the MAC).
+ */
 #define GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL 41
 
 /**
@@ -243,12 +255,6 @@ extern "C"
 #define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY 65
 
 /**
- * Notify clients about new peer-to-peer connections (before
- * key exchange and authentication).
- */
-#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_PRE_CONNECT 66
-
-/**
  * Notify clients about new peer-to-peer connections (triggered
  * after key exchange).
  */
@@ -518,25 +524,40 @@ extern "C"
 #define GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT 148
 
 /**
- * Request / receive information about transiting GETs
+ * Receive information about transiting GETs
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET             149
 
 /**
- * Request / receive information about transiting GET responses
+ * Receive information about transiting GET responses
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP        150
 
 /**
- * Request / receive information about transiting PUTs
+ * Receive information about transiting PUTs
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT             151
 
 /**
- * Request / receive information about transiting PUT responses (TODO)
+ * Receive information about transiting PUT responses (TODO)
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT_RESP        152
 
+/**
+ * Request information about transiting messages
+ */
+#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_START             153
+
+/**
+ * Stop information about transiting messages
+ */
+#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP             154
+
+/**
+ * Acknowledge receiving PUT request
+ */
+#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK             155
+
 
 /*******************************************************************************
  * HOSTLIST message types
@@ -1007,7 +1028,11 @@ extern "C"
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_IN_USE 351
 
-
+/**
+ * Type of the 'struct AddressUseMessage' sent by ATS to client
+ * to confirm that an address is used or not used anymore
+ */
+#define GNUNET_MESSAGE_TYPE_ATS_RESET_BACKOFF 352
 
 
 /*******************************************************************************
@@ -1260,8 +1285,27 @@ extern "C"
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_START 430
 
+/*******************************************************************************
+ * LOCKMANAGER message types
+ ******************************************************************************/
+
+/**
+ * Message to acquire Lock
+ */
+#define GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE 440
+
+/**
+ * Message to release lock
+ */
+#define GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE 441
+
+/**
+ * SUCESS reply from lockmanager
+ */
+#define GNUNET_MESSAGE_TYPE_LOCKMANAGER_SUCCESS 442
+
 /**
- *  Next available: 440
+ *  Next available: 450
  */
 
 /*******************************************************************************
diff --git a/src/include/gnunet_pseudonym_lib.h b/src/include/gnunet_pseudonym_lib.h
index bde98ef..8fd938d 100644
--- a/src/include/gnunet_pseudonym_lib.h
+++ b/src/include/gnunet_pseudonym_lib.h
@@ -44,12 +44,16 @@ extern "C"
  *
  * @param cls closure
  * @param pseudonym hash code of public key of pseudonym
+ * @param name name of the pseudonym (might be NULL)
+ * @param unique_name unique name of the pseudonym (might be NULL)
  * @param md meta data known about the pseudonym
  * @param rating the local rating of the pseudonym
  * @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
  */
 typedef int (*GNUNET_PSEUDONYM_Iterator) (void *cls,
                                           const GNUNET_HashCode * pseudonym,
+                                          const char *name,
+                                          const char *unique_name,
                                           const struct GNUNET_CONTAINER_MetaData
                                           * md, int rating);
 
@@ -110,22 +114,76 @@ GNUNET_PSEUDONYM_discovery_callback_unregister (GNUNET_PSEUDONYM_Iterator
                                                 iterator, void *closure);
 
 /**
- * Return the unique, human readable name for the given pseudonym.
+ * Return unique variant of the namespace name.
+ * Use after GNUNET_PSEUDONYM_id_to_name() to make sure
+ * that name is unique.
  *
- * @return NULL on failure (should never happen)
+ * @param cfg configuration
+ * @param nsid cryptographic ID of the namespace
+ * @param name name to uniquify
+ * @param suffix if not NULL, filled with the suffix value
+ * @return NULL on failure (should never happen), name on success.
+ *         Free the name with GNUNET_free().
  */
 char *
-GNUNET_PSEUDONYM_id_to_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                             const GNUNET_HashCode * pseudo);
+GNUNET_PSEUDONYM_name_uniquify (const struct GNUNET_CONFIGURATION_Handle *cfg,
+    const GNUNET_HashCode * nsid, const char *name, unsigned int *suffix);
 
 /**
- * Get the pseudonym ID belonging to the given human readable name.
+ * Get namespace name, metadata and rank
+ * This is a wrapper around internal read_info() call, and ensures that
+ * returned data is not invalid (not NULL).
+ * Writing back information returned by this function will give
+ * a name "no-name" to pseudonyms that have no name. This side-effect is
+ * unavoidable, but hardly harmful.
  *
- * @return GNUNET_OK on success
+ * @param cfg configuration
+ * @param nsid cryptographic ID of the namespace
+ * @param ret_meta a location to store metadata pointer. NULL, if metadata
+ *        is not needed. Destroy with GNUNET_CONTAINER_meta_data_destroy().
+ * @param ret_rank a location to store rank. NULL, if rank not needed.
+ * @param ret_name a location to store human-readable name. Name is not unique.
+ *        NULL, if name is not needed. Free with GNUNET_free().
+ * @param name_is_a_dup is set to GNUNET_YES, if ret_name was filled with
+ *        a duplicate of a "no-name" placeholder
+ * @return GNUNET_OK on success. GNUENT_SYSERR if the data was
+ *         unobtainable (in that case ret_* are filled with placeholders - 
+ *         empty metadata container, rank -1 and a "no-name" name).
+ */
+int
+GNUNET_PSEUDONYM_get_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
+    const GNUNET_HashCode * nsid, struct GNUNET_CONTAINER_MetaData **ret_meta,
+    int32_t *ret_rank, char **ret_name, int *name_is_a_dup);
+
+
+/**
+ * Get the namespace ID belonging to the given namespace name.
+ *
+ * @param cfg configuration to use
+ * @param ns_uname unique (!) human-readable name for the namespace
+ * @param nsid set to namespace ID based on 'ns_uname'
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
  */
 int
 GNUNET_PSEUDONYM_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                             const char *hname, GNUNET_HashCode * psid);
+    const char *ns_uname, GNUNET_HashCode * nsid);
+
+/**
+ * Set the pseudonym metadata, rank and name.
+ *
+ * @param cfg overall configuration
+ * @param nsid id of the pseudonym
+ * @param name name to set. Must be the non-unique version of it.
+ *        May be NULL, in which case it erases pseudonym's name!
+ * @param md metadata to set
+ *        May be NULL, in which case it erases pseudonym's metadata!
+ * @param rank rank to assign
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+int
+GNUNET_PSEUDONYM_set_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
+    const GNUNET_HashCode * nsid, const char *name,
+    const struct GNUNET_CONTAINER_MetaData *md, int rank);
 
 
 #if 0                           /* keep Emacsens' auto-indent happy */
diff --git a/src/include/gnunet_regex_lib.h b/src/include/gnunet_regex_lib.h
new file mode 100644
index 0000000..aec37c1
--- /dev/null
+++ b/src/include/gnunet_regex_lib.h
@@ -0,0 +1,180 @@
+/*
+     This file is part of GNUnet
+     (C) 2012 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file include/gnunet_regex_lib.h
+ * @brief library to parse regular expressions into dfa
+ * @author Maximilian Szengel
+ *
+ */
+
+#ifndef GNUNET_REGEX_LIB_H
+#define GNUNET_REGEX_LIB_H
+
+#include "gnunet_util_lib.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+/**
+ * Automaton (NFA/DFA) representation.
+ */
+struct GNUNET_REGEX_Automaton;
+
+/**
+ * Edge representation.
+ */
+struct GNUNET_REGEX_Edge
+{
+  /**
+   * Label of the edge.
+   */
+  const char *label;
+
+  /**
+   * Destionation of the edge.
+   */
+  GNUNET_HashCode destination;
+};
+
+/**
+ * Construct an NFA by parsing the regex string of length 'len'.
+ *
+ * @param regex regular expression string.
+ * @param len length of the string.
+ *
+ * @return NFA, needs to be freed using GNUNET_REGEX_destroy_automaton.
+ */
+struct GNUNET_REGEX_Automaton *
+GNUNET_REGEX_construct_nfa (const char *regex, const size_t len);
+
+/**
+ * Construct DFA for the given 'regex' of length 'len'.
+ *
+ * @param regex regular expression string.
+ * @param len length of the regular expression.
+ *
+ * @return DFA, needs to be freed using GNUNET_REGEX_destroy_automaton.
+ */
+struct GNUNET_REGEX_Automaton *
+GNUNET_REGEX_construct_dfa (const char *regex, const size_t len);
+
+/**
+ * Free the memory allocated by constructing the GNUNET_REGEX_Automaton.
+ * data structure.
+ *
+ * @param a automaton to be destroyed.
+ */
+void
+GNUNET_REGEX_automaton_destroy (struct GNUNET_REGEX_Automaton *a);
+
+/**
+ * Save the given automaton as a GraphViz dot file.
+ *
+ * @param a the automaton to be saved.
+ * @param filename where to save the file.
+ */
+void
+GNUNET_REGEX_automaton_save_graph (struct GNUNET_REGEX_Automaton *a,
+                                   const char *filename);
+
+/**
+ * Evaluates the given 'string' against the given compiled regex.
+ *
+ * @param a automaton.
+ * @param string string to check.
+ *
+ * @return 0 if string matches, non 0 otherwise.
+ */
+int
+GNUNET_REGEX_eval (struct GNUNET_REGEX_Automaton *a,
+                   const char *string);
+
+/**
+ * Get the first key for the given 'input_string'. This hashes
+ * the first x bits of the 'input_strings'.
+ *
+ * @param input_string string.
+ * @param string_len length of the 'input_string'.
+ * @param key pointer to where to write the hash code.
+ *
+ * @return number of bits of 'input_string' that have been consumed
+ *         to construct the key
+ */
+unsigned int
+GNUNET_REGEX_get_first_key (const char *input_string, unsigned int string_len,
+                            GNUNET_HashCode * key);
+
+/**
+ * Check if the given 'proof' matches the given 'key'.
+ *
+ * @param proof partial regex
+ * @param key hash
+ *
+ * @return GNUNET_OK if the proof is valid for the given key
+ */
+int
+GNUNET_REGEX_check_proof (const char *proof,
+                          const GNUNET_HashCode *key);
+
+/**
+ * Iterator callback function.
+ *
+ * @param cls closure.
+ * @param key hash for current state.
+ * @param proof proof for current state.
+ * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not.
+ * @param num_edges number of edges leaving current state.
+ * @param edges edges leaving current state.
+ */
+typedef void (*GNUNET_REGEX_KeyIterator)(void *cls,
+                                         const GNUNET_HashCode *key,
+                                         const char *proof,
+                                         int accepting,
+                                         unsigned int num_edges,
+                                         const struct GNUNET_REGEX_Edge *edges);
+
+/**
+ * Iterate over all edges starting from start state of automaton 'a'. Calling
+ * iterator for each edge.
+ *
+ * @param a automaton.
+ * @param iterator iterator called for each edge.
+ * @param iterator_cls closure.
+ */
+void
+GNUNET_REGEX_iterate_all_edges (struct GNUNET_REGEX_Automaton *a,
+                                GNUNET_REGEX_KeyIterator iterator,
+                                void *iterator_cls);
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* end of gnunet_regex_lib.h */
+#endif
+
diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h
index e16ccc5..4727534 100644
--- a/src/include/gnunet_scheduler_lib.h
+++ b/src/include/gnunet_scheduler_lib.h
@@ -238,7 +238,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls);
  * scheduled AFTER this call may still be delayed arbitrarily.
  */
 void
-GNUNET_SCHEDULER_shutdown ();
+GNUNET_SCHEDULER_shutdown (void);
 
 
 /**
@@ -309,26 +309,6 @@ GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, voi
 
 
 /**
- * Schedule a new task to be run after the specified prerequisite task
- * has completed. It will be run with DEFAULT priority.
- *
- * * @param prerequisite_task run this task after the task with the given
- *        task identifier completes (and any of our other
- *        conditions, such as delay, read or write-readiness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
- *        on completion of other tasks (this will cause the task to run as
- *        soon as possible).
- * @param task main function of the task
- * @param task_cls closure of task
- * @return unique task identifier for the job
- *         only valid until "task" is started!
- */
-GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                            GNUNET_SCHEDULER_Task task, void *task_cls);
-
-
-/**
  * Schedule a new task to be run with a specified priority.
  *
  * * @param prio how important is the new task?
@@ -432,6 +412,30 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
 
 
 /**
+ * Schedule a new task to be run with a specified priority and to be
+ * run after the specified delay or when the specified file descriptor
+ * is ready for reading.  The delay can be used as a timeout on the
+ * socket being ready.  The task will be scheduled for execution once
+ * either the delay has expired or the socket operation is ready.  It
+ * will be run with the DEFAULT priority.
+ *
+ * @param delay when should this operation time out? Use
+ *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param priority priority to use for the task
+ * @param rfd read file-descriptor
+ * @param task main function of the task
+ * @param task_cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "task" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
+					     enum GNUNET_SCHEDULER_Priority priority,
+					     struct GNUNET_NETWORK_Handle *rfd,
+					     GNUNET_SCHEDULER_Task task, void *task_cls);
+
+
+/**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
@@ -511,12 +515,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  *     || shutdown-active)
  * </code>
  *
- * * @param prio how important is this task?
- * @param prerequisite_task run this task after the task with the given
- *        task identifier completes (and any of our other
- *        conditions, such as delay, read or write-readiness
- *        are satisfied).  Use GNUNET_SCHEDULER_NO_TASK to not have any dependency
- *        on completion of other tasks.
+ * @param prio how important is this task?
  * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
  *        which means that the task will only be run after we receive SIGTERM
  * @param rs set of file descriptors we want to read (can be NULL)
@@ -527,8 +526,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
-                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,                            
                              struct GNUNET_TIME_Relative delay,
                              const struct GNUNET_NETWORK_FDSet *rs,
                              const struct GNUNET_NETWORK_FDSet *ws,
diff --git a/src/include/gnunet_server_lib.h b/src/include/gnunet_server_lib.h
index 7fb8ae7..73fe800 100644
--- a/src/include/gnunet_server_lib.h
+++ b/src/include/gnunet_server_lib.h
@@ -55,12 +55,16 @@ extern "C"
  */
 struct GNUNET_SERVER_Handle;
 
-
 /**
  * @brief opaque handle for a client of the server
  */
 struct GNUNET_SERVER_Client;
 
+/**
+ * @brief opaque handle server returns for aborting transmission to a client.
+ */
+struct GNUNET_SERVER_TransmitHandle;
+
 
 /**
  * Functions with this signature are called whenever a message is
@@ -151,12 +155,22 @@ GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
 
 
 /**
+ * Stop the listen socket and get ready to shutdown the server
+ * once only 'monitor' clients are left.
+ *
+ * @param server server to stop listening on
+ */
+void
+GNUNET_SERVER_stop_listening (struct GNUNET_SERVER_Handle *server);
+
+
+/**
  * Free resources held by this server.
  *
- * @param s server to destroy
+ * @param server server to destroy
  */
 void
-GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s);
+GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server);
 
 
 /**
@@ -190,10 +204,10 @@ GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
  * @param callback_cls closure for callback
  * @return non-NULL if the notify callback was queued; can be used
  *           to cancel the request using
- *           GNUNET_CONNECTION_notify_transmit_ready_cancel.
+ *           GNUNET_SERVER_notify_transmit_ready_cancel.
  *         NULL if we are already going to notify someone else (busy)
  */
-struct GNUNET_CONNECTION_TransmitHandle *
+struct GNUNET_SERVER_TransmitHandle *
 GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
                                      size_t size,
                                      struct GNUNET_TIME_Relative timeout,
@@ -202,6 +216,31 @@ GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
 
 
 /**
+ * Abort transmission request.
+ *
+ * @param th request to abort
+ */
+void
+GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th);
+
+
+/**
+ * Set the 'monitor' flag on this client.  Clients which have been
+ * marked as 'monitors' won't prevent the server from shutting down
+ * once 'GNUNET_SERVER_stop_listening' has been invoked.  The idea is
+ * that for "normal" clients we likely want to allow them to process
+ * their requests; however, monitor-clients are likely to 'never'
+ * disconnect during shutdown and thus will not be considered when
+ * determining if the server should continue to exist after
+ * 'GNUNET_SERVER_destroy' has been called.
+ *
+ * @param client the client to set the 'monitor' flag on
+ */
+void
+GNUNET_SERVER_client_mark_monitor (struct GNUNET_SERVER_Client *client);
+
+
+/**
  * Set the persistent flag on this client, used to setup client connection
  * to only be killed when the service it's connected to is actually dead.
  *
@@ -210,6 +249,7 @@ GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
 void
 GNUNET_SERVER_client_persist_ (struct GNUNET_SERVER_Client *client);
 
+
 /**
  * Resume receiving from this client, we are done processing the
  * current request.  This function must be called from within each
@@ -240,14 +280,6 @@ GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client,
 
 
 /**
- * Set if a client should finish a pending write when disconnecting.
- */
-void
-GNUNET_SERVER_client_set_finish_pending_write (struct GNUNET_SERVER_Client *client,
-                                               int finish);
-
-
-/**
  * Disable the warning the server issues if a message is not acknowledged
  * in a timely fashion.  Use this call if a client is intentionally delayed
  * for a while.  Only applies to the current message.
@@ -392,22 +424,6 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client);
 
 
 /**
- * Configure this server's connections to continue handling client
- * requests as usual even after we get a shutdown signal.  The change
- * only applies to clients that connect to the server from the outside
- * using TCP after this call.  Clients managed previously or those
- * added using GNUNET_SERVER_connect_socket and
- * GNUNET_SERVER_connect_callback are not affected by this option.
- *
- * @param h server handle
- * @param do_ignore GNUNET_YES to ignore, GNUNET_NO to restore default
- */
-void
-GNUNET_SERVER_ignore_shutdown (struct GNUNET_SERVER_Handle *h, int do_ignore);
-
-
-
-/**
  * Disable the "CORK" feature for communication with the given client,
  * forcing the OS to immediately flush the buffer on transmission
  * instead of potentially buffering multiple messages.
@@ -591,11 +607,15 @@ struct GNUNET_SERVER_MessageStreamTokenizer;
  * Functions with this signature are called whenever a
  * complete message is received by the tokenizer.
  *
+ * Do not call GNUNET_SERVER_mst_destroy in callback
+ *
  * @param cls closure
  * @param client identification of the client
  * @param message the actual message
+ *
+ * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
  */
-typedef void (*GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client,
+typedef int (*GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client,
                                                         const struct
                                                         GNUNET_MessageHeader *
                                                         message);
diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h
index 1641e0f..39e6a80 100644
--- a/src/include/gnunet_service_lib.h
+++ b/src/include/gnunet_service_lib.h
@@ -43,7 +43,7 @@ extern "C"
  * Get the list of addresses that a server for the given service
  * should bind to.
  *
- * @param serviceName name of the service
+ * @param service_name name of the service
  * @param cfg configuration (which specifies the addresses)
  * @param addrs set (call by reference) to an array of pointers to the
  *              addresses the server should bind to and listen on; the
@@ -60,7 +60,7 @@ extern "C"
  *              set to NULL).
  */
 int
-GNUNET_SERVICE_get_server_addresses (const char *serviceName,
+GNUNET_SERVICE_get_server_addresses (const char *service_name,
                                      const struct GNUNET_CONFIGURATION_Handle
                                      *cfg, struct sockaddr ***addrs,
                                      socklen_t ** addr_lens);
@@ -85,16 +85,22 @@ typedef void (*GNUNET_SERVICE_Main) (void *cls,
  */
 enum GNUNET_SERVICE_Options
 {
-    /**
-     * Use defaults.
-     */
+  /**
+   * Use defaults.
+   */
   GNUNET_SERVICE_OPTION_NONE = 0,
 
-    /**
-     * Do not trigger server shutdown on signals, allow for the user
-     * to terminate the server explicitly when needed.
-     */
-  GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN = 1
+  /**
+   * Do not trigger server shutdown on signals, allow for the user
+   * to terminate the server explicitly when needed.
+   */
+  GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN = 1,
+
+  /**
+   * Trigger a SOFT server shutdown on signals, allowing active
+   * non-monitor clients to complete their transactions.
+   */
+  GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN = 2
 };
 
 
@@ -104,32 +110,37 @@ enum GNUNET_SERVICE_Options
  *
  * @param argc number of command line arguments
  * @param argv command line arguments
- * @param serviceName our service name
- * @param opt service options
+ * @param service_name our service name
+ * @param options service options
  * @param task main task of the service
  * @param task_cls closure for task
  * @return GNUNET_SYSERR on error, GNUNET_OK
  *         if we shutdown nicely
  */
 int
-GNUNET_SERVICE_run (int argc, char *const *argv, const char *serviceName,
-                    enum GNUNET_SERVICE_Options opt, GNUNET_SERVICE_Main task,
+GNUNET_SERVICE_run (int argc, char *const *argv, const char *service_name,
+                    enum GNUNET_SERVICE_Options options, GNUNET_SERVICE_Main task,
                     void *task_cls);
 
 
+/**
+ * Opaque handle for a service.
+ */
 struct GNUNET_SERVICE_Context;
 
 /**
  * Run a service startup sequence within an existing
  * initialized system.
  *
- * @param serviceName our service name
+ * @param service_name our service name
  * @param cfg configuration to use
+ * @param options service options
  * @return NULL on error, service handle
  */
 struct GNUNET_SERVICE_Context *
-GNUNET_SERVICE_start (const char *serviceName,
-                      const struct GNUNET_CONFIGURATION_Handle *cfg);
+GNUNET_SERVICE_start (const char *service_name,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg,
+		      enum GNUNET_SERVICE_Options options);
 
 
 /**
diff --git a/src/include/gnunet_signatures.h b/src/include/gnunet_signatures.h
index 580282d..ee105c6 100644
--- a/src/include/gnunet_signatures.h
+++ b/src/include/gnunet_signatures.h
@@ -115,6 +115,12 @@ extern "C"
  */
 #define GNUNET_SIGNATURE_PURPOSE_NSE_SEND 14
 
+
+/**
+ * Signature of a gnunet naming system record block
+ */
+#define GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN 15
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_statistics_service.h b/src/include/gnunet_statistics_service.h
index bfd65f8..0515331 100644
--- a/src/include/gnunet_statistics_service.h
+++ b/src/include/gnunet_statistics_service.h
@@ -145,6 +145,7 @@ struct GNUNET_STATISTICS_GetHandle;
  * @param timeout after how long should we give up (and call
  *        notify with buf NULL and size 0)?
  * @param cont continuation to call when done (can be NULL)
+ *        This callback CANNOT destroy the statistics handle in the same call.
  * @param proc function to call on each value
  * @param cls closure for proc and cont
  * @return NULL on error
diff --git a/src/include/gnunet_stream_lib.h b/src/include/gnunet_stream_lib.h
index 930cc1d..e09c264 100644
--- a/src/include/gnunet_stream_lib.h
+++ b/src/include/gnunet_stream_lib.h
@@ -62,7 +62,12 @@ enum GNUNET_STREAM_Status
     /**
      * A serious error occured while operating on this stream
      */
-    GNUNET_STREAM_SYSERR = 3
+    GNUNET_STREAM_SYSERR = 3,
+    
+    /**
+     * An error resulted in an unusable stream
+     */
+    GNUNET_STREAM_BROKEN
   };
 
 /**
@@ -125,18 +130,51 @@ GNUNET_STREAM_open (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
- * Shutdown the stream for reading or writing (man 2 shutdown).
+ * Handle for shutdown
+ */
+struct GNUNET_STREAM_ShutdownHandle;
+
+
+/**
+ * Completion callback for shutdown
+ *
+ * @param cls the closure from GNUNET_STREAM_shutdown call
+ * @param operation the operation that was shutdown (SHUT_RD, SHUT_WR,
+ *          SHUT_RDWR) 
+ */
+typedef void (*GNUNET_STREAM_ShutdownCompletion) (void *cls,
+                                                  int operation);
+
+
+/**
+ * Shutdown the stream for reading or writing (similar to man 2 shutdown).
  *
  * @param socket the stream socket
- * @param how SHUT_RD, SHUT_WR or SHUT_RDWR 
+ * @param operation SHUT_RD, SHUT_WR or SHUT_RDWR
+ * @param completion_cb the callback that will be called upon successful
+ *          shutdown of given operation
+ * @param completion_cls the closure for the completion callback
+ * @return the shutdown handle; NULL in case of any error
  */
-void
+struct GNUNET_STREAM_ShutdownHandle *
 GNUNET_STREAM_shutdown (struct GNUNET_STREAM_Socket *socket,
-			int how);
+			int operation,
+                        GNUNET_STREAM_ShutdownCompletion completion_cb,
+                        void *completion_cls);
+
+
+/**
+ * Cancels a pending shutdown
+ *
+ * @param handle the shutdown handle returned from GNUNET_STREAM_shutdown
+ */
+void
+GNUNET_STREAM_shutdown_cancel (struct GNUNET_STREAM_ShutdownHandle *handle);
 
 
 /**
- * Closes the stream
+ * Closes the stream and frees the associated state. The stream should be
+ * shutdown before closing.
  *
  * @param socket the stream socket
  */
@@ -185,10 +223,10 @@ GNUNET_STREAM_listen (const struct GNUNET_CONFIGURATION_Handle *cfg,
 /**
  * Closes the listen socket
  *
- * @param socket the listen socket
+ * @param lsocket the listen socket
  */
 void
-GNUNET_STREAM_listen_close (struct GNUNET_STREAM_ListenSocket *socket);
+GNUNET_STREAM_listen_close (struct GNUNET_STREAM_ListenSocket *lsocket);
 
 
 /**
@@ -217,15 +255,22 @@ struct GNUNET_STREAM_IOWriteHandle;
 struct GNUNET_STREAM_IOReadHandle;
 
 /**
- * Tries to write the given data to the stream
+ * Tries to write the given data to the stream. The maximum size of data that
+ * can be written as part of a write operation is (64 * (64000 - sizeof (struct
+ * GNUNET_STREAM_DataMessage))). If size is greater than this it is not an API
+ * violation, however only the said number of maximum bytes will be written.
  *
  * @param socket the socket representing a stream
  * @param data the data buffer from where the data is written into the stream
  * @param size the number of bytes to be written from the data buffer
  * @param timeout the timeout period
- * @param write_cont the function to call upon writing some bytes into the stream
+ * @param write_cont the function to call upon writing some bytes into the
+ *          stream 
  * @param write_cont_cls the closure
- * @return handle to cancel the operation; NULL if a previous write is pending
+ *
+ * @return handle to cancel the operation; if a previous write is pending or
+ *           the stream has been shutdown for this operation then write_cont is
+ *           immediately called and NULL is returned.
  */
 struct GNUNET_STREAM_IOWriteHandle *
 GNUNET_STREAM_write (struct GNUNET_STREAM_Socket *socket,
@@ -243,7 +288,7 @@ GNUNET_STREAM_write (struct GNUNET_STREAM_Socket *socket,
  * @param cls the closure from GNUNET_STREAM_read
  * @param status the status of the stream at the time this function is called
  * @param data traffic from the other side
- * @param size the number of bytes available in data read 
+ * @param size the number of bytes available in data read; will be 0 on timeout 
  * @return number of bytes of processed from 'data' (any data remaining should be
  *         given to the next time the read processor is called).
  */
@@ -254,13 +299,16 @@ typedef size_t (*GNUNET_STREAM_DataProcessor) (void *cls,
 
 
 /**
- * Tries to read data from the stream
+ * Tries to read data from the stream.
  *
  * @param socket the socket representing a stream
  * @param timeout the timeout period
  * @param proc function to call with data (once only)
  * @param proc_cls the closure for proc
- * @return handle to cancel the operation
+ *
+ * @return handle to cancel the operation; if the stream has been shutdown for
+ *           this type of opeartion then the DataProcessor is immediately
+ *           called with GNUNET_STREAM_SHUTDOWN as status and NULL if returned
  */
 struct GNUNET_STREAM_IOReadHandle *
 GNUNET_STREAM_read (struct GNUNET_STREAM_Socket *socket,
@@ -270,12 +318,24 @@ GNUNET_STREAM_read (struct GNUNET_STREAM_Socket *socket,
 
 
 /**
- * Cancel pending write operation.
+ * Cancels pending write operation. Also cancels packet retransmissions which
+ * may have resulted otherwise.
+ *
+ * CAUTION: Normally a write operation is considered successful if the data
+ * given to it is sent and acknowledged by the receiver. As data is divided
+ * into packets, it is possible that not all packets are received by the
+ * receiver. Any missing packets are then retransmitted till the receiver
+ * acknowledges all packets or until a timeout . During this scenario if the
+ * write operation is cancelled all such retransmissions are also
+ * cancelled. This may leave the receiver's receive buffer incompletely filled
+ * as some missing packets are never retransmitted. So this operation should be
+ * used before shutting down transmission from our side or before closing the
+ * socket.
  *
  * @param ioh handle to operation to cancel
  */
 void
-GNUNET_STREAM_io_write_cancel (struct GNUNET_STREAM_IOWriteHandle *ioh);
+GNUNET_STREAM_io_write_cancel (struct GNUNET_STREAM_IOWriteHandle *iowh);
 
 
 /**
@@ -284,7 +344,7 @@ GNUNET_STREAM_io_write_cancel (struct GNUNET_STREAM_IOWriteHandle *ioh);
  * @param ioh handle to operation to cancel
  */
 void
-GNUNET_STREAM_io_read_cancel (struct GNUNET_STREAM_IOReadHandle *ioh);
+GNUNET_STREAM_io_read_cancel (struct GNUNET_STREAM_IOReadHandle *iorh);
 
 
 #if 0
diff --git a/src/include/gnunet_strings_lib.h b/src/include/gnunet_strings_lib.h
index 8101a81..54d2e30 100644
--- a/src/include/gnunet_strings_lib.h
+++ b/src/include/gnunet_strings_lib.h
@@ -66,12 +66,12 @@ GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size,
  * Convert a given fancy human-readable time to our internal
  * representation.
  *
- * @param fancy_size human readable string (i.e. 1 minute)
+ * @param fancy_time human readable string (i.e. 1 minute)
  * @param rtime set to the relative time
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_size,
+GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
                                        struct GNUNET_TIME_Relative *rtime);
 
 
@@ -121,6 +121,27 @@ GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset);
 char *
 GNUNET_STRINGS_from_utf8 (const char *input, size_t len, const char *charset);
 
+/**
+ * Convert the utf-8 input string to lowercase
+ * Output needs to be allocated appropriately
+ *
+ * @param input input string
+ * @param output output buffer
+ */
+void
+GNUNET_STRINGS_utf8_tolower(const char* input, char** output);
+
+
+/**
+ * Convert the utf-8 input string to lowercase
+ * Output needs to be allocated appropriately
+ *
+ * @param input input string
+ * @param output output buffer
+ */
+void
+GNUNET_STRINGS_utf8_toupper(const char* input, char** output);
+
 
 /**
  * Complete filename (a la shell) from abbrevition.
@@ -213,6 +234,42 @@ GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta);
 const char *
 GNUNET_STRINGS_get_short_name (const char *filename);
 
+
+/**
+ * Convert binary data to ASCII encoding.  The ASCII encoding is rather
+ * GNUnet specific.  It was chosen such that it only uses characters
+ * in [0-9A-V], can be produced without complex arithmetics and uses a
+ * small number of characters.  The GNUnet encoding uses 103 characters.
+ * Does not append 0-terminator, but returns a pointer to the place where
+ * it should be placed, if needed.
+ *
+ * @param data data to encode
+ * @param size size of data (in bytes)
+ * @param out buffer to fill
+ * @param out_size size of the buffer. Must be large enough to hold
+ * ((size*8) + (((size*8) % 5) > 0 ? 5 - ((size*8) % 5) : 0)) / 5
+ * @return pointer to the next byte in 'out' or NULL on error.
+ */
+char *
+GNUNET_STRINGS_data_to_string (const unsigned char *data, size_t size,
+			       char *out, size_t out_size);
+
+
+/**
+ * Convert ASCII encoding back to data
+ * out_size must match exactly the size of the data before it was encoded.
+ *
+ * @param enc the encoding
+ * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
+ * @param out location where to store the decoded data
+ * @param out_size sizeof the output buffer
+ * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
+ */
+int
+GNUNET_STRINGS_string_to_data (const char *enc, size_t enclen,
+                              unsigned char *out, size_t out_size);
+
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
@@ -220,6 +277,118 @@ GNUNET_STRINGS_get_short_name (const char *filename);
 }
 #endif
 
+enum GNUNET_STRINGS_FilenameCheck
+{
+  GNUNET_STRINGS_CHECK_EXISTS = 0x00000001,
+  GNUNET_STRINGS_CHECK_IS_DIRECTORY = 0x00000002,
+  GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004,
+  GNUNET_STRINGS_CHECK_IS_ABSOLUTE = 0x00000008
+};
+
+/**
+ * Parse a path that might be an URI.
+ *
+ * @param path path to parse. Must be NULL-terminated.
+ * @param scheme_part a pointer to 'char *' where a pointer to a string that
+ *        represents the URI scheme will be stored. Can be NULL. The string is
+ *        allocated by the function, and should be freed by GNUNET_free() when
+ *        it is no longer needed.
+ * @param path_part a pointer to 'const char *' where a pointer to the path
+ *        part of the URI will be stored. Can be NULL. Points to the same block
+ *        of memory as 'path', and thus must not be freed. Might point to '\0',
+ *        if path part is zero-length.
+ * @return GNUNET_YES if it's an URI, GNUNET_NO otherwise. If 'path' is not
+ *         an URI, '* scheme_part' and '*path_part' will remain unchanged
+ *         (if they weren't NULL).
+ */
+int
+GNUNET_STRINGS_parse_uri (const char *path, char **scheme_part,
+    const char **path_part);
+
+
+/**
+ * Check whether filename is absolute or not, and if it's an URI
+ *
+ * @param filename filename to check
+ * @param can_be_uri GNUNET_YES to check for being URI, GNUNET_NO - to
+ *        assume it's not URI
+ * @param r_is_uri a pointer to an int that is set to GNUNET_YES if 'filename'
+ *        is URI and to GNUNET_NO otherwise. Can be NULL. If 'can_be_uri' is
+ *        not GNUNET_YES, *r_is_uri is set to GNUNET_NO.
+ * @param r_uri_scheme a pointer to a char * that is set to a pointer to URI scheme.
+ *        The string is allocated by the function, and should be freed with
+ *        GNUNET_free (). Can be NULL.
+ * @return GNUNET_YES if 'filename' is absolute, GNUNET_NO otherwise.
+ */
+int
+GNUNET_STRINGS_path_is_absolute (const char *filename, 
+				 int can_be_uri,
+				 int *r_is_uri, 
+				 char **r_uri_scheme);
+
+
+/**
+ * Perform checks on 'filename;
+ * 
+ * @param filename file to check
+ * @param checks checks to perform
+ * @return GNUNET_YES if all checks pass, GNUNET_NO if at least one of them
+ *         fails, GNUNET_SYSERR when a check can't be performed
+ */
+int
+GNUNET_STRINGS_check_filename (const char *filename,
+			       enum GNUNET_STRINGS_FilenameCheck checks);
+
+
+/**
+ * Tries to convert 'zt_addr' string to an IPv6 address.
+ * The string is expected to have the format "[ABCD::01]:80".
+ * 
+ * @param zt_addr 0-terminated string. May be mangled by the function.
+ * @param addrlen length of zt_addr (not counting 0-terminator).
+ * @param r_buf a buffer to fill. Initially gets filled with zeroes,
+ *        then its sin6_port, sin6_family and sin6_addr are set appropriately.
+ * @return GNUNET_OK if conversion succeded. GNUNET_SYSERR otherwise, in which
+ *         case the contents of r_buf are undefined.
+ */
+int
+GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr, 
+				uint16_t addrlen,
+				struct sockaddr_in6 *r_buf);
+
+
+/**
+ * Tries to convert 'zt_addr' string to an IPv4 address.
+ * The string is expected to have the format "1.2.3.4:80".
+ * 
+ * @param zt_addr 0-terminated string. May be mangled by the function.
+ * @param addrlen length of zt_addr (not counting 0-terminator).
+ * @param r_buf a buffer to fill.
+ * @return GNUNET_OK if conversion succeded. GNUNET_SYSERR otherwise, in which case
+ *         the contents of r_buf are undefined.
+ */
+int
+GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr, 
+				uint16_t addrlen,
+				struct sockaddr_in *r_buf);
+
+
+/**
+ * Tries to convert 'addr' string to an IP (v4 or v6) address.
+ * Will automatically decide whether to treat 'addr' as v4 or v6 address.
+ * 
+ * @param addr a string, may not be 0-terminated.
+ * @param addrlen number of bytes in addr (if addr is 0-terminated,
+ *        0-terminator should not be counted towards addrlen).
+ * @param r_buf a buffer to fill.
+ * @return GNUNET_OK if conversion succeded. GNUNET_SYSERR otherwise, in which
+ *         case the contents of r_buf are undefined.
+ */
+int
+GNUNET_STRINGS_to_address_ip (const char *addr,
+			      uint16_t addrlen,
+			      struct sockaddr_storage *r_buf);
+
 
 /* ifndef GNUNET_UTIL_STRING_H */
 #endif
diff --git a/src/include/gnunet_testbed_service.h b/src/include/gnunet_testbed_service.h
new file mode 100644
index 0000000..ab8db87
--- /dev/null
+++ b/src/include/gnunet_testbed_service.h
@@ -0,0 +1,1029 @@
+/*
+      This file is part of GNUnet
+      (C) 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
+
+      GNUnet is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published
+      by the Free Software Foundation; either version 3, or (at your
+      option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with GNUnet; see the file COPYING.  If not, write to the
+      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+      Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * @file include/gnunet_testbed_service.h
+ * @brief API for writing tests and creating large-scale
+ *        emulation testbeds for GNUnet.
+ * @author Christian Grothoff
+ */
+
+#ifndef GNUNET_TESTBED_SERVICE_H
+#define GNUNET_TESTBED_SERVICE_H
+
+#include "gnunet_util_lib.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * Opaque handle to a host running experiments managed by the testbed framework.
+ * The master process must be able to SSH to this host without password (via
+ * ssh-agent).
+ */
+struct GNUNET_TESTBED_Host;
+
+/**
+ * Opaque handle to a peer controlled by the testbed framework.  A peer runs
+ * at a particular host.
+ */ 
+struct GNUNET_TESTBED_Peer;
+
+/**
+ * Opaque handle to an abstract operation to be executed by the testbed framework.
+ */
+struct GNUNET_TESTBED_Operation;
+
+/**
+ * Handle to interact with a GNUnet testbed controller.  Each controller has at
+ * least one master handle which is created when the controller is created; this
+ * master handle interacts with the controller via stdin/stdout of the controller
+ * process.  Additionally, controllers can interact with each other (in a P2P
+ * fashion); those links are established via TCP/IP on the controller's service
+ * port.
+ */
+struct GNUNET_TESTBED_Controller;
+
+/**
+ * Handle to a large-scale testbed that is managed at a high level.
+ */
+struct GNUNET_TESTBED_Testbed;
+
+
+/**
+ * Create a host to run peers and controllers on.
+ * 
+ * @param hostname name of the host, use "NULL" for localhost
+ * @param username username to use for the login; may be NULL
+ * @param port port number to use for ssh; use 0 to let ssh decide
+ * @return handle to the host, NULL on error
+ */
+struct GNUNET_TESTBED_Host *
+GNUNET_TESTBED_host_create (const char *hostname,
+			    const char *username,
+			    uint16_t port);
+
+
+/**
+ * Load a set of hosts from a configuration file.
+ *
+ * @param filename file with the host specification
+ * @param hosts set to the hosts found in the file
+ * @return number of hosts returned in 'hosts', 0 on error
+ */
+unsigned int
+GNUNET_TESTBED_hosts_load_from_file (const char *filename,
+				     struct GNUNET_TESTBED_Host **hosts);
+
+
+/**
+ * Destroy a host handle.  Must only be called once everything
+ * running on that host has been stopped.
+ *
+ * @param host handle to destroy
+ */
+void
+GNUNET_TESTBED_host_destroy (struct GNUNET_TESTBED_Host *host);
+
+
+/**
+ * Enumeration with (at most 64) possible event types that
+ * can be monitored using the testbed framework.
+ */
+enum GNUNET_TESTBED_EventType
+{
+  /**
+   * A peer has been started.
+   */
+  GNUNET_TESTBED_ET_PEER_START = 0,
+
+  /**
+   * A peer has been stopped.
+   */
+  GNUNET_TESTBED_ET_PEER_STOP = 1,
+
+  /**
+   * A connection between two peers was established.
+   */
+  GNUNET_TESTBED_ET_CONNECT = 2,
+
+  /**
+   * A connection between two peers was torn down.
+   */
+  GNUNET_TESTBED_ET_DISCONNECT = 3,
+
+  /**
+   * A requested testbed operation has been completed.
+   */
+  GNUNET_TESTBED_ET_OPERATION_FINISHED = 4,
+
+  /**
+   * The 'GNUNET_TESTBED_run' operation has been completed
+   */
+  GNUNET_TESTBED_ET_TESTBED_ONLINE = 5
+
+};
+
+
+/**
+ * Types of information that can be requested about a peer.
+ */
+enum GNUNET_TESTBED_PeerInformationType
+{
+
+  /**
+   * Special value (not valid for requesting information)
+   * that is used in the event struct if a 'generic' pointer
+   * is returned (for other operations not related to this
+   * enumeration).
+   */
+  GNUNET_TESTBED_PIT_GENERIC = 0,
+
+  /**
+   * What host is the peer running on?  Returns a 'const struct
+   * GNUNET_TESTBED_Host *'.  Valid until
+   * 'GNUNET_TESTBED_operation_done' is called.
+   */
+  GNUNET_TESTBED_PIT_HOST,
+
+  /**
+   * What configuration is the peer using?  Returns a 'const struct
+   * GNUNET_CONFIGURATION_Handle *'.  Valid until
+   * 'GNUNET_TESTNIG_operation_done' is called.  However, the
+   * values may be inaccurate if the peer is reconfigured in
+   * the meantime.
+   */
+  GNUNET_TESTBED_PIT_CONFIGURATION,
+
+  /**
+   * What is the identity of the peer?  Returns a
+   * 'const struct GNUNET_PeerIdentity *'.  Valid until
+   * 'GNUNET_TESTNIG_operation_done' is called.
+   */
+  GNUNET_TESTBED_PIT_IDENTITY
+
+};
+
+
+/**
+ * Argument to GNUNET_TESTBED_ControllerCallback with details about
+ * the event.
+ */
+struct GNUNET_TESTBED_EventInformation
+{
+  
+  /**
+   * Type of the event.
+   */
+  enum GNUNET_TESTBED_EventType type;
+
+  /**
+   * Details about the event.
+   */
+  union
+  {
+    
+    /**
+     * Details about peer start event.
+     */ 
+    struct
+    {
+      /**
+       * Handle for the host where the peer
+       * was started.
+       */
+      struct GNUNET_TESTBED_Host *host;
+
+      /**
+       * Handle for the peer that was started.
+       */
+      struct GNUNET_TESTBED_Peer *peer;
+      
+    } peer_start;
+
+    /**
+     * Details about peer stop event.
+     */ 
+    struct
+    {
+
+      /**
+       * Handle for the peer that was started.
+       */
+      struct GNUNET_TESTBED_Peer *peer;
+      
+    } peer_stop;
+
+    /**
+     * Details about connect event.
+     */ 
+    struct
+    {
+      /**
+       * Handle for one of the connected peers.
+       */
+      struct GNUNET_TESTBED_Peer *peer1;
+
+      /**
+       * Handle for one of the connected peers.
+       */
+      struct GNUNET_TESTBED_Peer *peer2;
+
+    } peer_connect;
+
+    /**
+     * Details about disconnect event.
+     */ 
+    struct
+    {
+      /**
+       * Handle for one of the disconnected peers.
+       */
+      struct GNUNET_TESTBED_Peer *peer1;
+
+      /**
+       * Handle for one of the disconnected peers.
+       */
+      struct GNUNET_TESTBED_Peer *peer2;
+      
+    } peer_disconnect;
+
+    /**
+     * Details about an operation finished event.
+     */ 
+    struct 
+    {
+
+      /**
+       * Handle for the operation that was finished.
+       */
+      struct GNUNET_TESTBED_Operation *operation;
+
+      /**
+       * Closure that was passed in when the event was
+       * requested.
+       */
+      void *op_cls;
+
+      /**
+       * Error message for the operation, NULL on success.
+       */ 
+      const char *emsg;
+
+      /**
+       * Peer information type; captures which of the types
+       * in the 'op_result' is actually in use.
+       */
+      enum GNUNET_TESTBED_PeerInformationType pit;
+
+      /**
+       * Pointer to an operation-specific return value; NULL on error;
+       * can be NULL for certain operations.  Valid until
+       * 'GNUNET_TESTBED_operation_done' is called.
+       */
+      union
+      {
+	/**
+	 * No result (NULL pointer) or generic result
+	 * (whatever the GNUNET_TESTBED_ConnectAdapter returned).
+	 */
+	void *generic;
+
+	/**
+	 * Identity of host running the peer.
+	 */
+	struct GNUNET_TESTBED_Host *host;
+
+	/**
+	 * Identity of the peer.
+	 */
+	const struct GNUNET_PeerIdentity *pid;
+
+	/**
+	 * Configuration of the peer.
+	 */
+	const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+      } op_result;
+
+    } operation_finished;   
+
+
+    /**
+     * Details about an testbed run completed event.
+     */ 
+    struct 
+    {
+
+      /**
+       * Error message for the operation, NULL on success.
+       */ 
+      const char *emsg;
+
+      /**
+       * Array of peers now running (valid until
+       * 'GNUNET_TESTBED_testbed_stop' is called).  Note that it is
+       * not allowed to call 'GNUNET_TESTBED_peer_destroy' on peers
+       * from this array.
+       */
+      struct GNUNET_TESTBED_Peer **peers;
+
+      /**
+       * Size of the 'peers' array.
+       */
+      unsigned int num_peers;
+      
+    } testbed_run_finished;   
+
+  } details;
+
+};
+
+
+/**
+ * Signature of the event handler function called by the
+ * respective event controller.
+ *
+ * @param cls closure
+ * @param event information about the event
+ */
+typedef void (*GNUNET_TESTBED_ControllerCallback)(void *cls,
+						  const struct GNUNET_TESTBED_EventInformation *event);						  
+
+
+/**
+ * Start a controller process using the given configuration at the
+ * given host.
+ *
+ * @param cfg configuration to use
+ * @param host host to run the controller on, NULL for 'localhost'
+ * @param event_mask bit mask with set of events to call 'cc' for;
+ *                   or-ed values of "1LL" shifted by the
+ *                   respective 'enum GNUNET_TESTBED_EventType'
+ *                   (i.e.  "(1LL << GNUNET_TESTBED_ET_CONNECT) | ...")
+ * @param cc controller callback to invoke on events
+ * @param cc_cls closure for cc
+ * @return handle to the controller
+ */
+struct GNUNET_TESTBED_Controller *
+GNUNET_TESTBED_controller_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+				 struct GNUNET_TESTBED_Host *host,
+				 uint64_t event_mask,
+				 GNUNET_TESTBED_ControllerCallback cc,
+				 void *cc_cls);
+
+
+/**
+ * Configure shared services at a controller.  Using this function,
+ * you can specify that certain services (such as "resolver")
+ * should not be run for each peer but instead be shared
+ * across N peers on the specified host.  This function
+ * must be called before any peers are created at the host.
+ * 
+ * @param controller controller to configure
+ * @param service_name name of the service to share
+ * @param num_peers number of peers that should share one instance
+ *        of the specified service (1 for no sharing is the default),
+ *        use 0 to disable the service
+ */
+void
+GNUNET_TESTBED_controller_configure_sharing (struct GNUNET_TESTBED_Controller *controller,
+					     const char *service_name,
+					     uint32_t num_peers);
+
+
+/**
+ * Stop the given controller (also will terminate all peers and
+ * controllers dependent on this controller).  This function 
+ * blocks until the testbed has been fully terminated (!).
+ *
+ * @param controller handle to controller to stop
+ */
+void
+GNUNET_TESTBED_controller_stop (struct GNUNET_TESTBED_Controller *controller);
+
+
+/**
+ * Create a link from a 'master' controller to a slave controller.
+ * Whenever the master controller is asked to start a peer at the
+ * given 'delegated_host', it will delegate the request to the
+ * specified slave controller.  Note that the slave controller runs at
+ * the 'slave_host', which may or may not be the same host as the
+ * 'delegated_host' (for hierarchical delegations).  The configuration
+ * of the slave controller is given and to be used to either create
+ * the slave controller or to connect to an existing slave controller
+ * process.  'is_subordinate' specifies if the given slave controller
+ * should be started and managed by the master controller, or if the
+ * slave already has a master and this is just a secondary master that
+ * is also allowed to use the existing slave.
+ *
+ * @param master handle to the master controller who creates the association
+ * @param delegated_host requests to which host should be delegated
+ * @param slave_host which host is used to run the slave controller 
+ * @param slave_cfg configuration to use for the slave controller
+ * @param is_subordinate GNUNET_YES if the slave should be started (and stopped)
+ *                       by the master controller; GNUNET_NO if we are just
+ *                       allowed to use the slave via TCP/IP
+ */
+void
+GNUNET_TESTBED_controller_link (struct GNUNET_TESTBED_Controller *master,
+				struct GNUNET_TESTBED_Host *delegated_host,
+				struct GNUNET_TESTBED_Host *slave_host,
+				const struct GNUNET_CONFIGURATION_Handle *slave_cfg,
+				int is_subordinate);
+
+
+/**
+ * Create the given peer at the specified host using the given
+ * controller.  If the given controller is not running on the target
+ * host, it should find or create a controller at the target host and
+ * delegate creating the peer.  Explicit delegation paths can be setup
+ * using 'GNUNET_TESTBED_controller_link'.  If no explicit delegation
+ * path exists, a direct link with a subordinate controller is setup
+ * for the first delegated peer to a particular host; the subordinate
+ * controller is then destroyed once the last peer that was delegated
+ * to the remote host is stopped.
+ *
+ * Creating the peer only creates the handle to manipulate and further
+ * configure the peer; use "GNUNET_TESTBED_peer_start" and
+ * "GNUNET_TESTBED_peer_stop" to actually start/stop the peer's
+ * processes.
+ *
+ * Note that the given configuration will be adjusted by the
+ * controller to avoid port/path conflicts with other peers.
+ * The "final" configuration can be obtained using
+ * 'GNUNET_TESTBED_peer_get_information'.
+ *
+ * @param controller controller process to use
+ * @param host host to run the peer on
+ * @param cfg configuration to use for the peer
+ * @return handle to the peer (actual startup will happen asynchronously)
+ */
+struct GNUNET_TESTBED_Peer *
+GNUNET_TESTBED_peer_create (struct GNUNET_TESTBED_Controller *controller,
+			    struct GNUNET_TESTBED_Host *host,
+			    const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Start the given peer.
+ *
+ * @param peer peer to start
+ * @return handle to the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_peer_start (struct GNUNET_TESTBED_Peer *peer);
+
+
+/**
+ * Stop the given peer.  The handle remains valid (use
+ * "GNUNET_TESTBED_peer_destroy" to fully clean up the 
+ * state of the peer).
+ *
+ * @param peer peer to stop
+ * @return handle to the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_peer_stop (struct GNUNET_TESTBED_Peer *peer);
+
+
+/**
+ * Request information about a peer.
+ *
+ * @param peer peer to request information about
+ * @param pit desired information
+ * @return handle to the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_peer_get_information (struct GNUNET_TESTBED_Peer *peer,
+				     enum GNUNET_TESTBED_PeerInformationType pit);
+
+
+/**
+ * Change peer configuration.  Must only be called while the
+ * peer is stopped.  Ports and paths cannot be changed this
+ * way.
+ *
+ * @param peer peer to change configuration for
+ * @param cfg new configuration (differences to existing
+ *            configuration only)
+ * @return handle to the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_peer_update_configuration (struct GNUNET_TESTBED_Peer *peer,
+					  const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Destroy the given peer; the peer should have been
+ * stopped first (if it was started).
+ *
+ * @param peer peer to stop
+ * @return handle to the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_peer_destroy (struct GNUNET_TESTBED_Peer *peer);
+
+
+/**
+ * Options for peer connections.
+ */
+enum GNUNET_TESTBED_ConnectOption
+{
+  /**
+   * No option (not valid as an argument).
+   */
+  GNUNET_TESTBED_CO_NONE = 0,
+  
+  /**
+   * Allow or disallow a connection between the specified peers.  
+   * Followed by GNUNET_NO (int) if a connection is disallowed
+   * or GNUNET_YES if a connection is allowed.  Note that the
+   * default (all connections allowed or disallowed) is
+   * specified in the configuration of the controller.
+   */
+  GNUNET_TESTBED_CO_ALLOW = 1,
+  
+  /**
+   * FIXME: add (and implement) options to limit connection to
+   * particular transports, force simulation of particular latencies
+   * or message loss rates, or set bandwidth limitations.
+   */
+  
+};
+
+
+/**
+ * Manipulate the P2P underlay topology by configuring a link
+ * between two peers.  
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param p1 first peer
+ * @param p2 second peer
+ * @param co option to change
+ * @param ap option-specific values
+ * @return handle to the operation, NULL if configuring the link at this
+ *         time is not allowed
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_underlay_configure_link_va (void *op_cls,
+					   struct GNUNET_TESTBED_Peer *p1,
+					   struct GNUNET_TESTBED_Peer *p2,
+					   enum GNUNET_TESTBED_ConnectOption co,
+					   va_list ap);
+
+
+/**
+ * Manipulate the P2P underlay topology by configuring a link
+ * between two peers.  
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param p1 first peer
+ * @param p2 second peer
+ * @param co option to change
+ * @param ... option-specific values
+ * @return handle to the operation, NULL if configuring the link at this
+ *         time is not allowed
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_underlay_configure_link (void *op_cls,
+					struct GNUNET_TESTBED_Peer *p1,
+					struct GNUNET_TESTBED_Peer *p2,
+					enum GNUNET_TESTBED_ConnectOption co, ...);
+
+
+
+/**
+ * Topologies supported for testbeds.
+ */
+enum GNUNET_TESTBED_TopologyOption
+{
+  /**
+   * A clique (everyone connected to everyone else).  No options.
+   */
+  GNUNET_TESTBED_TOPOLOGY_CLIQUE,
+
+  /**
+   * Small-world network (2d torus plus random links).  Followed
+   * by the number of random links to add (unsigned int).
+   */
+  GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD,
+
+  /**
+   * Small-world network (ring plus random links).  Followed
+   * by the number of random links to add (unsigned int).
+   */
+  GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING,
+
+  /**
+   * Ring topology.  No options.
+   */
+  GNUNET_TESTBED_TOPOLOGY_RING,
+
+  /**
+   * 2-d torus.  No options.
+   */
+  GNUNET_TESTBED_TOPOLOGY_2D_TORUS,
+
+  /**
+   * Random graph.  Followed by the link density, that is the
+   * percentage of links present in relation to a clique
+   * (float).
+   */
+  GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI,
+
+  /**
+   * Certain percentage of peers are unable to communicate directly
+   * replicating NAT conditions.  Followed by the fraction of
+   * NAT'ed peers (float).
+   */
+  GNUNET_TESTBED_TOPOLOGY_INTERNAT,
+
+  /**
+   * Scale free topology.   FIXME: options?
+   */
+  GNUNET_TESTBED_TOPOLOGY_SCALE_FREE,
+
+  /**
+   * Straight line topology.  No options.
+   */
+  GNUNET_TESTBED_TOPOLOGY_LINE,
+
+  /**
+   * All peers are disconnected.  No options.
+   */
+  GNUNET_TESTBED_TOPOLOGY_NONE,
+
+  /**
+   * Read a topology from a given file.  Followed by the name of the file (const char *).
+   */
+  GNUNET_TESTBED_TOPOLOGY_FROM_FILE
+};
+
+
+/**
+ * Configure overall network topology to have a particular shape.
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param num_peers number of peers in 'peers'
+ * @param peers array of 'num_peers' with the peers to configure
+ * @param topo desired underlay topology to use
+ * @param ap topology-specific options
+ * @return handle to the operation, NULL if configuring the topology
+ *         is not allowed at this time
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_underlay_configure_topology_va (void *op_cls,
+					       unsigned int num_peers,
+					       struct GNUNET_TESTBED_Peer **peers,
+					       enum GNUNET_TESTBED_TopologyOption topo,
+					       va_list ap);
+
+
+/**
+ * Configure overall network topology to have a particular shape.
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param num_peers number of peers in 'peers'
+ * @param peers array of 'num_peers' with the peers to configure
+ * @param topo desired underlay topology to use
+ * @param ... topology-specific options
+ * @return handle to the operation, NULL if configuring the topology
+ *         is not allowed at this time
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_underlay_configure_topology (void *op_cls,
+					    unsigned int num_peers,
+					    struct GNUNET_TESTBED_Peer **peers,
+					    enum GNUNET_TESTBED_TopologyOption topo,
+					    ...);
+
+
+/**
+ * Both peers must have been started before calling this function.
+ * This function then obtains a HELLO from 'p1', gives it to 'p2'
+ * and asks 'p2' to connect to 'p1'.
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param p1 first peer
+ * @param p2 second peer
+ * @return handle to the operation, NULL if connecting these two
+ *         peers is fundamentally not possible at this time (peers
+ *         not running or underlay disallows)
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_overlay_connect (void *op_cls,
+				struct GNUNET_TESTBED_Peer *p1,
+				struct GNUNET_TESTBED_Peer *p2);
+
+
+/**
+ * All peers must have been started before calling this function.
+ * This function then connects the given peers in the P2P overlay
+ * using the given topology.
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param num_peers number of peers in 'peers'
+ * @param peers array of 'num_peers' with the peers to configure
+ * @param topo desired underlay topology to use
+ * @param va topology-specific options
+ * @return handle to the operation, NULL if connecting these 
+ *         peers is fundamentally not possible at this time (peers
+ *         not running or underlay disallows)
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_overlay_configure_topology_va (void *op_cls,
+					      unsigned int num_peers,
+					      struct GNUNET_TESTBED_Peer *peers,
+					      enum GNUNET_TESTBED_TopologyOption topo,
+					      va_list va);
+
+
+/**
+ * All peers must have been started before calling this function.
+ * This function then connects the given peers in the P2P overlay
+ * using the given topology.
+ *
+ * @param op_cls closure argument to give with the operation event
+ * @param num_peers number of peers in 'peers'
+ * @param peers array of 'num_peers' with the peers to configure
+ * @param topo desired underlay topology to use
+ * @param ... topology-specific options
+ * @return handle to the operation, NULL if connecting these 
+ *         peers is fundamentally not possible at this time (peers
+ *         not running or underlay disallows)
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_overlay_configure_topology (void *op_cls,
+					   unsigned int num_peers,
+					   struct GNUNET_TESTBED_Peer *peers,
+					   enum GNUNET_TESTBED_TopologyOption topo,
+					   ...);
+
+
+
+/**
+ * Ask the testbed controller to write the current overlay topology to
+ * a file.  Naturally, the file will only contain a snapshot as the
+ * topology may evolve all the time.
+ *
+ * @param controller overlay controller to inspect
+ * @param filename name of the file the topology should
+ *        be written to.
+ */
+void
+GNUNET_TESTBED_overlay_write_topology_to_file (struct GNUNET_TESTBED_Controller *controller,
+					       const char *filename);
+
+
+/**
+ * Adapter function called to establish a connection to
+ * a service.
+ * 
+ * @param cls closure
+ * @param cfg configuration of the peer to connect to
+ * @return service handle to return in 'op_result', NULL on error
+ */
+typedef void * (*GNUNET_TESTBED_ConnectAdapter)(void *cls,
+						const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Adapter function called to destroy a connection to
+ * a service.
+ * 
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+typedef void (*GNUNET_TESTBED_DisconnectAdapter)(void *cls,
+						 void *op_result);
+
+
+/**
+ * Connect to a service offered by the given peer.  Will ensure that
+ * the request is queued to not overwhelm our ability to create and
+ * maintain connections with other systems.  The actual service
+ * handle is then returned via the 'op_result' member in the event
+ * callback.  The 'ca' callback is used to create the connection
+ * when the time is right; the 'da' callback will be used to 
+ * destroy the connection (upon 'GNUNET_TESTBED_operation_done').
+ * 'GNUNET_TESTBED_operation_cancel' can be used to abort this
+ * operation until the event callback has been called.
+ *
+ * @param op_cls closure to pass in operation event
+ * @param peer peer that runs the service
+ * @param service_name name of the service to connect to
+ * @param ca helper function to establish the connection
+ * @param da helper function to close the connection
+ * @param cada_cls closure for ca and da
+ * @return handle for the operation
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_service_connect (void *op_cls,
+				struct GNUNET_TESTBED_Peer *peer,
+				const char *service_name,
+				GNUNET_TESTBED_ConnectAdapter ca,
+				GNUNET_TESTBED_DisconnectAdapter da,
+				void *cada_cls);
+
+
+/**
+ * Cancel a pending operation.  Releases all resources
+ * of the operation and will ensure that no event
+ * is generated for the operation.  Does NOT guarantee
+ * that the operation will be fully undone (or that
+ * nothing ever happened).  
+ * 
+ * @param operation operation to cancel
+ */
+void
+GNUNET_TESTBED_operation_cancel (struct GNUNET_TESTBED_Operation *operation);
+
+
+/**
+ * Signal that the information from an operation has been fully
+ * processed.  This function MUST be called for each event
+ * of type 'operation_finished' to fully remove the operation
+ * from the operation queue.  After calling this function, the
+ * 'op_result' becomes invalid (!).
+ * 
+ * @param operation operation to signal completion for
+ */
+void
+GNUNET_TESTBED_operation_done (struct GNUNET_TESTBED_Operation *operation);
+
+
+/**
+ * Configure and run a testbed using the given
+ * master controller on 'num_hosts' starting
+ * 'num_peers' using the given peer configuration.
+ *
+ * @param controller master controller for the testbed
+ *                   (must not be destroyed until after the
+ *                    testbed is destroyed).
+ * @param num_hosts number of hosts in 'hosts', 0 to only
+ *        use 'localhost'
+ * @param hosts list of hosts to use for the testbed
+ * @param num_peers number of peers to start
+ * @param peer_cfg peer configuration template to use
+ * @param underlay_topology underlay topology to create
+ * @param va topology-specific options
+ * @return handle to the testbed
+ */
+struct GNUNET_TESTBED_Testbed *
+GNUNET_TESTBED_create_va (struct GNUNET_TESTBED_Controller *controller,
+			  unsigned int num_hosts,
+			  struct GNUNET_TESTBED_Host **hosts,
+			  unsigned int num_peers,
+			  const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
+			  enum GNUNET_TESTBED_TopologyOption underlay_topology,
+			  va_list va);
+
+
+/**
+ * Configure and run a testbed using the given
+ * master controller on 'num_hosts' starting
+ * 'num_peers' using the given peer configuration.
+ *
+ * @param controller master controller for the testbed
+ *                   (must not be destroyed until after the
+ *                    testbed is destroyed).
+ * @param num_hosts number of hosts in 'hosts', 0 to only
+ *        use 'localhost'
+ * @param hosts list of hosts to use for the testbed
+ * @param num_peers number of peers to start
+ * @param peer_cfg peer configuration template to use
+ * @param underlay_topology underlay topology to create
+ * @param ... topology-specific options
+ */
+struct GNUNET_TESTBED_Testbed *
+GNUNET_TESTBED_create (struct GNUNET_TESTBED_Controller *controller,
+		       unsigned int num_hosts,
+		       struct GNUNET_TESTBED_Host **hosts,
+		       unsigned int num_peers,
+		       const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
+		       enum GNUNET_TESTBED_TopologyOption underlay_topology,
+		       ...);
+
+
+/**
+ * Destroy a testbed.  Stops all running peers and then
+ * destroys all peers.  Does NOT destroy the master controller.
+ *
+ * @param testbed testbed to destroy
+ */
+void
+GNUNET_TESTBED_destroy (struct GNUNET_TESTBED_Testbed *testbed);
+
+
+/**
+ * Convenience method for running a testbed with
+ * a single call.  Underlay and overlay topology
+ * are configured using the "UNDERLAY" and "OVERLAY"
+ * options in the "[testbed]" section of the configuration\
+ * (with possible options given in "UNDERLAY_XXX" and/or
+ * "OVERLAY_XXX").
+ *
+ * The testbed is to be terminated using a call to
+ * "GNUNET_SCHEDULER_shutdown".
+ *
+ * @param host_filename name of the file with the 'hosts', NULL
+ *        to run everything on 'localhost'
+ * @param cfg configuration to use (for testbed, controller and peers)
+ * @param num_peers number of peers to start; FIXME: maybe put that ALSO into cfg?
+ * @param event_mask bit mask with set of events to call 'cc' for;
+ *                   or-ed values of "1LL" shifted by the
+ *                   respective 'enum GNUNET_TESTBED_EventType'
+ *                   (i.e.  "(1LL << GNUNET_TESTBED_ET_CONNECT) || ...")
+ * @param cc controller callback to invoke on events
+ * @param cc_cls closure for cc
+ * @param master task to run once the testbed is ready
+ * @param master_cls closure for 'task'.
+ */
+void
+GNUNET_TESTBED_run (const char *host_filename,
+		    const struct GNUNET_CONFIGURATION_Handle *cfg,
+		    unsigned int num_peers,
+		    uint64_t event_mask,
+		    GNUNET_TESTBED_ControllerCallback cc,
+		    void *cc_cls,
+		    GNUNET_SCHEDULER_Task master,
+		    void *master_cls);
+
+
+/**
+ * Signature of a main function for a testcase.
+ * 
+ * @param cls closure
+ * @param num_peers number of peers in 'peers'
+ * @param peers handle to peers run in the testbed
+ */
+typedef void (*GNUNET_TESTBED_TestMaster)(void *cls,
+					  unsigned int num_peers,
+					  struct GNUNET_TESTBED_Peer **peers);
+					  
+
+/**
+ * Convenience method for running a "simple" test on the local system
+ * with a single call from 'main'.  Underlay and overlay topology are
+ * configured using the "UNDERLAY" and "OVERLAY" options in the
+ * "[testbed]" section of the configuration (with possible options
+ * given in "UNDERLAY_XXX" and/or "OVERLAY_XXX").
+ *
+ * The test is to be terminated using a call to
+ * "GNUNET_SCHEDULER_shutdown".  If starting the test fails,
+ * the program is stopped without 'master' ever being run.
+ *
+ * NOTE: this function should be called from 'main', NOT from
+ * within a GNUNET_SCHEDULER-loop.  This function will initialze
+ * the scheduler loop, the testbed and then pass control to
+ * 'master'.
+ *
+ * @param testname name of the testcase (to configure logging, etc.)
+ * @param cfg_filename configuration filename to use
+ *              (for testbed, controller and peers)
+ * @param num_peers number of peers to start
+ * @param test_master task to run once the test is ready
+ * @param test_master_cls closure for 'task'.
+ */
+void
+GNUNET_TESTBED_test_run (const char *testname,
+			 const char *cfg_filename,
+			 unsigned int num_peers,
+			 GNUNET_TESTBED_TestMaster test_master,
+			 void *test_master_cls);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/gnunet_testing_lib-new.h b/src/include/gnunet_testing_lib-new.h
new file mode 100644
index 0000000..9b5f4c2
--- /dev/null
+++ b/src/include/gnunet_testing_lib-new.h
@@ -0,0 +1,299 @@
+/*
+      This file is part of GNUnet
+      (C) 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
+
+      GNUnet is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published
+      by the Free Software Foundation; either version 3, or (at your
+      option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with GNUnet; see the file COPYING.  If not, write to the
+      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+      Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * @file include/gnunet_testing_lib-new.h
+ * @brief convenience API for writing testcases for GNUnet;
+ *        can start/stop one or more peers on a system;
+ *        testing is responsible for managing private keys,
+ *        ports and paths; it is a low-level library that
+ *        does not support higher-level functions such as
+ *        P2P connection, topology management or distributed
+ *        testbed maintenance (those are in gnunet_testbed_service.h)
+ * @author Christian Grothoff
+ */
+
+#ifndef GNUNET_TESTING_LIB_NEW_H
+#define GNUNET_TESTING_LIB_NEW_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * Handle for a system on which GNUnet peers are executed;
+ * a system is used for reserving unique paths and ports.
+ */
+struct GNUNET_TESTING_System;
+
+
+/**
+ * Handle for a GNUnet peer controlled by testing.
+ */
+struct GNUNET_TESTING_Peer;
+
+
+/**
+ * Create a system handle.  There must only be one system
+ * handle per operating system.
+ *
+ * @param tmppath prefix path to use for all service homes
+ * @param controller hostname of the controlling host, 
+ *        service configurations are modified to allow 
+ *        control connections from this host; can be NULL
+ * @return handle to this system, NULL on error
+ */
+struct GNUNET_TESTING_System *
+GNUNET_TESTING_system_create (const char *tmppath,
+			      const char *controller);
+
+
+
+/**
+ * Free system resources.
+ *
+ * @param system system to be freed
+ * @param remove_paths should the 'tmppath' and all subdirectories
+ *        be removed (clean up on shutdown)?
+ */
+void
+GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system,
+			       int remove_paths);
+
+
+/**
+ * Testing includes a number of pre-created hostkeys for faster peer
+ * startup. This function loads such keys into memory from a file.
+ *
+ * @param system the testing system handle
+ * @param filename the path of the hostkeys file
+ * @return GNUNET_OK on success; GNUNET_SYSERR on error
+ */
+int
+GNUNET_TESTING_hostkeys_load (struct GNUNET_TESTING_System *system,
+                              const char *filename);
+
+
+/**
+ * Function to remove the loaded hostkeys
+ *
+ * @param system the testing system handle
+ */
+void
+GNUNET_TESTING_hostkeys_unload (struct GNUNET_TESTING_System *system);
+
+
+/**
+ * Testing includes a number of pre-created hostkeys for
+ * faster peer startup.  This function can be used to
+ * access the n-th key of those pre-created hostkeys; note
+ * that these keys are ONLY useful for testing and not
+ * secure as the private keys are part of the public 
+ * GNUnet source code.
+ *
+ * This is primarily a helper function used internally
+ * by 'GNUNET_TESTING_peer_configure'.
+ *
+ * @param system the testing system handle
+ * @param key_number desired pre-created hostkey to obtain
+ * @param id set to the peer's identity (hash of the public
+ *        key; if NULL, GNUNET_SYSERR is returned immediately
+ * @return GNUNET_SYSERR on error (not enough keys)
+ */
+int
+GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system,
+			    uint32_t key_number,
+			    struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Reserve a TCP or UDP port for a peer.
+ *
+ * @param system system to use for reservation tracking
+ * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
+ * @return 0 if no free port was available
+ */
+uint16_t 
+GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system,
+			     int is_tcp);
+
+
+/**
+ * Release reservation of a TCP or UDP port for a peer
+ * (used during GNUNET_TESTING_peer_destroy).
+ *
+ * @param system system to use for reservation tracking
+ * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
+ * @param port reserved port to release
+ */
+void
+GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system,
+			     int is_tcp,
+			     uint16_t port);
+
+
+/**
+ * Create a new configuration using the given configuration
+ * as a template; ports and paths will be modified to select
+ * available ports on the local system.  If we run
+ * out of "*port" numbers, return SYSERR.
+ *
+ * This is primarily a helper function used internally
+ * by 'GNUNET_TESTING_peer_configure'.
+ *
+ * @param system system to use to coordinate resource usage
+ * @param cfg template configuration to update
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error - the configuration will
+ *           be incomplete and should not be used there upon
+ */
+int
+GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system,
+				     struct GNUNET_CONFIGURATION_Handle *cfg);
+// FIXME: add dual to 'release' ports again...
+
+
+/**
+ * Configure a GNUnet peer.  GNUnet must be installed on the local
+ * system and available in the PATH. 
+ *
+ * @param system system to use to coordinate resource usage
+ * @param cfg configuration to use; will be UPDATED (to reflect needed
+ *            changes in port numbers and paths)
+ * @param key_number number of the hostkey to use for the peer
+ * @param id identifier for the daemon, will be set, can be NULL
+ * @param emsg set to error message (set to NULL on success), can be NULL
+ * @return handle to the peer, NULL on error
+ */
+struct GNUNET_TESTING_Peer *
+GNUNET_TESTING_peer_configure (struct GNUNET_TESTING_System *system,
+			       struct GNUNET_CONFIGURATION_Handle *cfg,
+			       uint32_t key_number,
+			       struct GNUNET_PeerIdentity *id,
+			       char **emsg);
+
+
+/**
+ * Start the peer. 
+ *
+ * @param peer peer to start
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)
+ */
+int
+GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer);
+
+
+/**
+ * Stop the peer. 
+ *
+ * @param peer peer to stop
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer not running)
+ */
+int
+GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer);
+
+
+/**
+ * Destroy the peer.  Releases resources locked during peer configuration.
+ * If the peer is still running, it will be stopped AND a warning will be
+ * printed (users of the API should stop the peer explicitly first).
+ *
+ * @param peer peer to destroy
+ */
+void
+GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer);
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ * 
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ */
+typedef void (*GNUNET_TESTING_TestMain)(void *cls,
+					const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Start a single peer and run a test using the testing library.
+ * Starts a peer using the given configuration and then invokes the
+ * given callback.  This function ALSO initializes the scheduler loop
+ * and should thus be called directly from "main".  The testcase
+ * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
+ *
+ * @param tmppath path for storing temporary data for the test
+ * @param cfgfilename name of the configuration file to use;
+ *         use NULL to only run with defaults
+ * @param tm main function of the testcase
+ * @param tm_cls closure for 'tm'
+ * @return 0 on success, 1 on error
+ */
+int
+GNUNET_TESTING_peer_run (const char *tmppath,
+			 const char *cfgfilename,
+			 GNUNET_TESTING_TestMain tm,
+			 void *tm_cls);
+
+
+
+/**
+ * Start a single service (no ARM, except of course if the given
+ * service name is 'arm') and run a test using the testing library.
+ * Starts a service using the given configuration and then invokes the
+ * given callback.  This function ALSO initializes the scheduler loop
+ * and should thus be called directly from "main".  The testcase
+ * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
+ *
+ * This function is useful if the testcase is for a single service
+ * and if that service doesn't itself depend on other services.
+ *
+ * @param tmppath path for storing temporary data for the test
+ * @param service_name name of the service to run
+ * @param cfgfilename name of the configuration file to use;
+ *         use NULL to only run with defaults
+ * @param tm main function of the testcase
+ * @param tm_cls closure for 'tm'
+ * @return 0 on success, 1 on error
+ */
+int
+GNUNET_TESTING_service_run (const char *tmppath,
+			    const char *service_name,
+			    const char *cfgfilename,
+			    GNUNET_TESTING_TestMain tm,
+			    void *tm_cls);
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/gnunet_testing_lib.h b/src/include/gnunet_testing_lib.h
index 03b8376..b170670 100644
--- a/src/include/gnunet_testing_lib.h
+++ b/src/include/gnunet_testing_lib.h
@@ -304,9 +304,34 @@ struct GNUNET_TESTING_Daemon
   void *update_cb_cls;
 
   /**
-   * PID of the process that we started last.
+   * PID of the process we used to run gnunet-arm or SSH to start the peer.
    */
-  struct GNUNET_OS_Process *proc;
+  struct GNUNET_OS_Process *proc_arm_start;
+
+  /**
+   * PID of the process we used to run gnunet-arm or SSH to stop the peer.
+   */
+  struct GNUNET_OS_Process *proc_arm_stop;
+
+  /**
+   * PID of the process we used to run gnunet-arm or SSH to manage services at the peer.
+   */
+  struct GNUNET_OS_Process *proc_arm_srv_start;
+
+  /**
+   * PID of the process we used to run gnunet-arm or SSH to manage services at the peer.
+   */
+  struct GNUNET_OS_Process *proc_arm_srv_stop;
+
+  /**
+   * PID of the process we used to run copy files
+   */
+  struct GNUNET_OS_Process *proc_arm_copying;
+
+  /**
+   * PID of the process we used to run gnunet-peerinfo.
+   */
+  struct GNUNET_OS_Process *proc_arm_peerinfo;
 
   /**
    * Handle to the server.
diff --git a/src/include/gnunet_time_lib.h b/src/include/gnunet_time_lib.h
index 7090c33..35d180c 100644
--- a/src/include/gnunet_time_lib.h
+++ b/src/include/gnunet_time_lib.h
@@ -90,32 +90,32 @@ GNUNET_NETWORK_STRUCT_END
 /**
  * Relative time zero.
  */
-#define GNUNET_TIME_UNIT_ZERO     GNUNET_TIME_relative_get_zero()
+#define GNUNET_TIME_UNIT_ZERO     GNUNET_TIME_relative_get_zero_()
 
 /**
  * Absolute time zero.
  */
-#define GNUNET_TIME_UNIT_ZERO_ABS GNUNET_TIME_absolute_get_zero()
+#define GNUNET_TIME_UNIT_ZERO_ABS GNUNET_TIME_absolute_get_zero_()
 
 /**
  * One millisecond, our basic time unit.
  */
-#define GNUNET_TIME_UNIT_MILLISECONDS GNUNET_TIME_relative_get_unit()
+#define GNUNET_TIME_UNIT_MILLISECONDS GNUNET_TIME_relative_get_unit_()
 
 /**
  * One second.
  */
-#define GNUNET_TIME_UNIT_SECONDS GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1000)
+#define GNUNET_TIME_UNIT_SECONDS GNUNET_TIME_relative_get_second_()
 
 /**
  * One minute.
  */
-#define GNUNET_TIME_UNIT_MINUTES GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define GNUNET_TIME_UNIT_MINUTES GNUNET_TIME_relative_get_minute_()
 
 /**
  * One hour.
  */
-#define GNUNET_TIME_UNIT_HOURS   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 60)
+#define GNUNET_TIME_UNIT_HOURS   GNUNET_TIME_relative_get_hour_()
 
 /**
  * One day.
@@ -141,43 +141,70 @@ GNUNET_NETWORK_STRUCT_END
  * Constant used to specify "forever".  This constant
  * will be treated specially in all time operations.
  */
-#define GNUNET_TIME_UNIT_FOREVER_REL GNUNET_TIME_relative_get_forever ()
+#define GNUNET_TIME_UNIT_FOREVER_REL GNUNET_TIME_relative_get_forever_ ()
 
 /**
  * Constant used to specify "forever".  This constant
  * will be treated specially in all time operations.
  */
-#define GNUNET_TIME_UNIT_FOREVER_ABS GNUNET_TIME_absolute_get_forever ()
+#define GNUNET_TIME_UNIT_FOREVER_ABS GNUNET_TIME_absolute_get_forever_ ()
+
 
 /**
  * Return relative time of 0ms.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_zero (void);
+GNUNET_TIME_relative_get_zero_ (void);
+
 
 /**
  * Return absolute time of 0ms.
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get_zero (void);
+GNUNET_TIME_absolute_get_zero_ (void);
+
 
 /**
  * Return relative time of 1ms.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_unit (void);
+GNUNET_TIME_relative_get_unit_ (void);
+
+
+/**
+ * Return relative time of 1s.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_second_ (void);
+
+
+/**
+ * Return relative time of 1 minute.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_minute_ (void);
+
+
+/**
+ * Return relative time of 1 hour.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_hour_ (void);
+
 
 /**
  * Return "forever".
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_forever (void);
+GNUNET_TIME_relative_get_forever_ (void);
+
 
 /**
  * Return "forever".
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get_forever (void);
+GNUNET_TIME_absolute_get_forever_ (void);
+
 
 /**
  * Get the current time.
@@ -187,6 +214,7 @@ GNUNET_TIME_absolute_get_forever (void);
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_get (void);
 
+
 /**
  * Convert relative time to an absolute time in the
  * future.
@@ -197,6 +225,7 @@ GNUNET_TIME_absolute_get (void);
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel);
 
+
 /**
  * Return the minimum of two relative time values.
  *
@@ -209,6 +238,7 @@ GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2);
 
 
+
 /**
  * Return the maximum of two relative time values.
  *
@@ -220,6 +250,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2);
 
+
 /**
  * Return the minimum of two absolute time values.
  *
@@ -231,6 +262,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2);
 
+
 /**
  * Return the maximum of two absolute time values.
  *
@@ -242,6 +274,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2);
 
+
 /**
  * Given a timestamp in the future, how much time
  * remains until then?
@@ -281,6 +314,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
                                      struct GNUNET_TIME_Absolute end);
 
+
 /**
  * Get the duration of an operation as the
  * difference of the current time and the given start time "hence".
@@ -317,6 +351,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
                                struct GNUNET_TIME_Relative duration);
 
+
 /**
  * Multiply relative time by a given factor.
  *
@@ -328,6 +363,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
                                unsigned int factor);
 
+
 /**
  * Divide relative time by a given factor.
  *
@@ -339,6 +375,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
                              unsigned int factor);
 
+
 /**
  * Add relative times together.
  *
@@ -350,6 +387,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
                           struct GNUNET_TIME_Relative a2);
 
+
 /**
  * Subtract relative timestamp from the other.
  *
@@ -371,6 +409,7 @@ GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
 struct GNUNET_TIME_RelativeNBO
 GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a);
 
+
 /**
  * Convert relative time from network byte order.
  *
@@ -380,6 +419,7 @@ GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a);
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a);
 
+
 /**
  * Convert relative time to network byte order.
  *
@@ -389,6 +429,7 @@ GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a);
 struct GNUNET_TIME_AbsoluteNBO
 GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a);
 
+
 /**
  * Convert relative time from network byte order.
  *
@@ -398,6 +439,7 @@ GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a);
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a);
 
+
 /**
  * Convert a relative time to a string.
  * NOT reentrant!
@@ -409,6 +451,7 @@ GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a);
 const char *
 GNUNET_TIME_relative_to_string (struct GNUNET_TIME_Relative time);
 
+
 /**
  * Set the timestamp offset for this instance.
  *
@@ -417,6 +460,7 @@ GNUNET_TIME_relative_to_string (struct GNUNET_TIME_Relative time);
 void
 GNUNET_TIME_set_offset (long long offset);
 
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_transport_plugin.h b/src/include/gnunet_transport_plugin.h
index 9b39a41..d1e03d7 100644
--- a/src/include/gnunet_transport_plugin.h
+++ b/src/include/gnunet_transport_plugin.h
@@ -136,7 +136,7 @@ typedef struct
  * @param addrlen length of the address
  * @return ATS Information containing the network type
  */
-typedef const struct GNUNET_ATS_Information
+typedef struct GNUNET_ATS_Information
 (*GNUNET_TRANSPORT_AddressToType) (void *cls,
                                    const struct sockaddr *addr,
                                    size_t addrlen);
@@ -218,7 +218,11 @@ struct GNUNET_TRANSPORT_PluginEnvironment
 
   /**
    * Function that should be called by the transport plugin
-   * whenever a message is received.
+   * whenever a message is received.  If this field is "NULL",
+   * the plugin should load in 'stub' mode and NOT fully
+   * initialize and instead only return an API with the 
+   * 'address_pretty_printer', 'address_to_string' and
+   * 'string_to_address' functions.
    */
   GNUNET_TRANSPORT_PluginReceiveCallback receive;
 
@@ -309,11 +313,12 @@ typedef void (*GNUNET_TRANSPORT_TransmitContinuation) (void *cls,
  *         and does NOT mean that the message was not transmitted (DV)
  */
 typedef ssize_t (*GNUNET_TRANSPORT_TransmitFunction) (void *cls,
-    struct Session *session,
-    const char *msgbuf, size_t msgbuf_size,
-    unsigned int priority,
-    struct GNUNET_TIME_Relative to,
-    GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls);
+						      struct Session *session,
+						      const char *msgbuf, size_t msgbuf_size,
+						      unsigned int priority,
+						      struct GNUNET_TIME_Relative to,
+						      GNUNET_TRANSPORT_TransmitContinuation cont,
+						      void *cont_cls);
 
 
 /**
@@ -423,6 +428,24 @@ typedef const char *(*GNUNET_TRANSPORT_AddressToString) (void *cls,
                                                          const void *addr,
                                                          size_t addrlen);
 
+/**
+ * Function called to convert a string address to
+ * a binary address.
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param addr string address
+ * @param addrlen length of the address
+ * @param buf location to store the buffer
+ *        If the function returns GNUNET_SYSERR, its contents are undefined.
+ * @param added length of created address
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+typedef int (*GNUNET_TRANSPORT_StringToAddress) (void *cls,
+                                                 const char *addr,
+                                                 uint16_t addrlen,
+                                                 void **buf,
+                                                 size_t *added);
+
 
 /**
  * Each plugin is required to return a pointer to a struct of this
@@ -477,6 +500,12 @@ struct GNUNET_TRANSPORT_PluginFunctions
   GNUNET_TRANSPORT_AddressToString address_to_string;
 
   /**
+   * Function that will be called to convert a string address
+   * to binary (numeric conversion only).
+   */
+  GNUNET_TRANSPORT_StringToAddress string_to_address;
+
+  /**
    * Function that will be called tell the plugin to create a session
    * object
    */
diff --git a/src/include/gnunet_tun_lib.h b/src/include/gnunet_tun_lib.h
index dac11d6..3bb1ea3 100644
--- a/src/include/gnunet_tun_lib.h
+++ b/src/include/gnunet_tun_lib.h
@@ -119,7 +119,7 @@ struct GNUNET_TUN_IPv4Header
    * Destination of the packet.
    */ 
   struct in_addr destination_address GNUNET_PACKED;
-};
+} GNUNET_GCC_STRUCT_LAYOUT;
 
 
 /**
@@ -163,7 +163,7 @@ struct GNUNET_TUN_IPv6Header
    * Destination of the packet.
    */ 
   struct in6_addr destination_address GNUNET_PACKED;
-};
+} GNUNET_GCC_STRUCT_LAYOUT;
 
 
 /**
@@ -224,7 +224,7 @@ struct GNUNET_TUN_TcpHeader
    * Urgent pointer.
    */
   uint16_t urgent_pointer GNUNET_PACKED;
-};
+} GNUNET_GCC_STRUCT_LAYOUT;
 
 
 /**
diff --git a/src/include/platform.h b/src/include/platform.h
index 7383e48..9a5d164 100644
--- a/src/include/platform.h
+++ b/src/include/platform.h
@@ -241,6 +241,14 @@ atoll (const char *nptr);
 #define O_LARGEFILE 0
 #endif
 
+/**
+ * AI_NUMERICSERV not defined in windows.  Then we just do without.
+ */
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0
+#endif
+
+
 #if defined(__sparc__)
 #define MAKE_UNALIGNED(val) ({ __typeof__((val)) __tmp; memmove(&__tmp, &(val), sizeof((val))); __tmp; })
 #else
diff --git a/src/include/plibc.h b/src/include/plibc.h
index 70cbd9e..1cb84e6 100644
--- a/src/include/plibc.h
+++ b/src/include/plibc.h
@@ -22,7 +22,7 @@
  * @brief PlibC header
  * @attention This file is usually not installed under Unix,
  *            so ship it with your application
- * @version $Revision$
+ * @version $Revision: 84 $
  */
 
 #ifndef _PLIBC_H_
@@ -336,9 +336,13 @@ typedef struct
 #define SetErrnoFromWinError(e) _SetErrnoFromWinError(e, __FILE__, __LINE__)
 
 BOOL _plibc_CreateShortcut(const char *pszSrc, const char *pszDest);
+BOOL _plibc_CreateShortcutW(const wchar_t *pwszSrc, const wchar_t *pwszDest);
 BOOL _plibc_DereferenceShortcut(char *pszShortcut);
+BOOL _plibc_DereferenceShortcutW(wchar_t *pwszShortcut);
 char *plibc_ChooseDir(char *pszTitle, unsigned long ulFlags);
+wchar_t *plibc_ChooseDirW(wchar_t *pwszTitle, unsigned long ulFlags);
 char *plibc_ChooseFile(char *pszTitle, unsigned long ulFlags);
+wchar_t *plibc_ChooseFileW(wchar_t *pwszTitle, unsigned long ulFlags);
 
 long QueryRegistry(HKEY hMainKey, const char *pszKey, const char *pszSubKey,
               char *pszBuffer, long *pdLength);
@@ -376,6 +380,7 @@ const char *inet_ntop(int af, const void *src, char *dst, size_t size);
 struct tm *gmtime_r(const time_t *clock, struct tm *result);
 
 int plibc_init(char *pszOrg, char *pszApp);
+int plibc_init_utf8(char *pszOrg, char *pszApp, int utf8_mode);
 void plibc_shutdown();
 int plibc_initialized();