/*
 * proxyserver.c
 *
 *  Created on: Oct 9, 2016
 *      Author: JKM
 */
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <sys/time.h>
#include <fcntl.h>
//#include "/usr/include/mysql/mysql.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
#include <errno.h>
#include <sys/stat.h>
#include <signal.h>
#include <string>
#include <map>
#include <vector>
#include <stdint.h>
#include <iostream>
#include <fstream>

#include <unistd.h>

#include <json/json.h>

#include "MD5Linux.h"

#include "HCNetSDK64/incCn/HCNetSDK.h"
#define  HPR_OK 0
#define  HPR_ERROR -1

#define MAX_NUM 32
#define MAX 1024
#define fileread_buf 128

volatile time_t last_alarmout;

typedef std::map<std::string, int> hcnetsdk_user_t; // decoder_ip, userid
hcnetsdk_user_t g_hcnetsdk_user;

enum EquipmentType
{
	ET__FIRST,
	ET_PC_SERVER,
	ET_HCNET_DECODER__FIRST,
	ET_HCNET_DECODER_POPWIN, // 3
	ET_HCNET_DECODER_LOGO, // 4
	ET_HCNET_DECODER_ALARMOUT, // 5
	ET_HCNET_DECODER__LAST,
	ET__LAST
};

struct HCNetSDKConfig
{
	std::string serverIP;
	int serverport;
	std::string username;
	std::string passwd;
};

HCNetSDKConfig g_hcnetsdkconfig;

struct HCNetCameraConfig
{
	int lUserID;
	std::string ip;
	int port;
	std::string username;
	std::string passwd;
	int channel;
	uint16_t byWallNo;
	uint16_t dwSubWinNo;
	std::vector<uint16_t> dwWinNo;
	uint16_t lAlarmOutPort;
};

typedef struct{
   int m_id;
   EquipmentType m_type;
   char serverIP[32];
   char serverport[10];
   char port[10];
   char ip[32];
   char user[64];
   char pass[64];
   int reboot;
   void* user_config;
}sockinfo,*lpsockinfo;
pthread_t thread_no[MAX_NUM];
pthread_t thread_noEQ[MAX_NUM];
pthread_t thread_Real[MAX_NUM];
sockinfo equipments[MAX_NUM];
int sock_upper[MAX_NUM],sock_down[MAX_NUM];
int rsock_down[MAX_NUM];
char byte_array[2600];
int bbbbb=0;
int CommandEquipIdx=0;
int CommandKind[MAX_NUM];
char sessionIDs[MAX_NUM][5];

char linkequip_ip[32];
char linkequip_port[10];
int focusServer=-1;
int focusEquip=-1;

int NUM=0,equip_num=0;

int SupperConnectedflag[MAX_NUM]={0,},EquipConnectedflag[MAX_NUM]={0,},serverflag=0,GPIO_flag=0;
int EquipRealAlarmConnectedflag[MAX_NUM];
timer_t* timerID;

std::vector<std::string> SupperConnectedIP;

int hcnetsdk_user = -1;

int Read_MysqlData();
int UpdateMysqData(int key);
void* createServerthread(void* arg);
void* createEquipmentthread(void* arg);
void* MyEquipmentthread(void* arg);


int net_test(char* serverIP,char* port);
void EquipCheckGPIOOut(void);
void GPIOinit(void);
int GPIOoutput(int no);
int time_lock(int year,int month,int day,int hour,int min,int sec,int during);

int GPIO_OPEN(int PortNum);
void GPIO_CLOSE(int PortNum);
int GPIO_READ(int PortNum);
void GPIO_WRITE(int PortNum,unsigned char DATA);
int RealEventStart(int Idx);
int gCapturing[MAX_NUM];
char sessions[MAX_NUM][10];

int n=0,m=0,k=0;
unsigned char DownBuffer[MAX_NUM][614000];
int DownCount[MAX_NUM];
int gCount=0;
int gCount30s=0;
int gCount2s=0;
void zclock_sleep (int msecs);

void zclock_sleep (int msecs)
{
    struct timespec t;
    t.tv_sec  =  msecs / 1000;
    t.tv_nsec = (msecs % 1000) * 1000000;
    nanosleep (&t, NULL);
}
void u_alarm_handler(int)
{
	//printf("connect fail==============");

}
void timer_handler(int signum)
{
	int i,j;

	////////////// added on 2016.11.8  //////////////////
	gCount2s++;
	if(gCount2s>=8){
		gCount2s=0;
		for(;CommandEquipIdx<MAX_NUM;CommandEquipIdx++){//connected
			if(EquipConnectedflag[CommandEquipIdx]>0) break;
		}
		if(CommandEquipIdx>=MAX_NUM){
			CommandEquipIdx = 0;
		}
	}
	/////////////////////////////////////////////////////
	gCount30s++;
	if(gCount30s>=120){//4*30=30s
		gCount30s=0;
		if(NUM>0){			
			EquipCheckGPIOOut();//GPIO Watchdog_Timer
		}
	}
	gCount++;
	if(gCount>=4){//1s
		gCount = 0;
		Read_MysqlData();
		equip_num=NUM;
		//time_lock(2016,10,28,10,10,10,30);
	}

	//serverthread
    for(i=0;i<NUM;i++)
	{
		for(j=0;j<i;j++)
			if(strcmp(equipments[i].serverIP,equipments[j].serverIP)==0 && strcmp(equipments[i].serverport,equipments[j].serverport)==0)
				break;
		if(j<i)
			continue;
		
		if(SupperConnectedflag[i]==0)
		{
			struct sockaddr_in servaddr;
			int strlen1=sizeof(servaddr);
			if(equipments[i].serverIP[0]!=0 && equipments[i].serverport[0]!=0)
			{
				if((sock_upper[i]=socket(PF_INET,SOCK_STREAM,0))<0)
				{
					perror("socket fail1");
					continue;
				}
				memset(&servaddr,0,strlen1);
				servaddr.sin_family=AF_INET;
				inet_pton(AF_INET,equipments[i].serverIP,&servaddr.sin_addr);
				servaddr.sin_port=htons(atoi(equipments[i].serverport));

				sigset(SIGALRM, u_alarm_handler);
				alarm(2);
				int rt = connect(sock_upper[i],(struct sockaddr*)&servaddr,strlen1);
				alarm(0);
				sigrelse(SIGALRM);
				if(rt<0)
				{
					printf("server connect fail-%s:%s\n",equipments[i].serverIP,equipments[i].serverport);
					close(sock_upper[i]);
					continue;
				}
				SupperConnectedflag[i]=1;
				SupperConnectedIP[i] = equipments[i].serverIP;
				//printf("server connect Success=:%s:%s\n",equipments[i].serverIP,equipments[i].serverport);
				pthread_create(&thread_no[i],NULL,&createServerthread,(void*)i);//super
			}
		}
	}
	//equipment thread
    for(i=0;i<NUM;i++)
	{
		for(j=0;j<i;j++)
			if(strcmp(equipments[i].ip,equipments[j].ip)==0 && strcmp(equipments[i].port,equipments[j].port)==0)
				break;
		if(j<i)
			continue;
		if(EquipConnectedflag[i]==0)
		{
		   if(equipments[i].ip[0]!=0 && equipments[i].port[0]!=0)
		   {
				struct sockaddr_in servaddr;
				int strlen1=sizeof(servaddr);
				if((sock_down[i]=socket(PF_INET,SOCK_STREAM,0))<0)
				{
					perror("socket fail2");
					continue;
				}
			   // printf("==============================3333\n");
				memset(&servaddr,0,strlen1);
				servaddr.sin_family=AF_INET;
				inet_pton(AF_INET,equipments[i].ip,&servaddr.sin_addr);
				servaddr.sin_port=htons(atoi(equipments[i].port));
				
				sigset(SIGALRM, u_alarm_handler);//add 2016.11.22
				alarm(2);
				int rt = connect(sock_down[i],(struct sockaddr*)&servaddr,strlen1);
				alarm(0);
				sigrelse(SIGALRM);		  
				if(rt<0)
				{
					printf("Equipment connect fail-%s:%s\n",equipments[i].ip,equipments[i].port);
					close(sock_down[i]);
					continue;
				}
				EquipConnectedflag[i]=1;
				pthread_create(&thread_noEQ[i],NULL,&createEquipmentthread,(void*)i);//super(void*)(&equipments[0])
				printf("equipment connect Success=:%s:%s\n",equipments[i].ip,equipments[i].port);
		   }
		}
		if(EquipRealAlarmConnectedflag[i]==0)
		{//////  added on 2017.11.21
			//printf("Myequipment connect ==================:");
			if(RealEventStart(i)==0) EquipRealAlarmConnectedflag[i]=1;	
		}
	}
}

