Cleanup, renaming

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

common/JackChannel.h

@@ -67,9 +67,9 @@ class JackClientChannelInterface
         virtual void Stop()
         {}
 
-        virtual void ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+        virtual void ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
         {}
-        virtual void ClientNew(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+        virtual void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
         {}
         virtual void ClientClose(int refnum, int* result)
         {}

common/JackDriver.cpp

@@ -70,12 +70,7 @@ int JackDriver::Open()
 {
     int refnum = -1;
 
-    if (fEngine->ClientCheckName(fClientControl->fName)) {
-        jack_error("client %s already registered", fClientControl->fName);
-        return -1;
-    }
-
-    if (fEngine->ClientInternalNew(fClientControl->fName, &refnum, &fEngineControl, &fGraphManager, this) != 0) {
+	if (fEngine->ClientInternalOpen(fClientControl->fName, &refnum, &fEngineControl, &fGraphManager, this) != 0) {
         jack_error("Cannot allocate internal client for audio driver");
         return -1;
     }
@@ -112,12 +107,7 @@ int JackDriver::Open(jack_nframes_t nframes,
     JackLog("JackDriver::Open playback_driver_name = %s\n", playback_driver_name);
     int refnum = -1;
 
-    if (fEngine->ClientCheckName(fClientControl->fName)) {
-        jack_error("client %s already registered", fClientControl->fName);
-        return -1;
-    }
-
-    if (fEngine->ClientInternalNew(fClientControl->fName, &refnum, &fEngineControl, &fGraphManager, this) != 0) {
+    if (fEngine->ClientInternalOpen(fClientControl->fName, &refnum, &fEngineControl, &fGraphManager, this) != 0) {
         jack_error("Cannot allocate internal client for audio driver");
         return -1;
     }

common/JackEngine.cpp

@@ -35,22 +35,12 @@ namespace Jack
 
 JackEngine::JackEngine(JackGraphManager* manager, 
 						JackSynchro** table, 
-						JackEngineControl* control,
-						bool sync, 
-						long time_out_ms, 
-						bool rt, 
-						long priority, 
-						bool ve)
+						JackEngineControl* control)
 {
     fGraphManager = manager;
     fSynchroTable = table;
     fEngineControl = control;
-    fEngineControl->fSyncMode = sync;
-    fEngineControl->fTimeOutUsecs = time_out_ms * 1000;
-    fEngineControl->fRealTime = rt;
-    fEngineControl->fPriority = priority;
-    fEngineControl->fVerbose = ve;
-    fChannel = JackGlobals::MakeServerNotifyChannel();
+	fChannel = JackGlobals::MakeServerNotifyChannel();
 	fSignal = JackGlobals::MakeInterProcessSync();
     fEngineTiming = new JackEngineTiming(fClientTable, fGraphManager, fEngineControl);
     for (int i = 0; i < CLIENT_NUM; i++)
@@ -366,32 +356,22 @@ bool JackEngine::ClientCheckName(const char* name)
 }
 
 // Used for external clients
-int JackEngine::ClientNew(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
+int JackEngine::ClientExternalOpen(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
 {
-    if (ClientCheckName(name)) {
+    JackLog("JackEngine::ClientOpen: name = %s \n", name);
+	
+	if (ClientCheckName(name)) {
         jack_error("client %s already registered", name);
         return -1;
     }
-
-    JackExternalClient* client = new JackExternalClient();
-    if (ClientExternalNew(name, ref, shared_engine, shared_client, shared_graph_manager, client) < 0) {
-        delete client;
-        return -1;
-    }
-
-    return 0;
-}
-
-// Used for external clients
-int JackEngine::ClientExternalNew(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager, JackExternalClient* client)
-{
-    JackLog("JackEngine::ClientNew: name = %s \n", name);
+	
 	int refnum = Allocate();
-
     if (refnum < 0) {
         jack_error("No more refnum available");
         return -1;
     }
+	
+	JackExternalClient* client = new JackExternalClient();
 
     if (!fSynchroTable[refnum]->Allocate(name, 0)) {
         jack_error("Cannot allocate synchro");
@@ -425,16 +405,22 @@ int JackEngine::ClientExternalNew(const char* name, int* ref, int* shared_engine
 error:
     ClientCloseAux(refnum, client, false);
     client->Close();
+	delete client;
     return -1;
 }
 
 // Used for server driver clients
-int JackEngine::ClientInternalNew(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client)
+int JackEngine::ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client)
 {
     JackLog("JackEngine::ClientInternalNew: name = %s\n", name);
+	
+	if (ClientCheckName(name)) {
+        jack_error("client %s already registered", name);
+        return -1;
+    }
+	
 	int refnum = Allocate();
-
-    if (refnum < 0) {
+	if (refnum < 0) {
         jack_error("No more refnum available");
         return -1;
     }
@@ -459,7 +445,7 @@ int JackEngine::ClientInternalNew(const char* name, int* ref, JackEngineControl*
 }
 
 // Used for externall clients
-int JackEngine::ClientClose(int refnum)
+int JackEngine::ClientExternalClose(int refnum)
 {
     JackClientInterface* client = fClientTable[refnum];
     if (client)	{

common/JackEngine.h

@@ -61,23 +61,23 @@ class JackEngine
         void GetZombifiedClients(bool clients[CLIENT_NUM], jack_time_t current_time);
 		void ProcessNext(jack_time_t callback_usecs);
 		void ProcessCurrent(jack_time_t callback_usecs);
+		bool ClientCheckName(const char* name);
+		int Allocate();
 
     public:
 
-        JackEngine(JackGraphManager* manager, JackSynchro** table, JackEngineControl* control, bool sync, long time_out_ms, bool rt, long priority, bool verbose);
+        JackEngine(JackGraphManager* manager, JackSynchro** table, JackEngineControl* controler);
         virtual ~JackEngine();
 
         int Open();
         int Close();
-		int Allocate();
+		
 
         // Client management
-        bool ClientCheckName(const char* name);
-        int ClientNew(const char* name, int* refnum, int* shared_engine, int* shared_client, int* shared_graph_manager);
-        int ClientExternalNew(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager, JackExternalClient* client);
-        int ClientInternalNew(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client);
+        int ClientExternalOpen(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
+        int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client);
 
-        int ClientClose(int refnum);
+        int ClientExternalClose(int refnum);
         int ClientInternalClose(int refnum);
         int ClientInternalCloseIm(int refnum);
 

common/JackEngineControl.h

@@ -37,19 +37,27 @@ struct JackEngineControl : public JackShmMem
 {
     jack_nframes_t fBufferSize;
     jack_nframes_t fSampleRate;
-    bool fRealTime;
-    int32_t fPriority;
     float fCPULoad;
+	bool fSyncMode;
     jack_time_t fPeriodUsecs;
     jack_time_t fTimeOutUsecs;
+	bool fRealTime;
+	int32_t fPriority;
     UInt64 fPeriod;
     UInt64 fComputation;
     UInt64 fConstraint;
     JackFrameTimer fFrameTimer;
     JackTransportEngine fTransport;
-    bool fSyncMode;
     bool fVerbose;
 	
+	JackEngineControl(bool sync, long timeout, bool rt, long priority, bool verbose)
+					:fSyncMode(sync), 
+					fTimeOutUsecs(timeout * 1000), 
+					fRealTime(rt), 
+					fPriority(priority), 
+					fVerbose(verbose)
+	{}
+	
 	void InitFrameTime()
 	{
 		fFrameTimer.InitFrameTime();

common/JackInternalClient.cpp

@@ -72,7 +72,7 @@ int JackInternalClient::Open(const char* name)
     strcpy(fClientControl->fName, name);
 
     // Require new client
-    fChannel->ClientNew(name, &fClientControl->fRefNum, &fEngineControl, &fGraphManager, this, &result);
+    fChannel->ClientOpen(name, &fClientControl->fRefNum, &fEngineControl, &fGraphManager, this, &result);
     if (result < 0) {
         jack_error("Cannot open client name = %s", name);
         goto error;

common/JackInternalClientChannel.h

@@ -44,9 +44,9 @@ class JackInternalClientChannel : public JackClientChannelInterface
         virtual ~JackInternalClientChannel()
         {}
 
-        void ClientNew(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+        void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
         {
-            *result = fEngine->ClientInternalNew(name, ref, shared_engine, shared_manager, client);
+            *result = fEngine->ClientInternalOpen(name, ref, shared_engine, shared_manager, client);
         }
         void ClientClose(int refnum, int* result)
         {

common/JackLibClient.cpp

@@ -79,7 +79,7 @@ int JackLibClient::Open(const char* name)
     }
 
     // Require new client
-    fChannel->ClientNew(name, &shared_engine, &shared_client, &shared_graph, &result);
+    fChannel->ClientOpen(name, &shared_engine, &shared_client, &shared_graph, &result);
     if (result < 0) {
         jack_error("Cannot open %s client", name);
         goto error;

common/JackRequest.h

@@ -59,7 +59,7 @@ public:
 
         kSetBufferSize = 20,
         kSetFreeWheel = 21,
-        kClientNew = 22,
+        kClientOpen = 22,
         kClientClose = 23,
         kConnectNamePorts = 24,
         kDisconnectNamePorts = 25,
@@ -121,14 +121,14 @@ struct JackResult
 \brief NewClient request.
 */
 
-struct JackClientNewRequest : public JackRequest
+struct JackClientOpenRequest : public JackRequest
 {
 
     char fName[JACK_CLIENT_NAME_SIZE + 1];
 
-    JackClientNewRequest()
+    JackClientOpenRequest()
     {}
-    JackClientNewRequest(const char* name): JackRequest(JackRequest::kClientNew)
+    JackClientOpenRequest(const char* name): JackRequest(JackRequest::kClientOpen)
     {
         snprintf(fName, sizeof(fName), "%s", name);
     }
@@ -149,7 +149,7 @@ struct JackClientNewRequest : public JackRequest
 \brief NewClient result.
 */
 
-struct JackClientNewResult : public JackResult
+struct JackClientOpenResult : public JackResult
 {
 
     int fSharedEngine;
@@ -157,10 +157,10 @@ struct JackClientNewResult : public JackResult
     int fSharedGraph;
     uint32_t fProtocolVersion;
 
-    JackClientNewResult()
+    JackClientOpenResult()
 		:fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
     {}
-    JackClientNewResult(int32_t status, int index1, int index2, int index3)
+    JackClientOpenResult(int32_t status, int index1, int index2, int index3)
          : JackResult(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
     {}
 

common/JackServer.cpp

@@ -51,14 +51,13 @@ JackServer::JackServer(bool sync, long timeout, bool rt, long priority, long loo
     for (int i = 0; i < CLIENT_NUM; i++)
         fSynchroTable[i] = JackGlobals::MakeSynchro();
     fGraphManager = new JackGraphManager();
-    fEngineControl = new JackEngineControl();
-    fEngine = new JackEngine(fGraphManager, fSynchroTable, fEngineControl, sync, timeout, rt, priority, verbose);
+    fEngineControl = new JackEngineControl(sync, timeout, rt, priority, verbose);
+    fEngine = new JackEngine(fGraphManager, fSynchroTable, fEngineControl);
     fFreewheelDriver = new JackThreadedDriver(new JackFreewheelDriver("freewheel", fEngine, fSynchroTable));
     fLoopbackDriver = new JackLoopbackDriver("loopback", fEngine, fSynchroTable);
     fChannel = JackGlobals::MakeServerChannel();
     fState = new JackConnectionManager();
-    fFreewheel = false;
-    fSyncMode = sync;
+	fFreewheel = false;
     fLoopback = loopback;
     fDriverInfo = NULL;
     fAudioDriver = NULL;
@@ -272,7 +271,7 @@ void JackServer::Notify(int refnum, int notify, int value)
             JackLog("JackServer: kDeadClient ref = %ld\n", refnum);
 			if (fEngine->ClientDeactivate(refnum) < 0)
 				jack_error("JackServer: DeadClient ref = %ld cannot be removed from the graph !!", refnum);
-			fEngine->ClientClose(refnum);
+			fEngine->ClientExternalClose(refnum);
 			break;
     }
 }

common/JackServer.h

@@ -55,9 +55,7 @@ class EXPORT JackServer
         JackGraphManager* fGraphManager;
         JackServerChannelInterface* fChannel;
         JackConnectionManager* fState;
-        JackSynchro* fSynchroTable[CLIENT_NUM];
-        
-        bool fSyncMode;
+        JackSynchro* fSynchroTable[CLIENT_NUM];        
         bool fFreewheel;
         long fLoopback;
 

common/JackSocketClientChannel.cpp

@@ -113,10 +113,10 @@ void JackSocketClientChannel::ServerAsyncCall(JackRequest* req, JackResult* res,
     }
 }
 
-void JackSocketClientChannel::ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+void JackSocketClientChannel::ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
-    JackClientNewRequest req(name);
-    JackClientNewResult res;
+    JackClientOpenRequest req(name);
+    JackClientOpenResult res;
     ServerSyncCall(&req, &res, result);
     *shared_engine = res.fSharedEngine;
     *shared_client = res.fSharedClient;

common/JackSocketClientChannel.h

@@ -57,7 +57,7 @@ class JackSocketClientChannel : public JackClientChannelInterface, public JackRu
         int Start();
         void Stop();
 
-        void ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, 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);

common/JackSocketServerChannel.cpp

@@ -92,7 +92,7 @@ void JackSocketServerChannel::AddClient(int fd, char* name, int* shared_engine,
 {
     JackLog("JackSocketServerChannel::AddClient\n");
     int refnum = -1;
-    *result = fServer->GetEngine()->ClientNew(name, &refnum, shared_engine, shared_client, shared_graph);
+	*result = fServer->GetEngine()->ClientExternalOpen(name, &refnum, shared_engine, shared_client, shared_graph);
     if (*result == 0) {
         fSocketTable[fd].first = refnum;
         fRebuild = true;
@@ -150,10 +150,10 @@ int JackSocketServerChannel::HandleRequest(int fd)
     // Read data
     switch (header.fType) {
 
-        case JackRequest::kClientNew: {
-                JackLog("JackRequest::ClientNew\n");
-                JackClientNewRequest req;
-                JackClientNewResult res;
+        case JackRequest::kClientOpen: {
+                JackLog("JackRequest::ClientOpen\n");
+                JackClientOpenRequest req;
+                JackClientOpenResult res;
                 if (req.Read(socket) == 0)
 					AddClient(fd, req.fName, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
                 res.Write(socket);
@@ -165,7 +165,7 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackClientCloseRequest req;
                 JackResult res;
                 if (req.Read(socket) == 0)
-					res.fResult = fServer->GetEngine()->ClientClose(req.fRefNum);
+					res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
                 res.Write(socket);
                 RemoveClient(fd, req.fRefNum);
                 break;
@@ -176,7 +176,6 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackResult res;
                 JackLog("JackRequest::ActivateClient\n");
                 if (req.Read(socket) == 0)
-					//res.fResult = fServer->Activate(req.fRefNum);
 					res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum);
                 res.Write(socket);
                 break;
@@ -187,7 +186,6 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackDeactivateRequest req;
                 JackResult res;
                 if (req.Read(socket) == 0)
-					//res.fResult = fServer->Deactivate(req.fRefNum);
 					res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
                 res.Write(socket);
                 break;

macosx/JackMacEngineRPC.cpp

@@ -31,7 +31,7 @@ using namespace Jack;
 
 #define rpc_type kern_return_t // for astyle
 
-rpc_type server_rpc_jack_client_new(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)
+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);
     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];

macosx/JackMachClientChannel.cpp

@@ -95,12 +95,12 @@ void JackMachClientChannel::Stop()
     fThread->Kill();
 }
 
-void JackMachClientChannel::ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+void JackMachClientChannel::ClientOpen(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
-    kern_return_t res = rpc_jack_client_new(fServerPort.GetPort(), (char*)name, &fPrivatePort, shared_engine, shared_client, shared_graph, result);
+    kern_return_t res = rpc_jack_client_open(fServerPort.GetPort(), (char*)name, &fPrivatePort, shared_engine, shared_client, shared_graph, result);
     if (res != KERN_SUCCESS) {
         *result = -1;
-        jack_error("JackMachClientChannel::ClientNew err = %s", mach_error_string(res));
+        jack_error("JackMachClientChannel::ClientOpen err = %s", mach_error_string(res));
     }
 }
 

macosx/JackMachClientChannel.h

@@ -54,7 +54,7 @@ class JackMachClientChannel : public JackClientChannelInterface, public JackRunn
         int Start();
         void Stop();
 
-        void ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, 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/JackMachServerChannel.cpp

@@ -80,7 +80,7 @@ JackServer* JackMachServerChannel::GetServer()
 void JackMachServerChannel::AddClient(char* name, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     int refnum = -1;
-    *result = GetEngine()->ClientNew(name, &refnum, shared_engine, shared_client, shared_graph);
+	*result = GetEngine()->ClientExternalOpen(name, &refnum, shared_engine, shared_client, shared_graph);
 
     if (*result == 0) {
         mach_port_t port = fServerPort.AddPort();
@@ -99,7 +99,7 @@ void JackMachServerChannel::AddClient(char* name, mach_port_t* private_port, int
 
 void JackMachServerChannel::RemoveClient(mach_port_t private_port, int refnum)
 {
-    GetEngine()->ClientClose(refnum);
+	GetEngine()->ClientExternalClose(refnum);
     fClientTable.erase(private_port);
 
     // Hum, hum....

macosx/RPC/JackRPCClientServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Sat Dec 23 15:21:20 2006
+ * stub generated Tue Jan 30 00:00:51 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 Sat Dec 23 15:21:20 2006
+ * stub generated Tue Jan 30 00:00:51 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */

macosx/RPC/JackRPCEngine.defs

@@ -28,7 +28,7 @@ ServerPrefix server_;
 type client_name_t = c_string[128];
 type client_port_name_t = c_string[128];
 
-routine rpc_jack_client_new(
+routine rpc_jack_client_open(
 	server_port	: mach_port_t;
 	client_name	: client_name_t;
 	out private_port : mach_port_make_send_t;

macosx/RPC/JackRPCEngine.h

@@ -43,13 +43,13 @@ __BeforeMigUserHeader
 __BEGIN_DECLS
 
 
-/* Routine rpc_jack_client_new */
+/* Routine rpc_jack_client_open */
 #ifdef	mig_external
 mig_external
 #else
 extern
 #endif	/* mig_external */
-kern_return_t rpc_jack_client_new
+kern_return_t rpc_jack_client_open
 (
 	mach_port_t server_port,
 	client_name_t client_name,
@@ -283,7 +283,7 @@ __END_DECLS
 		mach_msg_header_t Head;
 		NDR_record_t NDR;
 		client_name_t client_name;
-	} __Request__rpc_jack_client_new_t;
+	} __Request__rpc_jack_client_open_t;
 #ifdef  __MigPackStructs
 #pragma pack()
 #endif
@@ -477,7 +477,7 @@ __END_DECLS
 #ifndef __RequestUnion__JackRPCEngine_subsystem__defined
 #define __RequestUnion__JackRPCEngine_subsystem__defined
 union __RequestUnion__JackRPCEngine_subsystem {
-	__Request__rpc_jack_client_new_t Request_rpc_jack_client_new;
+	__Request__rpc_jack_client_open_t Request_rpc_jack_client_open;
 	__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;
@@ -513,7 +513,7 @@ union __RequestUnion__JackRPCEngine_subsystem {
 		int shared_client;
 		int shared_graph;
 		int result;
-	} __Reply__rpc_jack_client_new_t;
+	} __Reply__rpc_jack_client_open_t;
 #ifdef  __MigPackStructs
 #pragma pack()
 #endif
@@ -706,7 +706,7 @@ union __RequestUnion__JackRPCEngine_subsystem {
 #ifndef __ReplyUnion__JackRPCEngine_subsystem__defined
 #define __ReplyUnion__JackRPCEngine_subsystem__defined
 union __ReplyUnion__JackRPCEngine_subsystem {
-	__Reply__rpc_jack_client_new_t Reply_rpc_jack_client_new;
+	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
 	__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;
@@ -726,7 +726,7 @@ union __ReplyUnion__JackRPCEngine_subsystem {
 
 #ifndef subsystem_to_name_map_JackRPCEngine
 #define subsystem_to_name_map_JackRPCEngine \
-    { "rpc_jack_client_new", 1000 },\
+    { "rpc_jack_client_open", 1000 },\
     { "rpc_jack_client_close", 1001 },\
     { "rpc_jack_client_activate", 1002 },\
     { "rpc_jack_client_deactivate", 1003 },\

macosx/RPC/JackRPCEngineServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Sat Dec 23 15:21:20 2006
+ * stub generated Tue Jan 30 00:00:52 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */
@@ -111,7 +111,7 @@
 		mach_msg_header_t Head;
 		NDR_record_t NDR;
 		client_name_t client_name;
-	} __Request__rpc_jack_client_new_t;
+	} __Request__rpc_jack_client_open_t;
 #ifdef  __MigPackStructs
 #pragma pack()
 #endif
@@ -319,7 +319,7 @@
 		int shared_client;
 		int shared_graph;
 		int result;
-	} __Reply__rpc_jack_client_new_t;
+	} __Reply__rpc_jack_client_open_t;
 #ifdef  __MigPackStructs
 #pragma pack()
 #endif
@@ -513,7 +513,7 @@
 #ifndef __ReplyUnion__server_JackRPCEngine_subsystem__defined
 #define __ReplyUnion__server_JackRPCEngine_subsystem__defined
 union __ReplyUnion__server_JackRPCEngine_subsystem {
-	__Reply__rpc_jack_client_new_t Reply_rpc_jack_client_new;
+	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
 	__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;
@@ -533,7 +533,7 @@ union __ReplyUnion__server_JackRPCEngine_subsystem {
 /* Forward Declarations */
 
 
-mig_internal novalue _Xrpc_jack_client_new
+mig_internal novalue _Xrpc_jack_client_open
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
 
 mig_internal novalue _Xrpc_jack_client_close
@@ -581,117 +581,117 @@ mig_internal novalue _Xrpc_jack_client_rt_notify
 
 #if (__MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Request__JackRPCEngine_subsystem__
-#if !defined(__MIG_check__Request__rpc_jack_client_new_t__defined)
-#define __MIG_check__Request__rpc_jack_client_new_t__defined
-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name__defined
+#if !defined(__MIG_check__Request__rpc_jack_client_open_t__defined)
+#define __MIG_check__Request__rpc_jack_client_open_t__defined
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
 #if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
-#define	__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name__defined
-#define	__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined */
+#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined */
 
-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name__defined
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
 #if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
-#define	__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name__defined
-#define	__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined */
+#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined */
 
-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name__defined
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
 #if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
-#define	__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name__defined
-#define	__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined
-#define	__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name(a, f) \
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_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_new_t__client_name__defined */
+#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined */
 
 
-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_new_t(__Request__rpc_jack_client_new_t *In0P)
+mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_open_t(__Request__rpc_jack_client_open_t *In0P)
 {
 
-	typedef __Request__rpc_jack_client_new_t __Request;
+	typedef __Request__rpc_jack_client_open_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_new_t__client_name__defined)
+#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined)
 	if (In0P->NDR.int_rep != NDR_record.int_rep) {
-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name__defined)
-		__NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_new_t__client_name__defined */
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined */
 	}
 #endif	/* defined(__NDR_convert__int_rep...) */
 
-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name__defined)
+#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined)
 	if (In0P->NDR.char_rep != NDR_record.char_rep) {
-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name__defined)
-		__NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_new_t__client_name__defined */
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined */
 	}
 #endif	/* defined(__NDR_convert__char_rep...) */
 
-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name__defined)
+#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined)
 	if (In0P->NDR.float_rep != NDR_record.float_rep) {
-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name__defined)
-		__NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_new_t__client_name__defined */
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined */
 	}
 #endif	/* defined(__NDR_convert__float_rep...) */
 
 	return MACH_MSG_SUCCESS;
 }
-#endif /* !defined(__MIG_check__Request__rpc_jack_client_new_t__defined) */
+#endif /* !defined(__MIG_check__Request__rpc_jack_client_open_t__defined) */
 #endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
 
 
-/* Routine rpc_jack_client_new */
+/* Routine rpc_jack_client_open */
 #ifdef	mig_external
 mig_external
 #else
 extern
 #endif	/* mig_external */
-kern_return_t server_rpc_jack_client_new
+kern_return_t server_rpc_jack_client_open
 (
 	mach_port_t server_port,
 	client_name_t client_name,
@@ -702,8 +702,8 @@ kern_return_t server_rpc_jack_client_new
 	int *result
 );
 
-/* Routine rpc_jack_client_new */
-mig_internal novalue _Xrpc_jack_client_new
+/* Routine rpc_jack_client_open */
+mig_internal novalue _Xrpc_jack_client_open
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
 {
 
@@ -719,8 +719,8 @@ mig_internal novalue _Xrpc_jack_client_new
 #ifdef  __MigPackStructs
 #pragma pack()
 #endif
-	typedef __Request__rpc_jack_client_new_t __Request;
-	typedef __Reply__rpc_jack_client_new_t Reply;
+	typedef __Request__rpc_jack_client_open_t __Request;
+	typedef __Reply__rpc_jack_client_open_t Reply;
 
 	/*
 	 * typedef struct {
@@ -732,9 +732,9 @@ mig_internal novalue _Xrpc_jack_client_new
 
 	Request *In0P = (Request *) InHeadP;
 	Reply *OutP = (Reply *) OutHeadP;
-#ifdef	__MIG_check__Request__rpc_jack_client_new_t__defined
+#ifdef	__MIG_check__Request__rpc_jack_client_open_t__defined
 	kern_return_t check_result;
-#endif	/* __MIG_check__Request__rpc_jack_client_new_t__defined */
+#endif	/* __MIG_check__Request__rpc_jack_client_open_t__defined */
 
 #if	UseStaticTemplates
 	const static mach_msg_port_descriptor_t private_portTemplate = {
@@ -747,14 +747,14 @@ mig_internal novalue _Xrpc_jack_client_new
 #endif	/* UseStaticTemplates */
 
 	kern_return_t RetCode;
-	__DeclareRcvRpc(1000, "rpc_jack_client_new")
-	__BeforeRcvRpc(1000, "rpc_jack_client_new")
+	__DeclareRcvRpc(1000, "rpc_jack_client_open")
+	__BeforeRcvRpc(1000, "rpc_jack_client_open")
 
-#if	defined(__MIG_check__Request__rpc_jack_client_new_t__defined)
-	check_result = __MIG_check__Request__rpc_jack_client_new_t((__Request *)In0P);
+#if	defined(__MIG_check__Request__rpc_jack_client_open_t__defined)
+	check_result = __MIG_check__Request__rpc_jack_client_open_t((__Request *)In0P);
 	if (check_result != MACH_MSG_SUCCESS)
 		{ MIG_RETURN_ERROR(OutP, check_result); }
-#endif	/* defined(__MIG_check__Request__rpc_jack_client_new_t__defined) */
+#endif	/* defined(__MIG_check__Request__rpc_jack_client_open_t__defined) */
 
 #if	UseStaticTemplates
 	OutP->private_port = private_portTemplate;
@@ -764,7 +764,7 @@ mig_internal novalue _Xrpc_jack_client_new
 #endif	/* UseStaticTemplates */
 
 
-	RetCode = server_rpc_jack_client_new(In0P->Head.msgh_request_port, In0P->client_name, &OutP->private_port.name, &OutP->shared_engine, &OutP->shared_client, &OutP->shared_graph, &OutP->result);
+	RetCode = server_rpc_jack_client_open(In0P->Head.msgh_request_port, In0P->client_name, &OutP->private_port.name, &OutP->shared_engine, &OutP->shared_client, &OutP->shared_graph, &OutP->result);
 	if (RetCode != KERN_SUCCESS) {
 		MIG_RETURN_ERROR(OutP, RetCode);
 	}
@@ -775,7 +775,7 @@ mig_internal novalue _Xrpc_jack_client_new
 	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
 	OutP->msgh_body.msgh_descriptor_count = 1;
-	__AfterRcvRpc(1000, "rpc_jack_client_new")
+	__AfterRcvRpc(1000, "rpc_jack_client_open")
 }
 
 #if (__MigTypeCheck || __NDR_convert__ )
@@ -4342,7 +4342,7 @@ const struct server_JackRPCEngine_subsystem {
 	(vm_address_t)0,
 	{
           { (mig_impl_routine_t) 0,
-            (mig_stub_routine_t) _Xrpc_jack_client_new, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_new_t)},
+            (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_close, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_close_t)},
           { (mig_impl_routine_t) 0,

macosx/RPC/JackRPCEngineUser.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Sat Dec 23 15:21:20 2006
+ * stub generated Tue Jan 30 00:00:52 2007
  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com
  * OPTIONS: 
  */
@@ -109,265 +109,265 @@
 
 #if ( __MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Reply__JackRPCEngine_subsystem__
-#if !defined(__MIG_check__Reply__rpc_jack_client_new_t__defined)
-#define __MIG_check__Reply__rpc_jack_client_new_t__defined
-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
+#if !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
+#define __MIG_check__Reply__rpc_jack_client_open_t__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
 #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
 
 
-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
 #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
 
 
-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
 #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
 
 
-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
 #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_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_new_t__result__defined */
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
 
 
-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
 #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
 
 
-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client__defined
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
 #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
 
 
-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
 #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
 
 
-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result__defined
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
 #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_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_new_t__result__defined */
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
 
 
-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
 #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(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_new_t__shared_engine__defined */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
 
 
-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client__defined
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
 #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(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_new_t__shared_client__defined */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
 
 
-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
 #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(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_new_t__shared_graph__defined */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
 
 
-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result__defined
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
 #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_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_new_t__result__defined
-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result(a, f) \
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_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_new_t__result__defined */
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
 
 
 
-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_new_t(__Reply__rpc_jack_client_new_t *Out0P)
+mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_open_t(__Reply__rpc_jack_client_open_t *Out0P)
 {
 
-	typedef __Reply__rpc_jack_client_new_t __Reply;
+	typedef __Reply__rpc_jack_client_open_t __Reply;
 	boolean_t msgh_simple;
 #if	__MigTypeCheck
 	unsigned int msgh_size;
@@ -403,75 +403,75 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_new_t(__Reply__rp
 		{ return MIG_TYPE_ERROR; }
 #endif	/* __MigTypeCheck */
 
-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine__defined) || \
-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client__defined) || \
-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph__defined) || \
-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result__defined)
+#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine__defined)
-		__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.int_rep);
-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_engine__defined */
-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client__defined)
-		__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client(&Out0P->shared_client, Out0P->NDR.int_rep);
-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_client__defined */
-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph__defined)
-		__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.int_rep);
-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__shared_graph__defined */
-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result__defined)
-		__NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result(&Out0P->result, Out0P->NDR.int_rep);
-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_new_t__result__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
 	}
 #endif	/* defined(__NDR_convert__int_rep...) */
 
-#if	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine__defined) || \
-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client__defined) || \
-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph__defined) || \
-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result__defined)
+#if	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine__defined)
-		__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.char_rep);
-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_engine__defined */
-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client__defined)
-		__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client(&Out0P->shared_client, Out0P->NDR.char_rep);
-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_client__defined */
-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph__defined)
-		__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.char_rep);
-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__shared_graph__defined */
-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result__defined)
-		__NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result(&Out0P->result, Out0P->NDR.char_rep);
-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_new_t__result__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
 	}
 #endif	/* defined(__NDR_convert__char_rep...) */
 
-#if	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine__defined) || \
-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client__defined) || \
-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph__defined) || \
-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result__defined)
+#if	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine__defined)
-		__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.float_rep);
-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_engine__defined */
-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client__defined)
-		__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client(&Out0P->shared_client, Out0P->NDR.float_rep);
-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_client__defined */
-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph__defined)
-		__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.float_rep);
-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__shared_graph__defined */
-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result__defined)
-		__NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result(&Out0P->result, Out0P->NDR.float_rep);
-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_new_t__result__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
 	}
 #endif	/* defined(__NDR_convert__float_rep...) */
 
 	return MACH_MSG_SUCCESS;
 }
