用户自定义结构数据与VARIANT转换

用户自定义结构数据与VARIANT转换

cheungmine

将用户自定义的C结构数据存储成VARIANT类型，需要时再将VARIANT类型转为用户自定义的结构数据，有十分现实的意义，既然我们不想为这样的结构数据写一个COM包装类。虽然有很多方法和手段生成这样的VARIANT，但是，多数时候可能需要一个更加简单的，灵活的方法。我在做远程过程调用的C接口时，忽然联想到，既然RPC可以把任何数据以字节的形式发送，那么，就可以利用这个机制，把结构打包成字节数组。而字节数据是可以很方便地存储在VARIANT中。

这个过程是广为人知的，但是，真正把结构列集成字节数组，如果不想使用某些标称的序列化的方法，而全部自己写，的确要费一番功夫。不是

技术有多难，是很繁琐。我把前2年写的代码翻出来，简单调用一下，就有了这篇文章。采用我的方法，C/C++程序员可以把自己定义的结构放到VARIANT、CComVariant、COleVariant等各种VARIANT中，也可以反向转换。而VARIANT是可以很方便地在COM接口中传递。这样，就多了一种在自动化COM接口中传递自定义结构的手段。

不多说废话，全部内容见下面的代码，我还会上传整个工程。

struct2variant.cpp 如下：

