shm.h

基于UNIX的中间件编程,只能运行于UNIX操作系统

/***************************************************
recieve.h: shared memory header file
	
			zhoushijie
	    		     2000/3/4
****************************************************/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <time.h>
#include <ctype.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/mode.h>
#include <sys/sem.h>
#include <errno.h>

typedef int HANDLE;
typedef unsigned long DWORD;

#define I_PARTIONNUMBERS		2
#define O_PARTIONNUMBERS		9
#define O_BLOCKSIZE			512
#define I_BLOCKSIZE			512
#define O_MAXBLOCKS			1024
#define I_MAXBLOCKS			1024
#define O_SUPERNODESIZE		O_MAXBLOCKS*O_PARTIONNUMBERS
#define I_SUPERNODESIZE		I_MAXBLOCKS*I_PARTIONNUMBERS
#define O_PARTIONS		10	
#define I_PARTIONS		3	
#define I_PARTIONNO			1
#define O_PARTIONNO			2

/*
---------------------------------------------
define the filemapping mapping file name and key
O:ouput
I:Input
---------------------------------------------
*/
#define I_MAPPINGFILENAME				"../filein"
#define I_PROJECTID					1
#define O_MAPPINGFILENAME				"../fileout"
#define O_PROJECTID					1

#define I_KEY							9898989L	
#define O_KEY							8989898L	
#define I_MUTEX							7676767L	
#define O_MUTEX							6767676L		
#define OUT_SEMAPHORE_KEY					5454545L
#define IN_SEMAPHORE_KEY					4545454L

/*
----------------------------------------------------------------------
defien the semaphore file and project id
----------------------------------------------------------------------
*/
#define OUT_SEMAPHORE_FILE                                "../InSemFile"
#define IN_SEMAPHORE_FILE                                "../OutSemFile"
#define OUT_SEMAPHORE_ID                                   1
#define IN_SEMAPHORE_ID                                  1
#define INPUT_SEMAPHORE_NUMBERS                            3
#define OUTPUT_SEMAPHORE_NUMBERS                           10



/*
--------------------------------------------
  define the error No constant
--------------------------------------------
*/
#define E_Error						-1
#define E_Success					0
#define E_Network_Off				   	1
#define E_Middleware_No_Response			2
#define E_No_Service					3
#define E_No_Source					4
#define E_No_Destination				5
#define E_No_Socket					6
#define E_Close_Socket					7
#define E_API_Error					8
#define E_Timeout					9
#define E_ACK_Error					10
#define E_Write						11
#define E_Read						12
#define E_Other						30

#define LOGFILE "log.log"
/*
---------------------------------------------------------------------
  define the max lengthof the  message  AND the max message count
---------------------------------------------------------------------
*/
#define RECORDCOUNT  1024
#define MAXLEN		 512

/*
-----------------------------------------------
define the queue data structure
-----------------------------------------------
*/
#ifndef IP_ALEN
#define IP_ALEN				4
#endif
typedef  char	IPAddr[IP_ALEN+1]; 
typedef struct  S_MESSAGESTRUCTURE
 {
	char packettype[3];
	char sn[11];
	char requesttype[3];
	char oprcode[7];
	IPAddr source;
	IPAddr destination;
	char message[MAXLEN+1];
 }S_MESSAGESTRUCTURE;


/*
---------------------------------------------
define the request message queue structure
---------------------------------------------
*/
typedef struct S_MESSAGEQUEUE  
{
	S_MESSAGESTRUCTURE MessageQueue;
	int flag;	
};
typedef  struct S_MESSAGEQUEUE S_QueueEntry;

typedef struct S_QueueNode
{
	S_QueueEntry entry;
	int number;
	char *addr;
	struct S_QueueNode *next;
}S_QueueNode;

typedef struct S_Queue
{
	int  count;
	char *head;
	S_QueueNode *front;
	S_QueueNode *rear;
}S_Queue;


/*
-------------------------------------------------
define the shared memory data structure
--------------------------------------------------
*/

struct sm_Index
{
	char *StartAddress;
	int PartionNumbers;
	unsigned long TotalValue;
	unsigned long SuperNodeSize;
};

