first pass at working UUID-based clients and ports. many JACK clients work correctly without recompilation

6 files changed, 142 insertions, 120 deletions

diff --git a/jackd/Makefile.am b/jackd/Makefile.am
index e951462..94f521e 100644
--- a/jackd/Makefile.am
+++ b/jackd/Makefile.am
@@ -50,7 +50,7 @@ libjackserver_la_SOURCES = engine.c clientengine.c transengine.c controlapi.c \
         ../libjack/messagebuffer.c ../libjack/pool.c ../libjack/port.c \
         ../libjack/midiport.c ../libjack/ringbuffer.c ../libjack/shm.c \
         ../libjack/thread.c ../libjack/time.c  ../libjack/transclient.c \
-        ../libjack/unlock.c
+        ../libjack/unlock.c ../libjack/uuid.c
 libjackserver_la_LIBADD  = simd.lo @OS_LDFLAGS@ 
 libjackserver_la_LDFLAGS  = -export-dynamic -version-info @JACK_SO_VERSION@
 
diff --git a/jackd/clientengine.c b/jackd/clientengine.c
index 03147b6..45c9f4d 100644
--- a/jackd/clientengine.c
+++ b/jackd/clientengine.c
@@ -28,6 +28,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <signal.h>
+#include <uuid/uuid.h>
 
 #include "internal.h"
 #include "engine.h"
@@ -40,6 +41,8 @@
 #include "clientengine.h"
 #include "transengine.h"
 
+#include <jack/uuid.h>
+
 #include "libjack/local.h"
 
 static void
@@ -162,7 +165,8 @@ void
 jack_remove_client (jack_engine_t *engine, jack_client_internal_t *client)
 {
 	JSList *node;
-	jack_client_id_t finalizer=0;
+	jack_uuid_t finalizer;
+        jack_uuid_clear (finalizer);
 
 	/* caller must write-hold the client lock */
 
@@ -203,10 +207,8 @@ jack_remove_client (jack_engine_t *engine, jack_client_internal_t *client)
 	} 
 
 	for (node = engine->clients; node; node = jack_slist_next (node)) {
-		if (((jack_client_internal_t *) node->data)->control->id
-		    == client->control->id) {
-			engine->clients =
-				jack_slist_remove_link (engine->clients, node);
+		if (jack_uuid_compare (((jack_client_internal_t *) node->data)->control->uuid, client->control->uuid) == 0) {
+			engine->clients = jack_slist_remove_link (engine->clients, node);
 			jack_slist_free_1 (node);
 			break;
 		}
@@ -331,7 +333,7 @@ jack_remove_clients (jack_engine_t* engine, int* exit_freewheeling_when_done)
 		
 		if (client->error) {
 			
-			if (engine->freewheeling && client->control->id == engine->fwclient) {
+			if (engine->freewheeling && jack_uuid_compare (client->control->uuid, engine->fwclient) == 0) {
 				VERBOSE (engine, "freewheeling client has errors");
 				*exit_freewheeling_when_done = 1;
 			}
@@ -404,11 +406,13 @@ jack_client_by_name (jack_engine_t *engine, const char *name)
 	return client;
 }
 
-static jack_client_id_t
-jack_client_id_by_name (jack_engine_t *engine, const char *name)
+static int
+jack_client_id_by_name (jack_engine_t *engine, const char *name, jack_uuid_t id)
 {
-	jack_client_id_t id = 0;	/* NULL client ID */
 	JSList *node;
+        int ret = -1;
+
+        jack_uuid_clear (id);
 
 	jack_rdlock_graph (engine);
 
@@ -418,17 +422,18 @@ jack_client_id_by_name (jack_engine_t *engine, const char *name)
 			    name) == 0) {
 			jack_client_internal_t *client = 
 				(jack_client_internal_t *) node->data;
-			id = client->control->id;
+			jack_uuid_copy (id, client->control->uuid);
+                        ret = 0;
 			break;
 		}
 	}
 
 	jack_unlock_graph (engine);
-	return id;
+        return ret;
 }
 
 jack_client_internal_t *
