用戶自定義結構數據與VARIANT轉換 .

2016-09-28 00:00:00 廣州睿豐德信息科技有限公司閱讀

睿豐德科技專注RFID識別技術和條碼識別技術與管理軟件的集成項目。質量追溯系統、MES系統、金蝶與條碼系統對接、用友與條碼系統對接

用戶自定義結構數據與VARIANT轉換

cheungmine

將用戶自定義的C結構數據存儲成VARIANT類型，需要時再將VARIANT類型轉為用戶自定義的結構數據，有十分現實的意義，既然我們不想為這樣的結構數據寫一個COM包裝類。雖然有很多方法和手段生成這樣的VARIANT，但是，多數時候可能需要一個更加簡單的，靈活的方法。我在做遠程過程調用的C接口時，忽然聯想到，既然RPC可以把任何數據以字節的形式發送，那么，就可以利用這個機制，把結構打包成字節數組。而字節數據是可以很方便地存儲在VARIANT中。

這個過程是廣為人知的，但是，真正把結構列集成字節數組，如果不想使用某些標稱的序列化的方法，而全部自己寫，的確要費一番功夫。不是

技術有多難，是很繁瑣。我把前2年寫的代碼翻出來，簡單調用一下，就有了這篇文章。采用我的方法，C/C++程序員可以把自己定義的結構放到VARIANT、CComVariant、COleVariant等各種VARIANT中，也可以反向轉換。而VARIANT是可以很方便地在COM接口中傳遞。這樣，就多了一種在自動化COM接口中傳遞自定義結構的手段。

不多說廢話，全部內容見下面的代碼，我還會上傳整個工程。

struct2variant.cpp 如下：

[cpp] view plain copy print ?

///////////////////////////////////////////////////////////////////////
// struct2variant.cpp
// cheungmine@gmail.com
// 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);
}

///////////////////////////////////////////////////////////////////////
// struct2variant.cpp
// cheungmine@gmail.com
// 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可以參考如下：

[cpp] view plain copy print ?

/**
* rpcapi.h -cheungmine@gmail.com
* 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.h -cheungmine@gmail.com
 * 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如下：

[cpp] view plain copy print ?

/**
* rpcapi.c -cheungmine@gmail.com
*/
#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;
}

/**
 * rpcapi.c -cheungmine@gmail.com
 */
#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://cheungmine.download.csdn.net/

from:http://blog.csdn.net/ubuntu64fan/article/details/5660975

RFID管理系統集成商 RFID中間件條碼系統中間層物聯網軟件集成

上一條如何在WINDOWS下編譯BOOST C++庫 .
下一條 Agg vs. Cairo 二維繪圖引擎之比較和選擇 .