typedef struct sm_Index sm_Index;

struct sm_Partion
{
	int PartionNo;
	int TotalBlocks;
	int BlockSize;
	unsigned long StartBlockNo;
};
typedef struct sm_Partion sm_Partion;

struct sm_Block
{
	int BlockNo;
	int Flag;
};
typedef struct sm_Block sm_block;

/*
-------------------------------------------
 log record data structure
-------------------------------------------
*/
typedef struct
{
	int		log_level;
	char	PackType[5];
	char	log_date[11];
	char	log_time[9];
	char	log_event[50];
	char	log_cause[150];
}LOG;


/*
--------------------------------------------------
declare the functions:queue
--------------------------------------------------
*/
void S_CreateQueue(S_Queue *q);
void S_AppendNode(S_QueueNode *x,S_Queue *q);
int S_QueueSize(S_Queue *q);
int S_QueueFull(S_Queue *q,int  max);
void S_ServeNode(S_QueueNode **p,S_Queue *q);
int S_QueueEmpty(S_Queue *q);
void S_ClearQueue(S_Queue *q);
void S_QueueFront(S_QueueEntry *x,S_Queue  *q);
void S_QueueFrontNode(S_QueueNode *p,S_Queue *q);
void S_TraverseQueue(S_Queue *q,void (Visit(S_QueueEntry x)));
int  S_DeleteQueueNode(S_QueueNode *node,S_Queue *q,S_QueueNode **ReturnNode);
S_QueueNode *S_MakeQueueNode(S_QueueNode *p,S_QueueEntry x,int number,char *addr);
/*S_QueueNode *S_MakeQueueNode(S_QueueEntry x,int number,char *addr);*/
int S_AllocateNode(S_Queue *Source,S_Queue *Destination,S_MESSAGESTRUCTURE m_struct);
void S_SetNodeEntryContent(S_QueueNode *node,S_MESSAGESTRUCTURE message);
S_Queue *S_CopyQueue(S_Queue *destination,S_Queue *source);
int  S_Error(char *message);
void S_Warning(char *message);

/*
--------------------------------------------------
declare the functions:shared memory
--------------------------------------------------
*/
char *ShmCreat(key_t Key,unsigned long Size,int Perm);
int  ShmDel(key_t Key);
char * ShmOpen(key_t Key,unsigned long Size,int Flag);

struct sm_Index InitIndex(char *addr,int partionnumbers,struct sm_Partion Partion[]);
void SetIndexStartAddress(struct sm_Index *index,char *addr);
int InitShareMem(char **StartAddress,long key,unsigned long size,int perm);
int OpenShareMem(char **StartAddress,long key,unsigned long size,int perm);
int InitSuperNode(unsigned long supernodesize,char **SupperNode,char *shmStartAddress);
int GetSuperNode(unsigned long supenodesize,char **SupperNode,char *shmStartAddress);
void AllocatePointer(char *startaddress,struct sm_Partion Partion[],struct sm_Index Index,char *Pointer[]);
int SetByteValue(int value,char *addr,int position);
int GetByteValue(char addr[],unsigned int position);
char *ComputeBlockAddress(struct sm_Index index,struct sm_Partion Partion,int blocknumber);
int SearchUnusedBlock(struct sm_Partion Partion,char *Pointer);
int SearchUsedBlock(struct sm_Partion Partion,char *Pointer);
int WriteBlock(struct sm_Index index,struct sm_Partion Partion,char *pointer,char *content);
int ReadBlock(struct sm_Index index,struct sm_Partion Partion,char *pointer,char **content);

key_t CreateKey(char *KeyFileName ,char ProjectID);
LOG SetLogContents(int Log_Level,char *Log_Envent,char *Log_Cause);
int WriteLog(LOG *m_log);
char *  S_Readprofile(char *m_file,char m_section[],char m_key[]);
int S_FormatePacket(S_MESSAGESTRUCTURE m_struct,char *msg);
int S_SeparatePacket(char *buffer,S_MESSAGESTRUCTURE *m_struct);
char *S_SeparateHostName(char *string,char *sepstring,char returnstring[]);

