Automatic server launch and client renaming in progress

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@1506 0c269be4-1314-0410-8aa9-9f06e86f4224

common/JackAPI.cpp

@@ -1507,7 +1507,7 @@ static void start_server_aux(const char *server_name)
 		command[result] = '\0';
 	}
 
-	argv = (char **) malloc (255);
+	argv = (char **)malloc(255);
   
 	while (1) {
 		/* insert -T and -nserver_name in front of arguments */
@@ -1517,8 +1517,8 @@ static void start_server_aux(const char *server_name)
 			if (server_name) {
 				size_t optlen = strlen ("-n");
 				char* buf = (char*)malloc(optlen + strlen (server_name) + 1);
-				strcpy (buf, "-n");
-				strcpy (buf+optlen, server_name);
+				strcpy(buf, "-n");
+				strcpy(buf+optlen, server_name);
 				argv[i++] = buf;
 			}
 		}
@@ -1538,7 +1538,7 @@ static void start_server_aux(const char *server_name)
 
 	/* If execv() succeeds, it does not return. There's no point
 	 * in calling jack_error() here in the child process. */
-	perror("exec of JACK server failed");
+	fprintf(stderr, "exec of JACK server (command = \"%s\") failed: %s\n", command, strerror(errno));
 }
 
 static int start_server(const char *server_name, jack_options_t options)

common/JackChannel.h

@@ -48,7 +48,7 @@ class JackClientChannelInterface
         {}
 
         // Open the Server/Client connection
-        virtual int Open(const char* name, JackClient* obj)
+        virtual int Open(const char* name, JackClient* obj, jack_options_t options,  jack_status_t* status)
         {
             return 0;
         }
@@ -66,7 +66,9 @@ class JackClientChannelInterface
         // Stop listening for messages from the server
         virtual void Stop()
         {}
-
+		
+		virtual void ClientCheck(const char* name, char* name_res, int options, int* status, int* result)
+        {}
         virtual void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
         {}
         virtual void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)

common/JackClient.h

@@ -98,7 +98,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         JackClient(JackSynchro** table);
         virtual ~JackClient();
 
-        virtual int Open(const char* name) = 0;
+        virtual int Open(const char* name, jack_options_t options, jack_status_t* status) = 0;
         virtual int Close();
 
         virtual JackGraphManager* GetGraphManager() const = 0;

common/JackDebugClient.cpp

@@ -74,9 +74,9 @@ JackDebugClient::~JackDebugClient()
     delete fClient;
 }
 
-int JackDebugClient::Open(const char* name)
+int JackDebugClient::Open(const char* name, jack_options_t options, jack_status_t* status)
 {
-    int res = fClient->Open(name);
+    int res = fClient->Open(name, options, status);
     char provstr[256];
     char buffer[256];
     time_t curtime;

common/JackDebugClient.h

@@ -64,10 +64,10 @@ class JackDebugClient : public JackClient
 
     public:
 
-        JackDebugClient(JackClient *fTheClient);
+        JackDebugClient(JackClient* fTheClient);
         virtual ~JackDebugClient();
 
-        virtual int Open(const char* name);
+        virtual int Open(const char* name, jack_options_t options, jack_status_t* status);
         int Close();
 
         virtual JackGraphManager* GetGraphManager() const;

common/JackInternalClient.cpp

@@ -65,11 +65,14 @@ JackInternalClient::~JackInternalClient()
     delete fChannel;
 }
 
-int JackInternalClient::Open(const char* name)
+int JackInternalClient::Open(const char* name, jack_options_t options, jack_status_t* status)
 {
     int result;
     JackLog("JackInternalClient::Open name = %s\n", name);
     strcpy(fClientControl->fName, name);
+	
+	// TODO
+	// check client name
 
     // Require new client
     fChannel->ClientOpen(name, &fClientControl->fRefNum, &fEngineControl, &fGraphManager, this, &result);

common/JackInternalClient.h

@@ -45,7 +45,7 @@ class JackInternalClient : public JackClient
         JackInternalClient(JackServer* server, JackSynchro** table);
         virtual ~JackInternalClient();
 
-        int Open(const char* name);
+        int Open(const char* name, jack_options_t options, jack_status_t* status);
 
         JackGraphManager* GetGraphManager() const;
         JackEngineControl* GetEngineControl() const;

common/JackLibAPI.cpp

@@ -93,13 +93,13 @@ static jack_client_t* jack_client_open_aux(const char* client_name, jack_options
     JackClient* client = new JackLibClient(GetSynchroTable());
 #endif
 
-    int res = client->Open(client_name);
+    int res = client->Open(client_name, options, status);
     if (res < 0) {
         delete client;
         JackLibGlobals::Destroy(); // jack library destruction
         return NULL;
     } else {
-        *status = (jack_status_t)0;
+        *status = (jack_status_t)0;	 // TO REMOVE
         return (jack_client_t*)client;
     }
 }

common/JackLibClient.cpp

@@ -61,13 +61,13 @@ JackLibClient::~JackLibClient()
     delete fChannel;
 }
 
-int JackLibClient::Open(const char* name)
+int JackLibClient::Open(const char* name, jack_options_t options, jack_status_t* status)
 {
     int shared_engine, shared_client, shared_graph, result;
     JackLog("JackLibClient::Open %s\n", name);
 
     // Open server/client channel
-    if (fChannel->Open(name, this) < 0) {
+    if (fChannel->Open(name, this, options, status) < 0) {
         jack_error("Cannot connect to the server");
         goto error;
     }

common/JackLibClient.h

@@ -44,7 +44,7 @@ class JackLibClient : public JackClient
         JackLibClient(JackSynchro** table);
         virtual ~JackLibClient();
 
-        int Open(const char* name);
+        int Open(const char* name, jack_options_t options, jack_status_t* status);
 
         int ClientNotifyImp(int refnum, const char* name, int notify, int sync, int value);
 

common/JackServerAPI.cpp

@@ -66,7 +66,7 @@ extern "C"
 
 using namespace Jack;
 
-EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name)
+EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name, jack_options_t options, jack_status_t* status)
 {
     JackLog("jack_internal_client_new %s", client_name);
     if (client_name == NULL) {
@@ -79,7 +79,7 @@ EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name)
     JackClient* client = new JackInternalClient(JackServer::fInstance, GetSynchroTable()); // To improve...
 #endif
 
-    int res = client->Open(client_name);
+    int res = client->Open(client_name, options, status);
     if (res < 0) {
         delete client;
         return NULL;
@@ -147,13 +147,12 @@ EXPORT jack_client_t* jack_client_open(const char* client_name, jack_options_t o
     JackClient* client = new JackInternalClient(JackServer::fInstance, GetSynchroTable()); // To improve...
 #endif
 
-    int res = client->Open(client_name);
+    int res = client->Open(client_name, options, status);
     if (res < 0) {
         delete client;
         JackServerGlobals::Destroy(); // jack server destruction
         return NULL;
     } else {
-        *status = (jack_status_t)0;
         return (jack_client_t*)client;
     }
 }

common/JackSocketClientChannel.cpp

@@ -38,7 +38,7 @@ JackSocketClientChannel::~JackSocketClientChannel()
     delete fNotificationSocket;
 }
 
-int JackSocketClientChannel::Open(const char* name, JackClient* obj)
+int JackSocketClientChannel::Open(const char* name, JackClient* obj, jack_options_t options, jack_status_t* status)
 {
     JackLog("JackSocketClientChannel::Open name = %s\n", name);
 
@@ -113,6 +113,11 @@ void JackSocketClientChannel::ServerAsyncCall(JackRequest* req, JackResult* res,
     }
 }
 
+void JackSocketClientChannel::ClientCheck(const char* name,  char* name_res, int options, int* status, int* result)
+{
+
+}
+
 void JackSocketClientChannel::ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     JackClientOpenRequest req(name);

common/JackSocketClientChannel.h

@@ -51,12 +51,13 @@ class JackSocketClientChannel : public JackClientChannelInterface, public JackRu
         JackSocketClientChannel();
         virtual ~JackSocketClientChannel();
 
-        int Open(const char* name, JackClient* obj);
+        int Open(const char* name, JackClient* obj, jack_options_t options, jack_status_t* status);
         void Close();
 
         int Start();
         void Stop();
 
+		void ClientCheck(const char* name, char* name_res, int options, int* status, int* result);
         void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result);
         void ClientClose(int refnum, int* result);
 

