shmapply.cpp

linux 上http email 协议分析程序 主要能够处理大数据量的主干网的应用

/**************************************************************
  Copyright (C), 2002-2010, congxing Co., Ltd.
  File name:     ShmApply.cpp
  Author:        何杰锋  
  Version:       V01.00.00.00
  Date:          2004/01/13
  Description:   共享内存读写接口类
  Others:        
  History:      
***************************************************************/

// 引用头文件
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include "ShmApply.h"

/************************************************************
  Function:			类的构造器
  Description:    
  Calls:          
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:         
  Output:         
  Return:         
  Others:         
*************************************************************/
CShmApply::CShmApply()
{
	m_pshmwOffset=NULL;
	m_pshmrOffset=NULL;
	m_pshmData=NULL;
}

/************************************************************
  Function:			类的析构器
  Description:    
  Calls:          
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:			        
  Output:         
  Return:         
  Others:         
*************************************************************/
CShmApply::~CShmApply()
{
}

/************************************************************
  Function:			初始化共享内存
  Description:    
  Calls:         
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:			key--Key值，size--大小, flg--权限
  Output:			无
  Return:			成功返回0；否则返回-1
  Others:         
*************************************************************/
int CShmApply::init(key_t key, int size, int flg)
{
	int intShmid;
	unsigned short int arrSemval[] = {1, 1};
	
	/*if (size < 2*MEM_MIN_SIZE)
	{
		size = 2*MEM_MIN_SIZE;
	}*/
	
	// *********初始化共享内存
	
	intShmid = m_theShm.create(key, size, flg);
	if (intShmid < 0)
	{
		if (m_theShm.open(key, flg) < 0)
		{
			printf("[CShmApply::init]: open Shared Memory failed!\n");
			return -1;
		}
	}
	
	// 获取共享内存中管理区的地址
	char *paddr=(char *)m_theShm.getMemAddr();
	
	if (paddr == (void*)-1)
	{
		printf("[CShmApply::init]: get Shared Memory address failed!\n");
		return -1;
	}
	
	m_pshmrOffset = paddr;
	m_pshmwOffset =paddr+sizeof(int);
	m_pshmData = paddr + 2*sizeof(int);
	m_totalSize = m_theShm.getMemSize()-2*sizeof(int);
	//m_iendOffset =  m_totalsize - 1;
		
	if (intShmid == 0)
	{
		m_wOffset=0;
		m_rOffset=0;
		
		memcpy(m_pshmrOffset, &m_rOffset, sizeof(int));	
		memcpy(m_pshmwOffset, &m_wOffset, sizeof(int));	
			
	}
	
	if (m_theSem.init(key, flg) < 0)
    {
		printf("[CShmApply::init]: open Semaphore Arrays failed!\n");
		return -1;
	}
					
	
	printf("[CShmApply::init]: init sem ok\n");
	return 0;
}

