CN1257455C - Inter-process calling gate technique - Google Patents

Abstract

The present invention relates to calling gate technology among processes, which enables an object of one process to directly call the function of one object in another process. A registry table does not need to be dependent on in the process of final execution, processes of a single instance can realize multiple instances by multiple processes, and a component object model (COM) does not have the function. Meanwhile, the client end does not need to realize the storage of a dynamic link library (DLL), but the client end directly realizes storage. The client end and the server end are completely transparent to developers, and thereby, the developers have larger opportunities for participating in control processes. Most of application programs for C language development formerly are single instances and non objectization. If the programs are innovated by COM technology, the cost is large, and the realization is impossible sometimes. The calling gate technology is easy to solve the problems of large cost and impossible realization by adopting the COM technology. The calling gate technology only needs slight alteration for the original program and can realize multiple instances and objectization by a method for multiple processes.

Description

Inter-process calling gate technique

1 technical field

The present invention relates to a kind of being used for, the method for single example module multiple example type the module objectization of original non-objectization.And be particularly related to a kind of novelty and the effective software engineering (calling gate technique) of process communication, particularly, relate to and a kind of the function call parameter is broken into uniform data format, and come the technology of the real-time Communication for Power between implementation process with single transmission interface.

2 background technologies

In recent years, the software engineering develop rapidly, the renewal speed of software product is also more and more faster.Software product is a kind of basic trend with combining of network.And many companies original software product (or module) be non-objectification with single-instancing, this has hindered its application aspect network and multi-user, and the update of corresponding product.

At the objectification design aspect of software product, the The Component Object Model of MICROSOFT (hereinafter to be referred as COM) technology is one and well selects.But if rewrite these modules according to the COM standard fully, its cost will be huge.

Calling gate technique can well address this problem.Adopt this technology, only need to be used as less modification, just can make its objectification and multiple example type original.

By answering user's routine interface (hereinafter to be referred as API) function definition and calling in dynamic link library (DLL) implementation process is very general technology.The method that defines and call with the api function between executable file (as EXE) implementation process has multiple, as Local Procedure Call (LPC) and remote procedure call (RPC) etc., the mechanism of these methods is opaque for the developer, and can not realize directly calling another in-process api function.

3 summary of the invention

Calling gate technique makes the object of a process can directly call the function of the object in the another one process by certain method.It is to extend from the correlation technique of operating system, its a lot of ways of thinking and COM are the same, but do not need to depend on registration table in the time of final the execution, and can realize many examples to the program of single example by multi-process, this is that COM is unexistent.Simultaneously can need not realize the DLL counterfoil in client, but directly realize counterfoil, the client and server end all is fully transparent to the developer, thereby the developer has the chance of maximum participation control procedure.

Of the present invention theing contents are as follows:

(1) by call gate, the specified services process can be created and close to the object in the client process space;

(2) by call gate, the object in the client process space can be created a service specified object in the service processes space, and obtains the handle of this object;

(3) by call gate, the object in the client process space can call the function of object of an appointment in service processes space, and obtains the rreturn value of this function;

The soluble problem of the present invention is as follows:

(1) method with executable file (as EXE) realizes the api function interface, realizes another process directly calling these api functions by call gate;

(2) by call gate, the outer service routine of the process of can creating;

(3) by call gate, can realize many examples to the program of single example by multi-process.

4 description of drawings

Fig. 1 has provided the process that the object in the object in client process space and service processes space communicates by call gate.Call gate is as transfer, the service processes space is translated and be sent to the function call of the object that comes from the client process space (or other request), in the service processes space, call corresponding function then, and at last rreturn value is transferred back to the client process space.

Fig. 2 has provided the process of function call that call gate is handled the object in client process space.

Fig. 3 has provided the operational process sketch of client.

Fig. 4 has provided the operational process sketch of service end.

Fig. 5 has provided function time institute's event and the process thereof that client object is called the service end object.