macosx/JackMacEngineRPC.cpp

@@ -31,6 +31,14 @@ using namespace Jack;
 
 #define rpc_type kern_return_t // for astyle
 
+rpc_type server_rpc_jack_client_check(mach_port_t private_port, client_name_t name, client_name_t name_res, int options, int* status, int* result)
+{
+    JackLog("rpc_jack_client_check\n");
+    // TODO
+    *result = 0;
+    return KERN_SUCCESS;
+}
+
 rpc_type server_rpc_jack_client_open(mach_port_t server_port, client_name_t name, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     JackLog("rpc_jack_client_new %s\n", name);

macosx/JackMachClientChannel.cpp

@@ -41,7 +41,7 @@ JackMachClientChannel::~JackMachClientChannel()
 
 // Server <===> client
 
-int JackMachClientChannel::Open(const char* name, JackClient* client)
+int JackMachClientChannel::Open(const char* name, JackClient* client, jack_options_t options, jack_status_t* status)
 {
     JackLog("JackMachClientChannel::Open name = %s\n", name);
 
@@ -50,9 +50,18 @@ int JackMachClientChannel::Open(const char* name, JackClient* client)
         jack_error("Cannot connect to server Mach port");
         return -1;
     }
+	
+	// Check name in server
+	int result = 0;
+	char name_res[JACK_CLIENT_NAME_SIZE]; 
+	ClientCheck(name, name_res, (int)options, (int*)status, &result);
+    if (result < 0) {
+        jack_error("Cannot check clientname");
+		return -1;
+    }
 
     // Prepare local port using client name
-    char buf[256];
+    char buf[JACK_CLIENT_NAME_SIZE];
     snprintf(buf, sizeof(buf) - 1, "%s:%s", jack_client_entry, name);
 
     if (!fClientPort.AllocatePort(buf, 16)) {
@@ -95,6 +104,15 @@ void JackMachClientChannel::Stop()
     fThread->Kill();
 }
 
+void JackMachClientChannel::ClientCheck(const char* name, char* name_res, int options, int* status, int* result)
+{
+	kern_return_t res = rpc_jack_client_check(fPrivatePort, (char*)name, name_res, options, status, result);
+    if (res != KERN_SUCCESS) {
+        *result = -1;
+        jack_error("JackMachClientChannel::ClientCheck err = %s", mach_error_string(res));
+    }
+}
+
 void JackMachClientChannel::ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     kern_return_t res = rpc_jack_client_open(fServerPort.GetPort(), (char*)name, &fPrivatePort, shared_engine, shared_client, shared_graph, result);

macosx/JackMachClientChannel.h

@@ -48,13 +48,14 @@ class JackMachClientChannel : public JackClientChannelInterface, public JackRunn
         JackMachClientChannel();
         virtual ~JackMachClientChannel();
 
-        int Open(const char* name, JackClient* client);
+        int Open(const char* name, JackClient* client, jack_options_t options, jack_status_t* status);
         void Close();
 
         int Start();
         void Stop();
 
-        void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+        void ClientCheck(const char* name,  char* name_res, int options, int* status, int* result);
+		void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result);
         void ClientClose(int refnum, int* result);
 
         void ClientActivate(int refnum, int* result);

macosx/Jackdmp.xcodeproj/project.pbxproj

@@ -447,7 +447,7 @@
 		4B56881008B5C8620022B32D /* JackFifo.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackFifo.h; path = ../common/JackFifo.h; sourceTree = SOURCE_ROOT; };
 		4B60CE480AAABA31004956AA /* connect.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = connect.c; path = "../example-clients/connect.c"; sourceTree = SOURCE_ROOT; };
 		4B66A8580934964500A89560 /* JackConstants.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackConstants.h; path = ../common/JackConstants.h; sourceTree = SOURCE_ROOT; };
-		4B699BB1097D421600A18468 /* jackdmp */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jackdmp; sourceTree = BUILT_PRODUCTS_DIR; };
+		4B699BB1097D421600A18468 /* jackdmp */ = {isa = PBXFileReference; includeInIndex = 0; lastKnownFileType = "compiled.mach-o.executable"; path = jackdmp; sourceTree = BUILT_PRODUCTS_DIR; };
 		4B699C47097D421600A18468 /* Jackmp.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Jackmp.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		4B699CAC097D421600A18468 /* Jackdmp.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Jackdmp.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		4B699CBB097D421600A18468 /* jack_metro */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_metro; sourceTree = BUILT_PRODUCTS_DIR; };

macosx/RPC/JackRPCClientServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Tue Jan 30 00:00:51 2007
+ * stub generated Wed Aug 15 17:00:32 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */

macosx/RPC/JackRPCClientUser.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Tue Jan 30 00:00:51 2007
+ * stub generated Wed Aug 15 17:00:32 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */

macosx/RPC/JackRPCEngine.defs

@@ -37,6 +37,14 @@ routine rpc_jack_client_open(
 	out shared_graph : int;
 	out result : int);
 
