shmpool.c

公关系统服务器后台程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

//数据池写接口集
#include "shmpool.h"

void* shmStartPos=NULL;

//位置信息定义
#define shmMaintainMacID	(short*)(shmStartPos)

#define shmDataCount		(int*)(shmStartPos+4)
#define shmDataCur		(int*)(shmStartPos+8)
#define shmDataUsed		(int*)(shmStartPos+12)
#define shmDataSize		(int*)(shmStartPos+16)


#define shmMANAGE		(char*)(shmStartPos+20)
#define shmMANAGETOTAL		(char*)(shmStartPos+180)

#define nodeStartPos		(shmStartPos+182)

poolErr shmQueryMIp(char *ipaddr,short ipPos)
{
	memcpy(ipaddr,shmMANAGE+16*ipPos,16);
	return poolSuccess;
}

poolErr shmWriteMIp(char *ipaddr)
{
	char ipc=*shmMANAGETOTAL;
	if(ipc==10)
		return dataFailPara;

	memcpy(shmMANAGE+16*(ipc-1),ipaddr,16);
	*shmMANAGETOTAL=(ipc+1);
	return poolSuccess;
}

short shmQueryMc()
{
	char ipc;
	ipc=*shmMANAGETOTAL;
	return (short)ipc;
}

poolErr shmPoolInit(short dataCount,short nodeSize)
{
	int shmId;
	int shmSize;
	shmSize=dataCount*(nodeSize+1)+178;
	shmId=shmget(0x1002,shmSize,IPC_CREAT|SHM_R|SHM_W);
	if(shmId==-1)
		return dataFailShmGet;
	shmStartPos=shmat(shmId,0,0);
	
	if(*shmDataCount==0)
	{
		*shmDataCount=dataCount;
		*shmDataSize=nodeSize;
		*shmDataCur=0;
		*shmMaintainMacID=-1;
		return poolSuccess;
	}
	else
		return poolConnected;
		
}

poolErr poolGetFirst(void *node)
{
	*shmDataCur=0;
	memcpy(node,nodeStartPos,*shmDataSize);
	return poolSuccess;
}	

poolErr poolGetLast(void *node)
{
	*shmDataCur=*shmDataCount-1;
	memcpy(node,nodeStartPos+(*shmDataCur)*(*shmDataSize),*shmDataSize);
	return poolSuccess;
}

poolErr poolGetNext(void *node)
{
	if(*shmDataCur>=*shmDataCount)
		return dataEOF;
	memcpy(node,nodeStartPos+(*shmDataCur)*(*shmDataSize),*shmDataSize);
	*shmDataCur=*shmDataCur+1;
	
	return poolSuccess;
}

poolErr poolGetPrev(void *node)
{
	if(*shmDataCur==0)
		return dataEOF;

	memcpy(node,nodeStartPos+(*shmDataCur)*(*shmDataSize),*shmDataSize);
	*shmDataCur=*shmDataCur-1;
	return poolSuccess;

}

short poolGetCount()
{
	return (short)*shmDataCount;
}

/*
int poolGetCur()
{
	return (int)*shmDataCur;
}
*/

short poolGetUsed()
{
	return (short)*shmDataUsed;
}

void poolSetUsed(short value)
{
	*shmDataUsed=value;
}
/*
void poolSetCur(int curPos)
{
	*shmDataCur=curPos;
}
*/

void poolMove(short pos)
{
	if(pos>=(*shmDataCount))
		return;
	*shmDataCur=pos;
}

poolErr poolQueryNode(void *node,short nodePos)
{
	void *sourceNode;
	if(nodePos>(*shmDataCount-1))
		return dataFailPara;
	sourceNode=nodeStartPos+nodePos*(*shmDataSize);
	memcpy(node,sourceNode,*shmDataSize);
	return poolSuccess;
}


poolErr poolWriteNode(void *node,short nodePos)
{
	void *destNode;
	if(nodePos>*shmDataCount-1)
		return dataFailPara;

	destNode=nodeStartPos+nodePos*(*shmDataSize);
	memcpy(destNode,node,*shmDataSize);
	return poolSuccess;
}

short poolQueryNodeByMacID(short macid)
{
	int i,count;
	short *poolmacid=(short*)nodeStartPos;
	count=*shmDataUsed;
	for(i=0;i<count;i++)
	{
		poolmacid=nodeStartPos+i*(*shmDataSize);
#if DEBUG
		printf("poolmacid===%d,i=%d\n",*poolmacid,i);
#endif
		if(*poolmacid==macid)
			return i;
	}
	return -1;
}

short poolSetMaintainMark(short macid)
{
	int i,count;
	short *poolmacid=(short*)nodeStartPos;
	count=*shmDataCount;

	if(macid==-1)
	{
		*shmMaintainMacID=-1;
		return -1;
	}
	
	for(i=0;i<count;i++)
	{
		poolmacid=nodeStartPos+i*(*shmDataSize);
#if DEBUG
		printf("i==%d,poolmacid==%d\n",i,*poolmacid);
#endif
		if(*poolmacid==macid)
		{
			*shmMaintainMacID=macid;
			return i;
		}
		else
			continue;
			
	}
	return -1;
}

short poolGetMaintainMark()
{
	return *shmMaintainMacID;
}

poolErr poolDeleteNode(short macid)
{
	int i,count,countused;	
	short *poolmacid=(short*)nodeStartPos;
	void *sourceNode,*destNode;
	
	count=*shmDataCount;
	countused=*shmDataUsed;
	
	for(i=0;i<countused;i++)
	{
		poolmacid=nodeStartPos+i*(*shmDataSize);
		if(*poolmacid==macid)
		{
			for(;i<countused-1;i++)
			{
				destNode=nodeStartPos+i*(*shmDataSize);
				sourceNode=nodeStartPos+(i+1)*(*shmDataSize);
				memcpy(destNode,sourceNode,*shmDataSize);
			}
			memset(sourceNode,0,*shmDataSize);
			*shmDataUsed=*shmDataUsed-1;
			return poolSuccess;
		}
	}
	return dataFailPara;
}