int hcnetsdk_get_userid(const std::string& decode_ip)
{
	return hcnetsdk_user;
	//hcnetsdk_user_t::const_iterator iter = g_hcnetsdk_user.find(decode_ip);
	//if(iter == g_hcnetsdk_user.end())
	//	return -1;
	//else
	//	return iter->second;
}

void CALLBACK hcnetsdk_ExceptionCallBack(DWORD dwType, LONG lUserID, LONG lHandle, void *pUser)
{
	printf("hcnetsdk_ExceptionCallBack: %d\n", int(dwType));
}

int hcnetsdk_alarm_alarmout(LONG lUserID, const HCNetCameraConfig& camConfig)
{
	//报警时间段
	NET_DVR_SCHEDTIME net_dvr_schedtime = {0};
	net_dvr_schedtime.byStartHour = 0;
	net_dvr_schedtime. byStartMin = 1;
	net_dvr_schedtime.byStopHour = 11;
	net_dvr_schedtime.byStopMin = 59;
	
	//报警设置信息
	NET_DVR_ALARMOUTCFG_V30 net_dvr_alarmoutcfg = {0};
	net_dvr_alarmoutcfg.dwSize = sizeof(net_dvr_alarmoutcfg);
	memcpy(net_dvr_alarmoutcfg.sAlarmOutName, "ac", sizeof("ac"));
	net_dvr_alarmoutcfg.dwAlarmOutDelay = 0;
	memcpy(net_dvr_alarmoutcfg.struAlarmOutTime, &net_dvr_schedtime, sizeof(net_dvr_schedtime));
	//net_dvr_alarmoutcfg.byRes[16] = 0;
	if(!NET_DVR_SetDVRConfig(lUserID,NET_DVR_SET_ALARMOUTCFG_V30,0,&net_dvr_alarmoutcfg,net_dvr_alarmoutcfg.dwSize)){
		printf("NET_DVR_SetDVRConfig failed, err: %d\n", NET_DVR_GetLastError());
	}
		
	//开启警报
	if(NET_DVR_SetAlarmOut(lUserID,camConfig.lAlarmOutPort,1) == FALSE){
		printf("NET_DVR_SetAlarmOut failed, err: %d\n", NET_DVR_GetLastError());
	}
	last_alarmout = time(NULL);
	
	sleep(3);
	
	if (time(NULL) - last_alarmout >= 3)
	{
		//解除警报
		NET_DVR_SetAlarmOut(lUserID,camConfig.lAlarmOutPort,0);
	}
}

int hcnetsdk_alarm_popwin(LONG lUserID, const HCNetCameraConfig& camConfig)
{
	//LONG lUserID = hcnetsdk_get_userid(camConfig);
	if(lUserID < 0)
	{
		std::cerr << "hcnetsdk_get_userid ret -1" << std::endl;
		return -1;
	}
	
	//设置电视墙窗口参数，即开窗，坐标在电视墙范围之内
	DWORD m_dwWinCount=1;
	//开两个窗口
	DWORD m_dwWinNum[1];
	//1字节墙号+ 1字节保留+ 2字节窗口号m_dwWinNum[0] = 1<<24;
	//开窗时窗口号为0
	m_dwWinNum[0] = 1<<24;

	NET_DVR_VIDEOWALLWINDOWPOSITION m_struWinPos[1];
	memset(m_struWinPos, 0, sizeof(m_struWinPos));

	m_struWinPos[0].dwSize=sizeof(NET_DVR_VIDEOWALLWINDOWPOSITION);
	m_struWinPos[0].byEnable=1;
	m_struWinPos[0].struRect.dwXCoordinate=200;
	m_struWinPos[0].struRect.dwYCoordinate=200;
	m_struWinPos[0].struRect.dwWidth=1520;
	m_struWinPos[0].struRect.dwHeight=1520;

	DWORD m_dwWinStatus[1];
	DWORD dwRetWinNum[1];
	//开窗时窗口号由设备返回
	
	NET_DVR_IN_PARAM struInputPapam = {0};
	struInputPapam.struCondBuf.pBuf = &m_dwWinNum;
	//输入条件缓冲区
	struInputPapam.struCondBuf.nLen = m_dwWinCount * sizeof(DWORD);
	struInputPapam.dwRecvTimeout = 5000;
	//接收超时时间
	struInputPapam.struInParamBuf.pBuf = m_struWinPos;
	struInputPapam.struInParamBuf.nLen = m_dwWinCount * sizeof(NET_DVR_VIDEOWALLWINDOWPOSITION);
	
	NET_DVR_OUT_PARAM struOutputPapam = {0};
	struOutputPapam.lpStatusList = m_dwWinStatus;
	struOutputPapam.struOutBuf.pBuf = dwRetWinNum;
	struOutputPapam.struOutBuf.nLen = m_dwWinCount*sizeof(DWORD);
	
	if (!NET_DVR_SetDeviceConfigEx(lUserID, NET_DVR_SET_VIDEOWALLWINDOWPOSITION, m_dwWinCount, &struInputPapam, &struOutputPapam)) {
		printf("NET_DVR_SET_VIDEOWALLWINDOWPOSITION error, err: %d\n", NET_DVR_GetLastError());
		return -1;
	}

	//前端设备 动态解码
	NET_DVR_PU_STREAM_CFG_V41 m_struDynamicInfo= {0};
	m_struDynamicInfo.dwSize=sizeof(m_struDynamicInfo);
	m_struDynamicInfo.byStreamMode=1;
	strcpy((char *)m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.byAddress, camConfig.ip.c_str());
	m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.wDVRPort = camConfig.port;
	strcpy((char *)m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.sUserName, camConfig.username.c_str());
	strcpy((char *)m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.sPassword, camConfig.passwd.c_str());
	m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.byChannel = camConfig.channel;
	m_struDynamicInfo.uDecStreamMode.struDecStreamDev.struDevChanInfo.byFactoryType=0;
	
	//int byWallNo=1,dwSubWinNo=1,dwWinNo=1;
	//DWORD dwDecChanNum=0x01000002;
	
	int dwWinNo = 2;//#todo get max win count and +1
	{
		//NET_DVR_WINLIST winlist;
		//BYTE pBuffer[224*sizeof(NET_DVR_SCREEN_WINCFG)];
		//winlist.dwSize = sizeof(winlist);
		//winlist.pBuffer = pBuffer;
		//winlist.dwBufLen = 224;
		//if (!NET_DVR_GetAllValidWinInfo(lUserID, &winlist))
		//	printf("NET_DVR_GetAllValidWinInfo error, err: %d\n", NET_DVR_GetLastError());
		//
		//std::cout<<"winnum="<<winlist.dwWinNum<<std::endl;
	}
	
	DWORD dwDecChanNum=(camConfig.byWallNo << 24) | (camConfig.dwSubWinNo << 16) | dwWinNo;
	//1字节墙号+1字节子窗口号+2字节窗口号: (byWallNo << 24) | (dwSubWinNo<<16) |dwWinNo;
	if (!NET_DVR_MatrixStartDynamic_V41(lUserID, dwDecChanNum, &m_struDynamicInfo))
	{
		printf("NET_DVR_MatrixStartDynamic_V41 error, err: %d\n", NET_DVR_GetLastError());
		return -1;
	}
	
	std::cout << "hcnetsdk_alarm_popwin" << std::endl;
}