///////////////////////////////////////////////////////////////////////
// struct2variant.cpp
// [e-mail]
// 2010-6
// 下面的程序演示了如何在用户自定义的结构和VARIANT类型之间转换
// 保留所有权利
//
#include "stdafx.h"
#include "rpc/rpcapi.h"
#include <assert.h>
#ifdef _DEBUG
#  pragma comment(lib, "rpc/rpclib/debug/rpclib.lib")
#else
#  pragma comment(lib, "rpc/rpclib/release/rpclib.lib")
#endif
// 自定义结构标识
#define MY_STRUCT_ID  101	// 标识结构的任意数字
typedef struct _PointF
{
	double x;
	double y;
}PointF;
// 自定义结构
typedef struct _MyStruct
{
	CHAR      id[32];
	CHAR      server[130];
	CHAR      instance[10];
	CHAR      userid[32];
	BOOL      isdraw;
	ULONG     token;
	LONG      timeout;
	LONG      keepalive;
	LONG      reserved;
	BOOL      status;
	LONG      capacity;
	LONG volatile counter;
	// 说明如何保存变长数组
	SHORT     numPts;
	PointF   *ptArray;	
}MyStruct;
void PrintfMyStruct(const char *desc, MyStruct *data)
{
	printf("==========%s==========/n", desc);
	printf("id=%s/n", data->id);
	printf("server=%s/n", data->server);
	printf("instance=%s/n", data->instance);
	printf("userid=%s/n", data->userid);
	printf("isdraw=%d/n", data->isdraw);
	printf("token=%d/n", data->token);
	printf("timeout=%d/n", data->timeout);
	printf("keepalive=%d/n", data->keepalive);
	printf("reserved=%d/n", data->reserved);
	printf("status=%d/n", data->status);
	printf("capacity=%d/n", data->capacity);
	printf("counter=%d/n", data->counter);
	printf("numPts=%d/n", data->numPts);
	for(int i=0; i<data->numPts; i++)
		printf("ptArray[%d]= (x=%.3lf,     y=%.3lf)/n", i, data->ptArray[i].x, data->ptArray[i].y);
}
static HRESULT CreateStreamFromBytes(BYTE *inBytes, DWORD cbSize, IStream **ppStm)
{
	HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, 0);
	ATLASSERT(hGlobal);
	if (!hGlobal)
		return E_OUTOFMEMORY;
	
	CComPtr<IStream> spStm;
	HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &spStm);
	ATLASSERT(hr == S_OK);
	if (hr != S_OK || spStm == 0){
		GlobalFree(hGlobal);
		return hr;
	}
	
	ULONG  ulWritten = 0;
	hr = spStm->Write(inBytes, cbSize, &ulWritten);
	if (hr != S_OK || ulWritten != cbSize)
		return E_FAIL;
	return spStm.CopyTo(ppStm);
}
////////////////////////////////////////////////////////////////////
// 列集自定义数据到VARIANT
//
static void MarshallMyStruct(MyStruct *inData, VARIANT *outVar)
{
	assert(inData && outVar);
	rpc_invoke_descriptor  inv  = {0};
	rpc_invoke_init(&inv, MY_STRUCT_ID, 14);	// 14个参数
	// 下面每个结构成员参数都需要按次序绑定
	rpc_invoke_bind_param(&inv, 
				0,					  /* 结构成员参数索引0-based */
				RPCT_STRING,		  /* 指明字符串数组类型 */
				(void*)inData->id,	  /* 指向实际数据的指针 */
				strlen(inData->id)+1, /* 只需要保存有效的数据 */
				0					  /*0 表示我们不具有id的所有权(不负责释放内存) */
			);
	rpc_invoke_bind_param(&inv, 
				1,
				RPCT_STRING,
				(void*)inData->server,
				strlen(inData->server)+1,
				0
			);
	rpc_invoke_bind_param(&inv, 
				2,
				RPCT_STRING,
				(void*)inData->instance,
				strlen(inData->instance)+1,
				0
			);
	rpc_invoke_bind_param(&inv, 
				3,
				RPCT_STRING,
				(void*)inData->userid,
				strlen(inData->userid)+1,
				0
			);
	rpc_invoke_bind_param(&inv, 
				4,
				RPCT_BOOL,
				(void*) &inData->isdraw,
				0,	/* 不是数组, 为0 */
				0
			);
	rpc_invoke_bind_param(&inv, 
				5,
				RPCT_ULONG,
				(void*) &inData->token,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				6,
				RPCT_LONG,
				(void*) &inData->timeout,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				7,
				RPCT_LONG,
				(void*) &inData->keepalive,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				8,
				RPCT_LONG,
				(void*) &inData->reserved,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				9,
				RPCT_BOOL,
				(void*) &inData->status,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				10,
				RPCT_LONG,
				(void*) &inData->capacity,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				11,
				RPCT_LONG,
				(void*) &inData->counter,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				12,
				RPCT_SHORT,
				(void*) &inData->numPts,
				0,
				0
			);
	rpc_invoke_bind_param(&inv, 
				13,
				RPCT_DOUBLE,	/* 简单结构的成员类型 */
				(void*) inData->ptArray,	/* 内存结构=[x1,y1,x2,y2,...,xn,yn], 千万不可写成:(void*) &inData->ptArray */
				inData->numPts * (sizeof(PointF)/sizeof(double)), /* double类型成员的数目=点数x2 */
				0
			);
	/* 计算调用消息的字节总数 */
	dword_t cbOut = rpc_invoke_get_size(&inv);
	char *outBuf = (char*) malloc(cbOut);
	
	/* 列集全部数据到totalBuf中 */
	rpc_invoke_marshal(&inv, outBuf, cbOut);
	//////////////////////////////////////////////////////////
	// 到此，我们已经在outBuf中保存了结构的全部数据, 
	// 下面把数据转换成IStream进而转换成VARIANT
	CComPtr<IStream> spStm;
	CreateStreamFromBytes((BYTE*)outBuf, cbOut, &spStm);
	VariantInit(outVar);
	outVar->vt = VT_UNKNOWN;
	outVar->punkVal = (IUnknown*) spStm.Detach();
	free(outBuf);
	rpc_invoke_clear_all(&inv);
}
////////////////////////////////////////////////////////////////////
// 散集VARIANT到自定义数据
//
static void UnmarshallMyStruct(VARIANT *inVar, MyStruct *outData)
{
	assert(inVar && outData);
	assert(inVar->vt==VT_UNKNOWN && inVar->punkVal);
	HGLOBAL  hGlobal = 0;
	HRESULT hr = GetHGlobalFromStream((IStream*)inVar->punkVal, &hGlobal);
	assert(hr==S_OK);
	size_t  cbData = GlobalSize(hGlobal);
	char   *pbData = (char*) GlobalLock(hGlobal);
	char   *rpcHdr = pbData;
	assert(cbData >= RPC_INVOKE_HEADER_SIZE);
	assert(rpcHdr[0]=='R' && rpcHdr[1]=='C');
	rpc_invoke_descriptor  inv={0};
	rpc_invoke_init(&inv, 0, 0);
	inv.encPkg = rpcHdr[2];
	inv.encHdr = rpcHdr[3];
	assert (inv.encHdr == 0);
	inv.ordinal = word_ntoh(*((word_t*)(rpcHdr+20)));				// 方法序号: MY_STRUCT_ID
	assert(inv.ordinal == MY_STRUCT_ID);
	inv.invToken = dword_ntoh(*((dword_t*)(rpcHdr+4)));				// 用户标识	
	inv.totalBytes = dword_ntoh(*((dword_t*)(rpcHdr+8)));			// 总消息字节数(也许是压缩的)
	inv.bitsFlag = word_ntoh(*((word_t*)(rpcHdr+12)));				// 标志	
	inv.bigEndian = GET_BIT(inv.bitsFlag, RPC_BIGENDIAN_BIT);		// 客户方列集的字节次序
	inv.reserved = word_ntoh(*((word_t*)(rpcHdr+14)));				// 保留值
	inv.result = dword_ntoh(*((dword_t*)(rpcHdr+16)));			    // 返回值
	inv.num_params = word_ntoh(*((word_t*)(rpcHdr+22)));			// 参数数目
	rpc_invoke_error  err={0};
	rpc_invoke_unmarshal(&inv, rpcHdr, inv.totalBytes, &inv.params_list, &inv.num_params, &err);
		
	GlobalUnlock(hGlobal);
	strncpy_s(outData->id, sizeof(outData->id), (char*) inv.params_list[0].param_bytes, sizeof(outData->id)-1);
	strncpy_s(outData->server, sizeof(outData->server), (char*) inv.params_list[1].param_bytes, sizeof(outData->server)-1);
	strncpy_s(outData->instance, sizeof(outData->instance), (char*) inv.params_list[2].param_bytes, sizeof(outData->instance)-1);
	strncpy_s(outData->userid, sizeof(outData->userid), (char*) inv.params_list[3].param_bytes, sizeof(outData->userid)-1);
	outData->isdraw = PARAMVALUE(inv.params_list, 4, BOOL);
	outData->token = PARAMVALUE(inv.params_list, 5, ULONG);
	outData->timeout = PARAMVALUE(inv.params_list, 6, LONG);
	outData->keepalive = PARAMVALUE(inv.params_list, 7, LONG);
	outData->reserved = PARAMVALUE(inv.params_list, 8, LONG);
	outData->status = PARAMVALUE(inv.params_list, 9, BOOL);
	outData->capacity = PARAMVALUE(inv.params_list, 10, LONG);
	outData->counter = PARAMVALUE(inv.params_list, 11, LONG);
	outData->numPts = PARAMVALUE(inv.params_list, 12, SHORT);
	// 为输出分配 ptArray
	outData->ptArray = (PointF*) malloc(sizeof(PointF)*outData->numPts);
	memcpy(outData->ptArray, inv.params_list[13].param_bytes, sizeof(PointF)*outData->numPts);
	rpc_invoke_clear_all(&inv);
}
int main(int argc, CHAR* argv[])
{
	MyStruct     data, data2;
	CComVariant  var;	// 这个var 可以存储在任何需要使用到的地方
	// 初始化结构data
	strcpy_s(data.id, sizeof(data.id), "13890");
	strcpy_s(data.server, sizeof(data.server), "localhost");
	strcpy_s(data.instance, sizeof(data.instance), "port:6755");
	strcpy_s(data.userid, sizeof(data.userid), "cheungmine");
	data.isdraw = 1;
	data.token = 54321;
	data.timeout = 3000;
	data.keepalive = 6500;
	data.reserved=0;
	data.status = 0;
	data.capacity = 4096;
	data.counter = 99;
	data.numPts = 16;
	data.ptArray = (PointF*) malloc(data.numPts*sizeof(PointF));
	for(int i=0; i<data.numPts; i++){
		data.ptArray[i].x = 100+i;
		data.ptArray[i].y = 200+i;
	}
	PrintfMyStruct("input MyStruct", &data);
	
	// 用户的结构转换为VARIANT: data=>var
	MarshallMyStruct(&data, &var);
	free(data.ptArray);
	// ...使用var
	// VARIANT转为用户的结构: var=>data
	UnmarshallMyStruct(&var, &data2);
	PrintfMyStruct("output MyStruct", &data2);
	free(data2.ptArray);
}

其中：rpcapi.h可以参考如下：

/**
 * rpcapi.h [e-mail]
 * all rights reserved 2009
 */