int InitOutputSharedMem();
char *ReadOutputSharedMem(int PartionNumber);
char *WriteOutputSharedMem(int PartionNumber,char *content);
int InitInputSharedMem();
char *ReadInputSharedMem(int PartionNumber);
char *WriteInputSharedMem(int PartionNumber,char *content);

/*******************************************************
	DECLARE THE SEMAPHORE FUNCTION
*********************************************************/
int SemCreat(key_t semkey,int semnum,int *semval,int perm);
int SemDel(key_t semkey,int semnum);
int SemOpen(key_t semkey,int semnum);
int SemClose(int semid);
int SemP(int semid,int offset,int flag);
int SemV(int semid,int offset);
int InitSemaphoreValue();
int InitSemaphore();
int OpenSemaphore();
int SemaphoreP(int SempahoreID,int No);
int SemaphoreV(int SempahoreID,int No);

/**************************************************
	The API's return data structure 
***************************************************/
typedef struct 
{
	int flag;/*0:file transmit ;1:message transmit*/
	int partionnumbers;
	
	char packettype[3];
	char  ID[11];
	char requesttype[3];
	char oprcode[6];
	int socketno;		
	char  source[30];
	char  destination[30];	
	unsigned int appport;
	char  middledest[30];
	int breakof;
	char preserve[200];
	int errorno;
	char errorcause[150];
	int timer;

}sm_TID;

/*****************************************************
	Following is the API declare
******************************************************/
sm_TID *sm_OpenConn(sm_TID *tid);
sm_TID *sm_CloseConn(sm_TID *tid);
sm_TID *sm_SendMsg(int flag,char *buf,int bussize,char *filename,sm_TID *sm_tid);
sm_TID *sm_RecieveMsg(int flag,char **buf,int bufsize,char **filename,sm_TID *tid);
sm_TID *sm_CallMsg(int flag,char *sbuf,int sbufsize,char *sfilename,char *rbuf,int rbufsize,char *rfilename,sm_TID *tid);
sm_TID *sm_RecieveMsgBlocken(int flag,char **buf,int bufsize,char **filename,sm_TID *tid);


/***********************************************************
	define the glaobal variables
************************************************************/
/*
-------------------------------------------------------
	the partion index description table
-------------------------------------------------------
*/
struct sm_Index O_Index,I_Index;

/*
-------------------------------------------------------
	the partion description table
-------------------------------------------------------
*/
struct sm_Partion O_Partion[]=
{
	0,9*1024,1,0,
	1,1024,512,1,
	2,1024,512,1025,
	3,1024,512,2049,
	4,1024,512,3073,
	5,1024,512,4097,
	6,1024,512,5121,
	7,1024,512,6145,
	8,1024,512,7069,
	9,1024,512,8093,
};
struct sm_Partion I_Partion[]=
{
	0,2*1024,1,0,
	1,1024,512,1,
	2,1024,512,1025,

};

/*
------------------------------------------------------
the block description table
------------------------------------------------------
*/

struct sm_Block O_Block[O_PARTIONNUMBERS+1][O_MAXBLOCKS+1];
struct sm_Block I_Block[I_PARTIONNUMBERS+1][I_MAXBLOCKS+1];
/*
----------------------------------------------------
the global mapping file handle
----------------------------------------------------
*/
HANDLE O_MapHandle,I_MapHandle;

/*
------------------------------------------------------
the mapping file start address
------------------------------------------------------
*/
char *O_StartAddress,*I_StartAddress;

/*
------------------------------------------------------
the 0 block of the mapping file address
------------------------------------------------------
*/
char *O_SuperNode,*I_SuperNode;

/*
------------------------------------------------------
the start address of every block
------------------------------------------------------
*/
char *O_Pointer[O_PARTIONNUMBERS],*I_Pointer[I_PARTIONNUMBERS];

int InputSemaphoreValue[INPUT_SEMAPHORE_NUMBERS],OutputSemaphoreValue[OUTPUT_SEMAPHORE_NUMBERS];

int InputSemaphoreID, OutputSemaphoreID;