/************************************************************
  Function:			写数据到共享内存（只能单进程读）
  Description:    
  Calls:         
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:			buffer--数据的指针，size--数据的大小
  Output:			无
  Return:			成功返回0，等待返回-2,失败返回-1
  Others:         buffer=len+char[len]
*************************************************************/
int CShmApply::write(const void *buffer)
{	
	// 步骤：1、获取获取管理区的信息
	//       2、将数据写入共享内存
	//       3、保存写指针的当前地址
	int ipktsize;
	
	//含四字节长度
	memcpy(&ipktsize,buffer,sizeof(int));
			
	// 获取管理区的信息
	if (m_theSem.lockSem(0) < 0)
	{
		printf("[CShmApply::write]: Lock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	
	memcpy((char *)&m_rOffset,m_pshmrOffset,sizeof(int));	
	memcpy((char *)&m_wOffset,m_pshmwOffset,sizeof(int));	

	if (m_theSem.unlockSem(0) < 0)
	{
		printf("[CShmApply::write]: Unlock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
		
	int idlesize=m_rOffset-m_wOffset;
	if(idlesize<=0)
	{
		idlesize+=m_totalSize;
	}
	if(ipktsize>=idlesize)
	{
		return -1;
	}

	if(m_wOffset+ipktsize>m_totalSize)
	{//折断
		int ibsize=m_totalSize-m_wOffset;
		int iesize=ipktsize-ibsize;
		memcpy(m_pshmData+m_wOffset,buffer,ibsize);
		memcpy(m_pshmData,(char *)buffer+ibsize,iesize);

		m_wOffset=iesize + 0;
	}
	else
	{
		memcpy(m_pshmData+m_wOffset,buffer,ipktsize);
		m_wOffset+=ipktsize;
	}
	
	// 获取管理区的信息
	if (m_theSem.lockSem(0) < 0)
	{
		printf("[CShmApply::write]: Lock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	
	memcpy(m_pshmwOffset,(void *)&m_wOffset,sizeof(int));	

	if (m_theSem.unlockSem(0) < 0)
	{
		printf("[CShmApply::write]: Unlock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}


	return 0;
}

/************************************************************
  Function:			从共享内存中读取数据(可以多进程读)。每执行一次，读取共享内存中下一块完整的数据
  Description:    
  Calls:         
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:			无
  Output:			buffer--所获数据的指针
  Return:			成功返回数据的大小，等待返回-2,失败返回-1
  					没有数据返回0
  Others:         
*************************************************************/
int CShmApply::read(void *buffer)
{	
	// 步骤：1、加锁（信号量2）
	//       2、获取获取管理区的信息
	//       3、从共享内存中读取数据
	//       4、修改读指针的当前地址
	//       5、解锁（信号量2）
	
	
	// 获取管理区的信息
	if (m_theSem.lockSem(0) < 0)
	{
		printf("[CShmApply::read]: Lock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	
	memcpy((void *)&m_rOffset,m_pshmrOffset,sizeof(int));	
	memcpy((void *)&m_wOffset,m_pshmwOffset,sizeof(int));	

	if (m_theSem.unlockSem(0) < 0)
	{
		printf("[CShmApply::read]: Unlock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}

	//判断读写偏移量是否相等
	if (m_rOffset == m_wOffset)
	{
		//没有数据
		return 0;
	}
	int ipktsize;

	if(m_rOffset+sizeof(int)>m_totalSize)
	{//折断长度
		int ibsize=m_totalSize - m_rOffset;
		int iesize = m_rOffset + sizeof(int) - m_totalSize;
		memcpy((char *)&ipktsize,m_pshmData+m_rOffset,ibsize);

		memcpy((char *)&ipktsize+ibsize,m_pshmData+0,iesize);
		
		memcpy(buffer,m_pshmData+iesize,ipktsize-sizeof(int));
		
		m_rOffset=ipktsize-ibsize + 0;
	}
	else 
	{
		memcpy(&ipktsize,m_pshmData+m_rOffset,sizeof(int));
		m_rOffset+=sizeof(int);
		ipktsize-=sizeof(int);
		if(m_rOffset+ipktsize>m_totalSize)
		{//折断数据
			int ibsize=m_totalSize -m_rOffset;
			int iesize=ipktsize-ibsize;
			memcpy(buffer,m_pshmData+m_rOffset,ibsize);
			memcpy((char *)buffer+ibsize,m_pshmData+0,iesize);
			m_rOffset=iesize+0;
		}
		else
		{
			memcpy(buffer,m_pshmData+m_rOffset,ipktsize);
			m_rOffset+=ipktsize;
		}

	}

	// 获取管理区的信息
	if (m_theSem.lockSem(0) < 0)
	{
		printf("[CShmApply::read]: Lock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	
	memcpy(m_pshmrOffset,(char *)&m_rOffset,sizeof(int));	

	if (m_theSem.unlockSem(0) < 0)
	{
		printf("[CShmApply::read]: Unlock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	return ipktsize;
}



/************************************************************
  Function:			统计当前共享内存中使用率
  Description:    
  Calls:         
  Called By:      
  Table Accessed: 
  Table Updated:  
  Input:			无
  Output:			无
  Return:			成功返回使用率的大小，否则返回-1
  Others:         
*************************************************************/
float CShmApply::userate(void)
{
	// 获取管理区的信息
	
	// 获取管理区的信息
	if (m_theSem.lockSem(0) < 0)
	{
		printf("[CShmApply::write]: Lock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	
	memcpy((void *)&m_rOffset,m_pshmrOffset,sizeof(int));	
	memcpy((void *)&m_wOffset,m_pshmwOffset,sizeof(int));	

	if (m_theSem.unlockSem(0) < 0)
	{
		printf("[CShmApply::write]: Unlock semaphore[0] failed!(for get shm admin address)\n");
		return -1;
	}
	if(m_rOffset == m_wOffset)
		return 0;
	
	//printf("roffset=%d woffset=%d total=%d\n",m_rOffset,m_wOffset,m_totalSize);

	int idlesize=m_rOffset-m_wOffset;
	if(idlesize<=0)
	{
		idlesize+=m_totalSize;
	}

	float f=idlesize;
	float ff=m_totalSize;
	f=f/ff;
	return f;
	//return (idlesize*10000/m_totalSize);
	
}