5 embodiments

The present invention makes the directly function of the object of invoking server end of client object by certain mechanism, and obtains corresponding rreturn value.Its basic thought is:

● the object of client and server end derives from identical virtual base class, thereby they have identical virtual table (hereinafter to be referred as VTABLE), working as client object like this is sent to the address of relative address of function (with respect to client object) and server end object in the process of server end, then the server end process adds relative address to the server object handle, just can obtain the function that client will be called;

● transmit call parameters and information by shared drive at server end and server;

● by incident finish function call between process synchronously;

Client and server end object are in the different address spaces, do not know the other side's address between them, and their function is in respectively in the different address spaces, therefore can not directly call mutually.Client and server end can be shared same dynamic base, thereby they share identical code segment, and still, operating system might not be mapped to dynamic base in the identical address section of the different process spaces, therefore, can not directly pass through the corresponding function of these calls by location.

All com objects all derive from class IUnknown, and IUnknown is a pure virtual base class.Like this, first three interface of the VTABLE of all com objects is all identical, thereby all objects can search other interface by identical interface QueryInterface.Function calling method among the class IUnknown is obeyed standard WINDOWS function call (hereinafter to be referred as STDCALL) and is called rule.This rule of calling is only sent out the parameter that transmits fixed number, and it can not transmit the situation of variable element, therefore, the present invention has defined the pure virtual base class IBase of oneself, it does not adopt the STDCALL of COM to call rule, but adopts C to call rule, can transmit the function parameter of indefinite number like this.

IBase is defined as follows:

#ifdef＿cplusplus

class IBase

{

public：

virtual?HRESULT?QueryInterface(REFIID?iid，void**?ppvObject)＝0；

virtual?ULONG AddRef(void) ＝0；

virtual?ULONG Release(void)?＝0；

}；

#endif

#ifdef＿cplusplus

typedef?int(IBase：：*LPCLASSAPI)(...)；

#else

typedef?int(*LPCLASSAPI)()；

#endif

The server end object derives from identical interface with client object, and it can be the IBase interface, also can be the derivation interface of IBase.Client object has identical VTABLE with server object like this, and all is to obey C to call rule.

When client object is wanted the function of invoking server end object, client server end pointer to object and object function and parameter by CallGateFunc () thus be transformed into the object reference between implementation process of calling at the server end object.Provide call gate api interface function C allGateFunc definition among Fig. 2.Because the two ends object has identical VTABLE, so this calling is feasible.

Fig. 1 provides is the process that the object in the object in client process space and service processes space communicates by call gate.What Fig. 3 and Fig. 4 gave is the operational process of client and server end.

If client object needs the service of server end object, then it can be by the api function in call gate storehouse

HANDLE APIENTRY CreateServer (LPSTR lpExeFile, LPGUID lpSvrID) creates the service specified process, wherein lpExeFile is the path of process, and lpSvrID is service object's a sign, and it is a unified sign (hereinafter to be referred as a GUID) sign.This function returns the process handle of service processes.

When not needing the process of appointment, it can call the process that api function is closed appointment, and this api function is defined as follows:

INT?APIENTRY?DeleteServer(HANDLE?Handle)；

In the entrance of service end process function m ain or WinMain, call api function

INT?APIENTRY BeginServer(LPEXEGETCLASSOBJECT

lpGetClassObject，

LPEXECANEXITNOW lpExeCanExitNow, LPGUID lpSvrID) notice call gate storehouse oneself starts, simultaneously, and three information importing oneself into:

First lpGetClassObject is the function pointer that process oneself is used to create object, and it is defined as follows:

typedef?I?NT(APIENTRY*LPEXEGETCLASSOBJECT)(REFCLSID?rclsid，

REFIID?riid，LPVOID*ppv)；

Second lpExeCanExitNow is the function pointer that process oneself control is withdrawed from, and it is defined as follows:

typedef?VO?ID(APIENTRY*LPEXECANEXITNOW)(VOID)；

The GUID sign that the 3rd lpSvrID is process, it is used for unique identification oneself.

When service processes finishes, call api function EndServer notice call gate storehouse oneself and close, this function is defined as follows:

VOID?APIENTRY?EndServer(VOID)；

The process identification (PID) lpSvrID of service processes has been known in the call gate storehouse, process handle, create service object's function pointer lpGetClassObject and the function pointer lpExeCanExitNow that the control service is closed, like this it should effectively to control service processes be the client process service.

When the client process object needed the service object, it can call api function CreateObjectInstance and notify the call gate storehouse to create the service specified object, and CreateObjectInstance is defined as follows:

INTAPIENTRY?CreateObjectInstance(HANDLE?Handle，REFCLSID?rclsID，

REFIID?riID，LPVOID*lppv)；

Wherein Handle is the handle of service processes object, and rclsID is service object's class ID, and riId is service object ID, and lppv is an address pointer of accepting service object's pointer.

The object of appointment is created in the call gate storehouse by the lpGetClassObject function pointer.As aforementioned, all server end object and client object all realize the IBase interface, and identical VTABLE is arranged, and by the call gate storehouse, client object docking port function calls can well convert calling the server end interface to.

Call gate api function CallGateFunc can only transmit pointer type and integer type, if call function will transmit word string or other type, then can adopt the shared drive mode.Call end the client, create a shared drive, the information that copy will transmit is sent to server end to the handle of shared drive by CallGateFunc then in shared drive; Server end can take out corresponding data after obtaining this internal memory handle, and calls the corresponding interface function, to finish calling of client; After server end was finished the work, client can be removed shared drive.

Client realizes the calling by call gate and macro definition of object of service end.For example, the client object A QueryInterface method of calling the service end object B can be changed by following macro definition:

#define?A_QueryInterface(B，iid，lppv)\

CallGateFunc(hServer，(sizeof(iid)+sizeof(lppv))/4，

(LPCLASSAPI)B-＞QueryInterface，lpObject，iid，lppv))

Fig. 1 has provided the reciprocal process of client process and server end process.Client process calls api function CreateServer request and creates a process ((1) among Fig. 1), and it is passed to the path of the process that call gate will create and will create the sign GUID of process; After call gate obtained this request, calling system api function CreateProcess created the process ((2) among Fig. 1) of appointment, and obtained the handle of this process; In the process that service processes starts, it can call api function BeginServer to call gate registration oneself, and the content of registration comprises that the function pointer LPEXEGETCLASSOBJECT that creates the service object, function pointer LPEXECANEXITNOW that the suggest services process is closed and the GUID of process identify.Call gate is just known the situation of service processes like this, and can create service object and control service processes by these functions.

After client is created the object success, can call api function CreateObjectInstance and create a service object ((3) among Fig. 1) at server end, call gate obtains ((4 and 5) among Fig. 1) after this request, call the LPEXEGETCLASSOBJECT function pointer of corresponding process, create a service object, and return to client.

When client will be called function of service object ((6) among Fig. 1), client is sent to service processes ((7) among Fig. 1) to the be called handle of process, the number of call parameters, invoked function and parameter list by api function CallGateFunc; Call gate calls the function of appointment and rreturn value is passed back caller ((8) among Fig. 1) in service processes.So just finish the function call of a striding course.

If client no longer needs the service object, method that then can call function discharges ((9,10 and 11) among Fig. 1) to the service end object.

If client will be closed service processes, then can call api function DeleteServer and close service processes ((12 and 13) among Fig. 1).When service processes is closed, can call api function EndServer notice call gate oneself and close.