#ifndef _RPCAPI_H__
#define _RPCAPI_H__
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#include <process.h>	/* _beginthreadex, _endthread */
#include "../rc4/unistd.h"
#include "../rc4/md5.h"
#include "../rc4/rc4.h"
#include "rpctype.h"
#include "rpcerr.h"
#ifdef __cplusplus
extern "C" {
#endif
static BOOL  _rpc_is_bigendian = (('4321'>>24)=='1');
#define PARAMVALUE(pl,i,type)	  ((type)(*((type*) pl[i].param_bytes)))
typedef enum
{
	RPC_ENCHEADER_BIT  = 0,
    RPC_ENCPACKAGE_BIT  = 1,
	RPC_BIGENDIAN_BIT  = 7
}RPC_BITFLAG_ENUM;
/**
 * param descriptor 
 */
#define RPC_PARAM_HEADER_SIZE  16
typedef struct _rpc_param_descriptor
{
	word_t      param_type;         // 参数类型:变量类型或结构类型
	word_t      size_type;          // 参数类型尺寸字节
	size_t		array_size;         // 数组元素数目: 0 不是数组; >0数组
	
	size_t	    param_size;	        // 参数数据字节数=参数类型尺寸字节*元素数目
	void       *param_bytes;	    // 指向参数数据的指针的引用, 不复制数据
	BOOL        is_owner;			// 是否拥有数据. 如果为TRUE, 需要free(param_bytes)
}rpc_param_descriptor;
/**
 * invoke descriptor 
 */
#define RPC_INVOKE_HEADER_SIZE  24		/* 不可以更改 */
typedef struct _rpc_invoke_descriptor
{
	/* 24字节头 + 内容
	 *  ['RCmn'(4)|用户标识(4)|总消息字节(4)|标志(2)| 保留(2)|原始字节数(4)|方法序号(2)|参数数目(2)]
	 */
	dword_t				   totalBytes;  // 总消息字节4
	word_t		           bitsFlag;    // 标志位2: [7=BigEndian]
	word_t		           reserved;    // 保留2
	dword_t				   result;		// 返回值
	// 内部值, 调用时,需要列集在bitsFlag中
	dword_t                invToken;
	byte				   bigEndian;
	byte				   encHdr;
	byte                   encPkg;
	// 如果压缩或加密, 从以下位置内容开始	
	ushort		           ordinal;	    // 方法序号2	
	ushort                 num_params;	// 参数数目
	rpc_param_descriptor  *params_list; // 参数列表
	// 做为输入时, 存放临时值
	//
	char                  *pbBuf;
	union{
		char			   bVal;
		long               lVal;
		short			   sVal;
		float			   fVal;
		double             dVal;
		__int64			   llVal;
	};
}rpc_invoke_descriptor;
/**
 * connection descriptor
 */
typedef struct _rpc_connection_descriptor
{
	BOOL               is_bigendian;	// 字节顺序
	dword_t		       token;			// 调用标识
	dword_t			   timeout;			// 超时
	byte               enc_hdr;			// 头加密标志
	byte               enc_pkg;			// 参数包加密标志
	SOCKET             stream;			// SOCKET 连接
	char		       host[130];		// 主机名或IP地址
	char               port[6];			// 端口号
	
	rpc_invoke_error   last_err;		// 最近的错误
	char			   buffer[RPC_BUFFSIZE];  // 网络传输缓冲区
}rpc_connection_descriptor;
/*=============================================================================
						      Private Functions
				 host byte order and network byte order transform
=============================================================================*/
static int SafeStringSize(const char* psz)
{
	return (int)(psz? (strlen(psz)+1):0);
}
/**
 * More fast than swap_bytes(...) for handle word and dword type
 */
#define swap_word_type(x)  ((WORD)(((((WORD)(x))&0x00ff)<<8)|((((WORD)(x))&0xff00)>>8)))
#define swap_dword_type(x)  ((DWORD)(((((DWORD)(x))&0xff000000)>>24)|((((DWORD)(x))&0x00ff0000)>>8)|((((DWORD)(x))&0x0000ff00)<<8)|((((DWORD)(x))&0x000000ff)<<24)))
static void swap_bytes(void *wordP, size_t cbSize /*must be 2, 4, 8 */)
{
    size_t   i;
    byte     t;
    for(i=0; i<cbSize/2; i++){
        t = ((byte *) wordP)[i];
        ((byte *)wordP)[i] = ((byte *) wordP)[cbSize-i-1];
        ((byte *) wordP)[cbSize-i-1] = t;
    }
}
static dword_t  dword_hton(dword_t host)
{
	if (!_rpc_is_bigendian)
		host = swap_dword_type(host);
	return  host;
}
static dword_t  dword_ntoh(dword_t net)
{
	if (!_rpc_is_bigendian)
		net = swap_dword_type(net);
	return  net;
}
static word_t   word_hton(word_t host)
{
	if (!_rpc_is_bigendian)
		host = swap_word_type(host);
	return  host;
}
static word_t   word_ntoh(word_t net)
{
	if (!_rpc_is_bigendian)
		net = swap_word_type(net);
	return  net;
}
static qword_t  qword_hton(qword_t host)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&host, sizeof(qword_t));
	return  host;
}
static qword_t  qword_ntoh(qword_t net)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&net, sizeof(qword_t));
	return  net;
}
static double   double_hton(double host)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&host, sizeof(qword_t));
	return  host;
}
static double   double_ntoh(double net)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&net, sizeof(qword_t));
	return  net;
}
static float    float_hton(float host)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&host, sizeof(dword_t));
	return  host;
}
static float    float_ntoh(float net)
{
	if (!_rpc_is_bigendian)
		swap_bytes(&net, sizeof(dword_t));
	return  net;
}
/*=============================================================================
						      Private Functions
				           socket helper functions
=============================================================================*/
static int setbufsize(SOCKET s, int rcvlen /*RPC_BUFFSIZE*/, int sndlen /*RPC_BUFFSIZE*/)
{
	int rcv, snd;
	int rcvl = (int) sizeof(int);
	int sndl = rcvl;
	if ( getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char*)&rcv, &rcvl)==SOCKET_ERROR ||
		 getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char*)&snd, &sndl)==SOCKET_ERROR )
		return SOCKET_ERROR;
	
	if(rcv < rcvlen){
		rcv = rcvlen;
		rcvl = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char*)&rcv, rcvl);
		assert(rcvl==0);
	}
	
	if(snd < sndlen){
		snd = sndlen;	
		sndl = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char*)&snd, sndl);
		assert(sndl==0);
	}
	return 0;
}
static int sendmsg(SOCKET s, const char* msgbuf, int msglen, int flags)
{
	int ret;
	int offset = 0;
	int left = msglen;	
	while (left > 0) {
		ret = send(s, &msgbuf[offset], left, flags);
		if (ret==SOCKET_ERROR || ret==0)
			return ret;		
		left -= ret;
		offset += ret;
	}
	assert(offset==msglen);
	return offset;
}
static int recvmsg(SOCKET s, char* msgbuf, int buflen, int flags)
{
	int     ret;
	int		offset = 0;
	int		left = buflen;	
	while (left > 0){
		ret = recv(s, &msgbuf[offset], left, flags);
		if (ret==SOCKET_ERROR || ret==0)
			return ret;
		offset += ret;
		left -= ret;
	}
	assert(offset==buflen);
	return offset;
}
static BOOL sendbulk(SOCKET s, const char* data, int dataSize, int flags, int maxmsg)
{
	int send, ret;
	int offset = 0;
	int left = dataSize;
	while (left > 0) {
		send = left>maxmsg? maxmsg:left;
		ret = sendmsg(s, &data[offset], send, flags);
		if (ret != send)
			return FALSE;
		offset += ret;
		left -= ret;
	}
	return TRUE;
}
static BOOL recvbulk(SOCKET s, char* buf, int recvlen, int flags, int maxmsg)
{
	int  recv, ret;
	int  offset = 0;
	int  left = recvlen;
	while (left > 0){
		recv = left>maxmsg? maxmsg:left;
		ret = recvmsg(s, &buf[offset], recv, flags);
		if (ret != recv)
			return FALSE;
		offset += ret;
		left -= ret;
	}
	return TRUE;
}
static LPCSTR errmsg(DWORD dwCode, LPSTR lpszMsgBuf, DWORD dwMsgBufBytes)
{
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL, dwCode, 0, /* Default language */
			lpszMsgBuf,
			dwMsgBufBytes,
			NULL);
	return lpszMsgBuf;
}
static void rpc_error_clear(rpc_invoke_error *err)
{
	err->err_type = RPC_NO_ERROR;
	err->err_code = 0;
	*err->err_source = 0;
	*err->err_detail = 0;
}
// [RESM(4)|总消息字节(4)|err_type(2)|err_code(2)|err_source_size(2)|err_source_string|err_detail_size(2)|err_detail_string]
static BOOL rpc_error_short_msg(SOCKET s, char *buf, int size, rpc_invoke_error *err)
{
	int pos = 0;
	word_t w;
	ushort err_source_size = (ushort)strlen(err->err_source)+1;
	ushort err_detail_size = (ushort)strlen(err->err_detail)+1;
	ulong  msglen = 4+4+2+2+2+err_source_size+2+err_detail_size;
	*buf = 0;
	assert((ulong)size>=msglen);
	buf[pos++] = 'R';
	buf[pos++] = 'E';
	buf[pos++] = 'S';
	buf[pos++] = 'M';
	
	msglen = dword_hton(msglen);
	memcpy(buf+pos, &msglen, 4);
	pos += 4;
	w = word_hton((word_t)err->err_type);
	memcpy(buf+pos, &w, 2);
	pos += 2;
	w = word_hton((word_t)err->err_code);
	memcpy(buf+pos, &w, 2);
	pos += 2;
	w = word_hton((word_t)err_source_size);
	memcpy(buf+pos, &w, 2);
	pos += 2;	
	memcpy(buf+pos, err->err_source, err_source_size);
	pos += err_source_size;
	w = word_hton((word_t)err_detail_size);
	memcpy(buf+pos, &w, 2);
	pos += 2;
	memcpy(buf+pos, err->err_detail, err_detail_size);
	pos += err_detail_size;
	assert((ulong)pos == dword_ntoh(msglen));
	if (pos == (ulong)sendmsg(s, buf, pos, 0))
		return TRUE;
	err->err_type = RPC_SOCKET_ERROR;
	err->err_code = WSAGetLastError();
	*err->err_source = 0;
	errmsg(err->err_code, err->err_detail, RPC_ERROR_STRING_LEN);
	
	return FALSE;
}
static void debug_out(const char *debug_file, const char *fmt, ...)
{
#ifdef _DEBUG
	FILE *fp = 0;
	va_list ap;
	
	fopen_s(&fp, debug_file, "a+");
	assert(fp);
	
	va_start(ap, fmt);
	vfprintf(fp, fmt, ap);
	va_end(ap);
	fclose(fp);
#endif
}
/*============================================================================
					   RPC PUBLIC FUNCTIONS
 ============================================================================*/