void hcnetsdk_finial()
{
	//NET_DVR_Logout(lUserID); //#todo
	NET_DVR_Cleanup();
}

int hcnetsdk_init_logo(LONG lUserID)
{
	//logo信息
	NET_DVR_MATRIX_LOGO_INFO net_dvr_matrix_logocfg1;
	net_dvr_matrix_logocfg1.byRes[32]=0;
	net_dvr_matrix_logocfg1.dwSize=0;
	net_dvr_matrix_logocfg1.dwLogoSize=0;

	char logobuf[5000];
	{
		FILE * pFile;
		pFile = fopen("./ico.bmp","rb");
		if (pFile!=NULL)
		{
			net_dvr_matrix_logocfg1.dwLogoSize = fread(logobuf, 1, sizeof(logobuf), pFile);
			fclose (pFile);
		}
		else
		{
			perror ("Error opening file");
			return -1;
		}
	}

	net_dvr_matrix_logocfg1.dwSize= sizeof(net_dvr_matrix_logocfg1);

	//上传logo
	if (TRUE != NET_DVR_UploadLogo_NEW(lUserID, 1, &net_dvr_matrix_logocfg1 , logobuf))
	{
		printf("NET_DVR_UploadLogo_NEW error, err: %d\n", NET_DVR_GetLastError());
		return -1;
	}
	else
	{
		printf("NET_DVR_UploadLogo_NEW done.\n");
		return 0;
	}
	
	return -1;
}

int hcnetsdk_init()
{
	NET_DVR_Init();
	NET_DVR_SetConnectTime(2000, 1);
	NET_DVR_SetReconnect(10000, true);
	NET_DVR_SetExceptionCallBack_V30(0, NULL,hcnetsdk_ExceptionCallBack, NULL);

	LONG lUserID;

	NET_DVR_DEVICEINFO_V30 struDeviceInfo;
	hcnetsdk_user = lUserID = NET_DVR_Login_V30((char*)g_hcnetsdkconfig.serverIP.c_str(), g_hcnetsdkconfig.serverport, 
		(char*)g_hcnetsdkconfig.username.c_str(), (char*)g_hcnetsdkconfig.passwd.c_str(), &struDeviceInfo);
	if (lUserID < 0) {
		printf("NET_DVR_Login_V30 failed, err: %d\n", NET_DVR_GetLastError());
		NET_DVR_Cleanup();
		return -1;
	}
	
	g_hcnetsdk_user.insert(std::make_pair(g_hcnetsdkconfig.serverIP, int(lUserID)));
	
	hcnetsdk_init_logo(lUserID);
	
	return lUserID;
}

HCNetCameraConfig* hcnetsdk_find_config(const sockinfo& oldEquipConfig, int newChannel)
{
	for (size_t i = 0; i < NUM; i++)
	{
		sockinfo* equip = &(equipments[i]);
		if (equip->m_type > ET_HCNET_DECODER__FIRST || equip->m_type < ET_HCNET_DECODER__LAST)
		{
			HCNetCameraConfig* camConfig = (HCNetCameraConfig*)equip->user_config;
			if (camConfig != NULL && strcmp(equip->ip, oldEquipConfig.ip) == 0)
			{
				if (camConfig->channel == newChannel)
					return camConfig;
			}
		}
	}
	
	return NULL;
}

sockinfo* hcnetsdk_find_equip(const std::string& decoder_ip)
{
	for (size_t i = 0; i < NUM; i++)
	{
		sockinfo* equip = &(equipments[i]);
		if (equip->m_type > ET_HCNET_DECODER__FIRST || equip->m_type < ET_HCNET_DECODER__LAST)
		{
			if (equip->serverIP == decoder_ip)
				return equip;
		}
	}
	
	return NULL;
}

sockinfo* hcnetsdk_find_equip(const std::string& decoder_ip, int channel)
{
	for (size_t i = 0; i < NUM; i++)
	{
		sockinfo* equip = &(equipments[i]);
		if (equip->m_type > ET_HCNET_DECODER__FIRST || equip->m_type < ET_HCNET_DECODER__LAST)
		{
			HCNetCameraConfig* camConfig = (HCNetCameraConfig*)equip->user_config;
			if (camConfig != NULL && camConfig->channel == channel && equip->serverIP == decoder_ip)
				return equip;
		}
	}
	
	return NULL;
}

int hcnetsdk_alarm_logo(LONG lUserID, const HCNetCameraConfig& _camConfig, const std::string& ip, int channel, bool disalarm)
{
	HCNetCameraConfig camConfig(_camConfig);
	//if (camConfig.channel != channel)
	//{
	//	camConfig.channel = -1;
	//	sockinfo* equipConfig = hcnetsdk_find_equip(ip, channel);
	//	if (equipConfig != NULL)
	//		camConfig = *(HCNetCameraConfig*)(equipConfig->user_config);
	//}
	
	printf("hcnetsdk_alarm_logo, channel=%d, matchc=%d\n", channel, camConfig.channel);
	
	if (camConfig.channel < 0)
		return -1;
	
	//窗口配置信息
	NET_DVR_WIN_LOGO_CFG net_dvr_win_logo_cfg;
	net_dvr_win_logo_cfg.dwLogoNo = 1;
	net_dvr_win_logo_cfg.byEnable = (disalarm ? 0 : 1);//0:hidden,1:visible
	net_dvr_win_logo_cfg.byRes1[3] =0;
	net_dvr_win_logo_cfg.dwCoordinateX = 5;
	net_dvr_win_logo_cfg.dwCoordinateY =5;
	net_dvr_win_logo_cfg.byFlash = 1;
	net_dvr_win_logo_cfg.byTranslucent = 0;
	net_dvr_win_logo_cfg.byRes2[34] = 0;

	net_dvr_win_logo_cfg.dwSize = sizeof(net_dvr_win_logo_cfg);
	//设置窗口输出logo
	int byWallNo=1,dwSubWinNo=2,dwWinNo=1;
	
	for (int i= 0; i < camConfig.dwWinNo.size(); i++)
	{
		DWORD dwDecChanNum=(camConfig.byWallNo << 24) | (camConfig.dwSubWinNo << 16) | camConfig.dwWinNo[i];
		if(!NET_DVR_SetDVRConfig(lUserID,NET_DVR_SET_WIN_LOGO_CFG,dwDecChanNum,&net_dvr_win_logo_cfg,net_dvr_win_logo_cfg.dwSize))
		{
			printf("NET_DVR_SetDVRConfig2 error, err: %d\n", NET_DVR_GetLastError());
			//return -1;
		}
		else
		{
			printf("NET_DVR_SetDVRConfig2 done.\n");
			//return 0;
		}
	}
	
	return 0;
	
	//sleep(3);
	//net_dvr_win_logo_cfg.byEnable = 0;
	//NET_DVR_SetDVRConfig(lUserID,NET_DVR_SET_WIN_LOGO_CFG,dwDecChanNum,&net_dvr_win_logo_cfg,net_dvr_win_logo_cfg.dwSize);
}