-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_new_t__defined) */
+#endif /* !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
 
 
-/* Routine rpc_jack_client_new */
-mig_external kern_return_t rpc_jack_client_new
+/* Routine rpc_jack_client_open */
+mig_external kern_return_t rpc_jack_client_open
 (
 	mach_port_t server_port,
 	client_name_t client_name,
@@ -552,11 +552,11 @@ mig_external kern_return_t rpc_jack_client_new
 
 	mach_msg_return_t msg_result;
 
-#ifdef	__MIG_check__Reply__rpc_jack_client_new_t__defined
+#ifdef	__MIG_check__Reply__rpc_jack_client_open_t__defined
 	kern_return_t check_result;
-#endif	/* __MIG_check__Reply__rpc_jack_client_new_t__defined */
+#endif	/* __MIG_check__Reply__rpc_jack_client_open_t__defined */
 
-	__DeclareSendRpc(1000, "rpc_jack_client_new")
+	__DeclareSendRpc(1000, "rpc_jack_client_open")
 
 	InP->NDR = NDR_record;
 
@@ -569,20 +569,20 @@ mig_external kern_return_t rpc_jack_client_new
 	InP->Head.msgh_reply_port = mig_get_reply_port();
 	InP->Head.msgh_id = 1000;
 
-	__BeforeSendRpc(1000, "rpc_jack_client_new")
+	__BeforeSendRpc(1000, "rpc_jack_client_open")
 	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(1000, "rpc_jack_client_new")
+	__AfterSendRpc(1000, "rpc_jack_client_open")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
 	}
 
 
-#if	defined(__MIG_check__Reply__rpc_jack_client_new_t__defined)
-	check_result = __MIG_check__Reply__rpc_jack_client_new_t((__Reply__rpc_jack_client_new_t *)Out0P);
+#if	defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
+	check_result = __MIG_check__Reply__rpc_jack_client_open_t((__Reply__rpc_jack_client_open_t *)Out0P);
 	if (check_result != MACH_MSG_SUCCESS)
 		{ return check_result; }
-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_new_t__defined) */
+#endif	/* defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
 
 	*private_port = Out0P->private_port.name;
 	*shared_engine = Out0P->shared_engine;