/**
 * rpc_throw_error
 */
RPCRESULT rpc_throw_error(RPC_ERROR_TYPE err_type, LONG err_code, const char* err_source, rpc_invoke_error *err);
/**
 * rpc_invoke_free
 *   创建RPC调用描述符
 */
rpc_invoke_descriptor* rpc_invoke_create(rpc_invoke_descriptor **inv, ushort ordinal, ushort num_params);
/**
 * rpc_invoke_init
 *   初始化RPC调用描述符
 */
rpc_invoke_descriptor *
rpc_invoke_init(rpc_invoke_descriptor *inv, ushort ordinal, ushort num_params);
/**
 * rpc_invoke_clear_all
 *   清除RPC调用描述符, 此后RPC调用描述符可以重新绑定变量
 */
void rpc_invoke_clear_all(rpc_invoke_descriptor *inv);
/**
 * rpc_invoke_free
 *   删除RPC调用描述符, 此后RPC调用描述符将不可用
 */
void rpc_invoke_free(rpc_invoke_descriptor *inv);
/**
 * rpc_invoke_set_param
 *   设置指定的参数, 返回参数指针
 */
rpc_param_descriptor* rpc_invoke_set_param(rpc_invoke_descriptor *inv, ushort id, word_t type);
/**
 * rpc_param_clear
 *   清除参数内容
 */
void rpc_param_clear(rpc_param_descriptor *param);
/**
 * rpc_param_free_list
 *   清除参数列表内容
 */
void rpc_param_free_list(rpc_param_descriptor *param_list, word_t num_params);
/**
 * rpc_connection_create
 *   创建RPC连接
 */
RPCRESULT rpc_connection_create(rpc_connection_descriptor **conn, const char *host, const char *port, long rcvtimeo, rpc_invoke_error *err);
/**
 * rpc_connection_free
 *   清除RPC连接
 */
void rpc_connection_free(rpc_connection_descriptor *conn);
/**
 * rpc_connection_set
 *   设置RPC连接的属性
 */
void rpc_connection_set(rpc_connection_descriptor *conn, dword_t token, dword_t timeout, byte encheader, byte encpackage);
/**
 * rpc_connection_free
 *   设置输入的参数, 返回参数指针
 */
rpc_param_descriptor* rpc_invoke_bind_param(rpc_invoke_descriptor *inv, ushort id, word_t type, void *vaddr, size_t array_size, BOOL is_owner);
/**
 * rpc_connection_free
 *   计算参数字节总数
 */
dword_t rpc_param_get_size(rpc_param_descriptor *param);
/**
 * rpc_connection_free
 *   计算调用消息的字节总数
 */
dword_t rpc_invoke_get_size(rpc_invoke_descriptor *inv);
/**
 * rpc_invoke_marshal
 *   列集全部数据到totalBuf中
 */
int rpc_invoke_marshal(rpc_invoke_descriptor *inv, char *totalBuf, int totalSize);
/**
 * rpc_invokehdr_unmarshal
 *   散集调用头
 */
RPCRESULT rpc_invokehdr_unmarshal(SOCKET sClient, dword_t dwToken, char *rpcHdr, int hdrSize, rpc_invoke_descriptor *inv, rpc_invoke_error *err);
/**
 * rpc_invoke_unmarshal
 *   散集数据到参数中
 */