int main(int argc,char **argv)
{
	   struct sigaction sa;
	   struct itimerval timer;
	   linkequip_port[0]=0;
	   linkequip_ip[0]=0;	  
	   GPIOinit();
	   int i;
 	   Read_MysqlData();
 	   chmod("/etc/network/interfaces",0777);
	   chmod("/tmp/interfaces",0777);

       for(i=0;i<NUM;i++) {
  	       SupperConnectedflag[i]=0;
		   EquipConnectedflag[i]=0;
		   EquipRealAlarmConnectedflag[i]=0;
  	       sock_upper[i]= -1;
		   sock_down[i] = -1;
		   rsock_down[i] = -1;
	   }
	   
	   SupperConnectedIP.resize(sizeof(SupperConnectedflag)/sizeof(int));
	   
	   hcnetsdk_user = hcnetsdk_init();
	   if (hcnetsdk_user < 0)
	   {
		   printf("hcnetsdk_user < 0");
		   exit(EXIT_FAILURE);//#todo if debug equipment(analizer), remove this
	   }
		
	   /*Install timer_handler as th siganl handler for SIGVTALRM */
	   memset(&sa,0,sizeof(sa));
	   sa.sa_handler=&timer_handler;
	   sigaction(SIGVTALRM,&sa,NULL);
	   /* Configure the timer to expire after 250msec..*/
	   timer.it_value.tv_sec=0;
	   timer.it_value.tv_usec=250000;
	   /*...and every 250 msec after that.*/
	   timer.it_interval.tv_sec=0;
	   timer.it_interval.tv_usec=250000;
	   /*Start a virtual timer.It counts down whenever this process is executing.*/

	   //setitimer(ITIMER_VIRTUAL,&timer,NULL);
	   
	   
	   
	   
		while ( 1 )
		{
			zclock_sleep(250);
			timer_handler(0);
		} 
}

void* createServerthread_hcnetsdk(void* arg)
{
}

//=================================================================
void* createServerthread_pc_server(void* arg)
{
   int sidx = (int)arg; 
   int length=0;
   char buff[102400];
  
   puts("Step.1 ========>Server Thread is strarted......");
   unsigned char data[4096];  
  //=======================================equipment data================================
  int idx=0;  
  int i;
  data[idx++]=0x68;
  data[idx++]=0x05;
  for(i=0;i<NUM;i++){
	  data[idx++]=strlen(equipments[i].ip);
	  memcpy(&data[idx],equipments[i].ip,strlen(equipments[i].ip));idx+=strlen(equipments[i].ip);
	  data[idx++]=atoi(equipments[i].port)/256;
	  data[idx++]=atoi(equipments[i].port)%256;
	  data[idx++]=strlen(equipments[i].user);
	  memcpy(&data[idx],equipments[i].user,strlen(equipments[i].user));idx+=strlen(equipments[i].user);  
	  data[idx++]=strlen(equipments[i].pass);
	  memcpy(&data[idx],equipments[i].pass,strlen(equipments[i].pass));idx+=strlen(equipments[i].pass);
  }
  data[idx++]=0x16;
  write(sock_upper[sidx],&data,idx);//send to equipment;
  //printf("Send equipment's info to Server OK! len=:%d\n",idx);
  //=======================================data================================================
  while(1)
   {
		int j;
		length=read(sock_upper[sidx],&buff,sizeof(buff)-1);
		//printf("from Server received data===============:%d\n",length);
	    if(length<=0)
		{
			//printf(" Upper Socket closed \n");
			break;
		}
		else {            
            //====analysis
           // if(buff[0]==0x68 && buff[1]==0x07) {
			//	focusServer =-1;
			//	printf("from Server received data===============:%d%d\n",buff[0],buff[1]);
			//	memcpy(buff,&buff[3],length-3);
			//	length-=3;
			//	if(length<=0) continue;
			//}

            if(buff[0]==0x68 && buff[1]==0x03 )
        	{

				printf("=========================buffer=====%s\n",buff);
				
				int index=buff[2];
				char DownIP[32];
				char Downport[10];
				int result=-1;
				memcpy(&DownIP[0],&buff[3],index);
				int port=buff[index+3]*256+(unsigned char)buff[index+4];
				sprintf(Downport,"%d",port);
				if(buff[index+5]==0x16)
				{
					result=net_test(DownIP,Downport);
					printf("Result=%s:%d:%d \n",DownIP,port,result);
					if(result>0)
					{
						//response[0]=0x68;
						//response[1]=0x03;
						//response[2]=0x00;
						//write(sock_upper[sidx],response,3);						
						focusServer = sidx;
						for(j=0;j<NUM;j++) {
							if(strcmp(DownIP,equipments[j].ip)==0 && strcmp(Downport,equipments[j].port)==0) 
							{
								focusEquip = j;
								break;
							}
						}
						continue;
					}
					else{
						//response[0]=0x68;
						//response[1]=0x03;
						//response[2]=0x01;
						//write(sock_upper[sidx],response,3);
						continue;
					}
				//	memcpy(buff,&buff[index+6],length-(index+6));
				//	length-=index+6;
				//	if(length<=0) continue;
				}
			  }
            if(focusServer>=0)
			{
				if(focusEquip>=0 && sock_down[focusEquip]>0 ){
					write(sock_down[focusEquip],buff,length);
					printf("Directly down to Equipment data===============:%d\n",length);
				}
				else{
					printf("Saved to Equipment data=========================:%d\n",length);
					memcpy(DownBuffer[focusEquip],buff,length);//send to equipment;
					DownCount[focusEquip] = length;
				}
			 }
			continue;
		}
  }
  //puts("Server Thread is stoped..");
  close(sock_upper[sidx]);
  sock_upper[sidx] = -1;
  SupperConnectedflag[sidx]=0;//?//#todo
  pthread_exit((void*)thread_no[sidx]);
}

void* createServerthread(void* arg)
{
	return createServerthread_pc_server(arg);
}

