admserver.cc

此源代码只用于学习,不得用于其他商业活动 .

				/*错单回收*/
				char chStartDateTime[STRING_LEN];
				char chStartDate[10+1];
				char chStartTime[8+1];
				memset(chStartDate, 0, sizeof(chStartDate));
				memset(chStartTime, 0, sizeof(chStartTime));
				memset(chStartDateTime, 0, sizeof(chStartDateTime));

				pchTemp = strchr(Objects, ' ');
				pchTemp++;
				for(j = 0; *pchTemp != ' '; pchTemp++)
				{
					chChannelCode[j++] = *pchTemp;
				}
				Trim(chChannelCode);
cout<<"chChannelCode = "<<chChannelCode<<endl;
				pchTemp++;
				for(j = 0; *pchTemp != ' '; pchTemp++)
				{
					chMemoryIndex[j++] = *pchTemp;
				}
				Trim(chMemoryIndex);
cout<<"chMemoryIndex = "<<chMemoryIndex<<endl;
				memset(&ShareMemoryInformation,0,sizeof(ShareMemoryInformation));
				gv_ShareMemory.WriteShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
				pchTemp = Objects;
				for(j = 0; *pchTemp != '\0'; pchTemp++)
				{
					chCommand[j++] = *pchTemp;
				}
				chCommand[j] = 0;
				Trim(chCommand);
cout<<"chCommand = "<<chCommand<<endl;
				ExecuteProcess(chCommand, ConnectSocket);
				Socket.WriteLine(ConnectSocket,(char *)"Begin@",strlen("Begin@"));
cout<<"prepare to begin!"<<endl;

				//这个for循环用来判断程序是否启动成功
				for(;;)
				{
					gv_ShareMemory.ReadShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
					memset(chStartDate, 0, sizeof(chStartDate));
					memset(chStartTime, 0, sizeof(chStartTime));
					memset(chStartDateTime, 0, sizeof(chStartDateTime));
					strcpy(chStartDateTime, ShareMemoryInformation.startdate);
					strcat(chStartDateTime, ShareMemoryInformation.starttime);
					if(strlen(chStartDateTime) != 0)
					{
cout<<"in strlen(chStartDateTime)!!!"<<endl;
						break;
					}
					sleep(1);
				}
cout<<"start right!!!!"<<endl;
				//这个for循环用来给前台不停地发送消息
				for(;;)
				{
					gv_ShareMemory.ReadShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
					sprintf(SendBuffer,"%s@%s@%lu",ShareMemoryInformation.status,ShareMemoryInformation.object, ShareMemoryInformation.total);
					Trim(SendBuffer);
					Socket.WriteLine(ConnectSocket,SendBuffer,sizeof(SendBuffer));
					if(strlen(ShareMemoryInformation.procid) == 0)
					{
						break;
					}
					sleep(1);
				}
