connectivity_core_utils.cpp

270的linux说明

	if ( ctx == NULL ){
		debug("init SSL CTX failed:%s\n", ERR_reason_error_string(ERR_get_error()));
	}
	ssl = SSL_new(ctx);
	if ( ssl == NULL ){
		debug("new SSL with created CTX failed:%s\n", ERR_reason_error_string(ERR_get_error()));
	}
	ret = SSL_set_fd(ssl, sockfd);
	if ( ret == 0 ){
		debug("add SSL to tcp socket failed:%s\n",ERR_reason_error_string(ERR_get_error()));
	}
	// PRNG 
	RAND_poll();
	while ( RAND_status() == 0 ){
		unsigned short rand_ret = rand() % 65536;
		RAND_seed(&rand_ret, sizeof(rand_ret));
	}

	// SSL Connect 
	ret = SSL_connect(ssl);
	if( ret != 1 ){
		debug("SSL connection failed:%s\n", ERR_reason_error_string(ERR_get_error()));
	}

	// http request. 
	char buf[1024];
	//	sprintf(buf, "GET %s HTTP/1.0\r\nHost: %s\r\n\r\n",pUri->FileName.c_str(), pUri->DestPath.c_str());
		//sprintf(buf, "%s\r\n\r\n",request);
		sprintf(buf, "%s",request);
	//sprintf(buf, "GET /remediation/index.htm HTTP/1.0\r\nHost: remediation.intel.com\r\n\r\n");//https://remediation.intel.com/remediation/index.htm

//	printf("%s", buf);
	
	char* pHCode=NULL;
	char szHCode [8]; //response code
	int code=0;
	bool iRet=false;
	// https socket write.
	SSL_write(ssl, buf, strlen(buf));
	while((!iRet&&(n = SSL_read(ssl, buf, BUF_LEN-1)) > 0)){
		buf[n] = '\0';
//		write(1, buf, n);//printf for stdout..
		pHCode = strchr( buf, ' ' );	
		if( pHCode != NULL )
		{
			pHCode++;
			strncpy( szHCode, pHCode, 3 );//after pHCode+4 is msg..
		}
		if((code=atoi(szHCode))!=0)
			iRet=true;
	}
	if(n != 0){
		debug("SSL read failed:%s\n",ERR_reason_error_string(ERR_get_error()));
	}
	// close ssl tunnel.
	ret = SSL_shutdown(ssl);
	if( ret != 1 ){
		close(sockfd);
		debug("SSL shutdown failed:%s\n",ERR_reason_error_string(ERR_get_error()));
	}

	// close the plain socket handler.
//	close(sockfd);

	// clear ssl resource.
	SSL_free(ssl);
	SSL_CTX_free(ctx);
	ERR_free_strings();
	//return code;
	//printf("retcode%d\n", code);
	return code;
}
bool HTTPSIsReachable(int *pReachable, unsigned int *pTime, PURI_INFO pUri)
{
	try {

		bool	bRet = false;
		CQTime	cQTime;
		__int64	StartTime;
		__int64	StopTime;
		//HINTERNET hOpen=NULL, hConnect=NULL, hRequest=NULL;
		int conn, ret, n;
		CHAR szBuffer[80];
		DWORD dwLen	= 80;
		DWORD dwStatusCode;
		*pReachable	= false;
		if ( pTime )
			*pTime = 0;
		if ( pUri->Port	== 0 )
			pUri->Port = HTTPSPORT;

		StartTime =	cQTime.GetTimeEx();
		if (pUri->DestPath.length()     )
			conn = (int)socketClient( pUri->pHostIP, pUri->Port,0);
		if (conn < 0)
			goto GracefulExit;

		// Debug information
		//printf(	"StatusCode: %s\n",	szBuffer );
		//dwStatusCode = (DWORD) atoi((szBuffer));
		sprintf(szBuffer, "GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n",pUri->FileName.c_str(), pUri->DestPath.c_str());
		dwStatusCode = HttpsRequest(conn, szBuffer);
		StopTime=cQTime.GetTimeEx();
		close(conn);
		if ( dwStatusCode == 200 || dwStatusCode == 302 ) //302 for redirect
		{
			*pReachable	= true;
			bRet = true;
			if ( pTime )
				*pTime = (unsigned int)(StopTime-StartTime);
		}
		

	GracefulExit:
		return bRet;
	}
	catch(...) {
		THROWIMEXCEPTION("800432146");
	}

}

/* ________________________________________________________________

TCPIsReachable
________________________________________________________________ */
bool TCPIsReachable(int	*pReachable, unsigned int *pTime, PURI_INFO	pUri, unsigned long	ulSelectedIP=0)
{
	int		app;
	int		conn;
	bool	bRet = false;
	CQTime	cQTime;
	DWORD	StartTime;
	DWORD	StopTime;

	*pReachable	= false;
	if ( pTime )
		*pTime = 0;
	// get port
	app	= pUri->Port;
	StartTime =	cQTime.GetTime();
	// connect
	if (pUri->DestPath.length()	)
		conn = (int)socketClient( pUri->pHostIP, app,ulSelectedIP);
	if (conn < 0) 
		goto GracefulExit;
	*pReachable	= true;

	StopTime = cQTime.GetTime();
	if ( pTime )
		*pTime = (unsigned int)(StopTime - StartTime);
	bRet = true;
	close(conn);
GracefulExit:
	return bRet;
}