RPCRESULT rpc_invoke_unmarshal(rpc_invoke_descriptor *inv, 
							   char                  *totalBuf, 
							   size_t                 totalSize,
							   rpc_param_descriptor **out_params,
							   word_t                *num_params,
							   rpc_invoke_error      *err);
/**
 * rpc_param_get_short
 *   取得短整数参数值
 */
void rpc_param_get_short (rpc_param_descriptor *param, SHORT *val);
/**
 * rpc_param_get_ushort
 *   取得短整数参数值
 */
void rpc_param_get_ushort (rpc_param_descriptor *param, USHORT *val);
/**
 * rpc_param_get_long
 *   取得整数参数值
 */
void rpc_param_get_long (rpc_param_descriptor *param, LONG *val);
/**
 * rpc_param_get_ulong
 *   取得无符号整数参数值
 */
void rpc_param_get_ulong (rpc_param_descriptor *param, ULONG *val);
/**
 * rpc_param_get_int
 *   取得整数参数值
 */
void rpc_param_get_int (rpc_param_descriptor *param, INT *val);
/**
 * rpc_param_get_double
 *   取得双精度参数值
 */
void rpc_param_get_double (rpc_param_descriptor *param, double *val);
/**
 * rpc_invoke_send
 *   发送数据
 */
RPCRESULT rpc_invoke_send(rpc_connection_descriptor *conn, rpc_invoke_descriptor *inv, rpc_invoke_error *err);
/**
 * rpc_invoke_recv
 *   接收数据
 */
RPCRESULT rpc_invoke_recv(rpc_connection_descriptor *conn, rpc_invoke_descriptor *outv, rpc_invoke_error *err);
/**
 * rpc_connection_free
 *   执行RPC调用
 */
RPCRESULT rpc_invoke_execute(rpc_connection_descriptor *conn, 
							 rpc_invoke_descriptor     *inv, 
							 rpc_invoke_descriptor     *outv, 
							 rpc_invoke_error          *err);
#ifdef __cplusplus
}
#endif
#endif /* _RPCAPI_H__ */

rpcapi.c如下：

/**
 * rpcapi.c [e-mail]
 */