void* createEquipmentthread(void* arg)
 {
   int eidx = (int)arg; 
   printf("Step.2 ===%d=====>Equipment Thread is strarted......\n",eidx);

   int length=0;
   char buff[102400];
   while(1)
   {
	   if(DownCount[eidx]>0) {
			   write(sock_down[eidx],DownBuffer[eidx],DownCount[eidx]);//?
			   printf("down to Equipment data=============:%d\n",DownCount[eidx]);
			   DownCount[eidx]=0;
	   }
	   memset(buff,0,sizeof(buff));
	   length=read(sock_down[eidx],&buff,sizeof(buff)-1);	   
       if(length<=0)
		{
			printf(" Down Socket closed \n");
			break;
		}
	   else if(length>0){
		   if( focusServer>=0){
			   printf("Received data from Equipment length==========:%d\n",length);
			   if(sock_upper[focusServer] >0)   
			   {
				    write(sock_upper[focusServer],buff,length);//send to equipment;
				    printf("send data to length Sever ===============:%d\n",length);
				}
		   }
		    
	   }
  }
  close(sock_down[eidx]);
  sock_down[eidx]=-1;
  puts("Equipment Thread is stoped..");
  EquipConnectedflag[eidx]=0;
  CommandKind[CommandEquipIdx]=0;
  pthread_exit((void*)thread_noEQ[eidx]);
}
//=====================Reatime thread realstart=========================
void* MyEquipmentthread(void* arg)
 {
   int eidx = (int)arg;   
   const sockinfo& equipConfig(equipments[eidx]);
   printf("Step.3 ===%d=====>RealTimeEvent Thread is strarted......\n",eidx);

   int length=0;
   char buff[102400];
   while(1)
   {
	   memset(buff,0,sizeof(buff));
	   length=read(rsock_down[eidx],&buff,sizeof(buff)-1);	   
       if(length<=0)
		{
			printf(" Down Socket closed \n");
			break;
		}
	   else if(length>0)
	   {
		   std::cout << "buff:  " << buff<<std::endl;
		   
		   bool isDisalarm = false;
			if (strstr(buff, "ViqEventNotificationAlert") == NULL) // <urn
				continue;
			if (strstr(buff, "startTime") == NULL) // <urn
				isDisalarm = true;
			
			int channel = -1;
			{
				const char* strChannel = strstr(buff, "<urn:channelId>");
				if (strChannel != NULL)
				{
					channel = strtol(strChannel + strlen("<urn:channelId>"), NULL, 10);
				}
			}
			
			if (channel==1)
			{
				int aa=1;//#todo break
			}
			
            if(gCapturing[eidx]==1)
			{
				//add 20170327
				const std::string& ip(equipConfig.ip);
				const HCNetCameraConfig* camConfig =  (HCNetCameraConfig*)equipConfig.user_config;
				camConfig = hcnetsdk_find_config(equipConfig, channel);
				int lUserData = hcnetsdk_get_userid(ip);
				if (camConfig != NULL && hcnetsdk_user >= 0)
				{
					std::cout << "......alarm begin k=" << k << std::endl;
					if (equipConfig.m_type == ET_HCNET_DECODER_ALARMOUT && !isDisalarm)
						hcnetsdk_alarm_alarmout(lUserData, *camConfig);
					else if (equipConfig.m_type == ET_HCNET_DECODER_LOGO)
						hcnetsdk_alarm_logo(lUserData, *camConfig, ip, channel, isDisalarm);
					std::cout << "......alarm end k=" << k << std::endl;
				}
				else
				{
					std::cout << "alarm lost k=" << k << std::endl;
				}

				
				int k;
				for(k=0;k<MAX_NUM;k++)
				{
					//if(SupperConnectedflag[k]==1)
					//{
					//	write(sock_upper[k],buff,strlen(buff));
					//	printf("======>>>>>>>upper send length====%d======\n",strlen(buff));
					//	printf("=============================================================\n");

						//struct sockaddr peeraddr;
						//socklen_t len = sizeof(sockaddr);
						//if (getpeername(sock_upper[k], &peeraddr, &len) == 0)
						//{
						//	struct sockaddr_in* sin = (struct sockaddr_in*)(&peeraddr);
						//	int port = sin->sin_port;
						//	char addr_buffer[INET_ADDRSTRLEN];
						//	if (inet_ntop(AF_INET, &(sin->sin_addr), addr_buffer, INET_ADDRSTRLEN) == NULL)
						//	{
						//		std::cerr << "inet_ntop err" << std::endl;
						//	}
						//	else
						//	{
						//		//std::cout << "addr:" << addr_buffer << std::endl; // #todo
						//		HCNetCameraConfig* camConfig =  hcnetsdk_find_config(addr_buffer);
						//		if (camConfig != NULL)
						//		{
						//			std::cout << "alarm " << std::endl;
						//			hcnetsdk_alarm_popwin(*camConfig);
						//		}
						//	}
						//}

						//printf("%s",buff);
					//}
					//else
					//{
					//	if(SupperConnectedIP.size() > k)
					//	{
					//		const std::string& ip(SupperConnectedIP[k]);
					//		sockinfo* equipConfig = hcnetsdk_find_equip(ip);
					//		HCNetCameraConfig* camConfig =  hcnetsdk_find_config(ip);
					//		int lUserData = hcnetsdk_get_userid(ip);
					//		if (camConfig != NULL && equipConfig != NULL && lUserData >= 0)
					//		{
					//			std::cout << "......alarm begin k=" << k << std::endl;
					//			if (equipConfig->m_type == ET_HCNET_DECODER_ALARMOUT && !isDisalarm)
					//				hcnetsdk_alarm_alarmout(lUserData, *camConfig);
					//			else if (equipConfig->m_type == ET_HCNET_DECODER_LOGO)
					//				hcnetsdk_alarm_logo(lUserData, *camConfig, ip, channel, isDisalarm);
					//			std::cout << "......alarm end k=" << k << std::endl;
					//		}
					//		else
					//		{
					//			std::cout << "alarm lost k=" << k << std::endl;
					//		}
					//	}
					//}
				}
				continue;	
			}
	   }
  }
  close(rsock_down[eidx]);
  rsock_down[eidx]=-1;
  EquipRealAlarmConnectedflag[eidx]=0;
  puts("RealTimeEvent  Thread is stoped..");
  pthread_exit((void*)thread_Real[eidx]);
}

int Read_MysqlData()
{
	if (NUM > 0)
		return 1;
	
	std::vector<sockinfo> equipments_config;
	
	std::ifstream ifs;
	ifs.open("config.json");

	Json::Reader reader;
	Json::Value root;
	if (!reader.parse(ifs, root, false))
	{
		std::cout << "open config.json error" << std::endl;
		exit(EXIT_FAILURE);
	}
	
	//HCNetSDKConfig
	Json::Value jsonHcsdk = root["hcsdk"];
	g_hcnetsdkconfig.serverIP = jsonHcsdk["serverIP"].asString();
	g_hcnetsdkconfig.serverport = jsonHcsdk["serverport"].asInt();
	g_hcnetsdkconfig.username = jsonHcsdk["username"].asString();
	g_hcnetsdkconfig.passwd = jsonHcsdk["passwd"].asString();

	Json::Value jsonEquipments = root["equipments"];
	for (int i = 0; i < jsonEquipments.size() && i < sizeof(equipments) / sizeof(sockinfo); i++)
	{
		Json::Value jsonEquip = jsonEquipments[i];
		
		sockinfo equip;
		equip.m_id = jsonEquip["id"].asInt();;
		equip.m_type = (EquipmentType)jsonEquip["type"].asInt();;
		strcpy(equip.ip, jsonEquip["ip"].asString().c_str());
		strcpy(equip.port, jsonEquip["port"].asString().c_str());
		strcpy(equip.serverIP, jsonEquip["serverIP"].asString().c_str());
		strcpy(equip.serverport, jsonEquip["serverport"].asString().c_str());
		strcpy(equip.user, jsonEquip["user"].asString().c_str());
		strcpy(equip.pass, jsonEquip["pass"].asString().c_str());
		equip.reboot = jsonEquip["reboot"].asInt();
		equip.user_config = NULL;
		
		if (equip.m_type > ET_HCNET_DECODER__FIRST || equip.m_type < ET_HCNET_DECODER__LAST)
		{
			Json::Value jsonUserConfig = jsonEquip["user_config"];
			
			HCNetCameraConfig* camConfig = new HCNetCameraConfig; // #todo delete when exit
			equip.user_config = camConfig;

			camConfig->ip = jsonUserConfig["ip"].asString();
			camConfig->port = jsonUserConfig["port"].asInt();
			camConfig->username = jsonUserConfig["username"].asString();
			camConfig->passwd = jsonUserConfig["passwd"].asString();
			camConfig->channel = jsonUserConfig["channel"].asInt();
			camConfig->byWallNo = jsonUserConfig["byWallNo"].asInt();
			camConfig->dwSubWinNo = jsonUserConfig["dwSubWinNo"].asInt();
			
			Json::Value dwWinNoArrays = jsonUserConfig["dwWinNo"];
			if (dwWinNoArrays.isArray())
			{
				const int s = (int)(dwWinNoArrays.size());
				for(int i = 0; i < s; i++)
				{
					camConfig->dwWinNo.push_back(dwWinNoArrays[i].asInt());
				}
			}
			else
			{
				camConfig->dwWinNo.push_back(dwWinNoArrays.asInt());
			}
			
			camConfig->lAlarmOutPort = jsonUserConfig["lAlarmOutPort"].asInt();
		}
		
		memcpy(&(equipments[NUM]), &equip, sizeof(equip));
		NUM++;
		
	}

	return 1;
}

