myvtm/Module/mod_tokenmgr/TokenKeeper_server_g.h

#ifndef __TOKENKEEPER_SERVER_G_H
#define __TOKENKEEPER_SERVER_G_H

#pragma once

// This code is generated by spgen tool!

#include "TokenKeeper_def_g.h"

namespace TokenKeeper {
class TokenService_ServerSessionBase : public CServerSessionBase
{
public:
	TokenService_ServerSessionBase()
	{
		/// override by user
	}

	virtual ~TokenService_ServerSessionBase()
	{
		/// override by user
	}

	virtual bool IsExclusive() { return false; }

	virtual bool IsSessionOverlap() { return true; }

	virtual ErrorCodeEnum GetMessageAttr(DWORD dwMessageID, DWORD dwSignature, bool &bOverlap)
	{
		ErrorCodeEnum Error = Error_Succeed;
		switch (dwMessageID) {
		case TokenService_Method_GetToken:
			if (dwSignature == TokenService_MethodSignature_GetToken) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetToken:
			if (dwSignature == TokenService_MethodSignature_SetToken) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_GetSharedSK:
			if (dwSignature == TokenService_MethodSignature_GetSharedSK) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetSharedSK:
			if (dwSignature == TokenService_MethodSignature_SetSharedSK) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetKeyPair:
			if (dwSignature == TokenService_MethodSignature_SetKeyPair) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_GetPublicKey:
			if (dwSignature == TokenService_MethodSignature_GetPublicKey) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_EncryptWithPubKey:
			if (dwSignature == TokenService_MethodSignature_EncryptWithPubKey) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_DecryptWithPubKey:
			if (dwSignature == TokenService_MethodSignature_DecryptWithPubKey) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_EncryptWithPriKey:
			if (dwSignature == TokenService_MethodSignature_EncryptWithPriKey) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_DecryptWithPriKey:
			if (dwSignature == TokenService_MethodSignature_DecryptWithPriKey) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		default:
			Error = Error_MethodNotFound;
			break;
		}
		return Error;
	}

	int CheckMessageSignature(DWORD dwMessageID, DWORD dwSignature)
	{
		ErrorCodeEnum Error = Error_Succeed;
		switch (dwMessageID) {
		case TokenService_Method_GetToken:
			if (dwSignature != TokenService_MethodSignature_GetToken) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetToken:
			if (dwSignature != TokenService_MethodSignature_SetToken) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_GetSharedSK:
			if (dwSignature != TokenService_MethodSignature_GetSharedSK) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetSharedSK:
			if (dwSignature != TokenService_MethodSignature_SetSharedSK) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_SetKeyPair:
			if (dwSignature != TokenService_MethodSignature_SetKeyPair) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_GetPublicKey:
			if (dwSignature != TokenService_MethodSignature_GetPublicKey) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_EncryptWithPubKey:
			if (dwSignature != TokenService_MethodSignature_EncryptWithPubKey) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_DecryptWithPubKey:
			if (dwSignature != TokenService_MethodSignature_DecryptWithPubKey) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_EncryptWithPriKey:
			if (dwSignature != TokenService_MethodSignature_EncryptWithPriKey) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case TokenService_Method_DecryptWithPriKey:
			if (dwSignature != TokenService_MethodSignature_DecryptWithPriKey) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		default:
			Error = Error_MethodNotFound;
			break;
		}
		return Error;
	}