+routine rpc_jack_client_check(
+	server_port	: mach_port_t;
+	client_name	: client_name_t;
+	out client_name_res	: client_name_t;
+	options		: int;
+	out status	: int;
+	out result : int);
+
 routine  rpc_jack_client_close(
 	server_port	: mach_port_t;
 	refnum		: int;

macosx/RPC/JackRPCEngine.h

@@ -26,7 +26,7 @@ typedef function_table_entry 	*function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	JackRPCEngine_MSG_COUNT
-#define	JackRPCEngine_MSG_COUNT	15
+#define	JackRPCEngine_MSG_COUNT	16
 #endif	/* JackRPCEngine_MSG_COUNT */
 
 #include <mach/std_types.h>
@@ -60,6 +60,22 @@ kern_return_t rpc_jack_client_open
 	int *result
 );
 
+/* Routine rpc_jack_client_check */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t rpc_jack_client_check
+(
+	mach_port_t server_port,
+	client_name_t client_name,
+	client_name_t client_name_res,
+	int options,
+	int *status,
+	int *result
+);
+
 /* Routine rpc_jack_client_close */
 #ifdef	mig_external
 mig_external
@@ -288,6 +304,19 @@ __END_DECLS
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		client_name_t client_name;
+		int options;
+	} __Request__rpc_jack_client_check_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -478,6 +507,7 @@ __END_DECLS
 #define __RequestUnion__JackRPCEngine_subsystem__defined
 union __RequestUnion__JackRPCEngine_subsystem {
 	__Request__rpc_jack_client_open_t Request_rpc_jack_client_open;
+	__Request__rpc_jack_client_check_t Request_rpc_jack_client_check;
 	__Request__rpc_jack_client_close_t Request_rpc_jack_client_close;
 	__Request__rpc_jack_client_activate_t Request_rpc_jack_client_activate;
 	__Request__rpc_jack_client_deactivate_t Request_rpc_jack_client_deactivate;
@@ -518,6 +548,21 @@ union __RequestUnion__JackRPCEngine_subsystem {
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		client_name_t client_name_res;
+		int status;
+		int result;
+	} __Reply__rpc_jack_client_check_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -707,6 +752,7 @@ union __RequestUnion__JackRPCEngine_subsystem {
 #define __ReplyUnion__JackRPCEngine_subsystem__defined
 union __ReplyUnion__JackRPCEngine_subsystem {
 	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
+	__Reply__rpc_jack_client_check_t Reply_rpc_jack_client_check;
 	__Reply__rpc_jack_client_close_t Reply_rpc_jack_client_close;
 	__Reply__rpc_jack_client_activate_t Reply_rpc_jack_client_activate;
 	__Reply__rpc_jack_client_deactivate_t Reply_rpc_jack_client_deactivate;
@@ -727,20 +773,21 @@ union __ReplyUnion__JackRPCEngine_subsystem {
 #ifndef subsystem_to_name_map_JackRPCEngine
 #define subsystem_to_name_map_JackRPCEngine \
     { "rpc_jack_client_open", 1000 },\
-    { "rpc_jack_client_close", 1001 },\
-    { "rpc_jack_client_activate", 1002 },\
-    { "rpc_jack_client_deactivate", 1003 },\
-    { "rpc_jack_port_register", 1004 },\
-    { "rpc_jack_port_unregister", 1005 },\
-    { "rpc_jack_port_connect", 1006 },\
-    { "rpc_jack_port_disconnect", 1007 },\
-    { "rpc_jack_port_connect_name", 1008 },\
-    { "rpc_jack_port_disconnect_name", 1009 },\
-    { "rpc_jack_set_buffer_size", 1010 },\
-    { "rpc_jack_set_freewheel", 1011 },\
-    { "rpc_jack_release_timebase", 1012 },\
-    { "rpc_jack_set_timebase_callback", 1013 },\
-    { "rpc_jack_client_rt_notify", 1014 }
+    { "rpc_jack_client_check", 1001 },\
+    { "rpc_jack_client_close", 1002 },\
+    { "rpc_jack_client_activate", 1003 },\
+    { "rpc_jack_client_deactivate", 1004 },\
+    { "rpc_jack_port_register", 1005 },\
+    { "rpc_jack_port_unregister", 1006 },\
+    { "rpc_jack_port_connect", 1007 },\
+    { "rpc_jack_port_disconnect", 1008 },\
+    { "rpc_jack_port_connect_name", 1009 },\
+    { "rpc_jack_port_disconnect_name", 1010 },\
+    { "rpc_jack_set_buffer_size", 1011 },\
+    { "rpc_jack_set_freewheel", 1012 },\
+    { "rpc_jack_release_timebase", 1013 },\
+    { "rpc_jack_set_timebase_callback", 1014 },\
+    { "rpc_jack_client_rt_notify", 1015 }
 #endif
 
 #ifdef __AfterMigUserHeader

macosx/RPC/JackRPCEngineServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Tue Jan 30 00:00:52 2007
+ * stub generated Wed Aug 15 17:00:32 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */
@@ -116,6 +116,19 @@
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		client_name_t client_name;
+		int options;
+	} __Request__rpc_jack_client_check_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -324,6 +337,21 @@
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		client_name_t client_name_res;
+		int status;
+		int result;
+	} __Reply__rpc_jack_client_check_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -514,6 +542,7 @@
 #define __ReplyUnion__server_JackRPCEngine_subsystem__defined
 union __ReplyUnion__server_JackRPCEngine_subsystem {
 	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
+	__Reply__rpc_jack_client_check_t Reply_rpc_jack_client_check;
 	__Reply__rpc_jack_client_close_t Reply_rpc_jack_client_close;
 	__Reply__rpc_jack_client_activate_t Reply_rpc_jack_client_activate;
 	__Reply__rpc_jack_client_deactivate_t Reply_rpc_jack_client_deactivate;
@@ -536,6 +565,9 @@ union __ReplyUnion__server_JackRPCEngine_subsystem {
 mig_internal novalue _Xrpc_jack_client_open
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
 
+mig_internal novalue _Xrpc_jack_client_check
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+
 mig_internal novalue _Xrpc_jack_client_close
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
 
@@ -778,6 +810,256 @@ mig_internal novalue _Xrpc_jack_client_open
 	__AfterRcvRpc(1000, "rpc_jack_client_open")
 }
 
+#if (__MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Request__JackRPCEngine_subsystem__
+#if !defined(__MIG_check__Request__rpc_jack_client_check_t__defined)
+#define __MIG_check__Request__rpc_jack_client_check_t__defined
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__int_rep__string__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__int_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined */
+
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined */
+
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__char_rep__string__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__char_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined */
+
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined */
+
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__float_rep__string__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+	__NDR_convert__float_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined */
+
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined */
+
+
+mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_check_t(__Request__rpc_jack_client_check_t *In0P)
+{
+
+	typedef __Request__rpc_jack_client_check_t __Request;
+#if	__MigTypeCheck
+	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+	defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined */
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+	defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined)
+	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined */
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+	defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined)
+	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined */
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Request__rpc_jack_client_check_t__defined) */
+#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine rpc_jack_client_check */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t server_rpc_jack_client_check
+(
+	mach_port_t server_port,
+	client_name_t client_name,
+	client_name_t client_name_res,
+	int options,
+	int *status,
+	int *result
+);
+
+/* Routine rpc_jack_client_check */
+mig_internal novalue _Xrpc_jack_client_check
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+{
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		client_name_t client_name;
+		int options;
+		mach_msg_trailer_t trailer;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	typedef __Request__rpc_jack_client_check_t __Request;
+	typedef __Reply__rpc_jack_client_check_t Reply;
+
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	Request *In0P = (Request *) InHeadP;
+	Reply *OutP = (Reply *) OutHeadP;
+#ifdef	__MIG_check__Request__rpc_jack_client_check_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Request__rpc_jack_client_check_t__defined */
+
+	__DeclareRcvRpc(1001, "rpc_jack_client_check")
+	__BeforeRcvRpc(1001, "rpc_jack_client_check")
+
+#if	defined(__MIG_check__Request__rpc_jack_client_check_t__defined)
+	check_result = __MIG_check__Request__rpc_jack_client_check_t((__Request *)In0P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ MIG_RETURN_ERROR(OutP, check_result); }
+#endif	/* defined(__MIG_check__Request__rpc_jack_client_check_t__defined) */
+
+	OutP->RetCode = server_rpc_jack_client_check(In0P->Head.msgh_request_port, In0P->client_name, OutP->client_name_res, In0P->options, &OutP->status, &OutP->result);
+	if (OutP->RetCode != KERN_SUCCESS) {
+		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+	}
+
+	OutP->NDR = NDR_record;
+
+
+	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+	__AfterRcvRpc(1001, "rpc_jack_client_check")
+}
+
 #if (__MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Request__JackRPCEngine_subsystem__
 #if !defined(__MIG_check__Request__rpc_jack_client_close_t__defined)
@@ -931,8 +1213,8 @@ mig_internal novalue _Xrpc_jack_client_close
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_client_close_t__defined */
 
-	__DeclareRcvRpc(1001, "rpc_jack_client_close")
-	__BeforeRcvRpc(1001, "rpc_jack_client_close")
+	__DeclareRcvRpc(1002, "rpc_jack_client_close")
+	__BeforeRcvRpc(1002, "rpc_jack_client_close")
 
 #if	defined(__MIG_check__Request__rpc_jack_client_close_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_client_close_t((__Request *)In0P);
@@ -949,7 +1231,7 @@ mig_internal novalue _Xrpc_jack_client_close
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1001, "rpc_jack_client_close")
+	__AfterRcvRpc(1002, "rpc_jack_client_close")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -1105,8 +1387,8 @@ mig_internal novalue _Xrpc_jack_client_activate
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_client_activate_t__defined */
 