What Fig. 3 and Fig. 4 provided respectively is the operational process of client and server end.Fig. 2 has provided the process of function call that call gate is handled the object in client process space.Api function CallGateFune can transmit many arbitrarily argument of type integers, parameter is pop down ((14) among Fig. 2) from left to right, follow service object's handle pop down (((15) among Fig. 2), directly call the function ((16) among Fig. 2) of service object's correspondence then in the service processes space, last call gate sends back client process ((17) among Fig. 2) to the rreturn value of function.

What Fig. 5 provided is the process that client object is called the function of service end object.Invoked procedure is as follows:

(1) client object is initiated call ((18) among Fig. 5) to the function 3 of server end object;

(2) client object pack to calling parameter ((19) among Fig. 5) before entering call gate;

(3) then enter call gate ((20) among Fig. 5), call gate imports the parameter of function call into service processes;

(4) call gate starting service object's function 3, this function carries out parameter and unpacks ((21) among Fig. 5);

(5) service object's function 3 is carried out (((22) among Fig. 5);

(6) service object's function 3 rreturn value is packed ((23) among Fig. 5);

(7) call gate is obtained the good rreturn value ((24) among Fig. 5) of packing of service object's function 3, and sends client object to;

(8) client object rreturn value that call gate is passed back unpacks ((25) among Fig. 5);

(9) client obtains the rreturn value ((26) among Fig. 5) of the object of service end, so far, the client object success finished once invoked procedure to the server end object.

Calling gate technique is having same good performance with the COM technology aspect the outer service of implementation process, and it can make the developer farthest control development process.Simultaneously, it can solve the indeterminable problem of COM technology, and the front points out, is mostly single example and non-objectization with the application programs of C exploitation before the great majority.If adopt these programs of COM technological transformation, then its cost will be huge, and also be impossible sometimes.By calling gate technique, can address this problem easily.

Calling gate technique only needs original program is done little change, just can realize many examples and objectification by the method for multi-process.The basic thought of its change is:

Each example is exactly a service processes, and it can create a service object; When client process need be created a plurality of service object, just can create a plurality of service processess was customer service.Like this, for client process, just being equivalent to service processes is many examples.

Such as, the demoder of the MPEG1 stream of an existing motion picture expert group (MPEG), it is single example.Open a process and can only play the stream of a MPEG1 form.If realize supervisory system, require to have 16 monitoring terminals on the desktop with this demoder.The player of single example if use it, then will be created 16 broadcast processes hereto, and these 16 processes will be independently.If the developer need not calling gate technique of the present invention, he will face the technological challenge of the broadcast window of these 16 processes of control.If adopt calling gate technique of the present invention, only need original MPEG1 demoder is made seldom modification, make it can create a service object.Newly write a client object in addition, this to as if many examples, its each example all creates a service processes object accordingly.Realize supervisory system with this client object again, will be more easy to control.The developer is when this system of realization, and only the control that need be absorbed in client gets final product.By this method, the mpeg player of the new many examples of support of exploitation that do not need to require efforts again.

Claims (1)

1. a method that makes target client in the client process can directly call the function of the service object in the service processes comprises the steps:

Call gate is created service processes according to the solicited message of the target client in the client process, and described solicited message comprises: the path of service processes and the overall situation of service processes are unified identification code;

Service processes starts, and to the information of call gate registration oneself, comprising: create service object's function pointer, the function pointer that the notification service process is closed and the overall situation of service processes are unified identification code;

Call gate is created the service object according to target client's solicited message in service processes, solicited message comprises: the process handle of service processes, and service object's class identification code, service object's identification code is accepted the address pointer of service object's pointer;

When the target client need call service object's function, call gate is the process handle of service processes, service object's pointer, invoked function, the number of function parameter and function parameter tabulation are sent to service processes, call gate calls the function of service specified object in service processes, after invoked procedure finished, call gate returned the function call rreturn value to client process;

If the target client no longer needs the service object, then call gate discharges the service object according to target client's release service object's solicited message in service processes;

If the target client no longer needs service processes, the process handle of the service processes that provides according to the target client of call gate then calls and closes function and close service processes.

Images