1 files changed, 51 insertions, 53 deletions

diff --git a/libjack/client.c b/libjack/client.c
index 2be9e63..c585f1b 100644
--- a/libjack/client.c
+++ b/libjack/client.c
@@ -40,6 +40,7 @@
 #include <jack/jack.h>
 #include <jack/jslist.h>
 #include <jack/thread.h>
+#include <jack/uuid.h>
 
 #include "internal.h"
 #include "engine.h"
@@ -436,9 +437,9 @@ jack_client_handle_port_connection (jack_client_t *client, jack_event_t *event)
 	jack_port_t *other = 0;
 	JSList *node;
 	int need_free = FALSE;
-
-	if (client->engine->ports[event->x.self_id].client_id == client->control->id ||
-	    client->engine->ports[event->y.other_id].client_id == client->control->id) {
+        
+	if (jack_uuid_compare (client->engine->ports[event->x.self_id].client_id, client->control->uuid) == 0 ||
+	    jack_uuid_compare (client->engine->ports[event->y.other_id].client_id, client->control->uuid) == 0) {
 
 		/* its one of ours */
 
@@ -516,24 +517,24 @@ jack_client_handle_port_connection (jack_client_t *client, jack_event_t *event)
 int
 jack_client_handle_session_callback (jack_client_t *client, jack_event_t *event)
 {
-	char prefix[32];
+        char uuidstr[37];
 	jack_session_event_t *s_event;
 
 	if (! client->control->session_cbset) {
 		return -1;
 	}
 
-	snprintf( prefix, sizeof(prefix), "%d", client->control->uid );
+        uuid_unparse (client->control->uuid, uuidstr);
 
 	s_event = malloc( sizeof(jack_session_event_t) );
 	s_event->type = event->y.n;
-	s_event->session_dir = strdup( event->x.name );
-	s_event->client_uuid = strdup( prefix );
+	s_event->session_dir = strdup (event->x.name);
+	s_event->client_uuid = strdup (uuidstr);
 	s_event->command_line = NULL;
 	s_event->future = 0;
 
 	client->session_cb_immediate_reply = 0;
-	client->session_cb ( s_event, client->session_cb_arg);
+	client->session_cb (s_event, client->session_cb_arg);
 
 	if (client->session_cb_immediate_reply) {
 		return 2;
@@ -805,7 +806,7 @@ server_event_connect (jack_client_t *client, const char *server_name)
 		return -1;
 	}
 
-	req.client_id = client->control->id;
+	jack_uuid_copy (req.client_id, client->control->uuid);
 
 	if (write (fd, &req, sizeof (req)) != sizeof (req)) {
 		jack_error ("cannot write event connect request to server (%s)",
@@ -1032,10 +1033,13 @@ jack_request_client (ClientType type,
 
 	/* format connection request */
 
-	if( va->sess_uuid )
-		req.uuid = atoi( va->sess_uuid );
-	else
-		req.uuid = 0;
+	if (va->sess_uuid) {
+		if (jack_uuid_parse (va->sess_uuid, req.uuid) != 0) {
+                        goto fail;
+                }
+        } else {
+		jack_uuid_clear (req.uuid);
+        }
 	req.protocol_v = jack_protocol_version;
 	req.load = TRUE;
 	req.type = type;
@@ -1280,11 +1284,6 @@ jack_client_open_aux (const char *client_name,
 	client->deliver_request = oop_client_deliver_request;
 	client->deliver_arg = client;
 
-	if( va.sess_uuid )
-		client->control->uid = atoi( va.sess_uuid );
-	else
-		client->control->uid = 0U;
-
 	if ((ev_fd = server_event_connect (client, va.server_name)) < 0) {
 		goto fail;
 	}
@@ -1470,7 +1469,7 @@ jack_set_freewheel (jack_client_t* client, int onoff)
         VALGRIND_MEMSET (&request, 0, sizeof (request));
 
 	request.type = onoff ? FreeWheel : StopFreeWheel;
-	request.x.client_id = client->control->id;
+	jack_uuid_copy (request.x.client_id, client->control->uuid);
 	return jack_client_deliver_request (client, &request);
 }
 
@@ -1496,7 +1495,7 @@ jack_session_reply (jack_client_t *client, jack_session_event_t *event )
                 VALGRIND_MEMSET (&request, 0, sizeof (request));
 
 		request.type = SessionReply;
-		request.x.client_id = client->control->id;
+		jack_uuid_copy (request.x.client_id, client->control->uuid);
 
 		retval = jack_client_deliver_request(client, &request);
 	}
@@ -1565,7 +1564,8 @@ jack_session_notify (jack_client_t* client, const char *target, jack_session_eve
 	}
 
 	while( 1 ) {
-		jack_client_id_t uid;
+		jack_uuid_t uid;
+
 		if (read (client->request_fd, &uid, sizeof (uid)) != sizeof (uid)) {
 			jack_error ("cannot read result for request type %d from"
 					" server (%s)", request.type, strerror (errno));
@@ -1576,16 +1576,16 @@ jack_session_notify (jack_client_t* client, const char *target, jack_session_eve
 		retval = realloc( retval, (num_replies)*sizeof(jack_session_command_t) );
 		retval[num_replies-1].client_name = malloc (JACK_CLIENT_NAME_SIZE);
 		retval[num_replies-1].command = malloc (JACK_PORT_NAME_SIZE);
-		retval[num_replies-1].uuid = malloc (16);
+		retval[num_replies-1].uuid = malloc (JACK_UUID_STRING_SIZE);
 
 		if ( (retval[num_replies-1].client_name == NULL)
 		   ||(retval[num_replies-1].command     == NULL)
 		   ||(retval[num_replies-1].uuid        == NULL) )
 			   goto out;
 
-		if( uid == 0 )
+		if (jack_uuid_empty (uid)) {
 			break;
-
+                }
 
 		if (read (client->request_fd, (char *)retval[num_replies-1].client_name, JACK_CLIENT_NAME_SIZE) 
 			       	!= JACK_CLIENT_NAME_SIZE) {
@@ -1605,7 +1605,7 @@ jack_session_notify (jack_client_t* client, const char *target, jack_session_eve
 					" server (%s)", request.type, strerror (errno));
 			goto out;
 		}
-		snprintf( (char *)retval[num_replies-1].uuid, 16, "%d", uid );
+                uuid_unparse (uid, (char *)retval[num_replies-1].uuid);
 	}
 	free((char *)retval[num_replies-1].uuid);
 	retval[num_replies-1].uuid = NULL;
@@ -2342,7 +2342,7 @@ jack_activate (jack_client_t *client)
   startit:
 
 	req.type = ActivateClient;
-	req.x.client_id = client->control->id;
+	jack_uuid_copy (req.x.client_id, client->control->uuid);
 
 	return jack_client_deliver_request (client, &req);
 }
@@ -2358,7 +2358,7 @@ jack_deactivate_aux (jack_client_t *client)
 		if (client->control->active) { /* still active? */
                         VALGRIND_MEMSET (&req, 0, sizeof (req));
 			req.type = DeactivateClient;
-			req.x.client_id = client->control->id;
+			jack_uuid_copy (req.x.client_id, client->control->uuid);
 			rc = jack_client_deliver_request (client, &req);
 		}
 	}
@@ -2774,25 +2774,25 @@ jack_on_info_shutdown (jack_client_t *client, void (*function)(jack_status_t, co
 }
 
 char *
-jack_get_client_name_by_uuid( jack_client_t *client, const char *uuid )
+jack_get_client_name_by_uuid (jack_client_t *client, const char *uuid_str)
 { 
 	jack_request_t request;
-	char *end_ptr;
-	jack_client_id_t uuid_int = strtol( uuid, &end_ptr, 10 );
-	if ( *end_ptr != '\0' ) return NULL;
-
+        
         VALGRIND_MEMSET (&request, 0, sizeof (request));
 
+        if (uuid_parse (uuid_str, request.x.client_id) != 0) {
+                return NULL;
+        }
+
 	request.type = GetClientByUUID;
-	request.x.client_id = uuid_int;
-	if( jack_client_deliver_request( client, &request ) )
+	if( jack_client_deliver_request (client, &request)) 
 		return NULL;
 
-	return strdup( request.x.port_info.name );
+	return strdup  (request.x.port_info.name);
 }
 
 char*
-jack_get_uuid_for_client_name ( jack_client_t *client, const char *client_name )
+jack_get_uuid_for_client_name (jack_client_t *client, const char *client_name)
 {
 	jack_request_t request;
 	size_t len = strlen(client_name) + 1;
@@ -2804,40 +2804,38 @@ jack_get_uuid_for_client_name ( jack_client_t *client, const char *client_name )
 	request.type = GetUUIDByClientName;
 	memcpy(request.x.name, client_name, len);
 
-	if( jack_client_deliver_request( client, &request ) )
+	if (jack_client_deliver_request( client, &request)) {
 		return NULL;
+        }
 
-	return strdup( request.x.port_info.name );
+        char buf[37];
+        uuid_unparse (request.x.client_id, buf);
+        return strdup (buf);
 }
 
 char *
-jack_client_get_uuid( jack_client_t *client )
+jack_client_get_uuid (jack_client_t *client)
 { 
-	char retval[16];
-
-	snprintf( retval, sizeof(retval), "%d", client->control->uid );
-
-	return strdup(retval);
+	char retval[37];
+        uuid_unparse (client->control->uuid, retval);
+	return strdup (retval);
 }
 
 int
-jack_reserve_client_name( jack_client_t *client, const char *name, const char *uuid )
+jack_reserve_client_name (jack_client_t *client, const char *name, const char *uuid_str)
 { 
 	jack_request_t request;
-	char *end_ptr;
-	jack_client_id_t uuid_int = strtol( uuid, &end_ptr, 10 );
-
-	if( *end_ptr != '\0' ) {
-		return -1;
-        }
 
         VALGRIND_MEMSET (&request, 0, sizeof (request));
 
 	request.type = ReserveName;
 	snprintf( request.x.reservename.name, sizeof( request.x.reservename.name ),
 			"%s", name );
-	request.x.reservename.uuid = uuid_int;
-	return jack_client_deliver_request( client, &request );
+        if (uuid_parse (uuid_str, request.x.reservename.uuid) != 0) {
+                return NULL;
+        }
+
+	return jack_client_deliver_request (client, &request);
 }
 
 const char **