-	__DeclareRcvRpc(1002, "rpc_jack_client_activate")
-	__BeforeRcvRpc(1002, "rpc_jack_client_activate")
+	__DeclareRcvRpc(1003, "rpc_jack_client_activate")
+	__BeforeRcvRpc(1003, "rpc_jack_client_activate")
 
 #if	defined(__MIG_check__Request__rpc_jack_client_activate_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_client_activate_t((__Request *)In0P);
@@ -1123,7 +1405,7 @@ mig_internal novalue _Xrpc_jack_client_activate
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1002, "rpc_jack_client_activate")
+	__AfterRcvRpc(1003, "rpc_jack_client_activate")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -1279,8 +1561,8 @@ mig_internal novalue _Xrpc_jack_client_deactivate
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_client_deactivate_t__defined */
 
-	__DeclareRcvRpc(1003, "rpc_jack_client_deactivate")
-	__BeforeRcvRpc(1003, "rpc_jack_client_deactivate")
+	__DeclareRcvRpc(1004, "rpc_jack_client_deactivate")
+	__BeforeRcvRpc(1004, "rpc_jack_client_deactivate")
 
 #if	defined(__MIG_check__Request__rpc_jack_client_deactivate_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_client_deactivate_t((__Request *)In0P);
@@ -1297,7 +1579,7 @@ mig_internal novalue _Xrpc_jack_client_deactivate
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1003, "rpc_jack_client_deactivate")
+	__AfterRcvRpc(1004, "rpc_jack_client_deactivate")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -1676,8 +1958,8 @@ mig_internal novalue _Xrpc_jack_port_register
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_register_t__defined */
 
-	__DeclareRcvRpc(1004, "rpc_jack_port_register")
-	__BeforeRcvRpc(1004, "rpc_jack_port_register")
+	__DeclareRcvRpc(1005, "rpc_jack_port_register")
+	__BeforeRcvRpc(1005, "rpc_jack_port_register")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_register_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_register_t((__Request *)In0P);
@@ -1694,7 +1976,7 @@ mig_internal novalue _Xrpc_jack_port_register
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1004, "rpc_jack_port_register")
+	__AfterRcvRpc(1005, "rpc_jack_port_register")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -1924,8 +2206,8 @@ mig_internal novalue _Xrpc_jack_port_unregister
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_unregister_t__defined */
 
-	__DeclareRcvRpc(1005, "rpc_jack_port_unregister")
-	__BeforeRcvRpc(1005, "rpc_jack_port_unregister")
+	__DeclareRcvRpc(1006, "rpc_jack_port_unregister")
+	__BeforeRcvRpc(1006, "rpc_jack_port_unregister")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_unregister_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_unregister_t((__Request *)In0P);
@@ -1942,7 +2224,7 @@ mig_internal novalue _Xrpc_jack_port_unregister
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1005, "rpc_jack_port_unregister")
+	__AfterRcvRpc(1006, "rpc_jack_port_unregister")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -2246,8 +2528,8 @@ mig_internal novalue _Xrpc_jack_port_connect
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_connect_t__defined */
 
-	__DeclareRcvRpc(1006, "rpc_jack_port_connect")
-	__BeforeRcvRpc(1006, "rpc_jack_port_connect")
+	__DeclareRcvRpc(1007, "rpc_jack_port_connect")
+	__BeforeRcvRpc(1007, "rpc_jack_port_connect")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_connect_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_connect_t((__Request *)In0P);
@@ -2264,7 +2546,7 @@ mig_internal novalue _Xrpc_jack_port_connect
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1006, "rpc_jack_port_connect")
+	__AfterRcvRpc(1007, "rpc_jack_port_connect")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -2568,8 +2850,8 @@ mig_internal novalue _Xrpc_jack_port_disconnect
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_disconnect_t__defined */
 