/*
int Read_MysqlData(){
	int ret=0;
	MYSQL *conn;
	MYSQL_RES *res;
	MYSQL_ROW row;
	char *server="localhost";
	char *user="root";
	char *password="123";
	char *database="opentutorials";
	if(!(conn=mysql_init((MYSQL*)NULL))){
		printf("init fail\n");
		exit(1);
	}
	if(!mysql_real_connect(conn,server,user,password,NULL,3306,NULL,0)){
		printf("connect error.\n");
		exit(1);
	}
	if(mysql_select_db(conn,database)!=0){
		mysql_close(conn);
		printf("select_db_fail.\n");
		exit(1);
	}
	if(mysql_query(conn,"select * from tbl_deviceinfo")){
		printf("query fail\n");
		exit(1);
	}
	res=mysql_store_result(conn);
    NUM=0;    
	while((row=mysql_fetch_row(res))!=NULL){
	   equipments[NUM].m_id=atoi(row[0]);//id
//	   printf("====%s:%s",row[0],row[11]);	   //sprintf(equipments[NUM].m_id,"%d",row[0]);
	   if(strcmp(equipments[NUM].ip,row[1])!=0) ret = 1; 
	   if(strcmp(equipments[NUM].port,row[2])!=0) ret = 1; 
	   if(strcmp(equipments[NUM].serverIP,row[3])!=0) ret = 1; 
	   if(strcmp(equipments[NUM].serverport,row[4])!=0) ret = 1; 
	   if(strcmp(equipments[NUM].pass,row[5])!=0) ret = 1; 
	   if(strcmp(equipments[NUM].user,row[6])!=0) ret = 1; 	 
	   
	 
	   memset(equipments[NUM].ip,0,32);
	   strcpy(equipments[NUM].ip,row[1]);//equipIP
	   memset(equipments[NUM].port,0,10);
	   strcpy(equipments[NUM].port,row[2]);//equipPort
   
	   memset(equipments[NUM].serverIP,0,32);
	   strcpy(equipments[NUM].serverIP,row[3]);//ServerIP
	   memset(equipments[NUM].serverport,0,10);
	   strcpy(equipments[NUM].serverport,row[4]);//ServerPort

	   memset(equipments[NUM].user,0,64);
	   strcpy(equipments[NUM].user,row[6]);//equipUser
	   memset(equipments[NUM].pass,0,64);
	   strcpy(equipments[NUM].pass,row[5]);//equipPass
	   
	  equipments[NUM].reboot=atoi(row[11]);//reboot option.		  
	   NUM++;
	}
	mysql_close(conn);	
    puts("Step.0 ========>MySQL is getting ok");   
	return ret;
	
}
int UpdateMysqData(int key){
	int ret=0;
	MYSQL *conn;	
	char *server="localhost";
	char *user="root";
	char *password="123";
	char *database="opentutorials";
	char query[255];
    puts("Step.0 ========>MySQL is getting......");
	if(!(conn=mysql_init((MYSQL*)NULL))){
		printf("init fail\n");
		exit(1);
	}
	if(!mysql_real_connect(conn,server,user,password,NULL,3306,NULL,0)){
		printf("connect error.\n");
		exit(1);
	}
	if(mysql_select_db(conn,database)!=0){
		mysql_close(conn);
		printf("select_db_fail.\n");
		exit(1);
	}
	sprintf(query,"UPDATE tbl_deviceinfo SET reboot=0 where id=%d",key);	
	if(mysql_query(conn,query)){
		printf("query fail\n");
		exit(1);
	}	
	mysql_close(conn);
	return ret;
	
}*/

int net_test(char* serverIP,char* port){
		struct sockaddr_in servaddr;
	   int strlen=sizeof(servaddr);
	   int sockfdd;
	 if((sockfdd=socket(PF_INET,SOCK_STREAM,0))<0){
		perror("socket fail");
		close(sockfdd);
		return -1;
	 }
	  memset(&servaddr,0,strlen);
	  servaddr.sin_family=AF_INET;
	  inet_pton(AF_INET,serverIP,&servaddr.sin_addr);
	  servaddr.sin_port=htons(atoi(port));
	  if(connect(sockfdd,(struct sockaddr*)&servaddr,strlen)<0){
//		perror("connect fail-3");
		close(sockfdd);
		return -1;
	  }
	  close(sockfdd);
	  return 1;
}
void GPIOinit(void)
{
  int retVal = -1;
  int PortNum = 0xA06;
  unsigned char wVal = 0x15;
  retVal = GPIO_OPEN(PortNum);
  printf("GPIO OPEN RES = %d  \n",retVal);
  GPIO_WRITE(PortNum,wVal);
  printf("GPIO WRITE VALUE = 0x%X \n", wVal);
  
  retVal = GPIO_READ(PortNum);
  printf("GPIO READ VALUE 02 = 0x%X  \n",retVal);

  GPIO_CLOSE(PortNum);
}
int GPIOoutput(int no)
{
	int PortNum = 0xA06;
	switch(no){
		case 0: 
			GPIO_WRITE(PortNum,0x15);
			return 0;
		case 1: 
			GPIO_WRITE(PortNum,0x57);
			return 0;
		case 2: 
			GPIO_WRITE(PortNum,0x5D);
			return 0;
		case 3: 
			 GPIO_WRITE(PortNum,0x5F);
			 return 0;
		case 4: 
			 GPIO_WRITE(PortNum,0x75);
			 return 0;
		case 5:  
			GPIO_WRITE(PortNum,0x77);
			return 0;
		case 6: 
			GPIO_WRITE(PortNum,0x7D);
			return 0;
		case 7: 
			GPIO_WRITE(PortNum,0x7F);
			return 0;
		case 8: 
			GPIO_WRITE(PortNum,0xD5);
			return 0;		
		case 9:  
			GPIO_WRITE(PortNum,0xD7);
			return 0;
		case 10: 
			GPIO_WRITE(PortNum,0xDD);
			return 0;
		case 11: 
			GPIO_WRITE(PortNum,0xDF);
			return 0;
		case 12: 
			GPIO_WRITE(PortNum,0xF5);
			return 0;
		case 13: 
			GPIO_WRITE(PortNum,0xF7);
			return 0;
		case 14: 
			GPIO_WRITE(PortNum,0xFD);
			return 0;
		case 15: 
			GPIO_WRITE(PortNum,0xFF);
			return 0;
	}
	return -1;
}
int GPIO_OPEN(int PortNum)
{
	return ioperm(PortNum, 0x01, 0x01);
}

void GPIO_CLOSE(int PortNum)
{
	ioperm(PortNum, 0x01, 0x00);
}

int GPIO_READ(int PortNum)
{
	return inb(PortNum);
}

void GPIO_WRITE(int PortNum,unsigned char DATA)
{
	outb(DATA,PortNum);
}