-jack_client_internal_by_id (jack_engine_t *engine, jack_client_id_t id)
+jack_client_internal_by_id (jack_engine_t *engine, jack_uuid_t id)
 {
 	jack_client_internal_t *client = NULL;
 	JSList *node;
@@ -437,8 +442,7 @@ jack_client_internal_by_id (jack_engine_t *engine, jack_client_id_t id)
 
 	for (node = engine->clients; node; node = jack_slist_next (node)) {
 
-		if (((jack_client_internal_t *) node->data)->control->id
-		    == id) {
+		if (jack_uuid_compare (((jack_client_internal_t *) node->data)->control->uuid, id) == 0) {
 			client = (jack_client_internal_t *) node->data;
 			break;
 		}
@@ -453,8 +457,9 @@ jack_client_name_reserved( jack_engine_t *engine, const char *name )
 	JSList *node;
         for (node = engine->reserved_client_names; node; node = jack_slist_next (node)) {
 		jack_reserved_name_t *reservation = (jack_reserved_name_t *) node->data;
-		if( !strcmp( reservation->name, name ) )
+		if (!strcmp (reservation->name, name)) {
 			return 1;
+                }
 	}
 	return 0;
 }
@@ -532,8 +537,7 @@ jack_client_name_invalid (jack_engine_t *engine, char *name,
 /* Set up the engine's client internal and control structures for both
  * internal and external clients. */
 static jack_client_internal_t *
-jack_setup_client_control (jack_engine_t *engine, int fd,
-			   ClientType type, const char *name, jack_client_id_t uuid)
+jack_setup_client_control (jack_engine_t *engine, int fd, ClientType type, const char *name, jack_uuid_t uuid)
 {
 	jack_client_internal_t *client;
 
@@ -582,8 +586,13 @@ jack_setup_client_control (jack_engine_t *engine, int fd,
 	client->control->active = 0;
 	client->control->dead = FALSE;
 	client->control->timed_out = 0;
-	client->control->id = engine->next_client_id++;
-	client->control->uid = uuid;
+
+        if (jack_uuid_empty (uuid)) {
+                uuid_generate (client->control->uuid);
+        } else {
+                jack_uuid_copy (client->control->uuid, uuid);
+        }
+
 	strcpy ((char *) client->control->name, name);
 	client->subgraph_start_fd = -1;
 	client->subgraph_wait_fd = -1;
@@ -636,38 +645,45 @@ jack_setup_client_control (jack_engine_t *engine, int fd,
 }
 
 static void
-jack_ensure_uuid_unique (jack_engine_t *engine, jack_client_id_t uuid)
+jack_ensure_uuid_unique (jack_engine_t *engine, jack_uuid_t uuid)
 {
 	JSList *node;
+        jack_uuid_t jj;
+
+        if (jack_uuid_empty (uuid)) {
+                return;
+        }
 
 	jack_lock_graph (engine);
 	for (node=engine->clients; node; node=jack_slist_next (node)) {
 		jack_client_internal_t *client = (jack_client_internal_t *) node->data;
-		if (client->control->uid == uuid)
-			client->control->uid = 0;
+		if (jack_uuid_compare (client->control->uuid, uuid) == 0) {
+			jack_uuid_clear (uuid);
+                }
 	}
 	jack_unlock_graph (engine);
 }
 
 /* set up all types of clients */
 static jack_client_internal_t *
-setup_client (jack_engine_t *engine, ClientType type, char *name, jack_client_id_t uuid,
+setup_client (jack_engine_t *engine, ClientType type, char *name,
+              jack_uuid_t uuid,
 	      jack_options_t options, jack_status_t *status, int client_fd,
 	      const char *object_path, const char *object_data)
 {
 	/* called with the request_lock */
 	jack_client_internal_t *client;
+        char bufx[64];
 
 	/* validate client name, generate a unique one if appropriate */
 	if (jack_client_name_invalid (engine, name, options, status))
 		return NULL;
 
-	if (uuid != 0)
-		jack_ensure_uuid_unique (engine, uuid);
+        jack_ensure_uuid_unique (engine, uuid);
 
 	/* create a client struct for this name */
 	if ((client = jack_setup_client_control (engine, client_fd,
-						 type, name, uuid )) == NULL) {
+						 type, name, uuid)) == NULL) {
 		*status |= (JackFailure|JackInitFailure);
 		jack_error ("cannot create new client object");
 		return NULL;
@@ -684,9 +700,11 @@ setup_client (jack_engine_t *engine, ClientType type, char *name, jack_client_id
 		}
 	}
 
+        jack_uuid_unparse (client->control->uuid, bufx);
+                
 	VERBOSE (engine, "new client: %s, id = %" PRIu32
 		 " type %d @ %p fd = %d", 
-		 client->control->name, client->control->id, 
+		 client->control->name, bufx,
 		 type, client->control, client_fd);
 
 	if (jack_client_is_internal(client)) {
@@ -757,11 +775,16 @@ jack_create_driver_client (jack_engine_t *engine, char *name)
 	jack_client_connect_request_t req;
 	jack_status_t status;
 	jack_client_internal_t *client;
+        jack_uuid_t empty_uuid;
+
+        VALGRIND_MEMSET(&empty_uuid, 0, sizeof(empty_uuid));
 
 	snprintf (req.name, sizeof (req.name), "%s", name);
 
+        jack_uuid_clear (empty_uuid);
+
 	pthread_mutex_lock (&engine->request_lock);
-	client = setup_client (engine, ClientDriver, name, 0, JackUseExactName,
+	client = setup_client (engine, ClientDriver, name, empty_uuid, JackUseExactName,
 			       &status, -1, NULL, NULL);
 	pthread_mutex_unlock (&engine->request_lock);
 
@@ -769,7 +792,7 @@ jack_create_driver_client (jack_engine_t *engine, char *name)
 }
 
 static jack_status_t
-handle_unload_client (jack_engine_t *engine, jack_client_id_t id)
+handle_unload_client (jack_engine_t *engine, jack_uuid_t id)
 {
 	/* called *without* the request_lock */
 	jack_client_internal_t *client;
@@ -790,16 +813,16 @@ handle_unload_client (jack_engine_t *engine, jack_client_id_t id)
 }
 
 static char *
-jack_get_reserved_name( jack_engine_t *engine, jack_client_id_t uuid )
+jack_get_reserved_name (jack_engine_t *engine, jack_uuid_t uuid)
 {
 	JSList *node;
         for (node = engine->reserved_client_names; node; node = jack_slist_next (node)) {
 		jack_reserved_name_t *reservation = (jack_reserved_name_t *) node->data;
-		if( reservation->uuid== uuid ) {
-			char *retval = strdup( reservation->name );
-			free( reservation );
+		if (jack_uuid_compare (reservation->uuid, uuid) != 0) {
+			char *retval = strdup (reservation->name);
+			free (reservation);
 			engine->reserved_client_names = 
-				jack_slist_remove( engine->reserved_client_names, reservation );
+				jack_slist_remove (engine->reserved_client_names, reservation);
 			return retval;
 		}
 	}
@@ -816,6 +839,8 @@ jack_client_create (jack_engine_t *engine, int client_fd)
 
 	res.status = 0;
 
+        VALGRIND_MEMSET(&res, 0, sizeof (res));
+
 	nbytes = read (client_fd, &req, sizeof (req));
 
 	if (nbytes == 0) {		/* EOF? */
@@ -841,9 +866,9 @@ jack_client_create (jack_engine_t *engine, int client_fd)
 	if (!req.load) {		/* internal client close? */
 
 		int rc = -1;
-		jack_client_id_t id;
+		jack_uuid_t id;
 
-		if ((id = jack_client_id_by_name(engine, req.name))) {
+		if (jack_client_id_by_name(engine, req.name, id) == 0) {
 			rc = handle_unload_client (engine, id);
 		}
 		
@@ -852,13 +877,14 @@ jack_client_create (jack_engine_t *engine, int client_fd)
 	}
 	
 	pthread_mutex_lock (&engine->request_lock);
-	if( req.uuid ) {
-		char *res_name = jack_get_reserved_name( engine, req.uuid );
-		if( res_name ) {
-			snprintf( req.name, sizeof(req.name), "%s", res_name );
-			free(res_name);
+	if (!jack_uuid_empty (req.uuid)) {
+		char *res_name = jack_get_reserved_name (engine, req.uuid);
+		if (res_name) {
+			snprintf (req.name, sizeof(req.name), "%s", res_name);
+			free (res_name);
 		}
 	}
+
 	client = setup_client (engine, req.type, req.name, req.uuid,
 			       req.options, &res.status, client_fd,
 			       req.object_path, req.object_data);
@@ -912,7 +938,7 @@ jack_client_create (jack_engine_t *engine, int client_fd)
 }
 
 int
-jack_client_activate (jack_engine_t *engine, jack_client_id_t id)
+jack_client_activate (jack_engine_t *engine, jack_uuid_t id)
 {
 	jack_client_internal_t *client;
 	JSList *node;
@@ -920,6 +946,8 @@ jack_client_activate (jack_engine_t *engine, jack_client_id_t id)
 	int i;
 	jack_event_t event;
 
+        VALGRIND_MEMSET(&event, 0, sizeof(event));
+
 	jack_lock_graph (engine);
 
 	if ((client = jack_client_internal_by_id (engine, id)))
@@ -963,7 +991,7 @@ jack_client_activate (jack_engine_t *engine, jack_client_id_t id)
 }	
 
 int
-jack_client_deactivate (jack_engine_t *engine, jack_client_id_t id)
+jack_client_deactivate (jack_engine_t *engine, jack_uuid_t id)
 {
 	JSList *node;
 	int ret = -1;
@@ -974,8 +1002,8 @@ jack_client_deactivate (jack_engine_t *engine, jack_client_id_t id)
 
 		jack_client_internal_t *client =
 			(jack_client_internal_t *) node->data;
-
-		if (client->control->id == id) {
+                
+		if (jack_uuid_compare (client->control->uuid, id) == 0) {
 		        
 	        	JSList *portnode;
 			jack_port_internal_t *port;
@@ -1061,7 +1089,7 @@ jack_intclient_handle_request (jack_engine_t *engine, jack_request_t *req)
 
 	req->status = 0;
 	if ((client = jack_client_by_name (engine, req->x.intclient.name))) {
-		req->x.intclient.id = client->control->id;
+		jack_uuid_copy (req->x.intclient.uuid, client->control->uuid);
 	} else {
 		req->status |= (JackNoSuchClient|JackFailure);
 	}
@@ -1073,22 +1101,26 @@ jack_intclient_load_request (jack_engine_t *engine, jack_request_t *req)
 	/* called with the request_lock */
 	jack_client_internal_t *client;
 	jack_status_t status = 0;
+        jack_uuid_t empty_uuid;
 
 	VERBOSE (engine, "load internal client %s from %s, init `%s', "
 		 "options: 0x%x", req->x.intclient.name,
 		 req->x.intclient.path, req->x.intclient.init,
 		 req->x.intclient.options);
 
-	client = setup_client (engine, ClientInternal, req->x.intclient.name, 0,
+        VALGRIND_MEMSET (&empty_uuid, 0, sizeof (empty_uuid));
+        jack_uuid_clear (empty_uuid);
+
+	client = setup_client (engine, ClientInternal, req->x.intclient.name, empty_uuid,
 			       req->x.intclient.options, &status, -1,
 			       req->x.intclient.path, req->x.intclient.init);
 
 	if (client == NULL) {
 		status |= JackFailure;	/* just making sure */
-		req->x.intclient.id = 0;
+		jack_uuid_clear (req->x.intclient.uuid);
 		VERBOSE (engine, "load failed, status = 0x%x", status);
 	} else {
-		req->x.intclient.id = client->control->id;
+		jack_uuid_copy (req->x.intclient.uuid, client->control->uuid);
 	}
 
 	req->status = status;
@@ -1101,7 +1133,7 @@ jack_intclient_name_request (jack_engine_t *engine, jack_request_t *req)
 
 	jack_rdlock_graph (engine);
 	if ((client = jack_client_internal_by_id (engine,
-						  req->x.intclient.id))) {
+						  req->x.intclient.uuid))) {
 		strncpy ((char *) req->x.intclient.name,
 			 (char *) client->control->name,
 			 sizeof (req->x.intclient.name));
@@ -1118,10 +1150,10 @@ jack_intclient_unload_request (jack_engine_t *engine, jack_request_t *req)
 	/* Called with the request_lock, but we need to call
 	 * handle_unload_client() *without* it. */
 
-	if (req->x.intclient.id) {
+	if (!jack_uuid_empty (req->x.intclient.uuid)) {
+                /* non-empty UUID */
 		pthread_mutex_unlock (&engine->request_lock);
-		req->status =
-			handle_unload_client (engine, req->x.intclient.id);
+		req->status = handle_unload_client (engine, req->x.intclient.uuid);
 		pthread_mutex_lock (&engine->request_lock);
 	} else {
 		VERBOSE (engine, "invalid unload request");
diff --git a/jackd/clientengine.h b/jackd/clientengine.h
index bcda149..a3d6371 100644
--- a/jackd/clientengine.h
+++ b/jackd/clientengine.h
@@ -42,8 +42,8 @@ jack_client_state_name (jack_client_internal_t *client)
 
 #define JACK_ERROR_WITH_SOCKETS 10000000
 
-int	jack_client_activate (jack_engine_t *engine, jack_client_id_t id);
-int	jack_client_deactivate (jack_engine_t *engine, jack_client_id_t id);
+int	jack_client_activate (jack_engine_t *engine, jack_uuid_t id);
+int	jack_client_deactivate (jack_engine_t *engine, jack_uuid_t id);
 int	jack_client_create (jack_engine_t *engine, int client_fd);
 void	jack_client_delete (jack_engine_t *engine,
 			    jack_client_internal_t *client);
diff --git a/jackd/engine.c b/jackd/engine.c
index 2023567..8c4029b 100644
--- a/jackd/engine.c
+++ b/jackd/engine.c
@@ -40,6 +40,7 @@
 #include <limits.h>
 
 #include <jack/thread.h>
+#include <jack/uuid.h>
 
 #include "internal.h"
 #include "engine.h"
@@ -105,14 +106,14 @@ static int  jack_port_disconnect_internal (jack_engine_t *engine,
 					   jack_port_internal_t *src, 
 					   jack_port_internal_t *dst);
 static int  jack_send_connection_notification (jack_engine_t *,
-					       jack_client_id_t,
+					       jack_uuid_t,
 					       jack_port_id_t,
 					       jack_port_id_t, int);
 static void jack_deliver_event_to_all (jack_engine_t *engine,
 				       jack_event_t *event);
 static void jack_notify_all_port_interested_clients (jack_engine_t *engine,
-						     jack_client_id_t exclude_src_id,
-						     jack_client_id_t exclude_dst_id,
+						     jack_uuid_t exclude_src_id,
+						     jack_uuid_t exclude_dst_id,
 						     jack_port_id_t a,
 						     jack_port_id_t b,
 						     int connect);
@@ -124,7 +125,7 @@ static int   jack_run_one_cycle (jack_engine_t *engine, jack_nframes_t nframes,
 static void jack_engine_delay (jack_engine_t *engine,
 			       float delayed_usecs);
 static void jack_engine_driver_exit (jack_engine_t* engine);
-static int  jack_start_freewheeling (jack_engine_t* engine, jack_client_id_t);
+static int  jack_start_freewheeling (jack_engine_t* engine, jack_uuid_t);
 static int jack_client_feeds_transitive (jack_client_internal_t *source,
 					 jack_client_internal_t *dest);
 static int jack_client_sort (jack_client_internal_t *a,
@@ -134,9 +135,9 @@ static void jack_compute_all_port_total_latencies (jack_engine_t *engine);
 static void jack_compute_port_total_latency (jack_engine_t *engine, jack_port_shared_t*);
 static int jack_check_client_status (jack_engine_t* engine);
 static int jack_do_session_notify (jack_engine_t *engine, jack_request_t *req, int reply_fd );
-static void jack_do_get_client_by_uuid ( jack_engine_t *engine, jack_request_t *req);
-static void jack_do_get_uuid_by_client_name ( jack_engine_t *engine, jack_request_t *req);
-static void jack_do_reserve_name ( jack_engine_t *engine, jack_request_t *req);
+static void jack_do_get_client_by_uuid (jack_engine_t *engine, jack_request_t *req);
+static void jack_do_get_uuid_by_client_name (jack_engine_t *engine, jack_request_t *req);
+static void jack_do_reserve_name (jack_engine_t *engine, jack_request_t *req);
 static void jack_do_session_reply (jack_engine_t *engine, jack_request_t *req );
 static void jack_compute_new_latency (jack_engine_t *engine);
 static int jack_do_has_session_cb (jack_engine_t *engine, jack_request_t *req);
@@ -647,7 +648,7 @@ jack_process_external(jack_engine_t *engine, JSList *node)
         
         client = (jack_client_internal_t *) node->data;
         ctl = client->control;
-        
+
         engine->current_client = client;
 
 	// a race exists if we do this after the write(2) 
@@ -1763,7 +1764,6 @@ jack_engine_new (int realtime, int rtpriority, int do_mlock, int do_unlock,
 	engine->timeout_count = 0;
 	engine->problems = 0;
 
-	engine->next_client_id = 1;	/* 0 is a NULL client ID */
 	engine->port_max = port_max;
 	engine->server_thread = 0;
 	engine->rtpriority = rtpriority;
@@ -1773,7 +1773,7 @@ jack_engine_new (int realtime, int rtpriority, int do_mlock, int do_unlock,
 	engine->temporary = temporary;
 	engine->freewheeling = 0;
 	engine->stop_freewheeling = 0;
-	engine->fwclient = 0;
+	jack_uuid_clear (engine->fwclient);
 	engine->feedbackcount = 0;
 	engine->wait_pid = wait_pid;
 	engine->nozombies = nozombies;
@@ -2166,7 +2166,7 @@ jack_drivers_write (jack_engine_t *engine, jack_nframes_t nframes)
 	return engine->driver->write(engine->driver, nframes);
 }
 static int
-jack_start_freewheeling (jack_engine_t* engine, jack_client_id_t client_id)
+jack_start_freewheeling (jack_engine_t* engine, jack_uuid_t client_id)
 {
 	jack_event_t event;
 	jack_client_internal_t *client;
@@ -2192,7 +2192,7 @@ jack_start_freewheeling (jack_engine_t* engine, jack_client_id_t client_id)
 	client = jack_client_internal_by_id (engine, client_id);
 
 	if (client->control->process_cbset || client->control->thread_cb_cbset) {
-		engine->fwclient = client_id;
+		jack_uuid_copy (engine->fwclient, client_id);
 	}
 
 	engine->freewheeling = 1;
@@ -2240,7 +2240,7 @@ jack_stop_freewheeling (jack_engine_t* engine, int engine_exiting)
 	pthread_join (engine->freewheel_thread, &ftstatus);
 	VERBOSE (engine, "freewheel thread has returned");
 
-	engine->fwclient = 0;
+	jack_uuid_clear (engine->fwclient);
 	engine->freewheeling = 0;
 	engine->first_wakeup = 1;
 
@@ -2616,25 +2616,13 @@ jack_deliver_event_to_all (jack_engine_t *engine, jack_event_t *event)
 	jack_unlock_graph (engine);
 }
 
-static jack_client_id_t jack_engine_get_max_uuid( jack_engine_t *engine )
-{
-	JSList *node;
-	jack_client_id_t retval = 0;
-	for (node = engine->clients; node; node = jack_slist_next (node)) {
-		jack_client_internal_t* client = (jack_client_internal_t*) node->data;
-		if( client->control->uid > retval )
-			retval = client->control->uid;
-	}
-	return retval;
-}
-
 static void jack_do_get_client_by_uuid ( jack_engine_t *engine, jack_request_t *req)
 {
 	JSList *node;
 	req->status = -1;
 	for (node = engine->clients; node; node = jack_slist_next (node)) {
 		jack_client_internal_t* client = (jack_client_internal_t*) node->data;
-		if( client->control->uid == req->x.client_id ) {
+		if (jack_uuid_compare (client->control->uuid, req->x.client_id) == 0) {
 			snprintf( req->x.port_info.name, sizeof(req->x.port_info.name), "%s", client->control->name );
 			req->status = 0;
 			return;
@@ -2642,21 +2630,21 @@ static void jack_do_get_client_by_uuid ( jack_engine_t *engine, jack_request_t *
 	}
 }
 
-static void jack_do_get_uuid_by_client_name ( jack_engine_t *engine, jack_request_t *req)
+static void jack_do_get_uuid_by_client_name (jack_engine_t *engine, jack_request_t *req)
 {
 	JSList *node;
 	req->status = -1;
 	for (node = engine->clients; node; node = jack_slist_next (node)) {
 		jack_client_internal_t* client = (jack_client_internal_t*) node->data;
-		if( strcmp( client->control->name, req->x.name ) == 0 ) {
-			snprintf( req->x.port_info.name, sizeof(req->x.port_info.name), "%d", client->control->uid );
+		if (strcmp (client->control->name, req->x.name) == 0) {
+                        jack_uuid_copy (req->x.client_id, client->control->uuid);
 			req->status = 0;
 			return;
 		}
 	}
 }
 
-static void jack_do_reserve_name ( jack_engine_t *engine, jack_request_t *req)
+static void jack_do_reserve_name (jack_engine_t *engine, jack_request_t *req)
 {
 	jack_reserved_name_t *reservation;
 	JSList *node;
@@ -2669,23 +2657,23 @@ static void jack_do_reserve_name ( jack_engine_t *engine, jack_request_t *req)
 		}
 	}
 
-	reservation = malloc( sizeof( jack_reserved_name_t ) );
-	if( reservation == NULL ) {
+	reservation = malloc (sizeof (jack_reserved_name_t));
+	if (reservation == NULL) {
 		req->status = -1;
 		return;
 	}
 
-	snprintf( reservation->name, sizeof( reservation->name ), "%s", req->x.reservename.name );
-	reservation->uuid = req->x.reservename.uuid;
-	engine->reserved_client_names = jack_slist_append( engine->reserved_client_names, reservation );
+	snprintf (reservation->name, sizeof (reservation->name), "%s", req->x.reservename.name);
+	jack_uuid_copy (reservation->uuid, req->x.reservename.uuid);
+	engine->reserved_client_names = jack_slist_append (engine->reserved_client_names, reservation);
 
 	req->status = 0;
 }
 
 static int jack_send_session_reply ( jack_engine_t *engine, jack_client_internal_t *client )
 {
-	if (write (engine->session_reply_fd, (const void *) &client->control->uid, sizeof (client->control->uid))
-	    < (ssize_t) sizeof (client->control->uid)) {
+	if (write (engine->session_reply_fd, (const void *) &client->control->uuid, sizeof (client->control->uuid))
+	    < (ssize_t) sizeof (client->control->uuid)) {
 		jack_error ("cannot write SessionNotify result " 
 			    "to client via fd = %d (%s)", 
 			    engine->session_reply_fd, strerror (errno));
@@ -2725,9 +2713,11 @@ jack_do_session_notify (jack_engine_t *engine, jack_request_t *req, int reply_fd
 	jack_event_t event;
   
 	int reply;
-	jack_client_id_t finalizer=0;
+	jack_uuid_t finalizer;
         struct stat sbuf;
 
+        jack_uuid_clear (finalizer);
+
 	if (engine->session_reply_fd != -1) {
 		// we should have a notion of busy or somthing.
 		// just sending empty reply now.
@@ -2743,14 +2733,6 @@ jack_do_session_notify (jack_engine_t *engine, jack_request_t *req, int reply_fd
 	/* GRAPH MUST BE LOCKED : see callers of jack_send_connection_notification() 
 	 */
 
-	// make sure all uuids are set.
-	for (node = engine->clients; node; node = jack_slist_next (node)) {
-		jack_client_internal_t* client = (jack_client_internal_t*) node->data;
-		if( client->control->uid == 0 ) {
-			client->control->uid=jack_engine_get_max_uuid( engine ) + 1;
-		}
-	}
-
         if (stat (req->x.session.path, &sbuf) != 0 || !S_ISDIR (sbuf.st_mode)) {
                 jack_error ("session parent directory (%s) does not exist", req->x.session.path);
                 goto send_final;
@@ -2827,9 +2809,13 @@ out:
 
 static void jack_do_session_reply (jack_engine_t *engine, jack_request_t *req )
 {
-	jack_client_id_t client_id = req->x.client_id;
-	jack_client_internal_t *client = jack_client_internal_by_id (engine, client_id);
-	jack_client_id_t finalizer=0;
+	jack_uuid_t client_id;
+	jack_client_internal_t *client;
+	jack_uuid_t finalizer;
+
+        jack_uuid_copy (client_id, req->x.client_id);
+        client = jack_client_internal_by_id (engine, client_id);
+        jack_uuid_clear (finalizer);
 
 	req->status = 0;
 
@@ -2862,7 +2848,7 @@ static void jack_do_session_reply (jack_engine_t *engine, jack_request_t *req )
 }
 
 static void
-jack_notify_all_port_interested_clients (jack_engine_t *engine, jack_client_id_t src, jack_client_id_t dst, jack_port_id_t a, jack_port_id_t b, int connected)
+jack_notify_all_port_interested_clients (jack_engine_t *engine, jack_uuid_t src, jack_uuid_t dst, jack_port_id_t a, jack_port_id_t b, int connected)
 {
 	JSList *node;
 	jack_event_t event;
@@ -3112,6 +3098,8 @@ jack_rechain_graph (jack_engine_t *engine)
 	jack_event_t event;
 	int upstream_is_jackd;
 
+        VALGRIND_MEMSET(&event, 0, sizeof (event));
+
 	jack_clear_fifos (engine);
 
 	subgraph_client = 0;
@@ -3422,6 +3410,8 @@ jack_compute_new_latency (jack_engine_t *engine)
 	event.type = LatencyCallback;
 	event.x.n  = 0;
 
+        VALGRIND_MEMSET (&event, 0, sizeof (event));
+
 	/* iterate over all clients in graph order, and emit
 	 * capture latency callback.
 	 * also builds up list in reverse graph order.
@@ -4358,7 +4348,7 @@ fallback:
 
 next:
 	shared->ptype_id = engine->control->port_types[i].ptype_id;
-	shared->client_id = req->x.port_info.client_id;
+	jack_uuid_copy (shared->client_id, req->x.port_info.client_id);
 	shared->flags = req->x.port_info.flags;
 	shared->latency = 0;
 	shared->capture_latency.min = shared->capture_latency.max = 0;
@@ -4653,7 +4643,7 @@ jack_get_port_by_name (jack_engine_t *engine, const char *name)
 
 static int
 jack_send_connection_notification (jack_engine_t *engine,
-				   jack_client_id_t client_id, 
+				   jack_uuid_t client_id, 
 				   jack_port_id_t self_id,
 				   jack_port_id_t other_id, int connected)
 
@@ -4661,6 +4651,8 @@ jack_send_connection_notification (jack_engine_t *engine,
 	jack_client_internal_t *client;
  	jack_event_t event;
  
+        VALGRIND_MEMSET(&event, 0, sizeof(event));
+
 	if ((client = jack_client_internal_by_id (engine, client_id)) == NULL) {
 		jack_error ("no such client %" PRIu32
 			    " during connection notification", client_id);
diff --git a/jackd/transengine.c b/jackd/transengine.c
index 331f1fc..8c84639 100644
--- a/jackd/transengine.c
+++ b/jackd/transengine.c
@@ -52,8 +52,7 @@ jack_sync_poll_new (jack_engine_t *engine, jack_client_internal_t *client)
 		VERBOSE (engine, "force transport state to Starting");
 	}
 
-	VERBOSE (engine, "polling sync client %" PRIu32,
-		 client->control->id);
+	VERBOSE (engine, "polling sync client %s", client->control->name);
 }
 
 /* stop polling a specific slow-sync client
@@ -67,8 +66,7 @@ jack_sync_poll_deactivate (jack_engine_t *engine,
 		client->control->sync_poll = 0;
 		client->control->sync_new = 0;
 		engine->control->sync_remain--;
-		VERBOSE (engine, "sync poll interrupted for client %"
-			 PRIu32, client->control->id);
+		VERBOSE (engine, "sync poll interrupted for client %s", client->control->name);
 	}
 	client->control->active_slowsync = 0;
 	engine->control->sync_clients--;
@@ -169,7 +167,7 @@ jack_set_sample_rate (jack_engine_t *engine, jack_nframes_t nframes)
 
 /* on ResetTimeBaseClient request */
 int
-jack_timebase_reset (jack_engine_t *engine, jack_client_id_t client_id)
+jack_timebase_reset (jack_engine_t *engine, jack_uuid_t client_id)
 {
 	int ret;
 	struct _jack_client_internal *client;
@@ -197,7 +195,7 @@ jack_timebase_reset (jack_engine_t *engine, jack_client_id_t client_id)
 /* on SetTimeBaseClient request */
 int
 jack_timebase_set (jack_engine_t *engine,
-		   jack_client_id_t client_id, int conditional)
+		   jack_uuid_t client_id, int conditional)
 {
 	int ret = 0;
 	struct _jack_client_internal *client;
@@ -339,7 +337,7 @@ jack_transport_client_new (jack_client_internal_t *client)
 /* on ResetSyncClient request */
 int
 jack_transport_client_reset_sync (jack_engine_t *engine,
-				  jack_client_id_t client_id)
+				  jack_uuid_t client_id)
 {
 	int ret;
 	jack_client_internal_t *client;
@@ -364,7 +362,7 @@ jack_transport_client_reset_sync (jack_engine_t *engine,
 /* on SetSyncClient request */
 int
 jack_transport_client_set_sync (jack_engine_t *engine,
-				jack_client_id_t client_id)
+				jack_uuid_t client_id)
 {
 	int ret;
 	jack_client_internal_t *client;
diff --git a/jackd/transengine.h b/jackd/transengine.h
index 9bd238d..b433c47 100644
--- a/jackd/transengine.h
+++ b/jackd/transengine.h
@@ -20,9 +20,9 @@
 
 int	jack_set_sample_rate (jack_engine_t *engine, jack_nframes_t nframes);
 int	jack_timebase_reset (jack_engine_t *engine,
-			     jack_client_id_t client_id);
+			     jack_uuid_t client_id);
 int	jack_timebase_set (jack_engine_t *engine,
-			   jack_client_id_t client_id, int conditional);
+			   jack_uuid_t client_id, int conditional);
 void	jack_transport_activate (jack_engine_t *engine,
 				 jack_client_internal_t *client);
 void	jack_transport_init (jack_engine_t *engine);
@@ -30,9 +30,9 @@ void	jack_transport_client_exit (jack_engine_t *engine,
 				    jack_client_internal_t *client);
 void	jack_transport_client_new (jack_client_internal_t *client);
 int	jack_transport_client_reset_sync (jack_engine_t *engine,
-					  jack_client_id_t client_id);
+					  jack_uuid_t client_id);
 int	jack_transport_client_set_sync (jack_engine_t *engine,
-					jack_client_id_t client_id);
+					jack_uuid_t client_id);
 void	jack_transport_cycle_end (jack_engine_t *engine);
 void	jack_transport_cycle_start(jack_engine_t *engine, jack_time_t time);
 int	jack_transport_set_sync_timeout (jack_engine_t *engine,