#include "rpcapi.h"
// 打开socket
static RPCRESULT opensocket(SOCKET *pStream, const char *lpszServer, int nPort, rpc_invoke_error *pError)
{
	struct sockaddr_in   server;
	struct hostent      *hp = 0;
	unsigned int         iAddr;
	
	*pStream = INVALID_SOCKET;
	// Parse server host
	if(inet_addr(lpszServer) == INADDR_NONE){
		hp = gethostbyname(lpszServer);
		if(hp==0)
			return rpc_throw_error(RPC_USER_ERROR, RPC_INVALID_HOST, "opensocket()", pError);
		server.sin_addr.s_addr = *((unsigned long*)hp->h_addr);
	}
	else{
		iAddr = inet_addr(lpszServer);
		server.sin_addr.s_addr = iAddr;
	
		// too slow to use gethostbyaddr
	//OLD:	hp = gethostbyaddr((char*)&iAddr, sizeof(iAddr), AF_INET);
	//OLD:	if(hp==0)
	//OLD:		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALID_HOST, "opensocket()", pError);
	//OLD:	server.sin_addr.s_addr = *((unsigned long*)hp->h_addr);
	}
	server.sin_family = AF_INET;
	server.sin_port = htons((u_short)nPort);
	// Create a new socket and attempt to connect to server
	(*pStream) = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if ((*pStream) == INVALID_SOCKET)
		return rpc_throw_error(RPC_SOCKET_ERROR, WSAGetLastError(), "socket()", pError);
	// Make a connection to the server
	if (connect((*pStream), (struct sockaddr *) &server, sizeof(server))==SOCKET_ERROR){
		closesocket( *pStream );
		*pStream = INVALID_SOCKET;
		return rpc_throw_error(RPC_SOCKET_ERROR, WSAGetLastError(), "connect()", pError);
	}
	setbufsize(*pStream, RPC_BUFFSIZE, RPC_BUFFSIZE);
	return RPC_SUCCESS;
}
// 列集参数
static int rpc_param_marshal(rpc_param_descriptor *param, char *buf)
{
	word_t	 w;
	dword_t  dw;
	int pos = 0;
	// 参数头RPC_PARAM_HEADER_SIZE字节:
	//   [参数类型(2)|类型字节(2)|数组元素数目(4)|参数数据字节数(4)|参数成员数(2)=0|保留(2)=0]
	w = word_hton(param->param_type);
	memcpy(buf+pos, &w, 2);
	pos += 2;
	w = word_hton(param->size_type);
	memcpy(buf+pos, &w, 2);
	pos += 2;
	
	dw = dword_hton((dword_t)param->array_size);
	memcpy(buf+pos, &dw, 4);
	pos += 4;
	dw = dword_hton((dword_t)param->param_size);
	memcpy(buf+pos, &dw, 4);
	pos += 4;
	w = 0;
	memcpy(buf+pos, &w, 2);
	pos += 2;
	w = 0;
	memcpy(buf+pos, &w, 2);
	pos += 2;
	// 参数的数据
	memcpy(buf+pos, param->param_bytes, param->param_size);
	pos += (int)param->param_size;
	return pos;
}
// 散集参数
// 参数头RPC_PARAM_HEADER_SIZE字节:
//   [参数类型(2)|类型字节(2)|数组元素数目(4)|参数数据字节数(4)|参数成员数(2)|保留(2)=0]
static size_t rpc_param_unmarshal(BOOL marshal_bigendian, rpc_param_descriptor *param, char *buf)
{
	byte   *pcb;
	size_t  i;
	size_t  pos = 0;
	assert(param->array_size==0||param->array_size==param->param_size/param->size_type);
	// 参数类型
	param->param_type = word_ntoh(*((word_t*)(buf+pos)));
	pos += 2;
	param->size_type = word_ntoh(*((word_t*)(buf+pos)));
	pos += 2;
	param->array_size = dword_ntoh(*((dword_t*)(buf+pos)));
	pos += 4;
	param->param_size = dword_ntoh(*((dword_t*)(buf+pos)));
	pos += 4;
	// 参数成员
	pos += 2;
	// 保留值
	pos += 2;
	// 参数字节指针
	// 这里假设列集方marshal_bigendian和散集方_rpc_is_bigendian的字节次序一致, 
	// 以后要添加代码处理不一致的情况
	if (param->param_size==0){
		param->param_bytes = 0;
		return pos;
	}
	if (param->size_type==1 || marshal_bigendian==_rpc_is_bigendian){
		param->param_bytes = (void*)(buf+pos);
		return (pos + param->param_size);
	}
	
	// 必须交换字节次序
	//
	assert(param->size_type==2||param->size_type==4||param->size_type==8);
	assert(marshal_bigendian != _rpc_is_bigendian);
	param->param_bytes = (void*)(buf+pos);
	pcb = (buf+pos);
	
	i = param->param_size/param->size_type;
	while(i-->0){
		swap_bytes(&pcb[i*param->size_type], param->size_type);
	}
	assert(i==-1);
	return (pos + param->param_size);
}
void rpc_param_get_ushort (rpc_param_descriptor *param, USHORT *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_USHORT && param->size_type==RPC_TYPE_SIZE(RPCT_USHORT));
	
	*val = *((USHORT*)(param->param_bytes));
}
void rpc_param_get_short (rpc_param_descriptor *param, SHORT *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_SHORT && param->size_type==RPC_TYPE_SIZE(RPCT_SHORT));
	
	*val = *((SHORT*)(param->param_bytes));
}
void rpc_param_get_long (rpc_param_descriptor *param, LONG *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_LONG && param->size_type==RPC_TYPE_SIZE(RPCT_LONG));
	
	*val = *((LONG*)(param->param_bytes));
}
void rpc_param_get_int (rpc_param_descriptor *param, INT *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_INT && param->size_type==RPC_TYPE_SIZE(RPCT_INT));
	
	*val = *((INT*)(param->param_bytes));
}
void rpc_param_get_ulong (rpc_param_descriptor *param, ULONG *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_ULONG && param->size_type==RPC_TYPE_SIZE(RPCT_ULONG));
	
	*val = *((ULONG*)(param->param_bytes));
}
void rpc_param_get_double (rpc_param_descriptor *param, DOUBLE *val)
{
	assert(param && param->param_bytes && param->array_size==0 && 
		   param->param_type==RPCT_DOUBLE && param->size_type==RPC_TYPE_SIZE(RPCT_DOUBLE));
	
	*val = *((DOUBLE*)(param->param_bytes));
}
RPCRESULT rpc_invoke_send(rpc_connection_descriptor *conn, rpc_invoke_descriptor *inv, rpc_invoke_error *err)
{
	BOOL       br;
	char      *buffer = 0;
	dword_t    cbTotal = 0;
	
	cbTotal = rpc_invoke_get_size(inv);
		
	// 既然<=RPC_BUFFSIZE, 则使用默认的buffer
	if (cbTotal <= RPC_BUFFSIZE){
		cbTotal = rpc_invoke_marshal(inv, conn->buffer, cbTotal);
		assert(cbTotal != -1);
			
		if (cbTotal != sendmsg(conn->stream, conn->buffer, cbTotal, 0))
			return rpc_throw_error(RPC_SOCKET_ERROR, WSAGetLastError(), "rpc_invoke_send()", err);
		else
			return RPC_SUCCESS;
	}
	else {
		buffer = malloc(cbTotal);
		
		// 内存分配失败
		if (!buffer)
			return rpc_throw_error(RPC_SYSTEM_ERROR, GetLastError(), "rpc_invoke_send()", err);
		
		cbTotal = rpc_invoke_marshal(inv, buffer, cbTotal);
		assert(cbTotal != -1);
		
		// 发送大块数据
		br = sendbulk(conn->stream, buffer, cbTotal, 0, RPC_BUFFSIZE);
		FREE_S(buffer)
		if (!br)
			return rpc_throw_error(RPC_SOCKET_ERROR, WSAGetLastError(), "rpc_invoke_send()", err);
		else
			return RPC_SUCCESS;
	}
}
RPCRESULT rpc_invoke_recv(rpc_connection_descriptor *conn, rpc_invoke_descriptor *outv, rpc_invoke_error *err)
{
	RPCRESULT  res;
	// 接收头
	res = rpc_invokehdr_unmarshal(conn->stream, conn->token, conn->buffer, RPC_INVOKE_HEADER_SIZE, outv, err);
	if (RPC_SUCCESS != res)
		return res;
	// 验证token
	if (conn->token != outv->invToken)
		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALIDMSG, "rpc_invoke_recv()", err);
	// 接收其余全部数据
	if (outv->totalBytes > RPC_BUFFSIZE){
		MALLOC_S(outv->pbBuf, outv->totalBytes, char);
		memcpy(outv->pbBuf, conn->buffer, RPC_INVOKE_HEADER_SIZE);
	}
	else{
		outv->pbBuf = conn->buffer;
	}
	assert(outv->pbBuf);
	if (!recvbulk(conn->stream, outv->pbBuf+RPC_INVOKE_HEADER_SIZE, outv->totalBytes-RPC_INVOKE_HEADER_SIZE, 0, RPC_BUFFSIZE)){
		if (outv->pbBuf != conn->buffer){
			FREE_S(outv->pbBuf)
			outv->pbBuf = 0;
		}
		return rpc_throw_error(RPC_USER_ERROR, RPC_NETWORK_ERROR, "rpc_invoke_recv()", err);
	}
	if (RPC_SUCCESS != rpc_invoke_unmarshal(outv, outv->pbBuf, outv->totalBytes, &outv->params_list, &outv->num_params, err)){
		if (outv->pbBuf != conn->buffer){
			FREE_S(outv->pbBuf)
			outv->pbBuf = 0;
		}
		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALIDMSG, "rpc_invoke_recv()", err);
	}
	return RPC_SUCCESS;
}
/*=============================================================================
						      Public Functions
				      Remote Procedure Call Impementation
=============================================================================*/
rpc_invoke_descriptor*
rpc_invoke_create(rpc_invoke_descriptor **inv, ushort ordinal, ushort num_params)
{   
	assert(inv);
	MALLOC_S(*inv, 1, rpc_invoke_descriptor)
	assert(*inv);
	
	(*inv)->bigEndian = _rpc_is_bigendian;
	(*inv)->ordinal = ordinal;
	(*inv)->num_params = num_params;
		
	MALLOC_S((*inv)->params_list, num_params, rpc_param_descriptor)
		
	return (*inv);
}
rpc_invoke_descriptor *
rpc_invoke_init(rpc_invoke_descriptor *inv, ushort ordinal, ushort num_params)
{   
	assert(inv);
	rpc_invoke_clear_all(inv);
	inv->ordinal = ordinal;
	inv->num_params = num_params;	
	MALLOC_S(inv->params_list, num_params, rpc_param_descriptor)
	return inv;
}
void rpc_invoke_clear_all(rpc_invoke_descriptor *inv)
{
	assert(inv);
	if (inv->pbBuf && inv->totalBytes>RPC_BUFFSIZE){
		FREE_S(inv->pbBuf)
		assert(inv->pbBuf==0);
	}
	rpc_param_free_list(inv->params_list, inv->num_params);
	memset(inv, 0, sizeof(rpc_invoke_descriptor));
	inv->bigEndian = _rpc_is_bigendian? 1:0;
}
void rpc_invoke_free(rpc_invoke_descriptor *inv)
{
	rpc_invoke_clear_all(inv);
	FREE_S(inv)
}
rpc_param_descriptor* rpc_invoke_bind_param(rpc_invoke_descriptor *inv, ushort id, word_t type, void *vaddr, size_t array_size, BOOL is_owner)
{
	rpc_param_descriptor* p;
	assert(id>=0 && id<inv->num_params);
	p = &inv->params_list[id];
	p->param_type = type;
	p->size_type = RPC_TYPE_SIZE(type);	
	p->array_size = array_size;
	p->param_bytes = vaddr;		// may be NULL
	if (type == RPCT_STRING)
		p->param_size = array_size;
	else
		p->param_size = p->size_type * (array_size > 0? array_size : 1);
		
	p->is_owner = is_owner;
	return p;
}
void rpc_param_clear(rpc_param_descriptor *p)
{
	if (p->is_owner)
		FREE_S(p->param_bytes)
	
	memset(p, 0, sizeof(rpc_param_descriptor));
}
void rpc_param_free_list(rpc_param_descriptor *param_list, word_t num_params)
{
	while(num_params-->0)
		rpc_param_clear(&param_list[num_params]);
	FREE_S(param_list)
}
RPCRESULT rpc_connection_create(rpc_connection_descriptor **conn, const char *host, const char *port, long rcvtimeo, rpc_invoke_error *err)
{
	WSADATA   wsd;
	struct timeval tv_out;
	int       i;
	// 加载WinSock DLL
	if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
		return rpc_throw_error(RPC_USER_ERROR, RPC_WINSOCK_NOTFOUND, "WSAStartup()", err);
	// 创建对象
	MALLOC_S(*conn, 1, rpc_connection_descriptor)
	
	// 设置字节顺序
	(*conn)->is_bigendian = _rpc_is_bigendian;
	// 设置主机名
	if (!host || host[0]==0)
		strcpy_s((*conn)->host, 128, "localhost");
	else if (strlen(host)<128)
		strcpy_s((*conn)->host, 128,  host);
	else {
		rpc_connection_free(*conn);
		return rpc_throw_error(RPC_USER_ERROR, RPC_HOSTNAME_TOOLONG, "rpc_connection_create()", err);
	}
	
	// 设置端口号:
	// 必须是 gde:xxxx
	if (!port || port[0]==0 || strlen(port)<4 || strlen(port)>5) {
		rpc_connection_free(*conn);
		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALID_PORT, "rpc_connection_create()", err);
	}
	i = 0;
	while( port[i] != 0 ){
		if ( !isdigit(port[i]) ){
			rpc_connection_free(*conn);
			return rpc_throw_error(RPC_USER_ERROR, RPC_INVALID_PORT, "rpc_connection_create()", err);		
		}
		i++;
	}
	i = atoi(port);
	if (i<0x0400 || i>0xFFFF) { // port = [1024,65535]
		rpc_connection_free(*conn);
		return rpc_throw_error(RPC_USER_ERROR, RPC_PORTNUM_OUTOF_SCOPE, "rpc_connection_create()", err);
	}
	strcpy_s((*conn)->port, 6, port);
		
	// 打开SOCKET
	if (RPC_SUCCESS != opensocket(&((*conn)->stream), host, i, err)){
		rpc_connection_free(*conn);
		return RPC_ERROR;
	}
	/*
	 * set timeout for recv */
	if (rcvtimeo >= 0){
		tv_out.tv_sec  = rcvtimeo/1000;
		tv_out.tv_usec = (rcvtimeo%1000)*1000;
		i = setsockopt((*conn)->stream, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv_out, sizeof(tv_out));
		assert(i == 0);
	}
	(*conn)->timeout = rcvtimeo;
	return RPC_SUCCESS;
}
void rpc_connection_free(rpc_connection_descriptor *conn)
{
	if (conn){
		closesocket(conn->stream);
		WSACleanup();
		FREE_S(conn)
	}
}
void rpc_connection_set(rpc_connection_descriptor *conn, dword_t token, dword_t timeout, byte enc_hdr, byte enc_pkg)
{
	conn->token = token;
	conn->timeout = timeout;
	conn->enc_hdr = enc_hdr;
	conn->enc_pkg = enc_pkg;
}
// 计算参数字节总数
dword_t rpc_param_get_size(rpc_param_descriptor *param)
{
	return RPC_PARAM_HEADER_SIZE + (dword_t)param->param_size;
}
// 计算调用消息的字节总数
dword_t rpc_invoke_get_size(rpc_invoke_descriptor *inv)
{
	ushort   i;
	dword_t  cbTotal = RPC_INVOKE_HEADER_SIZE;
	
	// 列集头24字节:
	//   ['RCmn'(4)|用户标识(4)|总消息字节(4)|标志(2)| 保留(2)|返回值(4)|方法序号(2)|参数数目(2)]
	// 计算列集参数字节
	for (i=0; i<inv->num_params; i++)
		cbTotal += rpc_param_get_size(&(inv->params_list[i]));
	
	return cbTotal;
}
// 把当前调用的数据全部放到totalBuf中, 返回全部字节数
/*  24字节头 + 内容
 *  ['RCmn'(4)|用户token(4)|总消息字节(4)|标志(2)| 保留(2)|返回值(4)|方法序号(2)|参数数目(2)]
 */