-	__DeclareRcvRpc(1007, "rpc_jack_port_disconnect")
-	__BeforeRcvRpc(1007, "rpc_jack_port_disconnect")
+	__DeclareRcvRpc(1008, "rpc_jack_port_disconnect")
+	__BeforeRcvRpc(1008, "rpc_jack_port_disconnect")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_disconnect_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_disconnect_t((__Request *)In0P);
@@ -2586,7 +2868,7 @@ mig_internal novalue _Xrpc_jack_port_disconnect
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1007, "rpc_jack_port_disconnect")
+	__AfterRcvRpc(1008, "rpc_jack_port_disconnect")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -2890,8 +3172,8 @@ mig_internal novalue _Xrpc_jack_port_connect_name
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_connect_name_t__defined */
 
-	__DeclareRcvRpc(1008, "rpc_jack_port_connect_name")
-	__BeforeRcvRpc(1008, "rpc_jack_port_connect_name")
+	__DeclareRcvRpc(1009, "rpc_jack_port_connect_name")
+	__BeforeRcvRpc(1009, "rpc_jack_port_connect_name")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_connect_name_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_connect_name_t((__Request *)In0P);
@@ -2908,7 +3190,7 @@ mig_internal novalue _Xrpc_jack_port_connect_name
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1008, "rpc_jack_port_connect_name")
+	__AfterRcvRpc(1009, "rpc_jack_port_connect_name")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -3212,8 +3494,8 @@ mig_internal novalue _Xrpc_jack_port_disconnect_name
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_port_disconnect_name_t__defined */
 
-	__DeclareRcvRpc(1009, "rpc_jack_port_disconnect_name")
-	__BeforeRcvRpc(1009, "rpc_jack_port_disconnect_name")
+	__DeclareRcvRpc(1010, "rpc_jack_port_disconnect_name")
+	__BeforeRcvRpc(1010, "rpc_jack_port_disconnect_name")
 
 #if	defined(__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_port_disconnect_name_t((__Request *)In0P);
@@ -3230,7 +3512,7 @@ mig_internal novalue _Xrpc_jack_port_disconnect_name
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1009, "rpc_jack_port_disconnect_name")
+	__AfterRcvRpc(1010, "rpc_jack_port_disconnect_name")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -3386,8 +3668,8 @@ mig_internal novalue _Xrpc_jack_set_buffer_size
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_buffer_size_t__defined */
 
-	__DeclareRcvRpc(1010, "rpc_jack_set_buffer_size")
-	__BeforeRcvRpc(1010, "rpc_jack_set_buffer_size")
+	__DeclareRcvRpc(1011, "rpc_jack_set_buffer_size")
+	__BeforeRcvRpc(1011, "rpc_jack_set_buffer_size")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_buffer_size_t((__Request *)In0P);
@@ -3404,7 +3686,7 @@ mig_internal novalue _Xrpc_jack_set_buffer_size
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1010, "rpc_jack_set_buffer_size")
+	__AfterRcvRpc(1011, "rpc_jack_set_buffer_size")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -3560,8 +3842,8 @@ mig_internal novalue _Xrpc_jack_set_freewheel
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_freewheel_t__defined */
 
-	__DeclareRcvRpc(1011, "rpc_jack_set_freewheel")
-	__BeforeRcvRpc(1011, "rpc_jack_set_freewheel")
+	__DeclareRcvRpc(1012, "rpc_jack_set_freewheel")
+	__BeforeRcvRpc(1012, "rpc_jack_set_freewheel")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_freewheel_t((__Request *)In0P);
@@ -3578,7 +3860,7 @@ mig_internal novalue _Xrpc_jack_set_freewheel
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1011, "rpc_jack_set_freewheel")
+	__AfterRcvRpc(1012, "rpc_jack_set_freewheel")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -3734,8 +4016,8 @@ mig_internal novalue _Xrpc_jack_release_timebase
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_release_timebase_t__defined */
 
-	__DeclareRcvRpc(1012, "rpc_jack_release_timebase")
-	__BeforeRcvRpc(1012, "rpc_jack_release_timebase")
+	__DeclareRcvRpc(1013, "rpc_jack_release_timebase")
+	__BeforeRcvRpc(1013, "rpc_jack_release_timebase")
 
 #if	defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_release_timebase_t((__Request *)In0P);
@@ -3752,7 +4034,7 @@ mig_internal novalue _Xrpc_jack_release_timebase
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1012, "rpc_jack_release_timebase")
+	__AfterRcvRpc(1013, "rpc_jack_release_timebase")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -3982,8 +4264,8 @@ mig_internal novalue _Xrpc_jack_set_timebase_callback
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_timebase_callback_t__defined */
 
-	__DeclareRcvRpc(1013, "rpc_jack_set_timebase_callback")
-	__BeforeRcvRpc(1013, "rpc_jack_set_timebase_callback")
+	__DeclareRcvRpc(1014, "rpc_jack_set_timebase_callback")
+	__BeforeRcvRpc(1014, "rpc_jack_set_timebase_callback")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_timebase_callback_t((__Request *)In0P);
@@ -4000,7 +4282,7 @@ mig_internal novalue _Xrpc_jack_set_timebase_callback
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1013, "rpc_jack_set_timebase_callback")
+	__AfterRcvRpc(1014, "rpc_jack_set_timebase_callback")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -4303,8 +4585,8 @@ mig_internal novalue _Xrpc_jack_client_rt_notify
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_client_rt_notify_t__defined */
 
-	__DeclareRcvSimple(1014, "rpc_jack_client_rt_notify")
-	__BeforeRcvSimple(1014, "rpc_jack_client_rt_notify")
+	__DeclareRcvSimple(1015, "rpc_jack_client_rt_notify")
+	__BeforeRcvSimple(1015, "rpc_jack_client_rt_notify")
 
 #if	defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_client_rt_notify_t((__Request *)In0P);
@@ -4313,7 +4595,7 @@ mig_internal novalue _Xrpc_jack_client_rt_notify
 #endif	/* defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) */
 
 	OutP->RetCode = server_rpc_jack_client_rt_notify(In0P->Head.msgh_request_port, In0P->refnum, In0P->notify, In0P->value);
-	__AfterRcvSimple(1014, "rpc_jack_client_rt_notify")
+	__AfterRcvSimple(1015, "rpc_jack_client_rt_notify")
 }
 
 