	virtual void Handle_GetToken(SpReqAnsContext<TokenService_GetToken_Req, TokenService_GetToken_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetToken(SpReqAnsContext<TokenService_SetToken_Req, TokenService_SetToken_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetSharedSK(SpReqAnsContext<TokenService_GetSharedSK_Req, TokenService_GetSharedSK_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetSharedSK(SpReqAnsContext<TokenService_SetSharedSK_Req, TokenService_SetSharedSK_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetKeyPair(SpReqAnsContext<TokenService_SetKeyPair_Req, TokenService_SetKeyPair_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetPublicKey(SpReqAnsContext<TokenService_GetPublicKey_Req, TokenService_GetPublicKey_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_EncryptWithPubKey(SpReqAnsContext<TokenService_EncryptWithPubKey_Req, TokenService_EncryptWithPubKey_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_DecryptWithPubKey(SpReqAnsContext<TokenService_DecryptWithPubKey_Req, TokenService_DecryptWithPubKey_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_EncryptWithPriKey(SpReqAnsContext<TokenService_EncryptWithPriKey_Req, TokenService_EncryptWithPriKey_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_DecryptWithPriKey(SpReqAnsContext<TokenService_DecryptWithPriKey_Req, TokenService_DecryptWithPriKey_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		CAutoBuffer Buf;
		DWORD dwMessageID;
		DWORD dwMessageSignature;
		ErrorCodeEnum Error = pTransactionContext->GetReceiveBuffer(dwMessageID, dwMessageSignature, Buf);
		if (Error == Error_Succeed) {
#ifdef DEBUG
			assert(CheckMessageSignature(dwMessageID, dwMessageSignature) == Error_Succeed);
#else
			if (CheckMessageSignature(dwMessageID, dwMessageSignature) != Error_Succeed) {
				pTransactionContext->SendAnswer(Error_MethodSignatureFailed);
				return;
			}
#endif
			switch (dwMessageID) {
				case TokenService_Method_GetToken:
					{
						SpReqAnsContext<TokenService_GetToken_Req,TokenService_GetToken_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_GetToken_Req,TokenService_GetToken_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_GetToken(ctx);
					}
					break;
				case TokenService_Method_SetToken:
					{
						SpReqAnsContext<TokenService_SetToken_Req,TokenService_SetToken_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_SetToken_Req,TokenService_SetToken_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_SetToken(ctx);
					}
					break;
				case TokenService_Method_GetSharedSK:
					{
						SpReqAnsContext<TokenService_GetSharedSK_Req,TokenService_GetSharedSK_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_GetSharedSK_Req,TokenService_GetSharedSK_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_GetSharedSK(ctx);
					}
					break;
				case TokenService_Method_SetSharedSK:
					{
						SpReqAnsContext<TokenService_SetSharedSK_Req,TokenService_SetSharedSK_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_SetSharedSK_Req,TokenService_SetSharedSK_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_SetSharedSK(ctx);
					}
					break;
				case TokenService_Method_SetKeyPair:
					{
						SpReqAnsContext<TokenService_SetKeyPair_Req,TokenService_SetKeyPair_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_SetKeyPair_Req,TokenService_SetKeyPair_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_SetKeyPair(ctx);
					}
					break;
				case TokenService_Method_GetPublicKey:
					{
						SpReqAnsContext<TokenService_GetPublicKey_Req,TokenService_GetPublicKey_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_GetPublicKey_Req,TokenService_GetPublicKey_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_GetPublicKey(ctx);
					}
					break;
				case TokenService_Method_EncryptWithPubKey:
					{
						SpReqAnsContext<TokenService_EncryptWithPubKey_Req,TokenService_EncryptWithPubKey_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_EncryptWithPubKey_Req,TokenService_EncryptWithPubKey_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_EncryptWithPubKey(ctx);
					}
					break;
				case TokenService_Method_DecryptWithPubKey:
					{
						SpReqAnsContext<TokenService_DecryptWithPubKey_Req,TokenService_DecryptWithPubKey_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_DecryptWithPubKey_Req,TokenService_DecryptWithPubKey_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_DecryptWithPubKey(ctx);
					}
					break;
				case TokenService_Method_EncryptWithPriKey:
					{
						SpReqAnsContext<TokenService_EncryptWithPriKey_Req,TokenService_EncryptWithPriKey_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_EncryptWithPriKey_Req,TokenService_EncryptWithPriKey_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_EncryptWithPriKey(ctx);
					}
					break;
				case TokenService_Method_DecryptWithPriKey:
					{
						SpReqAnsContext<TokenService_DecryptWithPriKey_Req,TokenService_DecryptWithPriKey_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<TokenService_DecryptWithPriKey_Req,TokenService_DecryptWithPriKey_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						pTransactionContext->GetLinkContext(ctx->link);
						EntityResource::setLink(ctx->link);
						Handle_DecryptWithPriKey(ctx);
					}
					break;
				default:
					assert(0);
					break;
			}
			
		} else {
			pTransactionContext->SendAnswer(Error);
		}
	}

};


///////////////////////////

} // namespace TokenKeeper
#endif // __TOKENKEEPER_SERVER_G_H