void EquipCheckGPIOOut(void)
  {

   int PortNum = 0xA06; 
   int i;
   int retVal;
   int result;
   //printf("Step.3 ========>GPIO manupulation===> AnalyEquipmentNum=%d \n",equip_num);
   for(i=0;i<equip_num;i++)
   {
	  retVal = -1;
	  result=-1;
	   //printf("=============================:%d \n",equipments[i].reboot);
	   result=net_test(equipments[i].ip,equipments[i].port);
	   if(result<0)
	   {
		    	 //printf("Equipment(%d) check=%s:%s\n",i+1,equipments[i].ip,equipments[i].port);
						   retVal = GPIO_OPEN(PortNum);						 
						   if(retVal == 0)
						    {
								retVal = GPIOoutput(i+1);
								if(retVal==0) printf("GPIO output OK! \n");
								GPIO_CLOSE(PortNum);
							 }
						else printf("GPIO OPEN FAIL! \n");
		}
	   else 
	   {
		   //printf("Equipment(%d) Check Success!=%s:%s\n",i+1,equipments[i].ip,equipments[i].port);
		   }
	}  
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////// added on 2016.11.21
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int memorycmp(unsigned char* src ,int slen, char* token, int len)
{
	int start=0,k,i,klen=strlen(token);
lp1:
	for(i=start;i<slen;i++) if(src[i]==token[0]) break;
	if (i>=slen) return -1;
	k=i;
	for(i=0;i<klen;i++) 
	{
		if(src[k+i]!=token[i])
		{
			start=k+i;
			goto lp1;
		}
	}
	if(i>=klen) return k;
	return -1;
}
int stringcmp(char* src ,char* token, int len)
{
	int start=0,k,i,slen=strlen(src);
lp:
	for(i=start;i<slen;i++) if(src[i]==token[0]) break;
	if (i>=slen) return -1;
	k=i;
	for(i=0;i<len;i++) 
	{
		if(src[k+i]!=token[i])
		{
			start=k+i;
			goto lp;
		}
	}
	if(i>=len) return k;
	return -1;
}

void AurhorizationResponseBytesReal(char* byte_array_out,int * byte_array_length_out,char *Myuri, char *nonce,const char *cnonce,char *response)
{
	//	Authorization: Digest username="supervisor", realm="VideoIQ", nonce="n99u1VYBAABAf0HT+h92EO4hT2CzmfxG", uri="/PSIA/VIQ/Event/metadata/0/files", response="7d8d929e39655ad9f3e6e94e9004792e", qop=auth, nc=00000001, cnonce="0d2175d8cdb63f84f18894200e129ace", algorithm="MD5"
	int idx=0,len;
	idx = sprintf(byte_array_out,"%s","Authorization: Digest username="); 
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s","supervisor");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",realm=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s","VideoIQ");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",nonce=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx], "%s",nonce);idx+=len;//"n99u1VYBAABAf0HT+h92EO4hT2CzmfxG"
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",uri=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",Myuri);idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",algorithm=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s","MD5");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",cnonce=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",cnonce);idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",",nc=00000001,qop=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s","auth");idx+=len;//cnonce
	byte_array_out[idx++]=0x22;//'"'

	len = sprintf(&byte_array_out[idx],"%s",",response=");idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	len = sprintf(&byte_array_out[idx],"%s",response);idx+=len;
	byte_array_out[idx++]=0x22;//'"'
	*byte_array_length_out = idx;
}
int CharToByte(char* chars, char* bytes, unsigned int count,char* ptr1,char* ptr2,char* ptr3,char* ptr4,unsigned char* number){	
	int p=0;
	int n=0;
	int i=0;
	unsigned char temp;
	for(i = 0; i < count; i++)
	{
		temp = (unsigned char)chars[i];
		if (p==1)
		{
			if (temp!=0x22)
			{
				bytes[n++]=(unsigned char)chars[i];
			}			
		}
		if (temp==0x22)
		{
			p=p+1;
		}
		if (p==2)
		{
			bytes[n++]=0x2C;
			p=0;			
		}

	}
	char* token=NULL;
	char s[]=",";
	token=strtok(bytes,s);	
	number[0]=strlen(token);	
	memcpy(ptr1,token,strlen(token));
	int nn=0;
	while(token!=NULL)
	{
		token=strtok(NULL,s);		
		nn=nn+1;		
		if (nn==1)
		{
			number[1]=strlen(token);
			memcpy(ptr2,token,strlen(token));
		}
		if (nn==2)
		{
			//ptr3=new char[strlen(token)];
			number[2]=strlen(token);
			memcpy(ptr3,token,strlen(token));
		}
		if (nn==3)
		{
			if(token!=NULL)
			{
				number[3]=strlen(token);
				memcpy(ptr4,token,strlen(token));
			}//ptr3=new char[strlen(token)];

		}
	}
	return n;
}
//for real event
void MakeAuthorizedPacketReal_Digest(char* buff,int length, char* Method,char* uri,int Idx)
{
	char Device[150] ;
	char Realm_buf1[512] ;
	char nonce_buf2[512] ;
	char auth_buf3[512] ;
	char domain_buf4[512] ;
	unsigned char len[4];

	memset(Device,0,150);
	memset(domain_buf4,0,512);

	CharToByte((char*)buff, Device, length,Realm_buf1,nonce_buf2,auth_buf3,domain_buf4, len);
	const char* cnonce_buf="1oBAAAqkwXP9q9MorVCzgw5LNPc";//"08a9d86c1b5e45963cf82f43dca59c51";
	Realm_buf1[len[0]]=0;
	nonce_buf2[len[1]]=0;
	auth_buf3[len[2]]=0;
	const char* nc="00000001";
	//CString qop;qop=auth_buf3;/////////////////////////////
	char User[200];
	memset(User,0,200);
	sprintf(User,"%s:%s:%s",equipments[Idx].user,Realm_buf1,equipments[Idx].pass);

	char urii[200];
	int kk=sprintf(urii,"%s:%s",Method,uri);//PUT:/PSIA/System/reboot";
	urii[kk]=0;
	char* A1 = MDString(User);
	char AA1[33];
	memset(AA1,0,33);
	memcpy(AA1,A1,strlen(A1));
	char* A2 = MDString(urii);
	char AA2[33];
	memset(AA2,0,33);
	memcpy(AA2,A2,strlen(A2));
	char rrr[200];
	memset(rrr,0,200);
	sprintf(rrr,"%s:%s:%s:%s:auth:%s",AA1,nonce_buf2,nc,cnonce_buf,AA2);
	//	printf("%s:%s:%s:%s:auth:%s\n",AA1,nonce_buf2,nc,cnonce_buf,AA2);
	char* response = MDString(rrr);
	char res[33];
	memset(res,0,33);
	memcpy(res,response,strlen(response));

	//// 第二次 发送
	char byte_arrayxxx[2600];
	int lengthxxx = 0;
	int iidx = 0;
	AurhorizationResponseBytesReal(byte_arrayxxx,&lengthxxx,uri,nonce_buf2,cnonce_buf,res);

	int llen = sprintf(byte_array,"%s %s HTTP/1.1\r\n",Method,uri); iidx+=llen;
	llen = sprintf(&byte_array[iidx],"Content-Type: text/xml\r\n"); iidx+=llen;
	strncpy(&byte_array[iidx],byte_arrayxxx,lengthxxx); iidx+=lengthxxx;
	byte_array[iidx]=0x0d; iidx+=1;
	byte_array[iidx]=0x0a; iidx+=1;
	llen = sprintf(&byte_array[iidx],"Host: %s\r\n",equipments[Idx].ip); iidx+=llen;
	llen = sprintf(&byte_array[iidx],"Content-Length: 0\r\n"); iidx+=llen;
	//					llen = sprintf(&byte_array[iidx],"%s","Connection: Keep_Alive\r\n"); iidx+=llen;
	byte_array[iidx]=0x0d; iidx+=1;
	byte_array[iidx]=0x0a; iidx+=1;					
	byte_array[iidx]=0;

}