printf("end!!!!!!!!!!\n");
				Socket.WriteLine(ConnectSocket,(char *)"End@",strlen("End@"));
				close(ConnectSocket);
				ConnectSocket = -1;
			}
			else if(strncmp(Command, "Rollback@", 9) == 0)
			{
				//启动回退进程
printf("\nCommandLine = %s\n", Command);
				char chStartDateTime[STRING_LEN];
				char chStartDate[10+1];
				char chStartTime[8+1];
				memset(chStartDate, 0, sizeof(chStartDate));
				memset(chStartTime, 0, sizeof(chStartTime));
				memset(chStartDateTime, 0, sizeof(chStartDateTime));

				pchTemp = strchr(Objects, ' ');
				pchTemp++;
				for(j = 0; *pchTemp != ' '; pchTemp++)
				{
					chChannelCode[j++] = *pchTemp;

				}
				Trim(chChannelCode);
printf("\nChannelCode = %s\n", chChannelCode);

				pchTemp++;
				for(j = 0; *pchTemp != ' '; pchTemp++)
				{
					chMemoryIndex[j++] = *pchTemp;
				}
				Trim(chMemoryIndex);
printf("\nchMemoryIndex = %s\n", chMemoryIndex);
				memset(&ShareMemoryInformation,0,sizeof(ShareMemoryInformation));
				gv_ShareMemory.WriteShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
				//pchTemp = strchr(Objects, '/');
				pchTemp = Objects;
				for(j = 0; *pchTemp != '\0'; pchTemp++)
				{
					chCommand[j++] = *pchTemp;
				}
				Trim(chCommand);
				ExecuteProcess(chCommand, ConnectSocket);
				Socket.WriteLine(ConnectSocket,(char *)"Begin@",strlen("Begin@"));
printf("\nCommand = %s\n", chCommand);

				//这个for循环用来判断程序是否启动成功
				for(;;)
				{
					gv_ShareMemory.ReadShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
					memset(chStartDate, 0, sizeof(chStartDate));
					memset(chStartTime, 0, sizeof(chStartTime));
					memset(chStartDateTime, 0, sizeof(chStartDateTime));
					strcpy(chStartDateTime, ShareMemoryInformation.startdate);
					strcat(chStartDateTime, ShareMemoryInformation.starttime);
					if(strlen(chStartDateTime) != 0)
					{
						break;
					}
					sleep(1);
				}

				//这个for循环用来给前台不停地发送消息
				for(;;)
				{
					gv_ShareMemory.ReadShareMemory(atoi(chMemoryIndex),&ShareMemoryInformation);
					sprintf(SendBuffer,"%s@%s@%s",ShareMemoryInformation.status,ShareMemoryInformation.object, ShareMemoryInformation.step);
					Trim(SendBuffer);
printf("SendBuffer = %s\n", SendBuffer);
					Socket.WriteLine(ConnectSocket,SendBuffer,sizeof(SendBuffer));
					if(strlen(ShareMemoryInformation.procid) == 0)
					{
						break;
					}
					sleep(1);
				}
printf("Send = End@\n");
				Socket.WriteLine(ConnectSocket,(char *)"End@",strlen("End@"));
				close(ConnectSocket);
				ConnectSocket = -1;
			}
			else if ((strncmp(Command,"GetConfigString@",16)==0))
			{
				/*获取配置文件键值*/
				GetConfigString(ConnectSocket);
			}
			else if ((strncmp(Command,"SetConfigString@",16)==0))
			{
				/*设置配置文件键值*/
				SetConfigString(ConnectSocket);
			}
		}//end if
	}//end for(;;)
}
/****************************************************************
**
**	Function: AdmServer
**	Purpose:  连接服务器，接受客户机的连接请求并fork子进程
	          与客户机通讯
** 	Input Parammeters:
**	Return:
**	datetime:
**
*****************************************************************/
void AdmServer()
{
	int fp;
	C_Config Config;
	C_BaseSock Socket;
	char Buffer[STRING_LEN];
	int iOptReuseAddrOn = 1;
	int ListenSocket,ConnectSocket;
	struct sockaddr_in ServerAddress, ClientAddress;

	#if defined(aCC) || defined(CC)
	int AddressLength = sizeof(sockaddr_in);
	#endif

	#if defined(xlC) || defined(gcc)
	socklen_t AddressLength = (socklen_t)sizeof(sockaddr_in);
	#endif

	S_ShareMemoryInformation *lv_pShareMemory = 0;

	/*获取后台端口号*/
	if(Config.GetParam((char *)gv_chConfigFile,(char *)"AdmServer",(char *)"ServerPort", Buffer) == false)
	{
		printf(
			"Config file error at %s-->%s-->%s\n",
			gv_chConfigFile,
			"AdmServer",
			"ServerPort"
			);
		return;
	}

	/*获取日志文件路径*/
	memset(gv_chLogFile, 0, sizeof(gv_chLogFile));
	if(Config.GetParam((char *)gv_chConfigFile,(char *)"AdmServer",(char *)"LogPath", gv_chLogFile) == false)
	{
		printf(
			"Config file error at %s-->%s-->%s\n",
			gv_chConfigFile,
			"AdmServer",
			"LogPath"
			);
		return;
	}
	if(!IsDirectory(gv_chLogFile))
	{
		printf(
			"The directory \"%s\" is not exist!",
			gv_chLogFile
			);
		return;
	}
	FullPath(gv_chLogFile);
	strcat(gv_chLogFile, LOG_FILE);

	/*打开日志文件*/
    fp = open(gv_chLogFile, O_WRONLY |O_APPEND | O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
    if(-1 == fp)
    {
    	printf("open log file %s error!", LOG_FILE);
    	return;
    }

	if(ShareMemIsOccupy())
	{
		close(fp);
		return;
	}

	/*初始化共享内存*/
	if(!gv_ShareMemory.ShareMemoryInit())
	{
		printf("Admserver: init share memory fail!\n");
		close(fp);
		return;
	}

	gv_ShareMemory.ClearAllMemory();

	ListenSocket = Socket.Socket(AF_INET,SOCK_STREAM, 0);
	memset(&ServerAddress, 0, sizeof(ServerAddress));
	ServerAddress.sin_family = AF_INET;
	ServerAddress.sin_port = htons(atoi(Buffer));
	ServerAddress.sin_addr.s_addr = INADDR_ANY;
	Socket.SetSocketOpt(ListenSocket,SOL_SOCKET,SO_REUSEADDR,(char *)&iOptReuseAddrOn,sizeof(iOptReuseAddrOn));
	Socket.Bind(ListenSocket,(struct sockaddr *)(void *)&ServerAddress,sizeof(ServerAddress));
	Socket.Listen(ListenSocket,LISTENQ);

	for(;;)
	{
		ConnectSocket = Socket.Accept(ListenSocket,(struct sockaddr *)(void *)&ClientAddress,&AddressLength);
		if (ConnectSocket < 0)
		{
			if(errno == EINTR)
			{
				continue;
			}
			printf("connect error!\n");
			Socket.Close(ConnectSocket);
			continue;
		}
		WriteConnectLog(fp, ClientAddress);
		/*连接身份认证*/
		if(Socket.ReadLine(ConnectSocket,Buffer,sizeof(Buffer)) <= 0)
		{
			Socket.Close(ConnectSocket);
			continue;
		}
		else
		{
			if(strcmp(Buffer,"Linkage Billing User")!=0)
			{

				Socket.Close(ConnectSocket);
				continue;
			}
			else
			{
				strcpy(Buffer,"Yes");
				if(Socket.WriteLine(ConnectSocket,Buffer,sizeof(Buffer))<0)
				{
					Socket.Close(ConnectSocket);
					continue;
				}
			}
		}

		switch(fork())
		{
			case -1:
				close(fp);
				exit(-1);
			case 0:
				/*第一个子进程进入监听下一个连接*/
				Socket.Close(ConnectSocket);
				continue;
			default:
				break;
		}

		switch(fork())
		{
			case -1:
				close(fp);
				exit(-1);
			case 0:
				/*第二个子进程进行连接服务*/
				Socket.Close(ListenSocket);
				ConnectionService(ConnectSocket);
				Socket.Close(ConnectSocket);
				WriteCloseLog(fp, ClientAddress);
				close(fp);
				/*连接服务终止*/
				return;
			default:
				/*父进程终止*/
				Socket.Close(ListenSocket);
				Socket.Close(ConnectSocket);
				close(fp);
				return;
		}
	}//end for(;;)
}
/************************************************************************
**
**	Function: WriteConnectLog
**	Purpose:  写客户端连接日志
** 	Input Parammeters: fp -- 文件描述符  ClientAddress -- 客户端信息
**	Return:
**	datetime: 2002/12/05
**
**************************************************************************/
void WriteConnectLog(int fp, struct sockaddr_in &ClientAddress)
{
	int iFp;
	int iLock;
	time_t Now;
	struct tm  *Time = 0;
	char chBuffer[STRING_LEN];
	time(&Now);
	Time = localtime(&Now);
	iLock =SetLockStatus(fp,F_WRLCK, F_SETLK, 0, SEEK_SET, 0);
	if(-1 == iLock)
	{
		return;
	}
	memset(chBuffer, 0 ,sizeof(chBuffer));
	sprintf(
		chBuffer,
		"<%04d/%02d/%02d %02d:%02d:%02d>",
		Time->tm_year + 1900,
		Time->tm_mon + 1,
		Time->tm_mday,
		Time->tm_hour,
		Time->tm_min,
		Time->tm_sec
		);
	sprintf(
		chBuffer,
		"%s\tConnect from %s,\tPort %d\n",
		chBuffer,
		inet_ntoa(ClientAddress.sin_addr),
		ntohs(ClientAddress.sin_port)
		);
	iFp = write(fp,chBuffer,strlen(chBuffer));
	if(-1 == iFp)
	{
		printf("admserver.log: log file error!");
		return;
	}
	iLock =SetLockStatus(fp,F_UNLCK, F_SETLK, 0, SEEK_SET, 0);
	if(-1 == iLock)
	{
		return;
	}
	return;
}
/***********************************************************************
**
**	Function: WriteCloseLog
**	Purpose:  写客户端断开日志
** 	Input Parammeters: fp -- 文件描述符  ClientAddress -- 客户端信息
**	Return:
**	datetime: 2002/12/05
**
*************************************************************************/
void WriteCloseLog(int fp, struct sockaddr_in &ClientAddress)
{
	int iFp;
	int iLock;
	time_t Now;
	struct tm  *Time = 0;
	char chBuffer[STRING_LEN];

	time(&Now);
	Time = localtime(&Now);
	iLock =SetLockStatus(fp,F_WRLCK, F_SETLK, 0, SEEK_SET, 0);
	if(-1 == iLock)
	{
		return;
	}
	memset(chBuffer, 0, sizeof(chBuffer));
	sprintf(
		chBuffer,
		"<%04d/%02d/%02d %02d:%02d:%02d> ",
		Time->tm_year+1900,
		Time->tm_mon+1,
		Time->tm_mday,
		Time->tm_hour,
		Time->tm_min,
		Time->tm_sec
		);
	sprintf(
		chBuffer,
		"%s\tDisconnect from %s,\tPort %d\n",
		chBuffer,
		inet_ntoa(ClientAddress.sin_addr),
		ntohs(ClientAddress.sin_port)
		);
	iFp = write(fp,chBuffer, strlen(chBuffer));
	if(-1 == iFp)
	{
		printf("admserver.log :log file error!");
		return;
	}
	iLock =SetLockStatus(fp,F_UNLCK, F_SETLK, 0, SEEK_SET, 0);
	if(-1 == iLock)
	{
		return;
	}
	return;
}
/****************************************************************
**
**	Function: SetLockStatus
**	Purpose:  设置文件琐状态
** 	Input Parammeters: fp -- 文件描述符   Type -- 锁的类型
			   Cmd -- 命令        Offset -- 相对位移量
			   Whence -- 起始点   Len -- 区域长度
**	Return:
**	datetime: 2002/12/05
**
*****************************************************************/
int SetLockStatus(int Fd, int Type, int Cmd, off_t Offset, int Whence, off_t Len)
{
	struct flock Lock;

	Lock.l_type = Type;
	Lock.l_whence = Whence;
	Lock.l_start = Offset;
	Lock.l_len = Len;
	return fcntl(Fd, Cmd, &Lock);
}
/****************************************************************
**
**	Function: ShareMemIsOccupy
**	Purpose:  判断共享内存是否已被占用
** 	Input Parammeters:
**	Return:	true---已被占用或者出错,false---未被占用
**	datetime: 2002/12/13
**
*****************************************************************/
bool ShareMemIsOccupy(void)
{
	FILE *fp = 0;
	char chBuffer[STRING_LEN];
	char chShmkey[STRING_LEN];
	char chScanBuf[STRING_LEN];
	char *chPoint = 0;
	sprintf(chBuffer, "ipcs -m");
	if((fp = popen(chBuffer, "r")) == 0)
	{
		return true;
	}
	int i = 0;
	while(fgets(chBuffer, sizeof(chBuffer), fp) != 0)
	{
		memset(chScanBuf, 0, sizeof(chScanBuf));
		chPoint = strstr(chBuffer, "0x");
		if(chPoint == 0)
		{
			continue;
		}
		chPoint += 2;
		for(;*chPoint == '0'; chPoint++);
		if(*chPoint == ' ')
		{
			continue;
		}
        for(i =0; *chPoint != ' '; i++)
        {
        	chScanBuf[i] = *chPoint++;
        }
        chScanBuf[i]='\0';
		sprintf(chShmkey, "%x", SHM_KEY);
		if(strcmp(chScanBuf, chShmkey) == 0)
		{
			printf("Share Memory has been occupied !\n");
			pclose(fp);
			return true;
		}
	}
	pclose(fp);
	return false;
}

/*重启当前系统的所有正在运行的进程*/
void ResetAllProcess(void)
{
	S_ShareMemoryInformation *pShareMemory = 0;
	pShareMemory = gv_ShareMemory.GetpShareMemory();

	int ProcessIndex[MON_MAXPROC];
	int i = 1;
	for(i = 1; i < MON_MAXPROC; i++)
	{
		ProcessIndex[i] = 0;
		if(strlen((pShareMemory + i)->procid) != 0)
		{
			ProcessIndex[i] = (pShareMemory + i)->CurrentIndex;
			kill(atoi((pShareMemory + i)->procid), SIGTERM);
		}
	}

	int iResult = 0;
	while(1)
	{
		for(i = 1; i < MON_MAXPROC; i++)
		{
			if(strlen((pShareMemory + i)->procid) != 0)
			{
				iResult++;
			}
		}
		if(0 == iResult)
		{
			break;
		}
		iResult = 0;
		sleep(1);
	}
	for(i = 1; i< MON_MAXPROC; i++)
	{
		if(ProcessIndex[i] != 0)
		{
			StartProcess(ProcessIndex[i]);
		}
	}
	return;
}

void GetSysInfo(char *HostCpu, char *HostMem)
{
	return;
}

void GetProcInfo(int Processindex, char *ProcessCpu, char *ProcessMem)
{
	return;
}

//-------------------------------------The End-------------------------------------