/* ________________________________________________________________

UDPIsReachable
________________________________________________________________ */
bool UDPIsReachable(int	*pReachable, unsigned int *pTime, PURI_INFO	pUri)
{
	bool	bRet = false;
	SOCKET	conn;
	string	Response;
	CQTime	cQTime;
	DWORD	StartTime;
	DWORD	StopTime;
	struct sockaddr_in sa;
	const char buf[] = "hello";

	*pReachable	= false;

	if ( pUri->pHostIP == NULL)
		goto GracefulExit;

	memcpy((void*)&sa.sin_addr,	(void*)pUri->pHostIP->h_addr, pUri->pHostIP->h_length);
	sa.sin_family =	pUri->pHostIP->h_addrtype;

	sa.sin_port	= htons(pUri->Port);
	memset(&(sa.sin_zero), 0, 8);

	if ((conn =	socket(pUri->pHostIP->h_addrtype,SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET )
		goto GracefulExit;

	StartTime =	cQTime.GetTime();

	if ( sendto( conn, buf, (int)strlen(buf),	0, (SOCKADDR*)&sa, sizeof(sa) ) == SOCKET_ERROR )
		goto GracefulExit;
	*pReachable	= true;

	StopTime = cQTime.GetTime();
	if ( pTime )
		*pTime = (unsigned int)(StopTime - StartTime);
	bRet = true;
	close(conn);
GracefulExit:
	return bRet;
}


/* ________________________________________________________________

FTPIsReachable
________________________________________________________________ */
// for FTP
#define BUFFERSIZE 1024
int GetLine(int &sockfd, char *szBuffer )
{
   int done=0, iLen, iBuffLen=0;
   char *szPtr = szBuffer, nCode[3]={0},ch=0;
	fd_set set;
	FD_ZERO(&set);
	FD_SET(sockfd, &set);
	struct timeval tv;
	tv.tv_sec = 3;
	tv.tv_usec = 0;
	if(select(sockfd+1, &set, NULL, NULL, &tv) == -1)
	{
		perror("select");
		return 100 ;
	}
	//printf("getline\n");
  	while( (iBuffLen < BUFFERSIZE) && ((done=recv(sockfd, &ch, 1, MSG_PEEK)) > 0) ){
        iLen = recv(sockfd, &ch, 1, 0);
        iBuffLen += iLen;
        *szPtr = ch;
        szPtr += iLen;
        if( ch == '\n' )
            break;    // we have a line: return
   }

   *(szPtr+1) = (char)0;
	//printf("%s",szBuffer);
   strncpy(nCode, szBuffer, 3);
   return (atoi(nCode));
}



bool FTPIsReachable(int	*pReachable, unsigned int *pTime, PURI_INFO	pUri)
{
	try {
		int ctrl_sockfd, data_sockfd, flag=1,len;
                struct sockaddr_in  serv_addr, tempAddr;
                char *pport,*ipaddr;
                char szBuffer[BUFFERSIZE]={0};
                len = sizeof(tempAddr);

		bool	bRet = false;
		CQTime	cQTime;
		DWORD	StartTime;
		DWORD	StopTime;
		int iRetCode = 0;
                bool loop = true, line=true;

		if ( pTime )
			*pTime = 0;
		*pReachable=false;

		if ( pUri->Port	== 0 )
			pUri->Port=FTPPORT;

		StartTime =	cQTime.GetTime();
   	        // connect
   		if (pUri->DestPath.length()     )
   			ctrl_sockfd = (int)socketClient( pUri->pHostIP, pUri->Port, 0);
	printf("ftp port %d\n", pUri->Port);
		if (ctrl_sockfd< 0)
               	{
            	    perror("conn<0\n");
                	goto GracefulExit;
               }

                        if(getsockname(ctrl_sockfd,  (struct sockaddr *)&tempAddr,   &len)<0) {
                                perror("getsockname");
                                close(ctrl_sockfd);
                                return INVALID_SOCKET;
                        }

                        //create
                        if((data_sockfd=socket(AF_INET, SOCK_STREAM, 0))<0)
                        {
                                perror("socket");
                                return INVALID_SOCKET;
                        }

			bzero((char*)&serv_addr, sizeof(serv_addr));
                        serv_addr.sin_family=AF_INET;
                        serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
                        serv_addr.sin_port=htons(0);
                        if(bind(data_sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))<0)
                        {
                                perror("bind\n");
                                close(data_sockfd);
                                return INVALID_SOCKET;
                        }
                        len=sizeof(serv_addr);
                        if(getsockname(data_sockfd, (struct sockaddr*)&serv_addr, &len)<0)
                        {
                                perror("getsockname\n");
                                close(data_sockfd);
                                return INVALID_SOCKET;
                        }

                        pport  = (char *)&serv_addr.sin_port;
                        ipaddr = (char *)&tempAddr.sin_addr;

                        #define  UC(b)  (((int)b)&0xff)
sprintf(szBuffer,"PORT %d,%d,%d,%d,%d,%d\r\n",UC(ipaddr[0]), UC(ipaddr[1]), UC(ipaddr[2]), UC(ipaddr[3]),UC(pport/256), UC(pport%256));
                        if( listen(data_sockfd, 1) < 0) {
                                perror("listen");
                                close(data_sockfd);
                        }

                        //printf("send %s\n", szBuffer);
                        if( send(ctrl_sockfd,szBuffer,strlen(szBuffer),0) <= 0)
                        {
                                perror("send");
                                return 0;
                        }
		do
                {
                        memset(szBuffer,0,BUFFERSIZE);
			iRetCode = GetLine(ctrl_sockfd, szBuffer);
                        if( szBuffer[3] == '-' || iRetCode <= 0 )
                        {
                                printf("continue\n");
                                continue;
                        }
                        printf("iRetCode%d\n",iRetCode);

                        StopTime=cQTime.GetTimeEx();
			switch(iRetCode)
                        {

                        case 200:       //Command okay
                        case 230:       //Login OK, Proceed
                                loop=false;
                                *pReachable     = true;
                                bRet = true;
                                if ( pTime )
                                        *pTime = (unsigned int)(StopTime-StartTime);
                                break;
                        case 220:       //Welcome to VINEYARD FTP service
                        case 503:       //Login with USER first.
                        case 530:       //Please login with USER and PASS or Login incorrect
                                sprintf(szBuffer, "USER ");
                                strcat(szBuffer, "anonymous\r\n");
                                if( send(ctrl_sockfd,szBuffer,strlen(szBuffer),0) <= 0)
                                {
                                        perror("send");
                                        return 0;
                                }
                                printf("send %s\n", szBuffer);
                                break;
			case 331:       //331 Please specify the password.
                                sprintf(szBuffer, "PASS ");
                                strcat(szBuffer, "anonymous\r\n");
                                if( send(ctrl_sockfd,szBuffer,strlen(szBuffer),0) <= 0)
                                {
                                        perror("send");
                                        return 0;
                                }
                                printf("send %s\n", szBuffer);
                                break;
                        default:
                                printf("default\n");
                                loop=false;
                                *pReachable     = false;
                                bRet = false;
                                if ( pTime )
                                        *pTime = (unsigned int)(StopTime-StartTime);
                                break;
                        }

                }
                while(loop&&iRetCode!=0);
	if(ctrl_sockfd>0)close(ctrl_sockfd);
	if(data_sockfd>0)close(data_sockfd);
	GracefulExit:
		return bRet;
	}
	catch(...) {
		THROWIMEXCEPTION("80043216");
	}

}



/* ________________________________________________________________

IsReachable for Intelnal use only
________________________________________________________________ */
bool IsReachable(bool *pIsReachable, unsigned int *pTime, byte *pUri)
{
	bool bRet = false;
	static unsigned int SeqNum = 0;
	int Reachable;
	int Size;
	unsigned int TotalTime;
	URI_INFO UriInfo;
	vector<unsigned long> route;

	Size = MAX_Q;
	UriInfo.IPAddr = 0;
	UriInfo.pHostIP = NULL;
	UriInfo.Port = 0;
	UriInfo.Protocol = 0;
	UriInfo.DestPath.empty(); 
	UriInfo.FileName.empty();
	TotalTime = 0;
printf("isReachable... %s\n", pUri);
	if ( !pIsReachable )
		goto GracefulExit;
	else
		*pIsReachable = false;
	// Parse URI
	if ( !pUri || ParseURI(pUri, &UriInfo) )
		goto GracefulExit;

	// call each protocol's IsReachable
	switch ( UriInfo.Protocol )
	{
	case HTTP_PROTOCOL:	
		bRet = HTTPIsReachable(&Reachable, &TotalTime, &UriInfo);
		if (bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	case TCP_PROTOCOL:
		bRet = TCPIsReachable(&Reachable, &TotalTime, &UriInfo);
		if ( bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	case UDP_PROTOCOL: 
		bRet = UDPIsReachable(&Reachable, &TotalTime, &UriInfo);
		if ( bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	case FTP_PROTOCOL:
		bRet = FTPIsReachable(&Reachable, &TotalTime, &UriInfo);
		if ( bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	case ICMP_PROTOCOL:
		bRet = ICMPIsReachable( &Reachable, &TotalTime, &UriInfo, 0, &route );
		// Debug information
		/*
		for ( unsigned int i=0;i<route.size();i++ )
		{
			printf("Debug of IsReachable\tIP: ");
			BYTE *pb=(BYTE*)&(route[i]);
			for ( int j=0;j<4;j++ )
				printf("%d.",pb[j]);
			printf("\n");
		}*/
		if ( bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	case HTTPS_PROTOCOL:
		bRet = HTTPSIsReachable(&Reachable, &TotalTime, &UriInfo);
		if ( bRet && Reachable )
			*pIsReachable = true;
		else
			*pIsReachable = false;
		break;
	default:
		break;
	}