@@ -4333,16 +4615,18 @@ const struct server_JackRPCEngine_subsystem {
 	unsigned int	maxsize;	/* Max msg size */
 	vm_address_t	reserved;	/* Reserved */
 	struct routine_descriptor	/*Array of routine descriptors */
-		routine[15];
+		routine[16];
 } server_JackRPCEngine_subsystem = {
 	JackRPCEngine_server_routine,
 	1000,
-	1015,
+	1016,
 	(mach_msg_size_t)sizeof(union __ReplyUnion__server_JackRPCEngine_subsystem),
 	(vm_address_t)0,
 	{
           { (mig_impl_routine_t) 0,
             (mig_stub_routine_t) _Xrpc_jack_client_open, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_open_t)},
+          { (mig_impl_routine_t) 0,
+            (mig_stub_routine_t) _Xrpc_jack_client_check, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_check_t)},
           { (mig_impl_routine_t) 0,
             (mig_stub_routine_t) _Xrpc_jack_client_close, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_close_t)},
           { (mig_impl_routine_t) 0,
@@ -4394,7 +4678,7 @@ mig_external boolean_t JackRPCEngine_server
 	OutHeadP->msgh_local_port = MACH_PORT_NULL;
 	OutHeadP->msgh_id = InHeadP->msgh_id + 100;
 
-	if ((InHeadP->msgh_id > 1014) || (InHeadP->msgh_id < 1000) ||
+	if ((InHeadP->msgh_id > 1015) || (InHeadP->msgh_id < 1000) ||
 	    ((routine = server_JackRPCEngine_subsystem.routine[InHeadP->msgh_id - 1000].stub_routine) == 0)) {
 		((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
 		((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
@@ -4411,7 +4695,7 @@ mig_external mig_routine_t JackRPCEngine_server_routine
 
 	msgh_id = InHeadP->msgh_id - 1000;
 
-	if ((msgh_id > 14) || (msgh_id < 0))
+	if ((msgh_id > 15) || (msgh_id < 0))
 		return 0;
 
 	return server_JackRPCEngine_subsystem.routine[msgh_id].stub_routine;

macosx/RPC/JackRPCEngineUser.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Tue Jan 30 00:00:52 2007
+ * stub generated Wed Aug 15 17:00:32 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */
@@ -597,6 +597,425 @@ mig_external kern_return_t rpc_jack_client_open
     }
 }
 
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Reply__JackRPCEngine_subsystem__
+#if !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
+#define __MIG_check__Reply__rpc_jack_client_check_t__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
+	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
+
+
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__int_rep__string__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__int_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+
+
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
+
+
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
+
+
+
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__char_rep__string__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__char_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+
+
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
+
+
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
+
+
+
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+#elif	defined(__NDR_convert__float_rep__string__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+	__NDR_convert__float_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+
+
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
+
+
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
+
+
+
+mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_check_t(__Reply__rpc_jack_client_check_t *Out0P)
+{
+
+	typedef __Reply__rpc_jack_client_check_t __Reply;
+#if	__MigTypeCheck
+	unsigned int msgh_size;
+#endif	/* __MigTypeCheck */
+	if (Out0P->Head.msgh_id != 1101) {
+	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+		{ return MIG_SERVER_DIED; }
+	    else
+		{ return MIG_REPLY_MISMATCH; }
+	}
+
+#if	__MigTypeCheck
+	msgh_size = Out0P->Head.msgh_size;
+
+	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+	      Out0P->RetCode == KERN_SUCCESS)))
+		{ return MIG_TYPE_ERROR ; }
+#endif	/* __MigTypeCheck */
+
+	if (Out0P->RetCode != KERN_SUCCESS) {
+#ifdef	__NDR_convert__mig_reply_error_t__defined
+		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+#endif	/* __NDR_convert__mig_reply_error_t__defined */
+		return ((mig_reply_error_t *)Out0P)->RetCode;
+	}
+
+#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
+	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	0 || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
+	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	0 || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
+	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
+#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine rpc_jack_client_check */
+mig_external kern_return_t rpc_jack_client_check
+(
+	mach_port_t server_port,
+	client_name_t client_name,
+	client_name_t client_name_res,
+	int options,
+	int *status,
+	int *result
+)
+{
+    {
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		client_name_t client_name;
+		int options;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		client_name_t client_name_res;
+		int status;
+		int result;
+		mach_msg_trailer_t trailer;
+	} Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		client_name_t client_name_res;
+		int status;
+		int result;
+	} __Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	union {
+		Request In;
+		Reply Out;
+	} Mess;
+
+	Request *InP = &Mess.In;
+	Reply *Out0P = &Mess.Out;
+
+	mach_msg_return_t msg_result;
+
+#ifdef	__MIG_check__Reply__rpc_jack_client_check_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Reply__rpc_jack_client_check_t__defined */
+
+	__DeclareSendRpc(1001, "rpc_jack_client_check")
+
+	InP->NDR = NDR_record;
+
+	(void) mig_strncpy(InP->client_name, client_name, 128);
+
+	InP->options = options;
+
+	InP->Head.msgh_bits =
+		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+	/* msgh_size passed as argument */
+	InP->Head.msgh_request_port = server_port;
+	InP->Head.msgh_reply_port = mig_get_reply_port();
+	InP->Head.msgh_id = 1001;
+
+	__BeforeSendRpc(1001, "rpc_jack_client_check")
+	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+	__AfterSendRpc(1001, "rpc_jack_client_check")
+	if (msg_result != MACH_MSG_SUCCESS) {
+		__MachMsgErrorWithoutTimeout(msg_result);
+		{ return msg_result; }
+	}
+
+
+#if	defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
+	check_result = __MIG_check__Reply__rpc_jack_client_check_t((__Reply__rpc_jack_client_check_t *)Out0P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ return check_result; }
+#endif	/* defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
+
+	(void) mig_strncpy(client_name_res, Out0P->client_name_res, 128);
+
+	*status = Out0P->status;
+
+	*result = Out0P->result;
+
+	return KERN_SUCCESS;
+    }
+}
+
 #if ( __MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Reply__JackRPCEngine_subsystem__
 #if !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)
@@ -687,7 +1106,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_close_t(__Reply__
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1101) {
+	if (Out0P->Head.msgh_id != 1102) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -818,7 +1237,7 @@ mig_external kern_return_t rpc_jack_client_close
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_client_close_t__defined */
 
-	__DeclareSendRpc(1001, "rpc_jack_client_close")
+	__DeclareSendRpc(1002, "rpc_jack_client_close")
 
 	InP->NDR = NDR_record;
 
@@ -829,11 +1248,11 @@ mig_external kern_return_t rpc_jack_client_close
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1001;
+	InP->Head.msgh_id = 1002;
 
-	__BeforeSendRpc(1001, "rpc_jack_client_close")
+	__BeforeSendRpc(1002, "rpc_jack_client_close")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1001, "rpc_jack_client_close")
+	__AfterSendRpc(1002, "rpc_jack_client_close")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -942,7 +1361,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_activate_t(__Repl
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1102) {
+	if (Out0P->Head.msgh_id != 1103) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -1073,7 +1492,7 @@ mig_external kern_return_t rpc_jack_client_activate
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_client_activate_t__defined */
 
-	__DeclareSendRpc(1002, "rpc_jack_client_activate")
+	__DeclareSendRpc(1003, "rpc_jack_client_activate")
 
 	InP->NDR = NDR_record;
 
@@ -1084,11 +1503,11 @@ mig_external kern_return_t rpc_jack_client_activate
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1002;
+	InP->Head.msgh_id = 1003;
 
-	__BeforeSendRpc(1002, "rpc_jack_client_activate")
+	__BeforeSendRpc(1003, "rpc_jack_client_activate")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1002, "rpc_jack_client_activate")
+	__AfterSendRpc(1003, "rpc_jack_client_activate")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -1197,7 +1616,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_deactivate_t(__Re
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1103) {
+	if (Out0P->Head.msgh_id != 1104) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -1328,7 +1747,7 @@ mig_external kern_return_t rpc_jack_client_deactivate
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_client_deactivate_t__defined */
 
-	__DeclareSendRpc(1003, "rpc_jack_client_deactivate")
+	__DeclareSendRpc(1004, "rpc_jack_client_deactivate")
 
 	InP->NDR = NDR_record;
 
@@ -1339,11 +1758,11 @@ mig_external kern_return_t rpc_jack_client_deactivate
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1003;
+	InP->Head.msgh_id = 1004;
 
-	__BeforeSendRpc(1003, "rpc_jack_client_deactivate")
+	__BeforeSendRpc(1004, "rpc_jack_client_deactivate")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1003, "rpc_jack_client_deactivate")
+	__AfterSendRpc(1004, "rpc_jack_client_deactivate")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -1515,7 +1934,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_register_t(__Reply_
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1104) {
+	if (Out0P->Head.msgh_id != 1105) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -1667,7 +2086,7 @@ mig_external kern_return_t rpc_jack_port_register
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_register_t__defined */
 
-	__DeclareSendRpc(1004, "rpc_jack_port_register")
+	__DeclareSendRpc(1005, "rpc_jack_port_register")
 
 	InP->NDR = NDR_record;
 
@@ -1684,11 +2103,11 @@ mig_external kern_return_t rpc_jack_port_register
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1004;
+	InP->Head.msgh_id = 1005;
 
-	__BeforeSendRpc(1004, "rpc_jack_port_register")
+	__BeforeSendRpc(1005, "rpc_jack_port_register")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1004, "rpc_jack_port_register")
+	__AfterSendRpc(1005, "rpc_jack_port_register")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -1799,7 +2218,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_unregister_t(__Repl
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1105) {
+	if (Out0P->Head.msgh_id != 1106) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -1932,7 +2351,7 @@ mig_external kern_return_t rpc_jack_port_unregister
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_unregister_t__defined */
 
-	__DeclareSendRpc(1005, "rpc_jack_port_unregister")
+	__DeclareSendRpc(1006, "rpc_jack_port_unregister")
 
 	InP->NDR = NDR_record;
 
@@ -1945,11 +2364,11 @@ mig_external kern_return_t rpc_jack_port_unregister
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1005;
+	InP->Head.msgh_id = 1006;
 
-	__BeforeSendRpc(1005, "rpc_jack_port_unregister")
+	__BeforeSendRpc(1006, "rpc_jack_port_unregister")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1005, "rpc_jack_port_unregister")
+	__AfterSendRpc(1006, "rpc_jack_port_unregister")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -2058,7 +2477,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_t(__Reply__
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1106) {
+	if (Out0P->Head.msgh_id != 1107) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -2193,7 +2612,7 @@ mig_external kern_return_t rpc_jack_port_connect
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_connect_t__defined */
 
-	__DeclareSendRpc(1006, "rpc_jack_port_connect")
+	__DeclareSendRpc(1007, "rpc_jack_port_connect")
 
 	InP->NDR = NDR_record;
 
@@ -2208,11 +2627,11 @@ mig_external kern_return_t rpc_jack_port_connect
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1006;
+	InP->Head.msgh_id = 1007;
 
-	__BeforeSendRpc(1006, "rpc_jack_port_connect")
+	__BeforeSendRpc(1007, "rpc_jack_port_connect")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1006, "rpc_jack_port_connect")
+	__AfterSendRpc(1007, "rpc_jack_port_connect")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -2321,7 +2740,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_t(__Repl
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1107) {
+	if (Out0P->Head.msgh_id != 1108) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -2456,7 +2875,7 @@ mig_external kern_return_t rpc_jack_port_disconnect
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_t__defined */
 
-	__DeclareSendRpc(1007, "rpc_jack_port_disconnect")
+	__DeclareSendRpc(1008, "rpc_jack_port_disconnect")
 
 	InP->NDR = NDR_record;
 
@@ -2471,11 +2890,11 @@ mig_external kern_return_t rpc_jack_port_disconnect
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1007;
+	InP->Head.msgh_id = 1008;
 
-	__BeforeSendRpc(1007, "rpc_jack_port_disconnect")
+	__BeforeSendRpc(1008, "rpc_jack_port_disconnect")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1007, "rpc_jack_port_disconnect")
+	__AfterSendRpc(1008, "rpc_jack_port_disconnect")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -2584,7 +3003,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_name_t(__Re
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1108) {
+	if (Out0P->Head.msgh_id != 1109) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -2719,7 +3138,7 @@ mig_external kern_return_t rpc_jack_port_connect_name
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_connect_name_t__defined */
 
-	__DeclareSendRpc(1008, "rpc_jack_port_connect_name")
+	__DeclareSendRpc(1009, "rpc_jack_port_connect_name")
 
 	InP->NDR = NDR_record;
 
@@ -2734,11 +3153,11 @@ mig_external kern_return_t rpc_jack_port_connect_name
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1008;
+	InP->Head.msgh_id = 1009;
 
-	__BeforeSendRpc(1008, "rpc_jack_port_connect_name")
+	__BeforeSendRpc(1009, "rpc_jack_port_connect_name")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1008, "rpc_jack_port_connect_name")
+	__AfterSendRpc(1009, "rpc_jack_port_connect_name")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -2847,7 +3266,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_name_t(_
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1109) {
+	if (Out0P->Head.msgh_id != 1110) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -2982,7 +3401,7 @@ mig_external kern_return_t rpc_jack_port_disconnect_name
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined */
 
-	__DeclareSendRpc(1009, "rpc_jack_port_disconnect_name")
+	__DeclareSendRpc(1010, "rpc_jack_port_disconnect_name")
 
 	InP->NDR = NDR_record;
 
@@ -2997,11 +3416,11 @@ mig_external kern_return_t rpc_jack_port_disconnect_name
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1009;
+	InP->Head.msgh_id = 1010;
 
-	__BeforeSendRpc(1009, "rpc_jack_port_disconnect_name")
+	__BeforeSendRpc(1010, "rpc_jack_port_disconnect_name")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1009, "rpc_jack_port_disconnect_name")
+	__AfterSendRpc(1010, "rpc_jack_port_disconnect_name")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -3110,7 +3529,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Repl
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1110) {
+	if (Out0P->Head.msgh_id != 1111) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -3241,7 +3660,7 @@ mig_external kern_return_t rpc_jack_set_buffer_size
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */
 
-	__DeclareSendRpc(1010, "rpc_jack_set_buffer_size")
+	__DeclareSendRpc(1011, "rpc_jack_set_buffer_size")
 
 	InP->NDR = NDR_record;
 
@@ -3252,11 +3671,11 @@ mig_external kern_return_t rpc_jack_set_buffer_size
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1010;
+	InP->Head.msgh_id = 1011;
 
-	__BeforeSendRpc(1010, "rpc_jack_set_buffer_size")
+	__BeforeSendRpc(1011, "rpc_jack_set_buffer_size")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1010, "rpc_jack_set_buffer_size")
+	__AfterSendRpc(1011, "rpc_jack_set_buffer_size")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -3365,7 +3784,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply_
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1111) {
+	if (Out0P->Head.msgh_id != 1112) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -3496,7 +3915,7 @@ mig_external kern_return_t rpc_jack_set_freewheel
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */
 
-	__DeclareSendRpc(1011, "rpc_jack_set_freewheel")
+	__DeclareSendRpc(1012, "rpc_jack_set_freewheel")
 
 	InP->NDR = NDR_record;
 
@@ -3507,11 +3926,11 @@ mig_external kern_return_t rpc_jack_set_freewheel
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1011;
+	InP->Head.msgh_id = 1012;
 
-	__BeforeSendRpc(1011, "rpc_jack_set_freewheel")
+	__BeforeSendRpc(1012, "rpc_jack_set_freewheel")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1011, "rpc_jack_set_freewheel")
+	__AfterSendRpc(1012, "rpc_jack_set_freewheel")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -3620,7 +4039,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Rep
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1112) {
+	if (Out0P->Head.msgh_id != 1113) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -3751,7 +4170,7 @@ mig_external kern_return_t rpc_jack_release_timebase
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */
 
-	__DeclareSendRpc(1012, "rpc_jack_release_timebase")
+	__DeclareSendRpc(1013, "rpc_jack_release_timebase")
 
 	InP->NDR = NDR_record;
 
@@ -3762,11 +4181,11 @@ mig_external kern_return_t rpc_jack_release_timebase
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1012;
+	InP->Head.msgh_id = 1013;
 
-	__BeforeSendRpc(1012, "rpc_jack_release_timebase")
+	__BeforeSendRpc(1013, "rpc_jack_release_timebase")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1012, "rpc_jack_release_timebase")
+	__AfterSendRpc(1013, "rpc_jack_release_timebase")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -3875,7 +4294,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1113) {
+	if (Out0P->Head.msgh_id != 1114) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -4008,7 +4427,7 @@ mig_external kern_return_t rpc_jack_set_timebase_callback
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */
 
-	__DeclareSendRpc(1013, "rpc_jack_set_timebase_callback")
+	__DeclareSendRpc(1014, "rpc_jack_set_timebase_callback")
 
 	InP->NDR = NDR_record;
 
@@ -4021,11 +4440,11 @@ mig_external kern_return_t rpc_jack_set_timebase_callback
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = server_port;
 	InP->Head.msgh_reply_port = mig_get_reply_port();
-	InP->Head.msgh_id = 1013;
+	InP->Head.msgh_id = 1014;
 
-	__BeforeSendRpc(1013, "rpc_jack_set_timebase_callback")
+	__BeforeSendRpc(1014, "rpc_jack_set_timebase_callback")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-	__AfterSendRpc(1013, "rpc_jack_set_timebase_callback")
+	__AfterSendRpc(1014, "rpc_jack_set_timebase_callback")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -4089,7 +4508,7 @@ mig_external kern_return_t rpc_jack_client_rt_notify
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */
 
-	__DeclareSendSimple(1014, "rpc_jack_client_rt_notify")
+	__DeclareSendSimple(1015, "rpc_jack_client_rt_notify")
 
 	InP->NDR = NDR_record;
 
@@ -4104,11 +4523,11 @@ mig_external kern_return_t rpc_jack_client_rt_notify
 	/* msgh_size passed as argument */
 	InP->Head.msgh_request_port = client_port;
 	InP->Head.msgh_reply_port = MACH_PORT_NULL;
-	InP->Head.msgh_id = 1014;
+	InP->Head.msgh_id = 1015;
 
-	__BeforeSendSimple(1014, "rpc_jack_client_rt_notify")
+	__BeforeSendSimple(1015, "rpc_jack_client_rt_notify")
 	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, timeout, MACH_PORT_NULL);