void MakeAuthorizedPacketReal_Basic(char* buff,int length, char* Method,char* uri,int Idx)
{
	/*
POST /PSIA/VIQ/System/sessions HTTP/1.1
Content-Length: 0
Host: 192.168.1.5:80
Connection: Keep-Alive
Authorization: Basic c3VwZXJ2aXNvcjpzdXBlcnZpc29y
	*/
	
	int i = 0;
	sprintf(byte_array, 
		"%s %s HTTP/1.1\r\n"
		"Content-Length: 0\r\n"
		"Host: %s:80\r\n"
		"Connection: Keep-Alive\r\n"
		"Authorization: Basic %s\r\n"
		"\r\n",
		Method,
		uri,
		equipments[Idx].ip,
		"c3VwZXJ2aXNvcjpzdXBlcnZpc29y" // base64(supervisor:supervisor)
	);
}

//// 功能：开始查看实时监控
//// 输入：分析器IP,用户,密码
//// 输出：0（成功）, -1(初始化失败),-2(连接失败)
int RealEventStart(int Idx)
{
	
	char buff[10240];
	int bbbb=0;
	if(equipments[Idx].ip==NULL || equipments[Idx].ip[0]==0) return -1;

	struct sockaddr_in servaddr;
	int strlen1=sizeof(servaddr);
	if((rsock_down[Idx]=socket(PF_INET,SOCK_STREAM,0))<0){
		perror("socket fail2");
		return -1;
	}  
	memset(&servaddr,0,strlen1);
	servaddr.sin_family=AF_INET;
	inet_pton(AF_INET,equipments[Idx].ip,&servaddr.sin_addr);
	servaddr.sin_port=htons(atoi(equipments[Idx].port));
	
	sigset(SIGALRM, u_alarm_handler);//add 2016.11.22
	alarm(2);	
	int rt = connect(rsock_down[Idx],(struct sockaddr*)&servaddr,strlen1);	
	alarm(0);
	sigrelse(SIGALRM);		  
	if(rt<0){
		printf("Equipment connect fail-%s:%s\n",equipments[Idx].ip,equipments[Idx].port);
		close(rsock_down[Idx]);
		return -1;
	}
	
	int length = 0;
	length = sprintf(byte_array,"POST /PSIA/VIQ/System/sessions/permanent HTTP/1.1\r\nContent-Type: text/xml\r\nHost: %s\r\nContent-Length: 0\r\nConnection: Keep-Alive\r\n\r\n",equipments[Idx].ip);		 
	write(rsock_down[Idx],byte_array,length);
	printf("%s",byte_array);
	while(1){
		memset(buff,0,sizeof(buff));
		sigset(SIGALRM, u_alarm_handler);//add 2016.11.22
		alarm(2);
		length=read(rsock_down[Idx],&buff,sizeof(buff));
		//printf("RESPONSE: %s\n",&buff);	
		alarm(0);
		sigrelse(SIGALRM);	
		//printf("Myequipment connect ==================length =%d:\n",length);	
		if(length<=0)
		{
			close(rsock_down[Idx]);
			return -1;
		}
		if(memorycmp((unsigned char*)buff,length, "WWW-Authenticate:",17)>0 && bbbb==0)
		{
			// analyse reception
			MakeAuthorizedPacketReal_Basic(buff,length,"POST","/PSIA/VIQ/System/sessions/permanent",Idx);
			//for(int ii=0;ii<4;ii++)
			//{
				zclock_sleep(100);
				write(rsock_down[Idx],byte_array,strlen(byte_array));
			//}
			printf("%s\n",(char*)byte_array);					
			bbbb=1;
			continue;//#todo 20170325
			//break;
		}
		if(bbbb==1){
			//if (strstr((char*)buff,"Unauthorized") != NULL)
			//{
			//	bbbb=0;
			//}
			
			int sidx = stringcmp((char*)buff,"<urn:id>",8);
			if(sidx >=0){//<urn:ViqDateTimeInterval urn:version="1.0" xmlns:urn="urn:videoiq-com"><urn:startTime urn:version="1.0"><urn:date>2016-08-18T01:07:20.749</urn:date><urn:offset>0</urn:offset></urn:startTime><urn:endTime urn:version="1.0"><urn:date>2016-08-29T08:33:48.231</urn:date><urn:offset>0</urn:offset></urn:endTime></urn:ViqDateTimeInterval>
				int eidx = stringcmp((char*)buff,"</urn:id>",9);
				if(eidx>=0 && sidx+8<eidx){
					memcpy(sessions[Idx],&buff[sidx+8],eidx-sidx-8);
					bbbb=2;
					printf("SessionID =======> %s\n",(char*)sessions[Idx]);		
					break;
				}
			}
		}
	}
	close(rsock_down[Idx]);

	if((rsock_down[Idx]=socket(PF_INET,SOCK_STREAM,0))<0){
		perror("socket fail2");
		return -1;
	}
	memset(&servaddr,0,strlen1);
	servaddr.sin_family=AF_INET;
	inet_pton(AF_INET,equipments[Idx].ip,&servaddr.sin_addr);
	servaddr.sin_port=htons(80);
	sigset(SIGALRM, u_alarm_handler);//add 2016.11.22
	alarm(2);	
	rt = connect(rsock_down[Idx],(struct sockaddr*)&servaddr,strlen1);
	alarm(0);
	sigrelse(SIGALRM);	
	if(rt<0){
		printf("Equipment connect fail-%s:%d\n",equipments[Idx].ip,80);
		close(rsock_down[Idx]);
		return -2;
	}
	char uri[200];
	sprintf(uri,"/PSIA/Custom/Event/notification/notificationStream?sessionId=%s",sessions[Idx]);
	//sprintf(uri,"/PSIA/Custom/Event/notification/notificationStream?sessionId=5");
	printf("/PSIA/Custom/Event/notification/notificationStream?sessionId=%s\n",sessions[Idx]);
	length = sprintf(byte_array,"GET %s HTTP/1.1\r\nContent-Type: text/xml\r\nHost: %s\r\nContent-Length: 0\r\nConnection: Keep-Alive\r\n\r\n",uri,equipments[Idx].ip);		 
	write(rsock_down[Idx],byte_array,strlen(byte_array));
	while(1){
		memset(buff,0,sizeof(buff));
		sigset(SIGALRM, u_alarm_handler);//add 2016.11.22
		alarm(2);
		length=read(rsock_down[Idx],&buff,sizeof(buff));	
		alarm(0);
		sigrelse(SIGALRM);	
		if(length<=0)
		{
			close(rsock_down[Idx]);
			break;
		}
		if(memorycmp((unsigned char*)buff,length, "WWW-Authenticate:",17)>0 && bbbb==2)
		{
			char uri[200];
			sprintf(uri,"/PSIA/Custom/Event/notification/notificationStream?sessionId=%s",sessions[Idx]);
			MakeAuthorizedPacketReal_Basic(buff,length,"GET",uri,Idx);
			//for(int ii=0;ii<4;ii++)
			//{
			zclock_sleep(100);
			write(rsock_down[Idx],byte_array,strlen(byte_array));
			//}
			printf("%s\n",(char*)byte_array);	
			bbbb=3;			
			continue;
		}
		if(stringcmp(buff,"multipart/text; boundary=VIQeventEVENTeventVIQ",46)>0 && bbbb==3) 
		{
			pthread_create(&thread_Real[Idx],NULL,&MyEquipmentthread,(void*)Idx);//super(void*)(&equipments[0])
			gCapturing[Idx]=1;
			printf("%s\n","QQQQQQQQQQQQQQQQQQQQ  Capturing...");
			//printf("%s\n",buff);
			return 0;
		}
	}
	return -2;
}