int rpc_invoke_marshal(rpc_invoke_descriptor *inv, char *totalBuf, int totalSize)
{
	word_t	 w;
	dword_t  dw;
	dword_t  pos;
	char     key[33];
	SET_BIT(inv->bitsFlag, RPC_BIGENDIAN_BIT, inv->bigEndian);
	SET_BIT(inv->bitsFlag, RPC_ENCHEADER_BIT, inv->encHdr==0? 0:1);
	SET_BIT(inv->bitsFlag, RPC_ENCPACKAGE_BIT, inv->encPkg==0? 0:1);
	// 列集方法头
	totalBuf[0] = 'R';
	totalBuf[1] = 'C';
	totalBuf[2] = inv->encPkg;
	totalBuf[3] = inv->encHdr;
	pos = 4;
	dw = dword_hton(inv->invToken);
	memcpy(totalBuf+pos, &dw, 4);
	pos += 4;
	dw = dword_hton(totalSize);
	memcpy(totalBuf+pos, &dw, 4);
	pos += 4;
		
	w = word_hton(inv->bitsFlag);
	memcpy(totalBuf+pos, &w, 2);
	pos += 2;
	w = 0;
	memcpy(totalBuf+pos, &w, 2);
	pos += 2;
	dw = dword_hton(inv->result);
	memcpy(totalBuf+pos, &dw, 4);
	pos += 4;
	w = word_hton(inv->ordinal);
	memcpy(totalBuf+pos, &w, 2);
	pos += 2;
	w = word_hton(inv->num_params);
	memcpy(totalBuf+pos, &w, 2);
	pos += 2;
	assert(pos==RPC_INVOKE_HEADER_SIZE);
		
	// 列集每个参数
	for (w=0; w<inv->num_params; w++){
		assert((int)pos<=totalSize);
		pos += rpc_param_marshal(&inv->params_list[w], totalBuf+pos);		
	}
	// 加密包数据
	if (inv->encPkg != 0){
		dword_t dw = inv->encPkg;
		srand(dw);
		MD5_hash_string(totalBuf, RPC_INVOKE_HEADER_SIZE, (dw<<24)+rand(), key);
		RC4_encrypt_string(totalBuf+RPC_INVOKE_HEADER_SIZE, totalSize-RPC_INVOKE_HEADER_SIZE, key+8, 16);
	}
	// 加密消息头
	if (inv->encHdr != 0){
		dw = inv->encHdr;
		srand(dw);
		MD5_hash_string(totalBuf, 8, (dw<<16)+rand(), key);
		RC4_encrypt_string(totalBuf+4, RPC_INVOKE_HEADER_SIZE-4, key, 16);
	}
	return pos;	
}
/** 
 * 散集调用头 
 */