-	__AfterSendSimple(1014, "rpc_jack_client_rt_notify")
+	__AfterSendSimple(1015, "rpc_jack_client_rt_notify")
 		return msg_result;
 	return KERN_SUCCESS;
     }

windows/JackWinNamedPipeClientChannel.cpp

@@ -36,7 +36,7 @@ JackWinNamedPipeClientChannel::~JackWinNamedPipeClientChannel()
     delete fThread;
 }
 
-int JackWinNamedPipeClientChannel::Open(const char* name, JackClient* obj)
+int JackWinNamedPipeClientChannel::Open(const char* name, JackClient* obj, jack_options_t options, jack_status_t* status)
 {
     JackLog("JackWinNamedPipeClientChannel::Open name = %s\n", name);
 
@@ -112,6 +112,11 @@ void JackWinNamedPipeClientChannel::ServerAsyncCall(JackRequest* req, JackResult
     }
 }
 
+void JackWinNamedPipeClientChannel::ClientCheck(const char* name, char* name_res, int options, int* status, int* result)
+{
+
+}
+
 void JackWinNamedPipeClientChannel::ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     JackClientOpenRequest req(name);
@@ -148,7 +153,7 @@ void JackWinNamedPipeClientChannel::PortRegister(int refnum, const char* name, u
     JackPortRegisterRequest req(refnum, name, "audio", flags, buffer_size);
     JackPortRegisterResult res;
     ServerSyncCall(&req, &res, result);
-    *port_index = res.fPortIndex;
+    *port_index = res.fPortIndex;
 }
 
 void JackWinNamedPipeClientChannel::PortUnRegister(int refnum, jack_port_id_t port_index, int* result)

windows/JackWinNamedPipeClientChannel.h

@@ -50,13 +50,14 @@ class JackWinNamedPipeClientChannel : public JackClientChannelInterface, public
         JackWinNamedPipeClientChannel();
         virtual ~JackWinNamedPipeClientChannel();
 
-        int Open(const char* name, JackClient* obj);
+        int Open(const char* name, JackClient* obj, jack_options_t options, jack_status_t* status);
         void Close();
 
         int Start();
         void Stop();
 
-        void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+        void ClientCheck(const char* name, char* name_res, int options, int* status, int* result);
+		void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result);
         void ClientClose(int refnum, int* result);
 
         void ClientActivate(int refnum, int* result);