RPCRESULT rpc_invokehdr_unmarshal(SOCKET sClient, dword_t dwToken, char *rpcHdr, int hdrSize, rpc_invoke_descriptor *inv, rpc_invoke_error *err)
{
	/**
	 * Perform a blocking recv() call
	 *  ['RCmn'(4)|用户标识(4)|总消息字节(4)|标志(2)| 保留(2)|返回值(4)|方法序号(2)|参数数目(2)] */
	assert(hdrSize == RPC_INVOKE_HEADER_SIZE);
	if (RPC_INVOKE_HEADER_SIZE != recvmsg(sClient, rpcHdr, RPC_INVOKE_HEADER_SIZE, 0))
		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALIDMSG, "RecvRpcCallHeader", err);
			
	// 读调用声明 = "RPCn", n为0-255的密钥种子. 0表示不加密; !=0表示RC4加密的密钥种子
	if (rpcHdr[0]!='R'||rpcHdr[1]!='C')
		return rpc_throw_error(RPC_USER_ERROR, RPC_INVALIDMSG, "RecvRpcCallHeader", err);
	inv->encPkg = rpcHdr[2];
	inv->encHdr = rpcHdr[3];
	if (inv->encHdr != 0){
		dword_t dw;
		char    hdr[41];
		hdr[0]=rpcHdr[0];
		hdr[1]=rpcHdr[1];
		hdr[2]=rpcHdr[2];
		hdr[3]=rpcHdr[3];
		
		dw = dword_hton(dwToken);
		memcpy(&hdr[4], &dw, 4);
		dw=inv->encHdr;
		srand(dw);
		MD5_hash_string(hdr, 8, (dw<<16)+rand(), hdr+8);
		RC4_encrypt_string(rpcHdr+4, RPC_INVOKE_HEADER_SIZE-4, hdr+8, 16);
	}
	
	inv->invToken = dword_ntoh(*((dword_t*)(rpcHdr+4)));			// 用户标识	
	inv->totalBytes = dword_ntoh(*((dword_t*)(rpcHdr+8)));			// 总消息字节数(也许是压缩的)
	inv->bitsFlag = word_ntoh(*((word_t*)(rpcHdr+12)));				// 标志	
	inv->bigEndian = GET_BIT(inv->bitsFlag, RPC_BIGENDIAN_BIT);		// 客户方列集的字节次序
	inv->reserved = word_ntoh(*((word_t*)(rpcHdr+14)));				// 保留值
	inv->result = dword_ntoh(*((dword_t*)(rpcHdr+16)));			    // 返回值
	inv->ordinal = word_ntoh(*((word_t*)(rpcHdr+20)));				// 方法序号
	inv->num_params = word_ntoh(*((word_t*)(rpcHdr+22)));			// 参数数目
			
	return RPC_SUCCESS;
}
/* 散集数据到参数中, 数据头总是不压缩的. 参数数据总是先压缩后加密的
 * 24字节头 + 内容
 *  ['RCmn'(4)|用户标识(4)|总消息字节(4)|标志(2)| 保留(2)|返回值(4)|方法序号(2)|参数数目(2)] 
 */
RPCRESULT rpc_invoke_unmarshal(rpc_invoke_descriptor *inv, 
							   char *totalBuf, 
							   size_t totalSize,
							   rpc_param_descriptor **out_params,
							   word_t *num_params,
							   rpc_invoke_error *err)
{
	ushort    i;
	size_t    pos;
	rpc_param_descriptor *params_list;
	assert(totalSize >= RPC_INVOKE_HEADER_SIZE);
				
	// 读调用声明 = "RCmn", m,n为0-255的密钥种子. 0表示不加密; !=0表示RC4加密的密钥种子
	assert(totalBuf[0]=='R'&&totalBuf[1]=='C');
	// 解密包数据
	if (inv->encPkg != 0){
		char    key[33];
		dword_t dw = inv->encPkg;
		srand(dw);
		MD5_hash_string(totalBuf, RPC_INVOKE_HEADER_SIZE, (dw<<24)+rand(), key);
		RC4_encrypt_string(totalBuf+RPC_INVOKE_HEADER_SIZE, totalSize-RPC_INVOKE_HEADER_SIZE, key+8, 16);
	}
		
	pos = RPC_INVOKE_HEADER_SIZE;
	// 分配参数数组
	MALLOC_S(params_list, inv->num_params, rpc_param_descriptor)
	for (i=0; i<inv->num_params; i++){
		pos += rpc_param_unmarshal(inv->bigEndian, &params_list[i], totalBuf+pos);
	}	
	*out_params = params_list;
	*num_params = inv->num_params;
	assert(pos == totalSize);	
	return RPC_SUCCESS;
}
RPCRESULT rpc_invoke_execute(rpc_connection_descriptor *conn, rpc_invoke_descriptor *inv, rpc_invoke_descriptor *outv, rpc_invoke_error* err)
{
	inv->encHdr    = conn->enc_hdr;
	inv->encPkg    = conn->enc_pkg;	
	inv->invToken  = conn->token;
	inv->bigEndian = conn->is_bigendian? 1:0;
	if (RPC_SUCCESS != rpc_invoke_send(conn, inv, err)){
		assert(0);
		return err->err_code;
	}
	if (RPC_SUCCESS != rpc_invoke_recv(conn, outv, err))
		return err->err_code;
	return RPC_SUCCESS;
}

整个工程的代码随后上传:

http://download.csdn.net/source/2445024