Attachment #99619 for bug #165409

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 23-28 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/Connect2AC.c (-10 / +20 lines)
23	#include "Connect2AC.h"	23	#include "Connect2AC.h"
24	#include "RACClientSupport.h"	24	#include "RACClientSupport.h"
25		25
		26	#ifdef _WIN32
		27	#include "ws2tcpip.h"
		28	#endif
		29
26	#define CMD_BUFFER_LENGTH 8192 /* TODO: Use a universal definition */	30	#define CMD_BUFFER_LENGTH 8192 /* TODO: Use a universal definition */
27	#define MAX_AGENT_NAME 1024 /* TODO: Use a universal definition */	31	#define MAX_AGENT_NAME 1024 /* TODO: Use a universal definition */
28		32
Lines 957-964 Link Here
957	tptp_int32 flags = TPTP_DATA_PATH_TWOWAY;	961	tptp_int32 flags = TPTP_DATA_PATH_TWOWAY;
958	tptp_int32 dataConnectionID;	962	tptp_int32 dataConnectionID;
959	SOCKET dataSock;	963	SOCKET dataSock;
960	tptp_int32 clientIP;	964
961	tptp_int32 clientIPLen;	965	struct sockaddr_storage * addr;
		966
962	client_data_connection_block_t *dcb;	967	client_data_connection_block_t *dcb;
963	tptp_int32 rc;	968	tptp_int32 rc;
964	TID threadId;	969	TID threadId;
Lines 971-979 Link Here
971	status = getAgent(ccb->stateData, ccb, "ProcessController", &processControllerDestID);	976	status = getAgent(ccb->stateData, ccb, "ProcessController", &processControllerDestID);
972	}	977	}
973		978
974	getClientIP(ccb, (unsigned char*)&clientIP, &clientIPLen);	979	getClientIPAddr(ccb, &addr);
975	dataSock = openClientDataSocket(clientIP, remoteConsolePort);	980
		981	dataSock = openClientDataSocketAddr(addr, remoteConsolePort);
		982
		983	tptp_free(addr);
		984
976	if (dataSock != -1) {	985	if (dataSock != -1) {
		986
977	dcb = (client_data_connection_block_t*)tptp_malloc( sizeof(client_data_connection_block_t) );	987	dcb = (client_data_connection_block_t*)tptp_malloc( sizeof(client_data_connection_block_t) );
978	if ( dcb == NULL ) {	988	if ( dcb == NULL ) {
979	return FALSE;	989	return FALSE;
Lines 1470-1481 Link Here
1470	{	1480	{
1471	char* localIPStr;	1481	char* localIPStr;
1472		1482
1473	if (getSocketIPString( ccb->sock, &localIPStr) < 0) {	1483	if (getSocketIPStringIPv4M( ccb->sock, &localIPStr) < 0) {
1474	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");	1484	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");
1475	return -1;	1485	return -1;
1476	}	1486	}
1477		1487
1478	convertIPAddressStringToArray( localIPStr, localAddr);	1488	convertIPAddressStringToArrayIPv4M( localIPStr, localAddr);
1479	ra_createRASTRING3( &command->info.controller_request_monitor_port.node, localAddr, 4);	1489	ra_createRASTRING3( &command->info.controller_request_monitor_port.node, localAddr, 4);
1480		1490
1481	/* We're done with this now, so let's free it */	1491	/* We're done with this now, so let's free it */
Lines 1487-1493 Link Here
1487	command->info.controller_request_monitor_port.port = strtoul(peerPort, 0, 10);	1497	command->info.controller_request_monitor_port.port = strtoul(peerPort, 0, 10);
1488		1498
1489	/* Convert the peer address */	1499	/* Convert the peer address */
1490	convertIPAddressStringToArray( peerHost, peerAddr );	1500	convertIPAddressStringToArrayIPv4M( peerHost, peerAddr );
1491	ra_createRASTRING3( &command->info.controller_request_monitor_port.peerNode, peerAddr, 4 );	1501	ra_createRASTRING3( &command->info.controller_request_monitor_port.peerNode, peerAddr, 4 );
1492		1502
1493	/* Fill in the source agent's information */	1503	/* Fill in the source agent's information */
Lines 1559-1570 Link Here
1559	{	1569	{
1560	char* localIPStr;	1570	char* localIPStr;
1561		1571
1562	if (getSocketIPString( ccb->sock, &localIPStr) < 0) {	1572	if (getSocketIPStringIPv4M( ccb->sock, &localIPStr) < 0) {
1563	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");	1573	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");
1564	return -1;	1574	return -1;
1565	}	1575	}
1566		1576
1567	convertIPAddressStringToArray( localIPStr, localAddr);	1577	convertIPAddressStringToArrayIPv4M( localIPStr, localAddr);
1568	ra_createRASTRING3( &command->info.controller_request_monitor_port.node, localAddr, 4);	1578	ra_createRASTRING3( &command->info.controller_request_monitor_port.node, localAddr, 4);
1569		1579
1570	/* We're done with this now, so let's free it */	1580	/* We're done with this now, so let's free it */
Lines 1576-1582 Link Here
1576	command->info.controller_request_monitor_port.port = strtoul(peerPort, 0, 10);	1586	command->info.controller_request_monitor_port.port = strtoul(peerPort, 0, 10);
1577		1587
1578	/* Convert the peer address */	1588	/* Convert the peer address */
1579	convertIPAddressStringToArray( peerHost, command->info.controller_request_monitor_port.peerNode.data );	1589	convertIPAddressStringToArrayIPv4M( peerHost, command->info.controller_request_monitor_port.peerNode.data );
1580	command->info.controller_request_monitor_port.peerNode.length = 4;	1590	command->info.controller_request_monitor_port.peerNode.length = 4;
1581		1591
1582	/* Fill in the peer agent's information */	1592	/* Fill in the peer agent's information */

Lines 34-39 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/RACClientSupport.c (-4 / +102 lines)
34	#include "secureServer.h"	34	#include "secureServer.h"
35	#include "Connect2AC.h"	35	#include "Connect2AC.h"
36		36
		37	// Added for IPv6 support
		38	#ifdef _WIN32
		39	#include <winsock2.h>
		40	#include <ws2tcpip.h>
		41	#endif
		42
		43
37	#ifndef _WIN32	44	#ifndef _WIN32
38	#include <signal.h> // Used by ra_killProcess	45	#include <signal.h> // Used by ra_killProcess
39	#endif	46	#endif
Lines 740-751 Link Here
740	}	747	}
741	}	748	}
742		749
		750
		751	int getClientIPAddr(client_connection_block_t* ccb, struct sockaddr_storage ** addr) {
		752
		753	if (ccb->connectionType == CCTL_NATIVE_SOCKET) {
		754	*addr = getPeerAddrOfSocket(ccb->sock);
		755
		756	}
		757	else if(ccb->connectionType == CCTL_JAVA_SOCKET) {
		758	JNIEnv *env;
		759
		760	if(!ATTACH_THREAD(env)) {
		761	jclass clazz = fndclsid(env, INTERFACE_CLIENT_HANDLER);
		762	if(clazz) {
		763	jmethodID method = getmthdid(env, clazz, "getRemoteAddress", "()[B");
		764	if(method) {
		765	jbyteArray result=(jbyteArray)ENV(env)->CallObjectMethod(ENVPARM(env) ccb->javaObj, method);
		766	if(result) {
		767	jbyte *elements;
		768	jsize size = ENV(env)->GetArrayLength(ENVPARM(env) result);
		769	elements = ENV(env)->GetByteArrayElements(ENVPARM(env) result, JNI_FALSE);
		770	#ifdef _LP64
		771	assert(size<=INT_MAX);
		772	#endif
		773	getSockAddrFromByteFormat(elements, size == 4 ? PF_INET : PF_INET6, addr );
		774
		775	}
		776	}
		777	}
		778	DETACH_THREAD();
		779	}
		780	}
		781
		782	return 0;
		783	}
		784
743	int getClientIP(client_connection_block_t* ccb, unsigned char buffer, int length) {	785	int getClientIP(client_connection_block_t* ccb, unsigned char buffer, int length) {
744	//if(client->connection->type==RA_SOCKET_CONNECTION) { kevin we need to store this type info.	786	//if(client->connection->type==RA_SOCKET_CONNECTION) { kevin we need to store this type info.
745	if (ccb->connectionType == CCTL_NATIVE_SOCKET) {	787	if (ccb->connectionType == CCTL_NATIVE_SOCKET) {
746	/* Retrieve the IP address of the remote client */	788
747	getPeerName(ccb->sock, buffer);	789	struct sockaddr_storage * addr;
748	*length=4;	790	unsigned char *value;
		791	int family = 0;
		792	addr = getPeerAddrOfSocket(ccb->sock);
		793
		794	if(addr == NULL) {
		795	*length = 0;
		796	return -1;
		797	}
		798
		799	getByteFormatFromSockAddr(addr, (void **)&value, &family);
		800
		801	if(addr->ss_family == PF_INET) {
		802	memcpy(buffer, value, sizeof(struct in_addr));
		803	*length = sizeof(struct in_addr);
		804	tptp_free(value);
		805	} else if(addr->ss_family == PF_INET6) {
		806	memcpy(buffer, value, sizeof(struct in6_addr));
		807	*length = sizeof(struct in6_addr);
		808	tptp_free(value);
		809	} else {
		810	tptp_free(addr);
		811	*length = 0;
		812	return -1;
		813	}
		814
		815	tptp_free(addr);
		816
749	}	817	}
750	else if(ccb->connectionType == CCTL_JAVA_SOCKET) {	818	else if(ccb->connectionType == CCTL_JAVA_SOCKET) {
751	JNIEnv *env;	819	JNIEnv *env;
Lines 774-787 Link Here
774		842
775	return 0;	843	return 0;
776	}	844	}
		845	#ifndef _WIN32
		846	#define INVALID_SOCKET -1
		847	#endif
		848
		849	SOCKET openClientDataSocketAddr(struct sockaddr_storage *addr, int port) {
		850	char hostname[260];
		851	tptp_int32 rc = -1;
		852	SOCKET outSocket;
		853
		854	hostname[0] = 0;
		855
		856	// Resolve the host name
		857	rc = getnameinfo((struct sockaddr *)addr, sizeof(struct sockaddr_storage), hostname, 260, NULL, 0, 0);
		858	if(rc == 0) {
		859
		860	// Attempt to connect to the server by resolving the various addreses of the hostname
		861	connectToTCPServer(hostname, port, &outSocket);
		862
		863	if(outSocket != INVALID_SOCKET) {
		864	return outSocket;
		865	}
		866	}
		867
		868	// If we weren't able to resolve the host name, or couldn't succeed, try the IP address itself
		869	connectToTCPServerAddr(addr, port, &outSocket);
		870
		871	return outSocket;
		872
		873	}
777		874
		875	/** IPV4-ONLY */
778	SOCKET openClientDataSocket(tptp_int32 ip, tptp_int32 port)	876	SOCKET openClientDataSocket(tptp_int32 ip, tptp_int32 port)
779	{	877	{
780		878
781	SOCKET sock = -1 ;	879	SOCKET sock = -1 ;
782	tptp_int32 rc = -1;	880	tptp_int32 rc = -1;
783		881
784	rc = connectToTCPServer(ip, (unsigned short) port, &sock);	882	rc = connectToTCPServerIPv4M(ip, (unsigned short) port, &sock);
785		883
786	if (rc == -1) {	884	if (rc == -1) {
787	return -1;	885	return -1;

Lines 147-152 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/RACClientSupport.h (+5 lines)
147	/* computes a sockets ip address using getpeername */	147	/* computes a sockets ip address using getpeername */
148	int getClientIP(client_connection_block_t* ccb, unsigned char buffer, int length);	148	int getClientIP(client_connection_block_t* ccb, unsigned char buffer, int length);
149		149
		150
		151	int getClientIPAddr(client_connection_block_t* ccb, struct sockaddr_storage ** addr);
		152
150	SOCKET openClientDataSocket(tptp_int32 ip, tptp_int32 port);	153	SOCKET openClientDataSocket(tptp_int32 ip, tptp_int32 port);
151		154
		155	SOCKET openClientDataSocketAddr(struct sockaddr_storage *addr, int port);
		156
152	#endif /* __RACPROCESSLIST_H__ */	157	#endif /* __RACPROCESSLIST_H__ */




	int d, rc;
	SOCKET testSocket;
	unsigned long ipAddr;
	struct addrinfo *AI = NULL;

	host = readStringIntoBuffer(con);
	if (host == NULL) return -1;
	
	readInt (con->socket, &port); 

	testSocket = connectToHostWithHostname(host, port, &AI);

	d = 0;
	
	if(testSocket != INVALID_SOCKET) {
		d = 1;
		closeSocket(testSocket);
			closeSocket(testSocket);
		}
	}
	
	writeByte(con->socket, d);	// "server is reachable" responce


static SOCKET serverSocket;

static SOCKET * serverSockets;
static int numServerSockets;
static socket_accept_t socketAccept;

THREAD_USER_FUNC_RET_TYPE startNativeFileServer(LPVOID args){
	int rc, port;
	struct sockaddr_in  fsSockAddr;
	SOCKET clientSock;
	fs_connection_block_t* con;
	tl_state_data_t*    stateData;
	TID                 threadId;
	HANDLE              threadHandle;
	
	serverSockets = (SOCKET *) tptp_malloc(sizeof(SOCKET) * FD_SETSIZE);
	
	initSocketAccept(&socketAccept);

	stateData = (tl_state_data_t*) args;
	port = ((cctl_state_data_t*)stateData->implData)->filePort;
	if (port <= 0) port = RA_FILE_PORT_NUM_SERVER;
	
	rc = getTheSocket(port, serverSockets, &numServerSockets); 
	if (serverSocket < 0) {
		TPTP_LOG_ERROR_MSG(stateData, "NFS: unable to create the file server socket.");
		return 0;
	}

	//serverSocket = getTheSocket(port, &fsSockAddr);
	if (rc < 0 || numServerSockets == 0) {
		TPTP_LOG_ERROR_MSG(stateData, "NFS: unable to create the file server socket.");
		return 0;
	}
	
	while(1) { 
		clientSock = acceptSocketConnections(serverSockets, numServerSockets, &socketAccept); 
	    if (clientSock < 0) break;

		con = (fs_connection_block_t*) tptp_malloc(sizeof(fs_connection_block_t));

Lines 24-29 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/nativeFileServer.h (+4 lines)
24	#include <sys/types.h>	24	#include <sys/types.h>
25	#endif	25	#endif
26		26
		27	#ifndef _WIN32
		28	#define INVALID_SOCKET (-1)
		29	#endif
		30
27	#include "tptp/TPTPTypes.h"	31	#include "tptp/TPTPTypes.h"
28	#include "tptp/TPTPSupportTypes.h"	32	#include "tptp/TPTPSupportTypes.h"
29	#include "tptp/TransportSupport.h"	33	#include "tptp/TransportSupport.h"

Lines 22-30 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/ClientCTL.h (+9 lines)
22	#include "secureServer.h"	22	#include "secureServer.h"
23	#include "tptp/TPTPUtils.h"	23	#include "tptp/TPTPUtils.h"
24		24
		25	#include "tptp/TransportSupport.h"
		26	// I added the above header file for access to IPv4/IPv6 functions - jwest
		27
25	typedef struct	28	typedef struct
26	{	29	{
		30	// IPV4-ONLY
27	SOCKET sock;	31	SOCKET sock;
		32
		33	SOCKET * sockets; // List of servers sockets we are listening on
		34	tptp_uint32 numSockets; // Number of sockets we are listening on
		35	socket_accept_t sockAccept; // State of server socket listening struct
		36
28	tptp_uint32 port;	37	tptp_uint32 port;
29	tptp_uint32 filePort;	38	tptp_uint32 filePort;
30	tptp_uint32 acProtocolPort;	39	tptp_uint32 acProtocolPort;




	PID real_pid;
	ra_array_t finalEnvironment;

	tptp_int32 buffer;
	int bufferLen=6;
	SOCKET consoleSock; /* 9707 */
	ra_string_t uuid;


	 *   In addition to launching the process, we need to look for any agents that
	 *   the client expects to be associated with this process and attach to them
	 */
	
    getClientIP(ccb, (unsigned char*)&buffer, &bufferLen);

	//ra_logServiceMessage(__FILE__, __LINE__, RA_DEBUG, "Console publish 0x%x, desired 0x%x  socket=%d", command->info.launch_process.consoleIP, buffer, client->connection->handle.socket);

	real_pid=0;
	
	/* Launch Process */
	real_pid=startProcess(ccb, &command->info.launch_process.executable, 
							 &command->info.launch_process.arguments,
							 &command->info.launch_process.location,
							 &command->info.launch_process.environment,
							 0 /* This value isn't used. */,
							 (unsigned short)command->info.launch_process.consolePort,
							 &finalEnvironment,
							 &consoleSock,

	tptp_int32 rc = -1;
	tptp_int32 flags;
	tptp_int32 dataConnectionID;
	struct sockaddr_storage * addr;
	tptp_int32 clientIPLen;
	client_data_connection_block_t *dcb;
	SOCKET dataSock;


		flags = TPTP_DATA_PATH_RECEIVE | TPTP_DATA_PATH_DIRECT_SOCKET;

		if (agent->IPCBufCreated == FALSE) {
			getClientIP(ccb, (unsigned char*)&clientIP, &clientIPLen);
			dataSock = openClientDataSocket(clientIP, command->info.start_monitor_remote.port);

			getClientIPAddr(ccb, &addr);
			dataSock = openClientDataSocketAddr(addr, command->info.start_monitor_remote.port);
			
			if (dataSock == -1) {
				sendErrorMessage("RAC009",
				 "Start Monitoring failed due to data channel socket connection failure.", 

Lines 79-84 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/ClientCTL.c (-17 / +18 lines)
79	return TPTP_ERROR_OUT_OF_MEMORY;	79	return TPTP_ERROR_OUT_OF_MEMORY;
80	}	80	}
81	cctlData = (cctl_state_data_t*)stateData->implData;	81	cctlData = (cctl_state_data_t*)stateData->implData;
		82
		83	initSocketAccept(&(cctlData->sockAccept));
82		84
83	/* Read the TL configuration */	85	/* Read the TL configuration */
84	rc = getConfigurationString(pTransportData->configurationData, "IsDataMultiplexed", &isDataMultiplexed);	86	rc = getConfigurationString(pTransportData->configurationData, "IsDataMultiplexed", &isDataMultiplexed);
Lines 538-549 Link Here
538	tptp_int32 startTransportListener(tptp_object* tlo)	540	tptp_int32 startTransportListener(tptp_object* tlo)
539	{	541	{
540	int rc = 0;	542	int rc = 0;
541	struct sockaddr_in myServerSockAddr ;
542	tl_state_data_t* stateData;	543	tl_state_data_t* stateData;
543	cctl_state_data_t* cctlData;	544	cctl_state_data_t* cctlData;
544	TID threadId;	545	TID threadId;
545	HANDLE threadHandle;	546	HANDLE threadHandle;
546		547	SOCKET * socketList;
		548
547	if ( !isValidTPTPBlock(tlo, TPTP_BASETL_MAKE_OBJECT_ID(tlo)) )	549	if ( !isValidTPTPBlock(tlo, TPTP_BASETL_MAKE_OBJECT_ID(tlo)) )
548	return TPTP_ERROR_INVALID_PARAMETER;	550	return TPTP_ERROR_INVALID_PARAMETER;
549		551
Lines 560-582 Link Here
560	/* Create a pseudo-connection to monitor agent register events */	562	/* Create a pseudo-connection to monitor agent register events */
561	startAgentRegistrationListener( stateData );	563	startAgentRegistrationListener( stateData );
562		564
		565	socketList = (SOCKET )tptp_malloc(sizeof(SOCKET) FD_SETSIZE);
		566
		567	cctlData->sockets = socketList;
		568
563	/* create and initialize the server socket */	569	/* create and initialize the server socket */
564	cctlData->sock = getTheSocket( cctlData->port, &myServerSockAddr );	570	// cctlData->sock = getTheSocket( cctlData->port, &myServerSockAddr );
565		571
566	if ( cctlData->sock < 0 )	572	/* create and initialize the server socket */
		573	rc = getTheSocket(cctlData->port, cctlData->sockets, &(cctlData->numSockets));
		574
		575	if ( rc < 0 \|\| cctlData->numSockets == 0 )
567	{	576	{
568	TPTP_LOG_ERROR_MSG(stateData, "Error: unable to create the server socket.") ;	577	TPTP_LOG_ERROR_MSG(stateData, "Error: unable to create the server socket.") ;
569	return -1; // TODO: Use a more specific error	578	return -1; // TODO: Use a more specific error
570	}	579	}
571		580
572	rc = bindAndListen(cctlData->sock, (struct sockaddr*)&myServerSockAddr);
573	if ( rc != 0 )
574	{
575	TPTP_LOG_SEVERE_MSG(stateData, "ERROR: Cannot start Agent Controller. ");
576	TPTP_LOG_SEVERE_MSG1(stateData, "REASON: Cannot bind to socket port %d. Make sure the socket is free and no other Agent Controller is running.", cctlData->port);
577	return -1; // TODO: Use a more specific error
578	}
579
580	if ((!cctlData->isJavaUnsecuredFileServer) && !cctlData->securityEnabled) {	581	if ((!cctlData->isJavaUnsecuredFileServer) && !cctlData->securityEnabled) {
581	rc = tptpStartThread(startNativeFileServer, (LPVOID)stateData, &threadId, &threadHandle);	582	rc = tptpStartThread(startNativeFileServer, (LPVOID)stateData, &threadId, &threadHandle);
582	CLOSE_THREAD_HANDLE(threadHandle);	583	CLOSE_THREAD_HANDLE(threadHandle);
Lines 643-649 Link Here
643	{	644	{
644	int ret;	645	int ret;
645		646
646	ret = convertIPAddressUlongToString( cctlData->peerAttachAddress, &ipAddrStr );	647	ret = convertIPAddressUlongToStringIPv4M( cctlData->peerAttachAddress, &ipAddrStr );
647	if ( ret != 0 )	648	if ( ret != 0 )
648	{	649	{
649	return ret;	650	return ret;
Lines 653-659 Link Here
653	{	654	{
654	/* NOTE: This has problems if there are multiple IP addresses, but in	655	/* NOTE: This has problems if there are multiple IP addresses, but in
655	the case of compatibility mode, this isn't really used anyway */	656	the case of compatibility mode, this isn't really used anyway */
656	if (getSocketIPString( (SOCKET)NULL, &ipAddrStr) < 0) {	657	if (getSocketIPStringIPv4M( (SOCKET)NULL, &ipAddrStr) < 0) {
657	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");	658	TPTP_LOG_ERROR_MSG(stateData, "Unable to get local IP address");
658	return -1;	659	return -1;
659	}	660	}
Lines 737-743 Link Here
737	TPTP_LOG_ERROR_MSG1( stateData, "Unable to find host in sourceConnectionInfo: %s", sourceConnectionInfo );	738	TPTP_LOG_ERROR_MSG1( stateData, "Unable to find host in sourceConnectionInfo: %s", sourceConnectionInfo );
738	return rc;	739	return rc;
739	}	740	}
740	rc = convertIPAddressStringToUlong( ipAddrStr, &ipAddr );	741	rc = convertIPAddressStringToUlongIPv4M( ipAddrStr, &ipAddr );
741	if ( rc != 0 )	742	if ( rc != 0 )
742	{	743	{
743	TPTP_LOG_ERROR_MSG1( stateData, "Unable to convert IP address string to unsigned long: %s", ipAddrStr );	744	TPTP_LOG_ERROR_MSG1( stateData, "Unable to convert IP address string to unsigned long: %s", ipAddrStr );
Lines 748-754 Link Here
748	/* TODO: Check to see if this is local */	749	/* TODO: Check to see if this is local */
749		750
750	/* Connect to the remote AC */	751	/* Connect to the remote AC */
751	rc = connectToTCPServer( ipAddr, (unsigned short)port, &sock);	752	rc = connectToTCPServerIPv4M( ipAddr, (unsigned short)port, &sock);
752	if ( rc != 0 )	753	if ( rc != 0 )
753	{	754	{
754	TPTP_LOG_ERROR_MSG2( stateData, "Unable to connect to peer: %s, port %d", ipAddrStr, port );	755	TPTP_LOG_ERROR_MSG2( stateData, "Unable to connect to peer: %s, port %d", ipAddrStr, port );

Lines 465-471 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/CCTLServer.c (-4 / +10 lines)
465	/* accept and process one connection at a time */	465	/* accept and process one connection at a time */
466	while (stateData->processingThreadState == TPTP_TL_THREAD_RUNNING)	466	while (stateData->processingThreadState == TPTP_TL_THREAD_RUNNING)
467	{	467	{
468	clientSock = acceptSocketConnection(cctlData->sock);	468	// clientSock = acceptSocketConnection(cctlData->sock);
		469	clientSock = acceptSocketConnections(cctlData->sockets, cctlData->numSockets, &(cctlData->sockAccept));
469		470
470	if (isSocketValid(clientSock) == 0)	471	if (isSocketValid(clientSock) == 0)
471	{	472	{
Lines 478-485 Link Here
478	ra_message_t* message;	479	ra_message_t* message;
479	ra_command_t* command;	480	ra_command_t* command;
480	char *ipAddr;	481	char *ipAddr;
481	unsigned char address[12];
482	tptp_int32 rc;	482	tptp_int32 rc;
		483	struct sockaddr_storage *sockAddr;
		484
		485	sockAddr = getPeerAddrOfSocket(clientSock);
483		486
484	rc = getPeerIPString(clientSock, &ipAddr);	487	rc = getPeerIPString(clientSock, &ipAddr);
485	if (rc != 0)	488	if (rc != 0)
Lines 487-502 Link Here
487	TPTP_LOG_ERROR_MSG(stateData, "Connection refused could not getPeerIPString");	490	TPTP_LOG_ERROR_MSG(stateData, "Connection refused could not getPeerIPString");
488	continue;	491	continue;
489	}	492	}
490	convertIPAddressStringToArray(ipAddr, address);
491		493
492	if (!tptp_checkHost(cctlData->network_list, address)) {	494	if (!tptp_checkHostIPv6(cctlData->network_list, sockAddr)) {
		495
493	TPTP_LOG_ERROR_MSG2(stateData, "Connection refused on socket %d on host %s", clientSock, ipAddr);	496	TPTP_LOG_ERROR_MSG2(stateData, "Connection refused on socket %d on host %s", clientSock, ipAddr);
494	//printf("Connection refused on socket %d on host %s", clientSock, ipAddr);	497	//printf("Connection refused on socket %d on host %s", clientSock, ipAddr);
495	tptp_free(ipAddr);	498	tptp_free(ipAddr);
		499	tptp_free(sockAddr);
496	closeThisSocket(clientSock);	500	closeThisSocket(clientSock);
497	continue;	501	continue;
498	}	502	}
		503
499	tptp_free(ipAddr);	504	tptp_free(ipAddr);
		505	tptp_free(sockAddr);
500		506
501	setHandleInherited((HANDLE) clientSock) ;	507	setHandleInherited((HANDLE) clientSock) ;
502		508

Lines 74-79 Link Here

(-)src-native-new/include/tptp/MsgPipeline.h (+8 lines)
74	unsigned int peerAttachAddress;	74	unsigned int peerAttachAddress;
75	} PeerAttachInfo_t;	75	} PeerAttachInfo_t;
76		76
		77	/*
		78	typedef struct {
		79	char * transportType;
		80	tptp_list_t hostList;
		81	int port;
		82	} PeerIPv6Connection_t;
		83	*/
		84
77	/* Optional functions provided by TLs involved in peer monitoring */	85	/* Optional functions provided by TLs involved in peer monitoring */
78	typedef tptp_int32 (setPeerAttachInfo_ptr_t)( tptp_object tlo, PeerAttachInfo_t* peerInfo );	86	typedef tptp_int32 (setPeerAttachInfo_ptr_t)( tptp_object tlo, PeerAttachInfo_t* peerInfo );
79	typedef tptp_int32 (getPeerConnectionInfo_ptr_t)( tptp_object tlo, tptp_string* type, tptp_string** ci );	87	typedef tptp_int32 (getPeerConnectionInfo_ptr_t)( tptp_object tlo, tptp_string* type, tptp_string** ci );




 *    non-zero   failure code
 *
 *********************************************************/
int convertIPAddressStringToArrayIPv4M( char *addrStr, unsigned char* addrArray );

/**
 *********************************************************

 *    non-zero   failure code
 *
 *********************************************************/
int convertIPAddressStringToUlongIPv4M( char *addrStr, unsigned long* addr );

/**
 *********************************************************

 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressUlongToStringIPv4M( unsigned long addr, char **addrStr );

/**
 *********************************************************

 *    non-zero   failure code
 *
 *********************************************************/
int getSocketIPStringIPv4M( SOCKET sock, char** ipAddrStr );

/**
 *********************************************************

 * @return
 *    host info data structure
 *********************************************************/
struct sockaddr_storage* getHostInfo();

struct hostent * getHostInfoIPv4M();

/**
 *********************************************************

 * @return
 *    host info data structure
 *********************************************************/
struct hostent * getTargetHostInfoIPv4M(char* hostname);

/**
 *********************************************************

 *    the raw unconnected socket
 *
 *********************************************************/
int getTheSocket(int portNum, SOCKET *outResult, int *outNumSockets);

/**
 *********************************************************

 *    0 - Success
 *    nonzero - Error.
 *********************************************************/
SOCKET bindAndListen(struct addrinfo *AI);

/**
 *********************************************************

 *    connect to the given system
 *
 * @return
 *    If we were able to connect pSock contans a SOCKET, otherwise, it's INVALID_SOCKET.
 *********************************************************/
int connectToTCPServer(char * hostname, int port, SOCKET *pSock);


/**
 *********************************************************
 *
 * @brief
 *    connect to the given system
 *
 * @return
 *    If we were able to connect pSock contans a SOCKET, otherwise, it's INVALID_SOCKET.
 *********************************************************/
int connectToTCPServerAddr(struct sockaddr_storage * addr, int port, SOCKET *pSock);


int connectToTCPServerIPv4M(unsigned long ipAddr, unsigned short portNum, SOCKET *pSock);

/**
 *********************************************************


int closeSocket(int socket);

/** SOCKET ->  struct sockaddr_storage * for the peer. */
struct sockaddr_storage * getPeerAddrOfSocket(SOCKET ConnSocket);

/** struct sockaddr_storage * => IP address in byte format (e.g. in_addr / in6_addr) + family 
    The bytes are stored in outAddr, and the family is stored in family.*/
void getByteFormatFromSockAddr(struct sockaddr_storage *addr, void ** outAddr, int *family);

void getSockAddrFromByteFormat(void *inAddr, int family, struct sockaddr_storage **outResult);

void setSockaddrStoragePort(struct sockaddr_storage *addr, int port);

typedef struct {
	tptp_list_t serverSocketList;

	tptp_list_t socketsToProcess;
	Lock_t sockProcLock;

} socket_accept_t;

SOCKET acceptSocketConnections(SOCKET * sockets, int numSockets, socket_accept_t * sockAcceptState);
void initSocketAccept(socket_accept_t * sat);

struct sockaddr_storage * cloneSockAddr(struct sockaddr_storage * addr);


int isAddrLocal(struct sockaddr_storage * addr);
int compareAddresses(struct sockaddr_storage * one, struct sockaddr_storage * two);
char * convertAddrToHostname(struct sockaddr_storage *addr);

void getLocalHostAddresses(struct sockaddr_storage *** arrOfAddr, int * numAddr);

void freeAddressList(struct sockaddr_storage ** arrOfAddr, int numAddr);

int convertHostnameToAddrs(char *hostname, struct sockaddr_storage *** outResult, int *outNumResults);

struct sockaddr_storage * getSelfAddrOfSocket(SOCKET ConnSocket);

void printSockAddrStorage(struct sockaddr_storage *inAddr);

SOCKET connectToHostWithHostname(char * hostnameOrIp, int port, struct addrinfo ** sockAddrOut );

#ifdef __cplusplus
}
#endif

Lines 77-82 Link Here

(-)src-native-new/include/tptp/TransportOSCalls.h (+2 lines)
77	*	77	*
78	* @return	78	* @return
79	* 0 - always	79	* 0 - always
		80	* IPV4-ONLY
80	*********************************************************/	81	*********************************************************/
81	int printSocketRequest(SOCKET sock, struct sockaddr_in * pRequester) ;	82	int printSocketRequest(SOCKET sock, struct sockaddr_in * pRequester) ;
82		83
Lines 110-115 Link Here
110	*********************************************************/	111	*********************************************************/
111	int closeThisSocket(SOCKET sock) ;	112	int closeThisSocket(SOCKET sock) ;
112		113
		114	/** IPV4-ONLY */
113	void extractAddressFromSockAddr(struct sockaddr_in connection, unsigned char address);	115	void extractAddressFromSockAddr(struct sockaddr_in connection, unsigned char address);
114		116
115		117

Lines 95-100 Link Here

(-)src-native-new/include/tptp/TransportSupport.h (+4 lines)
95		95
96	BOOL tptp_checkHost(network_list_t list, unsigned char address);	96	BOOL tptp_checkHost(network_list_t list, unsigned char address);
97		97
		98	SOCKET connectToHostWithAddr(struct sockaddr_storage *addr);
		99
		100	BOOL tptp_checkHostIPv6(network_list_t list, struct sockaddr_storage addr);
		101
98	#ifdef __cplusplus	102	#ifdef __cplusplus
99	}	103	}
100	#endif	104	#endif

Lines 98-103 Link Here

(-)src-native-new/include/tptp/TPTPUtils.h (+7 lines)
98	unsigned char net[4]; /* The network address information in network byte order. Note that this is IPV4 specific */	98	unsigned char net[4]; /* The network address information in network byte order. Note that this is IPV4 specific */
99	unsigned char mask[4]; /* the subnet mask information in network byte order. Note that this is IPV4 specific */	99	unsigned char mask[4]; /* the subnet mask information in network byte order. Note that this is IPV4 specific */
100	char *hostname;	100	char *hostname;
		101
		102	unsigned char netipv6[16];
		103	unsigned char maskipv6[16];
		104
		105	int netAndMaskAreIpv4;
		106
101	}network_t;	107	}network_t;
102		108
103	typedef struct _network_list_node {	109	typedef struct _network_list_node {
Lines 234-239 Link Here
234	int tptp_deleteSemaphore(Semaphore_t *pSem);	240	int tptp_deleteSemaphore(Semaphore_t *pSem);
235	int tptp_waitSemaphore(Semaphore_t *pSem);	241	int tptp_waitSemaphore(Semaphore_t *pSem);
236	int tptp_postSemaphore(Semaphore_t *pSem);	242	int tptp_postSemaphore(Semaphore_t *pSem);
		243	/int tptp_waitSemaphoreTimeout(Semaphore_t pSem, int timeoutInSecs);*/
237		244
238	int getFileSize(char *fileName);	245	int getFileSize(char *fileName);
239	int validateDirectory(char* dirName);	246	int validateDirectory(char* dirName);




  * @returns  0 - create server was successful.
  *         <>0 - create failed, call ra_getlastErrorMajor/Minor
  *               to get the failure details.
  *  IPV4-ONLY
  */
int ra_createBoundUDPServer(short portNum,
							ra_serverInfo_t *result) {

  * @returns  0 - create server was successful.
  *         <>0 - create failed, call ra_getlastErrorMajor/Minor
  *               to get the failure details.
  * IPV4-ONLY
  */

int ra_createTCPServer(unsigned short portNum,
					   ra_serverInfo_t *result) {


  * @returns   0 - connect was successful
  *           <0 - connect failed, can ra_getLastErrorMajor/Minor
  *                to get the failure details.
  * IPV4-ONLY
  */
int ra_connectToTCPServer(ra_uint_t remoteIP,
						  unsigned short remotePortNum,

 *           The number of characters written to the parameter buffer (excluding 
 *           null terminator character.  Otherwise, -1 if a severe error occurred. 
 *           Call ra_getLastErrorMajor/Minor() to determine the error conditions.
 * IPV4-ONLY
 */
short ra_getFormattedLocalIPAddress(char *ipAddressBuffer){
	

  *           -1 - severe error occured getting the IP address.  Call
  *                ra_getLastErrorMajor/Minor to determine the
  *                error conditions.
  * IPV4-ONLY
  */
long ra_getLocalIPAddress() {
	char localhost[MAX_HOST_NAME_LENGTH];


	return result;
}
 

/** GET_LOCAL_IP_ADDRESSES *******************************************
  * Get all the IP addresses associated with this physical host.

  *           -1 - severe error occured getting the IP address.  Call
  *                ra_getLastErrorMajor/Minor to determine the
  *                error conditions.
  *  IPV4-ONLY
  */
short ra_getLocalIPAddresses(ra_IPAddresses_t *addr) {
	char localhost[MAX_HOST_NAME_LENGTH];

	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);


	/* 1.1 in wVersion since that is the version we */
	/* requested. */

	if ( LOBYTE( wsaData.wVersion ) != 2 ||
		HIBYTE( wsaData.wVersion ) != 2 ) {
		/* Tell the user that we couldn't find a useable */
		/* winsock.dll. */
		ra_setLastError(SOCKET_INITIALIZE_FAILED, err);




  * @returns  0 - create server was successful.
  *         <>0 - create failed, call ra_getlastErrorMajor/Minor
  *               to get the failure details.
  * IPV4-ONLY
  */
extern int ra_createBoundUDPServer(short portNum,
								   ra_serverInfo_t *resultSet);

  * @returns  0 - create server was successful.
  *         <>0 - create failed, call ra_getlastErrorMajor/Minor
  *               to get the failure details.
  * IPV4-ONLY
  */
extern int ra_createTCPServer(unsigned short portNum,
							  ra_serverInfo_t *resultSet);

 *           The number of characters written to the parameter buffer (excluding 
 *           null terminator character.  Otherwise, -1 if a severe error occurred. 
 *           Call ra_getLastErrorMajor/Minor() to determine the error conditions.
 * IPV4-ONLY
 */
extern short ra_getFormattedLocalIPAddress(char *ipAddressBuffer);





	ipcMemWrite  					  @22
	ipcFlushToFunc					  @23
	ipcStopFlushing					  @24
	convertHostnameToAddrs			  @25
	setHandleInherited				  @26
	isSocketValid					  @27
	destroyNamedPipe				  @28

	ipcMemWriteWithDIME				  @36
	isValidTPTPBlock				  @37
	getPeerName				          @38
	convertIPAddressStringToArrayIPv4M @39
	convertIPAddressStringToUlong     @40
	getSocketIPString				  @41
	ipcFlushToFD					  @42
	tptp_checkHost					  @43
	openNonCriticalWriteOnlyNamedPipe @44
	getPeerIPString				      @45
	convertIPAddressUlongToStringIPv4M     @46
	getSocketPort                     @47
	ipcStopFlusher                    @48
	ipcCloseMem                    	  @49
	isMemOpen						  @50
	ipcMemDetach					  @51
	closeSocket						  @52
	getHostInfoIPv4M				  @53
	convertIPAddressStringToUlongIPv4M @54
	getSocketIPStringIPv4M			  @55
	freeAddressList					  @56
	getTargetHostInfoIPv4M			  @57
	getPeerAddrOfSocket				  @58
	getByteFormatFromSockAddr	      @59
	getSockAddrFromByteFormat		  @60
	connectToHostWithAddr			  @61
	setSockaddrStoragePort			  @62
	connectToTCPServerAddr			  @63
	connectToTCPServerIPv4M			  @64
	acceptSocketConnections			  @65
	initSocketAccept				  @66
	cloneSockAddr					  @67
	getLocalHostAddresses			  @68
	tptp_checkHostIPv6				  @69
	getSelfAddrOfSocket				  @70
	printSockAddrStorage			  @71
	connectToHostWithHostname		  @72





#include "tptp/NoLog.h"

// The following if-else was added for IPv6 support
#ifdef _WIN32
	#include <ws2tcpip.h>
#else 
	#define INVALID_SOCKET -1
	#define SOCKET_ERROR -1
#endif

static void convertAddrToIpString(struct sockaddr_storage * addr, char **hostname);
static SOCKET getSocketFromAddrList(struct addrinfo *AddrInfo, struct addrinfo **sockAddrOut);

/**
 *********************************************************
 *
 * @brief
 *    get the localhost (server) socket connection 
 *
 * @param portNum The port number of the local host to listen on. 
 * @param outResult A pointer to an array of SOCKETS to be listened on
 * @param outNumSockets The integer that is passed in as a pointer to this function is set to the number of sockets of the outResult array
 *********************************************************/
int getTheSocket(int portNum, SOCKET *outResult, int *outNumSockets) {
	int Family = PF_UNSPEC;
    int SocketType = SOCK_STREAM;
    char PortStr[8];
    char *Address = NULL;
    int i, RetVal;

	struct addrinfo Hints, *AddrInfo, *AI;
    SOCKET* sockArr;
	
	SOCKET serverSocket;

	int ServSockSize = 0;

	sprintf(PortStr, "%d", portNum);

	sockArr = outResult;

    // MS' description of the following call:
    // By setting the AI_PASSIVE flag in the hints to getaddrinfo, we're
    // indicating that we intend to use the resulting address(es) to bind
    // to a socket(s) for accepting incoming connections.  This means that
    // when the Address parameter is NULL, getaddrinfo will return one
    // entry per allowed protocol family containing the unspecified address
    // for that family.
    //
    memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
    Hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
    RetVal = getaddrinfo(Address, PortStr, &Hints, &AddrInfo);
    if (RetVal != 0) {
        return -1;
    }

	// First check for IPv6 connections
    for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next) {

        // Highly unlikely, but check anyway.
        if (i == FD_SETSIZE) {
               		TPTP_LOG_ERROR_MSG("getaddrinfo exceeded the number of available addrs");
            return -1;
        }

        // PF_INET6 only
		if (!(AI->ai_family == PF_INET6)) {
            continue;
		}

		serverSocket = bindAndListen(AI);
		if(serverSocket >= 0) {
			sockArr[ServSockSize++] = serverSocket;
		}
		i++;
    }

	// Then check IPv4
	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next) {

        // Highly unlikely, but check anyway.
        if (i == FD_SETSIZE) {
           		TPTP_LOG_ERROR_MSG("getaddrinfo returned more addresses than we could use.");
            return -1;
        }
        
		if (!(AI->ai_family == PF_INET)) {
            continue;
		}

		// jwest: On our Linux machines, listening on IPv6 also listened on IPv4. So if we get an error here, "Address already in Use", we can ignore it.
		serverSocket = bindAndListen(AI);
		if(serverSocket >= 0) {
			sockArr[ServSockSize++] = serverSocket;
		}
		
		i++;
    }

    freeaddrinfo(AddrInfo);

	*outNumSockets = ServSockSize;

    if (ServSockSize == 0) {
   		TPTP_LOG_ERROR_MSG("Fatal error: unable to serve on any address.") ;
        return -1;
    }

	return 0;
}

/**
 *********************************************************
 *
 * @brief
 *    bind and prepare the server socket
 *
 * @return
 *    0 - Success
 *    nonzero - Error.
 *********************************************************/
SOCKET bindAndListen(struct addrinfo *AI) {

	SOCKET ServSock;

	// Open a socket with the correct address family for this address.
    ServSock = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol);
    if (ServSock == INVALID_SOCKET) {
		return -1;
    }

	if (bind(ServSock, AI->ai_addr, (int)AI->ai_addrlen) == SOCKET_ERROR) {
		closeThisSocket(ServSock);
		return (-1);
       }

	if (listen(ServSock, 5) == SOCKET_ERROR) {
		closeThisSocket(ServSock);
		return (-1);
	}

	return (ServSock);

	return socket(AF_INET, SOCK_STREAM, 0) ;
}

/**

 *
 * @return
 *    the port number
 * IPV4-ONLY
 *********************************************************/
int getSocketPort(SOCKET sock)
{

 *********************************************************
 *
 * @brief
 *		Gets the localhost info. 
 * 		
 * 		Note: When resolving the addresses of the local host, this function will always return the 
 *	 	first in the list of addresses given to it by the operating system. For the actual list of local addresses, 
 * 		use a different function.   
 * 		
 * 		Returns NULL if no address could be obtained.
 *  
 * @return
 *    host info data structure
 *********************************************************/
struct sockaddr_storage* getHostInfo() 
{
	int RetVal;
	char *Address = NULL;
	char *Port = "10002"; // Hardcoded because we need a port

	struct addrinfo Hints, *AddrInfo;
	struct sockaddr_storage *result = NULL;


    int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
    int SocketType = SOCK_STREAM;
	
	memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
    Hints.ai_flags = AI_NUMERICHOST;

    RetVal = getaddrinfo(Address, Port, &Hints, &AddrInfo);

    if(RetVal == 0) {
    
		result = cloneSockAddr((struct sockaddr_storage *)AddrInfo->ai_addr);
		
		freeaddrinfo(AddrInfo);
    }
	
	return (result);
}

struct hostent * getHostInfoIPv4M() 
{
	char   localhost[MAX_HOST_NAME_LENGTH+1];


 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressStringToUlongIPv4M( char *addrStr, unsigned long* addr )
{
	*addr = inet_addr( addrStr );
	if ( *addr == INADDR_NONE )

 *********************************************************/
int getSocketIPString( SOCKET sock, char** ipAddrStr )
{
	struct sockaddr_storage *sockAddrPtr = NULL;

	if ( sock == (SOCKET)NULL )
	{
		sockAddrPtr = getHostInfo();
	}
	else
	{
		sockAddrPtr = getSelfAddrOfSocket(sock);
	}

	if (sockAddrPtr == NULL) return -1;

	convertAddrToIpString(sockAddrPtr, ipAddrStr);
	if ( *ipAddrStr == NULL )
	{
		return TPTP_SYS_NO_MEM;
	}
	return 0;
}

int getSocketIPStringIPv4M( SOCKET sock, char** ipAddrStr )
{
	char*  temp;

	if ( sock == (SOCKET)NULL )
	{
		struct hostent* hinfo;

		hinfo = getHostInfoIPv4M();
		if (hinfo == NULL) return -1;

		/* The socket code owns 'temp' as returned below, so we need to copy it */

	return 0;
}


/**
 *********************************************************
 *

 *********************************************************/
int getPeerIPString( SOCKET sock, char** ipAddrStr )
{
	struct sockaddr_storage *sockAddrPtr = NULL;

	if ( sock == (SOCKET)NULL )
	{
		return -1;
	}
	else
	{
		int                saSize;
		struct sockaddr_in saddr;

	sockAddrPtr = getPeerAddrOfSocket(sock);	
		saddr.sin_port        = htons(0);
		saddr.sin_addr.s_addr = INADDR_ANY;
		BZERO(&saddr.sin_zero,8);

	if(sockAddrPtr == NULL) {
		TPTP_LOG_ERROR_MSG("Error: Unable to get the address information for the remote peer.") ;
		//of the clinet we need to call getpeername.
		getpeername(sock,(struct sockaddr *)&saddr,&saSize);

		/* The socket code owns 'temp' as returned below, so we need to copy it */
		temp = inet_ntoa(saddr.sin_addr);
	}

	convertAddrToIpString(sockAddrPtr, ipAddrStr);
	tptp_free(sockAddrPtr);
	if ( *ipAddrStr == NULL )
	{
		return TPTP_SYS_NO_MEM;
	}

	strcpy( *ipAddrStr, temp );

	return 0;
}


struct hostent * getTargetHostInfoIPv4M(char* hostname) 
 *
 * @brief
 *    get the localhost info
 *
 * @return
 *    host info data structure
 *********************************************************/
struct hostent * getTargetHostInfo(char* hostname) 
{
	struct hostent *pInfo = NULL ;


	return ( pInfo );
}


/**
 *********************************************************
 *
 * @brief
 *    get the localhost info
 *
 * @return
 *    host info data structure
 *    nonzero - Error.
 *********************************************************/
int convertHostnameToAddrs(char *hostname, struct sockaddr_storage *** outResult, int *outNumResults) {
	int RetVal;
	int i;

	struct addrinfo Hints, *AddrInfo, *AI;
				SOL_SOCKET,
				SO_REUSEADDR,
				0,
				0);

    int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
    int SocketType = SOCK_STREAM; // TCP only

	struct sockaddr_storage ** result;

	// malloc an array of pointers to struct sockaddr_storages
	result = (struct sockaddr_storage **)tptp_malloc(sizeof(struct sockaddr_storage *) * 128);
	
	memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
	
	// This was originally in the code, but it prevents lookups of host names, e.g. www.google.com. It only works with numeric hosts.
    // Hints.ai_flags = AI_NUMERICHOST;  

    RetVal = getaddrinfo(hostname, NULL, &Hints, &AddrInfo);

	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next, i++) {
		result[i] = cloneSockAddr((struct sockaddr_storage *)AI->ai_addr);
	}
	freeaddrinfo(AddrInfo);
	{
		int result;

	*outResult = result;
	*outNumResults = i;

	return RetVal;
}


/**
 *********************************************************
 *
 * @brief
 *    frees acquired addresses list
 *
 * @return
 *    host info data structure
 *********************************************************/
void freeAddressList(struct sockaddr_storage ** arrOfAddr, int numAddr) {
	int x = 0;

	for(x = 0; x < numAddr; x++) {
		tptp_free(arrOfAddr[x]);
	}

	return ( rc ) ;
}

/**

 * @return
 *    0 - Success
 *    nonzero - Error.
 *  IPV4-ONLY 
 *********************************************************/
int getPeerName(SOCKET sock, unsigned char* pAddr)
{

SOCKET  acceptSocketConnection(SOCKET serverSock)
{
	SOCKET clientSock ;
	struct sockaddr_storage clientAddress;
	size_t clientLen=sizeof(clientAddress);
	int    rc = 0 ;
	int    enable=1;

 *    0 - Success and the socket representing this connection
 *    nonzero - Error.
 *********************************************************/
int connectToTCPServer(char * hostname, int port, SOCKET *pSock)
{
	int    rc = 0 ;
	SOCKET sock ;
	struct addrinfo *AI = NULL;

	TPTP_LOG_DEBUG_MSG("connectToTCPServer...") ;

	sock = connectToHostWithHostname(hostname, port, &AI);

	freeaddrinfo(AI);

	*pSock = sock ;

	return ( rc ) ;
}


int connectToTCPServerIPv4M(unsigned long ipAddr,
					   unsigned short portNum,
					   SOCKET *pSock)
{

 *********************************************************
 *
 * @brief
 *    connect to the given system
 *
 * @return
 *    0 - Success and the socket representing this connection
 *    nonzero - Error.
 *********************************************************/
int connectToTCPServerAddr(struct sockaddr_storage * addr, int port, SOCKET *pSock)
{
	int    rc = 0 ;
	SOCKET sock ;

	TPTP_LOG_DEBUG_MSG("connectToTCPServerAddr...") ;

	setSockaddrStoragePort(addr, port);
	
	sock = connectToHostWithAddr(addr);

	*pSock = sock ;

	return ( rc ) ;
}




/**
 *********************************************************
 *
 * @brief
 *    common interface to terminate the given connection
 *    (socket).
 *

	return closeThisSocket(socket);
}
#endif

struct sockaddr_storage * cloneSockAddr(struct sockaddr_storage * addr) {
	struct sockaddr_storage* result;

	if(addr->ss_family == PF_INET){
		result = (struct sockaddr_storage *)tptp_malloc(sizeof(struct sockaddr_in));
		memcpy(result, (struct sockaddr_in *)addr,sizeof(struct sockaddr_in));
		
	} else if(addr->ss_family == PF_INET6) {
		result = (struct sockaddr_storage *) tptp_malloc(sizeof(struct sockaddr_in6));
		memcpy(result, (struct sockaddr_in6 *)addr, sizeof(struct sockaddr_in6));
	} else {
		result = (struct sockaddr_storage *) NULL;
	}

	return result;
}

static void convertAddrToIpString(struct sockaddr_storage * addr, char **hostname) {
	int r;

	*hostname = (char *)tptp_malloc(sizeof(char) * NI_MAXHOST);
	if(*hostname == NULL) return;
	
	memset(*hostname, 0, sizeof(char) * NI_MAXHOST);
	// hostname[0] = 0;

	r = getnameinfo((struct sockaddr *)addr, sizeof(struct sockaddr_storage), *hostname, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
}

/** SOCKET ->  struct sockaddr_storage * for the peer. */
struct sockaddr_storage * getPeerAddrOfSocket(SOCKET ConnSocket) {
	int result = 0;
	int addrLen = 0;
	struct sockaddr_storage * addr;

	addrLen = sizeof(struct sockaddr_storage);
    addr = (struct sockaddr_storage *)tptp_malloc(sizeof(struct sockaddr_storage));

	result = getpeername(ConnSocket, (struct sockaddr *) addr, &addrLen);

	if(result == SOCKET_ERROR) {
   		TPTP_LOG_ERROR_MSG("getpeername call failed to get peer address") ;
		return NULL;
	}

	return addr;	
}

/** SOCKET => struct sockaddr_storage *, of the host's side of the socket. For the peer's address, use getPeerAddrOfSocket. */
struct sockaddr_storage * getSelfAddrOfSocket(SOCKET ConnSocket) {
	struct sockaddr_storage Addr;
	struct sockaddr_storage *result;
	int r = 0;
	
	socklen_t AddrLen = 0;

	AddrLen = sizeof (Addr);

	r = getsockname(ConnSocket, (struct sockaddr *) & Addr, &AddrLen);

	if(r != 0) return NULL;

	result = (struct sockaddr_storage *)tptp_malloc(sizeof(struct sockaddr_storage));

	memcpy(result, &Addr, sizeof(struct sockaddr_storage));

	return result;
}

/** Creates a client socket connection to the given hostname/ip, on the given port. The sockAddrOut variable is set to the particular
	struct addrinfo that was used to create the connection. This allows you to determine the family, either IPV4 of IPV6 (if needed.)
	
	If a hostname is specified in 'hostnameOrIp', this method will try to connect on both the IPv4 and IPv6 addresses of the hostname, where available. It
	returns the first successful SOCKET connection as a result.

	If an IP address is specified in 'hostnameOrIp', this method will only connect on either the IPv4 (x.x.x.x) or IPv6 (xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx)
	address of that host (based on the format of the ip address that is based in).
	*/
SOCKET connectToHostWithHostname(char * hostnameOrIp, int port, struct addrinfo ** sockAddrOut ) {
    int Family = PF_UNSPEC;
    int SocketType = SOCK_STREAM; // TCP
    int RetVal;
	char portStr[8];
    struct addrinfo Hints, *AddrInfo;
    SOCKET ConnSocket;

	// Convert the integer port to a string for getaddrinfo
	sprintf(portStr, "%d", port);

    //
    // By not setting the AI_PASSIVE flag in the hints to getaddrinfo, we're
    // indicating that we intend to use the resulting address(es) to connect
    // to a service.  This means that when the Server parameter is NULL,
    // getaddrinfo will return one entry per allowed protocol family
    // containing the loopback address for that family.
    //

    memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
    RetVal = getaddrinfo(hostnameOrIp, portStr, &Hints, &AddrInfo);

    if (RetVal != 0) {
        return -1;
    }

	if (AddrInfo == NULL) {
        return -1;
    }
	
	ConnSocket = getSocketFromAddrList(AddrInfo, sockAddrOut);
	
	return ConnSocket;
}

/** Connects to the given address, and returns a SOCKET for that conncetion. If a socket could not be created,
	then INVALID_SOCKET is returned. Note: The struct sockaddr_storage must have a port specified. */
SOCKET connectToHostWithAddr(struct sockaddr_storage *addr) {
	SOCKET sock;
	int    enable = 1 ;
	BOOL   nagle  = FALSE;
	struct linger linger;
	int    rc = 0 ;
	int loopcnt = 0;

	// Open a socket with the correct address family for this address.
	sock = socket(addr->ss_family, SOCK_STREAM, 0); 
	
	setsockopt(sock,
			   SOL_SOCKET,
			   SO_KEEPALIVE,
			   (const char*)&enable,
			   sizeof(enable));

	linger.l_onoff=1;
	linger.l_linger=3;
	setsockopt(sock,
			   SOL_SOCKET,
			   SO_LINGER,
			   (const char*)&linger,
			   sizeof(linger));

	setsockopt(sock,
			   IPPROTO_TCP,
			   TCP_NODELAY,
			   (const char*)&nagle,
			   sizeof(nagle));

		/* go make the connection */
#ifndef _WIN32
	do {
		rc = connect(sock, (struct sockaddr*)addr, sizeof(struct sockaddr_storage));
		loopcnt++;
	} while (rc == -1 && errno == EINTR && loopcnt < 50);
#else
	rc = connect(sock, (struct sockaddr*)addr, sizeof(struct sockaddr_storage)) ;
#endif

	/*
	if (connect(sock, (struct sockaddr *)addr, sizeof(struct sockaddr_storage)) == SOCKET_ERROR) {
		closeThisSocket(sock);
		return INVALID_SOCKET;
	}*/
	
	return sock;
}

/** Sets the port of a struct sockaddr_storage. */
void setSockaddrStoragePort(struct sockaddr_storage *addr, int port) {
	if(addr->ss_family == PF_INET) {
		struct sockaddr_in *saddr = (struct sockaddr_in *)addr;
		saddr->sin_port = htons(port);

	} else if(addr->ss_family == PF_INET6) {
		struct sockaddr_in6 *saddr = (struct sockaddr_in6 *) addr;

		saddr->sin6_port = htons(port);
	}
}

/** Given a list of addresses (AddrInfo), it returns a SOCKET for the first one it is able to successfully connect to. The socket is returned
	as the return value from this function, and the the address of that socket is returned in sockAddrOut. 
	Note: If a connection cannot be made, INVALID_SOCKET is returned. */
static SOCKET getSocketFromAddrList(struct addrinfo *AddrInfo, struct addrinfo **sockAddrOut) {
	struct addrinfo *AI;
	SOCKET ConnSocket = INVALID_SOCKET;
	char AddrName[NI_MAXHOST];

	if(sockAddrOut != NULL) {
		*sockAddrOut = 0;
	}

	//
    // Try each address getaddrinfo returned, until we find one to which
    // we can successfully connect.
    //
    for (AI = AddrInfo; AI != NULL; AI = AI->ai_next) {

        // Open a socket with the correct address family for this address. (on error -1 is returned)
        ConnSocket = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol);

        if (ConnSocket == INVALID_SOCKET) {
            continue;
        }

        // printf("Attempting to connect to: %s\n", Server ? Server : "localhost");
		if (connect(ConnSocket, AI->ai_addr, (int)AI->ai_addrlen) != SOCKET_ERROR) {
			if(sockAddrOut != NULL) {
				*sockAddrOut = AI;
			}
            break;
		}
		
		if (getnameinfo(AI->ai_addr, (socklen_t)AI->ai_addrlen, AddrName, sizeof (AddrName), NULL, 0, NI_NUMERICHOST) != 0) {
		}

		closeThisSocket(ConnSocket);
		ConnSocket = INVALID_SOCKET;
    }

	return ConnSocket;
}

/** struct sockaddr_storage * => IP address in byte format (e.g. in_addr / in6_addr) + family 
    The bytes are stored in outAddr, and the family is stored in family.*/
void getByteFormatFromSockAddr(struct sockaddr_storage *addr, void ** outAddr, int *family) {
	
	if(addr->ss_family == PF_INET) {

		struct sockaddr_in * sin = (struct sockaddr_in *) addr;
		struct in_addr ia = sin->sin_addr;
		
		struct in_addr *result = (struct in_addr *)tptp_malloc(sizeof(struct in_addr));
		memcpy(result, &ia, sizeof(ia));
		
		*family = PF_INET;

		*outAddr = result;

	} else { // PF_INET6

		struct sockaddr_in6 * sin6 = (struct sockaddr_in6 *) addr;
		struct in6_addr ia = sin6->sin6_addr;
		struct in6_addr *result = (struct in6_addr *)tptp_malloc(sizeof(struct in6_addr));
		memset(result, 0, sizeof(struct in6_addr));

		memcpy(result, &ia, sizeof(struct in6_addr));
		*family = PF_INET6;

		*outAddr = result;
		
	}
}

/** Given the IP Address in byte format (e.g. in_addr/inaddr_6) and the family 
		=>		struct sockaddr_storage * (either sockaddr_in or sockaddr_in6)  */
void getSockAddrFromByteFormat(void *inAddr, int family, struct sockaddr_storage **outResult) {
	
	if(family == PF_INET) {
		struct in_addr * ia = (struct in_addr *)inAddr;
		struct sockaddr_in * result = (struct sockaddr_in *)tptp_malloc(sizeof(struct sockaddr_in));
		
		memcpy(&result->sin_addr, ia, sizeof(struct in_addr));
		result->sin_family = family;
		result->sin_port = htons(0);
		memset(result->sin_zero, 0, 8);

		*outResult = (struct sockaddr_storage*)result;
		
	} else { // PF_INET6

		struct in6_addr * ia = (struct in6_addr *)inAddr;
		struct sockaddr_in6 * result = (struct sockaddr_in6 *) tptp_malloc(sizeof(struct sockaddr_in6));

		memcpy(&result->sin6_addr, ia, sizeof(struct in6_addr));
		result->sin6_family = family;
		result->sin6_port = htons(0);
		result->sin6_flowinfo = 0; 
		result->sin6_scope_id = 0; 

		*outResult = (struct sockaddr_storage*)result;
	}
}

void initSocketAccept(socket_accept_t * sat) {
	tptp_list_init(&(sat->serverSocketList));
	tptp_list_init(&(sat->socketsToProcess));
	
	tptp_initializeLock(&sat->sockProcLock);

}

typedef struct {
	socket_accept_t * sat;
	SOCKET * serverSocket;

} listenOnSocket_parameters_t;

/** Used by acceptSocketConnections. Parameter is a listenOnSocket_parameters_t pointer. */
THREAD_USER_FUNC_RET_TYPE listenAcceptSocketConnections(LPVOID args) 
{
	SOCKET *serverSock;
	SOCKET clientSock;
	SOCKET *outClientSock;
	socket_accept_t * sat;
	struct sockaddr_storage clientAddress;
	size_t clientLen=sizeof(clientAddress);

	listenOnSocket_parameters_t *lpt;

	lpt = (listenOnSocket_parameters_t *) args;

	serverSock = lpt->serverSocket;
	sat = lpt->sat;

	while(1) {
		// Listen on the socket that we have been passed
		clientSock = accept(*serverSock, (struct sockaddr * ) & clientAddress, (int *)&clientLen);  
		
		if(clientSock == INVALID_SOCKET) {
   			TPTP_LOG_ERROR_MSG("An invalid socket was returned by an accept() call.") ;
	   		continue;
		}

		// Add the socket to the list of sockets

		tptp_getWriteLock(&(sat->sockProcLock));

		outClientSock = (SOCKET *) tptp_malloc(sizeof(SOCKET));
		*outClientSock = clientSock;
		
		tptp_list_add(&(sat->socketsToProcess), outClientSock);
		
		tptp_releaseWriteLock(&(sat->sockProcLock));
		
	}
	
	return 0;

}


/** 
Spawns threads to accept() on a list of given sockets, and returns the SOCKET from those threads.
*/
SOCKET acceptSocketConnections(SOCKET * sockets, int numSockets, socket_accept_t * sockAcceptState) {
	int i = 0;
	tptp_node_t * node;
	tptp_list_t * socketsMonitored = &(sockAcceptState->serverSocketList);
	SOCKET * s;
	SOCKET result;
	int matchFound = 0;
	TID threadID;
	HANDLE threadHandle;
	int socketsWaiting = 0;

	listenOnSocket_parameters_t *params;

    // Given the list of sockets, scan through and see if we are being asked to listen on any new ones
	for(i = 0; i < numSockets; i++) {
		s = &(sockets[i]);
		matchFound = 0;
		
		// Scan through the list of sockets that we're already monitoring: check if there are any new additions
		node = socketsMonitored->head;
		while(node != NULL) {
			if(node->data == s) {
				matchFound = 1;
				break;
			}
			node = node->next;
		}

		if(!matchFound) {
			tptp_list_add(socketsMonitored, s);
			params = (listenOnSocket_parameters_t*) tptp_malloc(sizeof(listenOnSocket_parameters_t));
			params->sat = sockAcceptState;
			params->serverSocket = s;

			tptpStartThread(listenAcceptSocketConnections, params, &threadID, &threadHandle) ;
		}
	}

	do {
		// Check if there are any client sockets waiting...
		tptp_getReadLock(&(sockAcceptState->sockProcLock));
		
		socketsWaiting = (sockAcceptState->socketsToProcess).count;
		
		tptp_releaseReadLock(&(sockAcceptState->sockProcLock));
		
		if(!socketsWaiting) {
			Sleep(10);
		}
		
	} while(!socketsWaiting); // While (there are no new sockets)

	tptp_getWriteLock(&(sockAcceptState->sockProcLock));

	// Get the value at the top of the list.
	node = sockAcceptState->socketsToProcess.head;

	result = *((SOCKET *)node->data);
	
	s = (SOCKET*)(node->data);
	tptp_list_remove(&(sockAcceptState->socketsToProcess), s); // This calls frees the malloced socket.

	tptp_releaseWriteLock(&(sockAcceptState->sockProcLock));

	return result;

}


/** A (binary) comparison of the contents of two addresses. 
Note, it does not compare the port value, or any of the other sockaddr_in/sockaddr_in6 fields, merely the address field.
Also note, if the family of the two addresses differs, then this function will return FALSE. If you're looking for a way to compare IPv4 and
IPv6 addresses together, try comparing their resolved hostnames. */
int compareAddresses(struct sockaddr_storage * one, struct sockaddr_storage * two) {
	struct sockaddr_in * a4;
	struct sockaddr_in * b4;

	struct sockaddr_in6 *a6;
	struct sockaddr_in6 *b6;
	int x = 0;

	unsigned char a;
	unsigned char b;

	if(one->ss_family != two->ss_family) return 0;

	if(one->ss_family == PF_INET) {
		a4 = (struct sockaddr_in *)one;
		b4 = (struct sockaddr_in *)two;

		if(sizeof(a4->sin_addr) != sizeof(b4->sin_addr)) return 0;

		for(x = 0; x < sizeof(a4->sin_addr); x++) {
			a = ((unsigned char*)&a4->sin_addr)[x];
			b = ((unsigned char*)&b4->sin_addr)[x];

			if(a != b) return 0;
		}

	} else if(one->ss_family == PF_INET6) {
		a6 = (struct sockaddr_in6 *)one;
		b6 = (struct sockaddr_in6 *)two;
		
		if(sizeof(a6->sin6_addr) != sizeof(b6->sin6_addr)) return 0; 
		
		for(x = 0; x < sizeof(a6->sin6_addr); x++) {
			a = ((unsigned char*)&a6->sin6_addr)[x];
			b = ((unsigned char*)&b6->sin6_addr)[x];

			if(a != b) return 0;
			
		}

	} else {
		return 0;
	}
    
	return 1;
}

/** sockaddr_storage -> "www.google.com" */
char * convertAddrToHostname(struct sockaddr_storage *addr) {
	char * hostname;
	hostname = (char *)tptp_malloc(sizeof(char) * 260);
	hostname[0] = 0;

	getnameinfo((struct sockaddr *)addr, sizeof(struct sockaddr_storage), hostname, 260, NULL, 0, 0);

	return hostname;

}

/** This method uses a number of tricks to determine whether or not the given address is local. */
int isAddrLocal(struct sockaddr_storage * addr) {
	int foundMatch = 0;
	int x = 0;
	struct sockaddr_storage ** addrList;
	int addrListSize = 0;
	
	char *hostName;
	char *localHostName = NULL;

	getLocalHostAddresses(&addrList, &addrListSize);
	for(x = 0; x < addrListSize; x++) {

		if(!foundMatch) {
			foundMatch = compareAddresses(addrList[x], addr);

			if(localHostName == NULL) {
				localHostName = convertAddrToHostname(addrList[x]);
			}
		}
	}

	// If we couldn't match using binary comparison, resolve both hostnames and compare those, also try standard localhost addrs
	if(!foundMatch) {

		hostName = convertAddrToHostname(addr);

		if(hostName != NULL && (strcmp(hostName, "::1") == 0 || strcmp(hostName, "127.0.0.1") == 0 || strcmp(hostName, "localhost") == 0)) {
			foundMatch = 1;
		}

		if(localHostName != NULL && hostName != NULL && strcmp(localHostName, hostName) == 0 ) {
			foundMatch = 1;
		}
		tptp_free(hostName);
	}
	
	freeAddressList(addrList, addrListSize);
	tptp_free(localHostName);
	
	return foundMatch;
}



/** Get localhost addresses in sockaddr_storage form. Note that sockaddr_storages received from this method use port
10002, and this will need to change if they are being listened on. */
void getLocalHostAddresses(struct sockaddr_storage *** arrOfAddr, int * numAddr) {
	int RetVal;
	char *Address = NULL;
	char *Port = "10002"; // One needs to specify a port, so I'm giving it this one.
	int i = 0, size = 0, x = 0, y = 0;
	struct sockaddr_storage ** addrs;
	int matchFound = 0;

	char hostname[260];

	struct sockaddr_storage ** resultArr = (struct sockaddr_storage **)tptp_malloc(sizeof(struct sockaddr_storage) * 64);

	struct addrinfo Hints, *AddrInfo = NULL, *AI;

    int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
    int SocketType = SOCK_STREAM;

	*numAddr = 0;

	memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
    Hints.ai_flags = AI_NUMERICHOST;

    RetVal = getaddrinfo(Address, Port, &Hints, &AddrInfo);
	
	if(RetVal != 0) return;

	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next) {
		resultArr[i] = cloneSockAddr((struct sockaddr_storage *)AI->ai_addr);
		
		i++;
	}

	freeaddrinfo(AddrInfo);

	// Grab the user's hostname
	if(gethostname(hostname, 260) == 0) {

		// Resolve it to a list of IP addresses
		convertHostnameToAddrs(hostname, &addrs, &size);

		// For each address...
		for(x = 0; x< size; x++) {
			matchFound = 0;

			// Verify that that address is not already in the list
			for(y = 0; y < i; y++) {
				if(compareAddresses(addrs[x], resultArr[y])) {
					matchFound = 1;
					break;
				}
			}

			// If it's not found, add it to the list
			if(!matchFound) {
				resultArr[i] = addrs[x];
				i++;
			} else {
				// Otherwise, that address is already in the list, so free it
				tptp_free(addrs[x]);
			}
		}
	}

	

	*numAddr = i;
	*arrOfAddr = resultArr;
}


/** Given a range of bytes, print their int value. */
void printChars(unsigned char *b, int l) {
	int x = 0;

	for(x = 0; x < l; x++) {
		printf("[%d]", (*b));
		b++;
	}
}

/** For debug purposes, prints the values of the fields of sockaddr_storage.*/
void printSockAddrStorage(struct sockaddr_storage *inAddr) {

	if(inAddr->ss_family == PF_INET) {
		struct sockaddr_in * ia = (struct sockaddr_in *)inAddr;
		
		printf("addr: "); 
		printChars((unsigned char*)&(ia->sin_addr), 4);
		printf("\r\n");

		printf("family: %d\r\n", ia->sin_family);
		printf("port: %d\r\n", ia->sin_port);
		printf("zero: %s\r\n", ia->sin_zero);
		

	} else { // PF_INET6

		struct sockaddr_in6 * ia = (struct sockaddr_in6 *)inAddr;

		printf("addr: "); 
		printChars((unsigned char*)&(ia->sin6_addr), 16);
		printf("\r\n");

		printf("family: %d\r\n", (int)ia->sin6_family);
		printf("flowinfo: %d\r\n", (int)ia->sin6_flowinfo);
		printf("port: %d\r\n", (int)ia->sin6_port);
		printf("scope_id: %d\r\n", (int)ia->sin6_scope_id);
		
	}

}




	return (isValid) ;
}

/* IPV4-ONLY */
long tptp_getLocalIPAddress() {
	char localhost[MAX_HOST_NAME_LENGTH];
	struct hostent *hpLocal;

	return result;
}

short tptp_getLocalIPAddressesIPv4M(tptp_IPAddresses_t *addr) {
	char localhost[MAX_HOST_NAME_LENGTH];
	struct hostent *hpLocal;
	int count, i;

	return 0;
}

int isLocalHostIPv4M(char* name) {
	tptp_IPAddresses_t localAddresses;
	struct hostent *he;
	unsigned char *addr, *cur;

	
	addr = he->h_addr_list[0];
	
	if(tptp_getLocalIPAddressesIPv4M(&localAddresses) != 0) return 0;
	
	res = 0;
	len = localAddresses.addressLength;

	return res;
}

/** IPV4-ONLY */
BOOL tptp_checkHost(network_list_t *list, unsigned char *address) {
	network_list_node_t *current;


			/* We need to continuously recheck the IP address of the local machine as this can change
			   on modern operating systems without a reboot
			*/
			if(tptp_getLocalIPAddressesIPv4M(&localAddresses)==0) {
				int len=localAddresses.addressLength;
				unsigned char *current;
				current=localAddresses.addresses;

					aliases++;
				}

				if (isLocalHostIPv4M(hostnameAllowed) && isLocalHostIPv4M(hostnameEntry)) {
					return entry->allow ? TRUE : FALSE;
				}
			}


	return FALSE;
}

BOOL tptp_checkHostIPv6(network_list_t *list, struct sockaddr_storage * addr) {
	network_list_node_t *current;
	int x = 0;
	unsigned char * ipaddr;
	int family = 0;
	int r = 0;

	//If the list or host address is not specified then return TRUE.
	//this means configuration is not specified.	
	if (list == NULL) {
		return TRUE;
	}

	if (addr == NULL) {
		return TRUE;
	}

	current = list->head;

	/* Look at the host list in order and find a matching rule */
	while(current) {
		network_t *entry=current->entry;
		/* Is this an allow rule */

		switch(entry->wildcard) {

		case TPTP_HW_ALL:
			if(entry->allow) {
				return TRUE;
			}
			return FALSE;
			break;
		case TPTP_HW_LOCAL:	

			if(isAddrLocal(addr)) {
				if(entry->allow) {
					return TRUE;
				}
				return FALSE;
			} 
			break;
		/* We are currently going to ignore UNKNOWN, and KNOWN posibilities */
		case TPTP_HW_UNKNOWN:
			break;
		case TPTP_HW_KNOWN:
			break;
		case TPTP_HW_MAX_VALUE:
			break;
		case TPTP_HW_NET:
			{
				getByteFormatFromSockAddr(addr, (void **)&ipaddr, &family);
				if(entry->netAndMaskAreIpv4 && addr->ss_family == PF_INET) {
					/* Check to see if the host is OK based upon net and mask.  If the mask and the remote address
					   and-ed together equal the net then it is a match */
					if((entry->mask[0] & ipaddr[0]) == entry->net[0]
						&& (entry->mask[1] & ipaddr[1]) == entry->net[1]
						&& (entry->mask[2] & ipaddr[2]) == entry->net[2]
						&& (entry->mask[3] & ipaddr[3]) == entry->net[3]) {
						if(entry->allow) {
							return TRUE;
						}
						return FALSE;
					}				
				} else if(!entry->netAndMaskAreIpv4 && addr->ss_family == PF_INET6){

					r = 1;
					for(x = 0; x < 16; x++) {
						if( (entry->maskipv6[x] & ipaddr[x]) == entry->netipv6[x]) {
							// No mismatch, this is good.
						} else {
							// We've found a mismatch. Set false and break.
							r = 0;
							break;
						}
					}
					if(r) {
						if(entry->allow) {
							return TRUE;
						}
						return FALSE;						
					}
				}
				
			}
			break;
		case TPTP_HW_NAMED:
			{
				char *hostname;

				struct sockaddr_storage ** addrs;
				int numAddrs = 0;
				int x = 0;

				// Convert the config host name to a list of addresses and compare them
				convertHostnameToAddrs(entry->hostname, &addrs, &numAddrs);
				for(x = 0; x < numAddrs; x++) {
					if(compareAddresses(addr, addrs[x])) {
						freeAddressList(addrs, numAddrs);
						
						if(entry->allow) {						
							return TRUE;
						}
						return FALSE;						
						
					}
				}
				freeAddressList(addrs, numAddrs);
				
				if(isAddrLocal(addr)) {
					return (entry->allow) ? TRUE : FALSE;					
				}
				
				hostname = convertAddrToHostname(addr);
				
				if(strcasecmp(hostname, entry->hostname) == 0) {
					tptp_free(hostname);
					return (entry->allow) ? TRUE : FALSE;					
				}
				
				tptp_free(hostname);

			}
			break;
		}
		current=current->next;
	}

	return FALSE;
}




	WSADATA  wsaData;
	int      rc = 0 ;

	wVersionRequested = MAKEWORD(2, 2);

	rc = WSAStartup(wVersionRequested, &wsaData);

	if (rc == 0) 
	{
		if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 2 ) 
		{
			WSACleanup();
			rc = -1 ;

 *
 * @return
 *    0 - always
 * IPV4-ONLY
 *********************************************************/
int printSocketRequest(SOCKET sock, struct sockaddr_in *pRequester)
{

 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressStringToArrayIPv4M( char *addrStr, unsigned char* addrArray )
{
	struct in_addr addr;
	

 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressUlongToStringIPv4M( unsigned long addr, char **addrStr )
{
	char* tempAddrStr;
	struct in_addr  saddr;

	return 0;
}

/** IPV4-ONLY */
void extractAddressFromSockAddr(struct sockaddr_in *connection, unsigned char *address)
{
	address[0]=connection->sin_addr.S_un.S_un_b.s_b1;




 *
 * @return
 *    0 - always
 * IPV4-ONLY
 *********************************************************/
int printSocketRequest(SOCKET sock, struct sockaddr_in *pRequester)
{

 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressStringToArrayIPv4M( char *addrStr, unsigned char* addrArray )
{
	struct in_addr addr;
	int            rc;

 *    0          success
 *    non-zero   failure
 *********************************************************/
int convertIPAddressUlongToStringIPv4M( unsigned long addr, char **addrStr )
{
	char* tempAddrStr;
	struct in_addr  saddr;

	return 0;
}

/** IPV4-ONLY */
void extractAddressFromSockAddr(struct sockaddr_in *connection, unsigned char *address)
{
	unsigned long tmpAddr;

Lines 20-25 Link Here

(-)src-native-new/src/shared/TPTPUtil/TPTPSemaphore.c (+44 lines)
20	#include <errno.h>	20	#include <errno.h>
21	#endif	21	#endif
22		22
		23	/*
		24	#ifndef _WIN32
		25	#include <semaphore.h>
		26	#include <time.h>
		27	#endif
		28	*/
23	/* Semaphore utilities */	29	/* Semaphore utilities */
24		30
25	/*	31	/*
Lines 114-116 Link Here
114		120
115	return 0;	121	return 0;
116	}	122	}
		123	/*
		124	int tptp_waitSemaphoreTimeout(Semaphore_t *pSem, int timeoutInSecs) {
		125	// Note this code is a placeholder that hasn't been tested.
		126	// Keep this in mind when using it. - jwest
		127	#ifdef _WIN32
		128	unsigned long rc;
		129	if (pSem->hSem == NULL)
		130	return -1;
		131
		132	rc = WaitForSingleObject(pSem->hSem, timeoutInSecs*1000);
		133	if(rc == WAIT_TIMEOUT) {
		134	return -2;
		135	} else
		136	if (rc != WAIT_OBJECT_0)
		137	return -1;
		138
		139	#else
		140	struct timespec waitTime;
		141	if (clock_gettime(CLOCK_REALTIME, &waitTime) == -1) {
		142	return -1;
		143	}
		144	waitTime.tv_sec += timeoutInSecs;
		145
		146	while (1) {
		147	int rc = sem_timedwait(&(pSem->sem), &waitTime);
		148	if (rc == 0) break;
		149
		150	if(errno == ETIMEDOUT) {
		151	return -2;
		152	}
		153	if (errno != EINTR) return -1;
		154	}
		155	#endif
		156
		157	return 0;
		158	}
		159	*/
		160




#define ELEMENT_TRANS_LYR_VARIABLE "TransportLayer"
#define ELEMENT_CONFIGURATION_VARIABLE "Configuration"


/** Converts an ASCII hex character to an int. */
int getcharhexval(char c) {
    if(c >= '0' && c <=  '9') {
         return c - '0';
    }

    if(c >= 'A' && c <= 'F') {
         return c - 'A' + 10;
    }    
    
    if(c >= 'a' && c <= 'f') {
         return c - 'a' + 10;         
    }
    
    return -1;
    
}

void parseStringIntoBlock(char *str, unsigned char *result) {
	unsigned int val = 0;

	val = getcharhexval(str[2])*16 + getcharhexval(str[3]);
	result[1] = (unsigned char)val;
	

	val = getcharhexval(str[0]) * 16 + getcharhexval(str[1]);
	result[0] = (unsigned char)val;

}

void parseIPv6IP(char *str, unsigned char *result) {
	
	char *nameTemp = 0;
	int i;
	
	nameTemp = (char *)tptp_malloc(strlen(str)+10);
	strcpy(nameTemp, str);
	
	if(strcmp(str, "::1") == 0) {
		for(int x = 0; x < 16; x++) {
			result[x] = 0;
		}
		result[15] = 1;
		
		return;
	}

	/* start at the back of the string and calculate the address*/
	for(i=14; i>0; i-=2) {
		char *current=strrchr(nameTemp, ':');
		if(current == NULL) {
			// The IP address is of an improper format, so bail.
			tptp_free(nameTemp);
			for(int x = 0; x < 16; x++) {
				result[x] = 0;
			}
			return;
		}
		// result[i]=(char)atoi(current+1);
		parseStringIntoBlock(current+1, &(result[i]));

		*current='\0';
	}
	parseStringIntoBlock(nameTemp, &(result[0]));
	// result[0]=atoi(nameTemp);

	tptp_free(nameTemp);
	
}

void tptp_addNetwork(network_list_t *list, int allow, tptp_host_wildcard_t wildcard, char *name, char *mask)
{
	char *nameTemp = NULL;


	/* set the type in the node */
	network->allow=allow;
	
	/* copy name to a temporary buffer */
	if (name != NULL) {
		nameTemp = (char *) tptp_malloc(strlen(name) +1);
		strcpy(nameTemp, name);
	}
	
	/* copy mask to a temporary buffer */
	if (mask != NULL) {
		maskTemp = (char *) tptp_malloc(strlen(mask) +1);


	/* If the wildcard in TPTP_HW_NAMED then we need to copy the address information */
	if(wildcard==TPTP_HW_NAMED) {
		network->hostname = (char *) tptp_malloc(strlen(nameTemp) +1);
		strcpy(network->hostname, nameTemp);
		   is effectively the same as a TPTP_HW_NET with a mask of 255.255.255.255
		*/
		if(isdigit((int)*nameTemp)) {
			maskTemp = (char*)tptp_malloc(sizeof(char) * 16); /* one extra char for null char */
			strcpy(maskTemp, "255.255.255.255");
			wildcard=TPTP_HW_NET;
		}
		else {
			network->hostname = (char *) tptp_malloc(strlen(nameTemp) +1);
			strcpy(network->hostname, nameTemp);
		}
	}

	/* If this is a network then we need to copy the IPv4 address information */
	if(wildcard==TPTP_HW_NET && strstr(name, ".") != NULL) {
		int i;

		/* start at the back of the string and calculate the address*/

			*current='\0';
		}
		network->mask[0]=atoi(maskTemp);
		
		network->netAndMaskAreIpv4 = 1;
	
	} // TPTP_HW_NET - IPv6 address
	else if(wildcard==TPTP_HW_NET && strstr(name, ":") != NULL) {

		parseIPv6IP(name, network->netipv6);
		parseIPv6IP(mask, network->maskipv6);
		
		network->netAndMaskAreIpv4 = 0;
	}

	if(nameTemp) tptp_free(nameTemp); nameTemp = NULL;

Lines 115-120 Link Here

(-)src-native-new/src/transport/socketTL/SocketListener.c (-14 / +42 lines)
115	int setSSL(request_block_ptr_t pBlk);	115	int setSSL(request_block_ptr_t pBlk);
116	int handleAUTHENTICATE(request_block_ptr_t pBlk, char *pMsg);	116	int handleAUTHENTICATE(request_block_ptr_t pBlk, char *pMsg);
117		117
		118	THREAD_USER_FUNC_RET_TYPE serveRequestThread(LPVOID args);
		119
		120	typedef struct {
		121	SOCKET serverSock;
		122	server_block_ptr_t pServerData;
		123	} serve_request_params_t;
		124
		125
118	/**	126	/**
119	*********************************************************	127	*********************************************************
120	*	128	*
Lines 658-663 Link Here
658	return ( pRequestDataBlock ) ;	666	return ( pRequestDataBlock ) ;
659	}	667	}
660		668
		669	THREAD_USER_FUNC_RET_TYPE serveRequestThread(LPVOID args) {
		670
		671	serve_request_params_t * params = (serve_request_params_t *)args;
		672	serveRequest(params->serverSock, params->pServerData);
		673
		674	return 0;
		675	}
		676
661		677
662	/**	678	/**
663	*********************************************************	679	*********************************************************
Lines 678-683 Link Here
678	TID threadId;	694	TID threadId;
679	HANDLE threadHandle ;	695	HANDLE threadHandle ;
680		696
		697	// struct sockaddr_storage *selfaddr;
		698
681	/* initial status before the thread is running */	699	/* initial status before the thread is running */
682	pServerData->threadStatus = RUNNING ;	700	pServerData->threadStatus = RUNNING ;
683	pServerData->serverSock = serverSock ;	701	pServerData->serverSock = serverSock ;
Lines 687-692 Link Here
687	{	705	{
688	clientSock = acceptSocketConnection(serverSock);	706	clientSock = acceptSocketConnection(serverSock);
689		707
		708	// selfaddr = getSelfAddrOfSocket(clientSock);
		709
690	if (isSocketValid(clientSock) == 0)	710	if (isSocketValid(clientSock) == 0)
691	{	711	{
692	TPTP_LOG_ERROR_MSG(pServerData, "Accept() receives invalid socket request. ") ;	712	TPTP_LOG_ERROR_MSG(pServerData, "Accept() receives invalid socket request. ") ;
Lines 761-789 Link Here
761	THREAD_USER_FUNC_RET_TYPE doListening(LPVOID args)	781	THREAD_USER_FUNC_RET_TYPE doListening(LPVOID args)
762	{	782	{
763	int rc = 0;	783	int rc = 0;
764	SOCKET serverSock ;	784	SOCKET serverSockets[FD_SETSIZE];
		785	int socketNum = 0;
		786	int i;
		787	unsigned long pthreadId;
		788	HANDLE pthreadHandle;
765		789
766	struct sockaddr_in myServerSockAddr ;	790	serve_request_params_t * params;
767		791
768	server_block_ptr_t pParam = (server_block_ptr_t) args ;	792	server_block_ptr_t pParam = (server_block_ptr_t) args ;
769		793
770	/* create and initialize the server socket */	794	/* create and initialize the server socket */
771	serverSock = getTheSocket(pParam->port, &myServerSockAddr) ;	795	rc = getTheSocket(pParam->port, serverSockets, &socketNum) ;
772		796
773	if (serverSock < 0)	797	if (socketNum == 0)
774	{	798	{
775	TPTP_LOG_ERROR_MSG(pParam, "Error: unable to create the server socket.") ;	799	TPTP_LOG_ERROR_MSG(pParam, "Error: unable to create the server socket.") ;
776	}	800	}
777		801
778	else
779	rc = bindAndListen(serverSock, (struct sockaddr*)&myServerSockAddr) ;
780
781
782	/* ready to accept incoming connection requests */	802	/* ready to accept incoming connection requests */
783	if (rc == 0)	803	if (socketNum != 0 && rc == 0)
784	{	804	{
785	TPTP_LOG_DEBUG_MSG1(pParam, "Socket server is running at port number of %d.", pParam->port) ;	805	TPTP_LOG_DEBUG_MSG1(pParam, "Socket server is running at port number of %d.", pParam->port) ;
786	serveRequest(serverSock, pParam) ;	806	for (i=0; i < socketNum; ++i) {
		807
		808	params = (serve_request_params_t *)tptp_malloc(sizeof(serve_request_params_t));
		809	params->pServerData = pParam;
		810	params->serverSock = serverSockets[i];
		811
		812	tptpStartThread(serveRequestThread, params, &pthreadId, &pthreadHandle);
		813
		814	}
787	}	815	}
788		816
789	return ( 0 );	817	return ( 0 );
Lines 1111-1117 Link Here
1111	/* NOTE: This has problems if there are multiple IP addresses, but in	1139	/* NOTE: This has problems if there are multiple IP addresses, but in
1112	the case of compatibility mode, this isn't really used anyway */	1140	the case of compatibility mode, this isn't really used anyway */
1113		1141
1114	if (getSocketIPString( (SOCKET)NULL, &ipAddrStr) < 0) {	1142	if (getSocketIPStringIPv4M( (SOCKET)NULL, &ipAddrStr) < 0) {
1115	TPTP_LOG_ERROR_MSG(pServerData, "Unable to get local IP address");	1143	TPTP_LOG_ERROR_MSG(pServerData, "Unable to get local IP address");
1116	return -1;	1144	return -1;
1117	}	1145	}
Lines 1169-1175 Link Here
1169	TPTP_LOG_ERROR_MSG1( pServerData, "Unable to find host in connection info: %s", sourceConnectionInfo );	1197	TPTP_LOG_ERROR_MSG1( pServerData, "Unable to find host in connection info: %s", sourceConnectionInfo );
1170	return rc;	1198	return rc;
1171	}	1199	}
1172	rc = convertIPAddressStringToUlong( ipAddrStr, &ipAddr );	1200	rc = convertIPAddressStringToUlongIPv4M( ipAddrStr, &ipAddr );
1173	if ( rc != 0 )	1201	if ( rc != 0 )
1174	{	1202	{
1175	TPTP_LOG_ERROR_MSG1( pServerData, "Unable to convert IP address string to unsigned long: %s", ipAddrStr );	1203	TPTP_LOG_ERROR_MSG1( pServerData, "Unable to convert IP address string to unsigned long: %s", ipAddrStr );
Lines 1180-1186 Link Here
1180	/* TODO: Check to see if this is local */	1208	/* TODO: Check to see if this is local */
1181		1209
1182	/* Connect to the remote AC */	1210	/* Connect to the remote AC */
1183	rc = connectToTCPServer( ipAddr, (unsigned short)port, &sock);	1211	rc = connectToTCPServerIPv4M( ipAddr, (unsigned short)port, &sock);
1184	if ( rc != 0 )	1212	if ( rc != 0 )
1185	{	1213	{
1186	TPTP_LOG_ERROR_MSG2( pServerData, "Unable to connect to peer: %s, port %d", ipAddrStr, port );	1214	TPTP_LOG_ERROR_MSG2( pServerData, "Unable to connect to peer: %s, port %d", ipAddrStr, port );




	if ( formattedLocalIPAddress[0] == '\0' ) 
	{
		char hostname[CBE_HOSTNAME_SIZE+1];
		struct hostent *host;

		// TODO: Make WSAStartup call on Windows
	
		if ( gethostname(hostname, CBE_HOSTNAME_SIZE) == 0 ) 
		{
			sprintf(formattedLocalIPAddress, "%s", hostname);
			if(host == NULL) 
			{
				sprintf(formattedLocalIPAddress, "%s", hostname);
			}
			else 
			{
				sprintf(formattedLocalIPAddress, "%s", host->h_name);
			}
		}
		else 
		{
			sprintf(formattedLocalIPAddress, "localhost");
		}
	}


Lines 35-41 Link Here

(-)src-native-new/src/shared/TPTPLogUtils/TPTPLogUtils.cpp (-1 / +1 lines)
35	{	35	{
36	WSADATA wsaData;	36	WSADATA wsaData;
37		37
38	WSAStartup( MAKEWORD(1, 1), &wsaData);	38	WSAStartup( MAKEWORD(2, 2), &wsaData);
39	}	39	}
40	break;	40	break;
41		41








/**
 *********************************************************
 *                                                       
 * @brief                                                
 *    Given a hostname, get the current host IP address. An array of sockaddr_storages are stored in outResult, and the size
 *	  of that array is stored in outNumResults.
 * @return
 *    the IP address number
 *
 *********************************************************/
/*
void TCPDataServer::getIPAddresses(char *hostname, struct sockaddr_storage *** outResult, int *outNumResults) {
	int RetVal;
	int i;

	struct addrinfo Hints, *AddrInfo, *AI;

    int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
    int SocketType = SOCK_STREAM; // TCP only

	struct sockaddr_storage ** result;

	int    rc = 0 ;

	rc = initForSocketCalls();
	if(rc != 0) {
		*outNumResults = 0;
	}
	
	result = (struct sockaddr_storage **)tptp_malloc(sizeof(struct sockaddr_storage *) * 128);
	
	memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
	
	// This was originally in the code, but it prevents lookups of host names, e.g. www.google.com. It only works with numeric hosts.
    // Hints.ai_flags = AI_NUMERICHOST;  

    RetVal = getaddrinfo(hostname, NULL, &Hints, &AddrInfo);

	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next, i++) {
		result[i] = cloneSockAddr((struct sockaddr_storage *)AI->ai_addr);
	}
	freeaddrinfo(AddrInfo);

	*outResult = result;
	*outNumResults = i;

	return RetVal;
}*/


/**
 *********************************************************
 *                                                       

 *    the IP address number
 *
 *********************************************************/
/*
unsigned long TCPDataServer::getLocalIPAddress() {
	struct hostent *hpLocal = NULL;
	unsigned long   result = 0 ;

	rc = initForSocketCalls() ;
	if (rc == 0)
	{
		hpLocal = getHostInfoIPv4M() ;

		if (hpLocal != NULL)
			memcpy(&result, hpLocal->h_addr_list[0], sizeof(long));


	return result;
}
*/

#define MAX_HOST_NAME_LENGTH	128

void TCPDataServer::connect()
{

	char buffer[1024] ;
	int  bufferLength = 1024 ;
	int  bytesRead = 0 ;
	
	char hostname[MAX_HOST_NAME_LENGTH];
	
	// Get the local host informantion 
	if (gethostname(hostname,MAX_HOST_NAME_LENGTH) < 0) {
		TPTP_LOG_DEBUG_MSG("Error: Unable to resolve local host name.");
		return;
	}

	/* go make connection */
	rc = connectToTCPServer(hostname, _port, &_sock) ;

	if (rc != 0)
	{

Lines 72-78 Link Here

(-)src-native-new/src/client/ConnectionImpl.h (-1 / +2 lines)
72		72
73	void init();	73	void init();
74	unsigned long getLocalIPAddress();	74	unsigned long getLocalIPAddress();
75	unsigned long getIPAddress(char* hostname);	75	void getIPAddresses(char hostname, struct sockaddr_storage ** outResult, int *outNumResults);
		76	unsigned long getIPAddressIPv4(char* hostname);
76	int sendControlCommand(SOCKET sockconn, int commandflags);	77	int sendControlCommand(SOCKET sockconn, int commandflags);
77	int sendCONNECT_DATACommand(SOCKET datasock, int direction, int commandflags);	78	int sendCONNECT_DATACommand(SOCKET datasock, int direction, int commandflags);
78	int processControlMessage(char buffer[], int length);	79	int processControlMessage(char buffer[], int length);

Lines 32-38 Link Here

(-)src-native-new/src/client/ConnectionImpl.cpp (-11 / +61 lines)
32	using namespace std;	32	using namespace std;
33	using namespace TPTP::Client;	33	using namespace TPTP::Client;
34		34
35		35	#ifdef _WIN32
		36	#include <Ws2tcpip.h>
		37	#endif
36		38
37	ConnectionImpl::ConnectionImpl()	39	ConnectionImpl::ConnectionImpl()
38	{	40	{
Lines 219-226 Link Here
219	* @return	221	* @return
220	* the IP address number	222	* the IP address number
221	*	223	*
		224	* IPV4-ONLY
222	*********************************************************/	225	*********************************************************/
223
224	unsigned long ConnectionImpl::getLocalIPAddress() {	226	unsigned long ConnectionImpl::getLocalIPAddress() {
225	struct hostent *hpLocal = NULL;	227	struct hostent *hpLocal = NULL;
226	unsigned long result = 0 ;	228	unsigned long result = 0 ;
Lines 229-235 Link Here
229	rc = initForSocketCalls() ;	231	rc = initForSocketCalls() ;
230	if (rc == 0)	232	if (rc == 0)
231	{	233	{
232	hpLocal = getHostInfo() ;	234	hpLocal = getHostInfoIPv4M() ; // TODO replace with portable impl
233		235
234	if (hpLocal != NULL)	236	if (hpLocal != NULL)
235	memcpy(&result, hpLocal->h_addr_list[0], sizeof(long));	237	memcpy(&result, hpLocal->h_addr_list[0], sizeof(long));
Lines 245-258 Link Here
245	*********************************************************	247	*********************************************************
246	*	248	*
247	* @brief	249	* @brief
248	* get the current host IP address	250	* Given a hostname, get the current host IP address. An array of sockaddr_storages are stored in outResult, and the size
249	*	251	* of that array is stored in outNumResults.
250	* @return	252	* @return
251	* the IP address number	253	* the IP address number
252	*	254	*
253	*********************************************************/	255	*********************************************************/
		256	void ConnectionImpl::getIPAddresses(char hostname, struct sockaddr_storage ** outResult, int *outNumResults) {
		257	int RetVal;
		258	int i;
		259
		260	struct addrinfo Hints, AddrInfo, AI;
		261
		262	int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
		263	int SocketType = SOCK_STREAM; // TCP only
		264
		265	struct sockaddr_storage ** result;
		266
		267	int rc = 0 ;
		268
		269	rc = initForSocketCalls();
		270	if(rc != 0) {
		271	*outNumResults = 0;
		272	}
		273
		274	result = (struct sockaddr_storage *)tptp_malloc(sizeof(struct sockaddr_storage ) * 128);
		275
		276	memset(&Hints, 0, sizeof (Hints));
		277	Hints.ai_family = Family;
		278	Hints.ai_socktype = SocketType;
		279
		280	// This was originally in the code, but it prevents lookups of host names, e.g. www.google.com. It only works with numeric hosts.
		281	// Hints.ai_flags = AI_NUMERICHOST;
		282
		283	RetVal = getaddrinfo(hostname, NULL, &Hints, &AddrInfo);
254		284
255	unsigned long ConnectionImpl::getIPAddress(char* hostname) {	285	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next, i++) {
		286	result[i] = cloneSockAddr((struct sockaddr_storage *)AI->ai_addr);
		287	}
		288	freeaddrinfo(AddrInfo);
		289
		290	if(i == 0) {
		291	tptp_free(result);
		292	result = NULL;
		293	}
		294
		295	*outResult = result;
		296	*outNumResults = i;
		297
		298	}
		299
		300
		301
		302
		303
		304	unsigned long ConnectionImpl::getIPAddressIPv4(char* hostname) {
256	struct hostent *hpHost = NULL;	305	struct hostent *hpHost = NULL;
257	unsigned long result = 0 ;	306	unsigned long result = 0 ;
258	int rc = 0 ;	307	int rc = 0 ;
Lines 260-266 Link Here
260	rc = initForSocketCalls() ;	309	rc = initForSocketCalls() ;
261	if (rc == 0)	310	if (rc == 0)
262	{	311	{
263	hpHost = getTargetHostInfo(hostname) ;	312	hpHost = getTargetHostInfoIPv4M(hostname) ;
264		313
265	if (hpHost != NULL)	314	if (hpHost != NULL)
266	memcpy(&result, hpHost->h_addr_list[0], sizeof(long));	315	memcpy(&result, hpHost->h_addr_list[0], sizeof(long));
Lines 270-276 Link Here
270	}	319	}
271		320
272		321
273
274	int ConnectionImpl::connect(INode* node, int port)	322	int ConnectionImpl::connect(INode* node, int port)
275	{	323	{
276	int rc = 0;	324	int rc = 0;
Lines 279-285 Link Here
279	_port = port;	327	_port = port;
280	/* go make connection */	328	/* go make connection */
281	init();	329	init();
282	rc = connectToTCPServer(getIPAddress(_node->getName()), port, &sock) ;	330
		331
		332	rc = connectToTCPServer(_node->getName(), port, &sock) ;
283		333
284	if (rc != 0)	334	if (rc != 0)
285	{	335	{
Lines 307-313 Link Here
307	_port = connInfo->getPortNum();	357	_port = connInfo->getPortNum();
308	/* go make connection */	358	/* go make connection */
309	init();	359	init();
310	rc = connectToTCPServer(getIPAddress(connInfo->getHostName()), _port, &sock) ;	360	rc = connectToTCPServer(connInfo->getHostName(), _port, &sock) ;
311		361
312	if (rc != 0)	362	if (rc != 0)
313	{	363	{
Lines 513-519 Link Here
513	SOCKET datasock = 0;	563	SOCKET datasock = 0;
514	int dataConnectionId;	564	int dataConnectionId;
515		565
516	rc = connectToTCPServer(getIPAddress(this->_node->getName()), _port, &datasock) ;	566	rc = connectToTCPServer(this->_node->getName(), _port, &datasock) ;
517		567
518	if (rc != 0)	568	if (rc != 0)
519	{	569	{

Lines 21-26 Link Here

(-)src-native-new/src/client/TPTP_INetAddress.cpp (-1 / +2 lines)
21		21
22	#ifdef _WIN32	22	#ifdef _WIN32
23		23
		24	/* IPV4-ONLY */
24	int TPTP_INetAddress::getAddress(char* hostname,char** inetaddr)	25	int TPTP_INetAddress::getAddress(char* hostname,char** inetaddr)
25	{	26	{
26	hostent* remote_hostname;	27	hostent* remote_hostname;
Lines 28-34 Link Here
28	WSAData wsaData;	29	WSAData wsaData;
29	WSACleanup();	30	WSACleanup();
30		31
31	if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)	32	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
32	{	33	{
33	return -1;	34	return -1;
34	}	35	}

Return to bug 165409

Lines 1685-1690 Link Here

(-)src-native-new/src/shared/TPTPUtil/TPTPUtil.cpp (-16 / +87 lines)
1685	#define ELEMENT_TRANS_LYR_VARIABLE "TransportLayer"	1685	#define ELEMENT_TRANS_LYR_VARIABLE "TransportLayer"
1686	#define ELEMENT_CONFIGURATION_VARIABLE "Configuration"	1686	#define ELEMENT_CONFIGURATION_VARIABLE "Configuration"
1687		1687
		1688
		1689	/** Converts an ASCII hex character to an int. */
		1690	int getcharhexval(char c) {
		1691	if(c >= '0' && c <= '9') {
		1692	return c - '0';
		1693	}
		1694
		1695	if(c >= 'A' && c <= 'F') {
		1696	return c - 'A' + 10;
		1697	}
		1698
		1699	if(c >= 'a' && c <= 'f') {
		1700	return c - 'a' + 10;
		1701	}
		1702
		1703	return -1;
		1704
		1705	}
		1706
		1707	void parseStringIntoBlock(char str, unsigned char result) {
		1708	unsigned int val = 0;
		1709
		1710	val = getcharhexval(str[2])*16 + getcharhexval(str[3]);
		1711	result[1] = (unsigned char)val;
		1712
		1713
		1714	val = getcharhexval(str[0]) * 16 + getcharhexval(str[1]);
		1715	result[0] = (unsigned char)val;
		1716
		1717	}
		1718
		1719	void parseIPv6IP(char str, unsigned char result) {
		1720
		1721	char *nameTemp = 0;
		1722	int i;
		1723
		1724	nameTemp = (char *)tptp_malloc(strlen(str)+10);
		1725	strcpy(nameTemp, str);
		1726
		1727	if(strcmp(str, "::1") == 0) {
		1728	for(int x = 0; x < 16; x++) {
		1729	result[x] = 0;
		1730	}
		1731	result[15] = 1;
		1732
		1733	return;
		1734	}
		1735
		1736	/* start at the back of the string and calculate the address*/
		1737	for(i=14; i>0; i-=2) {
		1738	char *current=strrchr(nameTemp, ':');
		1739	if(current == NULL) {
		1740	// The IP address is of an improper format, so bail.
		1741	tptp_free(nameTemp);
		1742	for(int x = 0; x < 16; x++) {
		1743	result[x] = 0;
		1744	}
		1745	return;
		1746	}
		1747	// result[i]=(char)atoi(current+1);
		1748	parseStringIntoBlock(current+1, &(result[i]));
		1749
		1750	*current='\0';
		1751	}
1752	parseStringIntoBlock(nameTemp, &(result[0]));
1753	// result[0]=atoi(nameTemp);
1754
1755	tptp_free(nameTemp);
1756
1757	}
1758
1688	void tptp_addNetwork(network_list_t list, int allow, tptp_host_wildcard_t wildcard, char name, char *mask)	1759	void tptp_addNetwork(network_list_t list, int allow, tptp_host_wildcard_t wildcard, char name, char *mask)
1689	{	1760	{
1690	char *nameTemp = NULL;	1761	char *nameTemp = NULL;
Lines 1699-1710 Link Here
1699		1770
1700	/* set the type in the node */	1771	/* set the type in the node */
1701	network->allow=allow;	1772	network->allow=allow;
1702		1773
1703	/* copy name to a temporary buffer */	1774	/* copy name to a temporary buffer */
1704	if (name != NULL) {	1775	if (name != NULL) {
1705	nameTemp = (char *) tptp_malloc(strlen(name) +1);	1776	nameTemp = (char *) tptp_malloc(strlen(name) +1);
1706	strcpy(nameTemp, name);	1777	strcpy(nameTemp, name);
1707	}	1778	}
		1779
1708	/* copy mask to a temporary buffer */	1780	/* copy mask to a temporary buffer */
1709	if (mask != NULL) {	1781	if (mask != NULL) {
1710	maskTemp = (char *) tptp_malloc(strlen(mask) +1);	1782	maskTemp = (char *) tptp_malloc(strlen(mask) +1);
Lines 1713-1735 Link Here
1713		1785
1714	/* If the wildcard in TPTP_HW_NAMED then we need to copy the address information */	1786	/* If the wildcard in TPTP_HW_NAMED then we need to copy the address information */
1715	if(wildcard==TPTP_HW_NAMED) {	1787	if(wildcard==TPTP_HW_NAMED) {
1716		1788	network->hostname = (char *) tptp_malloc(strlen(nameTemp) +1);
1717	/* If the first character is a digit then we have a numeric address. This	1789	strcpy(network->hostname, nameTemp);
1718	is effectively the same as a TPTP_HW_NET with a mask of 255.255.255.255
1719	*/
1720	if(isdigit((int)*nameTemp)) {
1721	maskTemp = (char)tptp_malloc(sizeof(char) 16); /* one extra char for null char */
1722	strcpy(maskTemp, "255.255.255.255");
1723	wildcard=TPTP_HW_NET;
1724	}
1725	else {
1726	network->hostname = (char *) tptp_malloc(strlen(nameTemp) +1);
1727	strcpy(network->hostname, nameTemp);
1728	}
1729	}	1790	}
1730		1791
1731	/* If this is a network then we need to copy the address information */	1792	/* If this is a network then we need to copy the IPv4 address information */
1732	if(wildcard==TPTP_HW_NET) {	1793	if(wildcard==TPTP_HW_NET && strstr(name, ".") != NULL) {
1733	int i;	1794	int i;
1734		1795
1735	/* start at the back of the string and calculate the address*/	1796	/* start at the back of the string and calculate the address*/
Lines 1746-1751 Link Here
1746	*current='\0';	1807	*current='\0';
1747	}	1808	}
1748	network->mask[0]=atoi(maskTemp);	1809	network->mask[0]=atoi(maskTemp);
		1810
		1811	network->netAndMaskAreIpv4 = 1;
		1812
		1813	} // TPTP_HW_NET - IPv6 address
		1814	else if(wildcard==TPTP_HW_NET && strstr(name, ":") != NULL) {
		1815
		1816	parseIPv6IP(name, network->netipv6);
		1817	parseIPv6IP(mask, network->maskipv6);
		1818
		1819	network->netAndMaskAreIpv4 = 0;
1749	}	1820	}
1750		1821
1751	if(nameTemp) tptp_free(nameTemp); nameTemp = NULL;	1822	if(nameTemp) tptp_free(nameTemp); nameTemp = NULL;

Lines 252-270 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/nativeFileServer.c (-20 / +24 lines)
252	int d, rc;	252	int d, rc;
253	SOCKET testSocket;	253	SOCKET testSocket;
254	unsigned long ipAddr;	254	unsigned long ipAddr;
255		255	struct addrinfo *AI = NULL;
		256
256	host = readStringIntoBuffer(con);	257	host = readStringIntoBuffer(con);
257	if (host == NULL) return -1;	258	if (host == NULL) return -1;
258		259
259	readInt (con->socket, &port);	260	readInt (con->socket, &port);
260		261
		262	testSocket = connectToHostWithHostname(host, port, &AI);
		263
261	d = 0;	264	d = 0;
262	rc = convertIPAddressStringToUlong(host, &ipAddr); // reverse call	265
263	if (rc == 0) {	266	if(testSocket != INVALID_SOCKET) {
264	if (!connectToTCPServer(ipAddr, (unsigned short) port, &testSocket)) {	267	d = 1;
265	d = 1;	268	closeSocket(testSocket);
266	closeSocket(testSocket);
267	}
268	}	269	}
269		270
270	writeByte(con->socket, d); // "server is reachable" responce	271	writeByte(con->socket, d); // "server is reachable" responce
Lines 502-534 Link Here
502		503
503	static SOCKET serverSocket;	504	static SOCKET serverSocket;
504		505
		506	static SOCKET * serverSockets;
		507	static int numServerSockets;
		508	static socket_accept_t socketAccept;
		509
505	THREAD_USER_FUNC_RET_TYPE startNativeFileServer(LPVOID args){	510	THREAD_USER_FUNC_RET_TYPE startNativeFileServer(LPVOID args){
506	int rc, port;	511	int rc, port;
507	struct sockaddr_in fsSockAddr;
508	SOCKET clientSock;	512	SOCKET clientSock;
509	fs_connection_block_t* con;	513	fs_connection_block_t* con;
510	tl_state_data_t* stateData;	514	tl_state_data_t* stateData;
511	TID threadId;	515	TID threadId;
512	HANDLE threadHandle;	516	HANDLE threadHandle;
		517
		518	serverSockets = (SOCKET ) tptp_malloc(sizeof(SOCKET) FD_SETSIZE);
		519
		520	initSocketAccept(&socketAccept);
513		521
514	stateData = (tl_state_data_t*) args;	522	stateData = (tl_state_data_t*) args;
515	port = ((cctl_state_data_t*)stateData->implData)->filePort;	523	port = ((cctl_state_data_t*)stateData->implData)->filePort;
516	if (port <= 0) port = RA_FILE_PORT_NUM_SERVER;	524	if (port <= 0) port = RA_FILE_PORT_NUM_SERVER;
517		525
518	serverSocket = getTheSocket(port, &fsSockAddr);	526	rc = getTheSocket(port, serverSockets, &numServerSockets);
519	if (serverSocket < 0) {
520	TPTP_LOG_ERROR_MSG(stateData, "NFS: unable to create the file server socket.");
521	return 0;
522	}
523		527
524	rc = bindAndListen(serverSocket, (struct sockaddr*)&fsSockAddr);	528	//serverSocket = getTheSocket(port, &fsSockAddr);
525	if (rc != 0) {	529	if (rc < 0 \|\| numServerSockets == 0) {
526	TPTP_LOG_ERROR_MSG(stateData, "NFS: cannot bind to server socket");	530	TPTP_LOG_ERROR_MSG(stateData, "NFS: unable to create the file server socket.");
527	return 0;	531	return 0;
528	}	532	}
529		533
530	while(1) {	534	while(1) {
531	clientSock = acceptSocketConnection(serverSocket);	535	clientSock = acceptSocketConnections(serverSockets, numServerSockets, &socketAccept);
532	if (clientSock < 0) break;	536	if (clientSock < 0) break;
533		537
534	con = (fs_connection_block_t*) tptp_malloc(sizeof(fs_connection_block_t));	538	con = (fs_connection_block_t*) tptp_malloc(sizeof(fs_connection_block_t));

Lines 185-192 Link Here

(-)src-native-new/src/transport/TPTPClientCompTL/RACmdHandlers.c (-11 / +7 lines)
185	PID real_pid;	185	PID real_pid;
186	ra_array_t finalEnvironment;	186	ra_array_t finalEnvironment;
187		187
188	tptp_int32 buffer;
189	int bufferLen=6;
190	SOCKET consoleSock; /* 9707 */	188	SOCKET consoleSock; /* 9707 */
191	ra_string_t uuid;	189	ra_string_t uuid;
192		190
Lines 203-221 Link Here
203	* In addition to launching the process, we need to look for any agents that	201	* In addition to launching the process, we need to look for any agents that
204	* the client expects to be associated with this process and attach to them	202	* the client expects to be associated with this process and attach to them
205	*/	203	*/
206		204
207	getClientIP(ccb, (unsigned char*)&buffer, &bufferLen);
208
209	//ra_logServiceMessage(__FILE__, __LINE__, RA_DEBUG, "Console publish 0x%x, desired 0x%x socket=%d", command->info.launch_process.consoleIP, buffer, client->connection->handle.socket);	205	//ra_logServiceMessage(__FILE__, __LINE__, RA_DEBUG, "Console publish 0x%x, desired 0x%x socket=%d", command->info.launch_process.consoleIP, buffer, client->connection->handle.socket);
210		206
211	real_pid=0;	207	real_pid=0;
212		208
213	/* Launch Process */	209	/* Launch Process */
214	real_pid=startProcess(ccb, &command->info.launch_process.executable,	210	real_pid=startProcess(ccb, &command->info.launch_process.executable,
215	&command->info.launch_process.arguments,	211	&command->info.launch_process.arguments,
216	&command->info.launch_process.location,	212	&command->info.launch_process.location,
217	&command->info.launch_process.environment,	213	&command->info.launch_process.environment,
218	buffer,	214	0 /* This value isn't used. */,
219	(unsigned short)command->info.launch_process.consolePort,	215	(unsigned short)command->info.launch_process.consolePort,
220	&finalEnvironment,	216	&finalEnvironment,
221	&consoleSock,	217	&consoleSock,
Lines 739-746 Link Here
739	tptp_int32 rc = -1;	735	tptp_int32 rc = -1;
740	tptp_int32 flags;	736	tptp_int32 flags;
741	tptp_int32 dataConnectionID;	737	tptp_int32 dataConnectionID;
742	tptp_int32 clientIP;	738	struct sockaddr_storage * addr;
743	tptp_int32 clientIPLen;
744	client_data_connection_block_t *dcb;	739	client_data_connection_block_t *dcb;
745	SOCKET dataSock;	740	SOCKET dataSock;
746		741
Lines 796-804 Link Here
796	flags = TPTP_DATA_PATH_RECEIVE \| TPTP_DATA_PATH_DIRECT_SOCKET;	791	flags = TPTP_DATA_PATH_RECEIVE \| TPTP_DATA_PATH_DIRECT_SOCKET;
797		792
798	if (agent->IPCBufCreated == FALSE) {	793	if (agent->IPCBufCreated == FALSE) {
799	getClientIP(ccb, (unsigned char*)&clientIP, &clientIPLen);
800	dataSock = openClientDataSocket(clientIP, command->info.start_monitor_remote.port);
801		794
		795	getClientIPAddr(ccb, &addr);
		796	dataSock = openClientDataSocketAddr(addr, command->info.start_monitor_remote.port);
		797
802	if (dataSock == -1) {	798	if (dataSock == -1) {
803	sendErrorMessage("RAC009",	799	sendErrorMessage("RAC009",
804	"Start Monitoring failed due to data channel socket connection failure.",	800	"Start Monitoring failed due to data channel socket connection failure.",

Lines 40-46 Link Here

(-)src-native-new/include/tptp/TransportSupportSocket.h (-13 / +68 lines)
40	* non-zero failure code	40	* non-zero failure code
41	*	41	*
42	*********************************************************/	42	*********************************************************/
43	int convertIPAddressStringToArray( char addrStr, unsigned char addrArray );	43	int convertIPAddressStringToArrayIPv4M( char addrStr, unsigned char addrArray );
44		44
45	/**	45	/**
46	*********************************************************	46	*********************************************************
Lines 54-60 Link Here
54	* non-zero failure code	54	* non-zero failure code
55	*	55	*
56	*********************************************************/	56	*********************************************************/
57	int convertIPAddressStringToUlong( char addrStr, unsigned long addr );	57	int convertIPAddressStringToUlongIPv4M( char addrStr, unsigned long addr );
58		58
59	/**	59	/**
60	*********************************************************	60	*********************************************************
Lines 69-75 Link Here
69	* 0 success	69	* 0 success
70	* non-zero failure	70	* non-zero failure
71	*********************************************************/	71	*********************************************************/
72	int convertIPAddressUlongToString( unsigned long addr, char **addrStr );	72	int convertIPAddressUlongToStringIPv4M( unsigned long addr, char **addrStr );
73		73
74	/**	74	/**
75	*********************************************************	75	*********************************************************
Lines 88-94 Link Here
88	* non-zero failure code	88	* non-zero failure code
89	*	89	*
90	*********************************************************/	90	*********************************************************/
91	int getSocketIPString( SOCKET sock, char** ipAddrStr );	91	int getSocketIPStringIPv4M( SOCKET sock, char** ipAddrStr );
92		92
93	/**	93	/**
94	*********************************************************	94	*********************************************************
Lines 118-124 Link Here
118	* @return	118	* @return
119	* host info data structure	119	* host info data structure
120	*********************************************************/	120	*********************************************************/
121	struct hostent * getHostInfo() ;	121	struct sockaddr_storage* getHostInfo();
		122
		123	struct hostent * getHostInfoIPv4M();
122		124
123	/**	125	/**
124	*********************************************************	126	*********************************************************
Lines 129-135 Link Here
129	* @return	131	* @return
130	* host info data structure	132	* host info data structure
131	*********************************************************/	133	*********************************************************/
132	struct hostent * getTargetHostInfo(char* hostname) ;	134	struct hostent * getTargetHostInfoIPv4M(char* hostname);
133		135
134	/**	136	/**
135	*********************************************************	137	*********************************************************
Lines 141-147 Link Here
141	* the raw unconnected socket	143	* the raw unconnected socket
142	*	144	*
143	*********************************************************/	145	*********************************************************/
144	SOCKET getTheSocket(int portNum, struct sockaddr_in *pAddr) ;	146	int getTheSocket(int portNum, SOCKET outResult, int outNumSockets);
145		147
146	/**	148	/**
147	*********************************************************	149	*********************************************************
Lines 153-159 Link Here
153	* 0 - Success	155	* 0 - Success
154	* nonzero - Error.	156	* nonzero - Error.
155	*********************************************************/	157	*********************************************************/
156	int bindAndListen(SOCKET sock, struct sockaddr *pAddr) ;	158	SOCKET bindAndListen(struct addrinfo *AI);
157		159
158	/**	160	/**
159	*********************************************************	161	*********************************************************
Lines 173-184 Link Here
173	* connect to the given system	175	* connect to the given system
174	*	176	*
175	* @return	177	* @return
176	* 0 - Success and the socket representing this connection	178	* If we were able to connect pSock contans a SOCKET, otherwise, it's INVALID_SOCKET.
177	* nonzero - Error.	179	*********************************************************/
		180	int connectToTCPServer(char * hostname, int port, SOCKET *pSock);
		181
		182
		183	/**
		184	*********************************************************
		185	*
		186	* @brief
		187	* connect to the given system
		188	*
		189	* @return
		190	* If we were able to connect pSock contans a SOCKET, otherwise, it's INVALID_SOCKET.
178	*********************************************************/	191	*********************************************************/
179	int connectToTCPServer(unsigned long ipAddr,	192	int connectToTCPServerAddr(struct sockaddr_storage * addr, int port, SOCKET *pSock);
180	unsigned short portNum,	193
181	SOCKET *pSock);	194
		195	int connectToTCPServerIPv4M(unsigned long ipAddr, unsigned short portNum, SOCKET *pSock);
182		196
183	/**	197	/**
184	*********************************************************	198	*********************************************************
Lines 198-203 Link Here
198		212
199	int closeSocket(int socket);	213	int closeSocket(int socket);
200		214
		215	/** SOCKET -> struct sockaddr_storage * for the peer. */
		216	struct sockaddr_storage * getPeerAddrOfSocket(SOCKET ConnSocket);
		217
		218	/** struct sockaddr_storage * => IP address in byte format (e.g. in_addr / in6_addr) + family
		219	The bytes are stored in outAddr, and the family is stored in family.*/
		220	void getByteFormatFromSockAddr(struct sockaddr_storage addr, void * outAddr, int *family);
		221
		222	void getSockAddrFromByteFormat(void inAddr, int family, struct sockaddr_storage *outResult);
		223
		224	void setSockaddrStoragePort(struct sockaddr_storage *addr, int port);
		225
		226	typedef struct {
		227	tptp_list_t serverSocketList;
		228
		229	tptp_list_t socketsToProcess;
		230	Lock_t sockProcLock;
		231
		232	} socket_accept_t;
		233
		234	SOCKET acceptSocketConnections(SOCKET * sockets, int numSockets, socket_accept_t * sockAcceptState);
		235	void initSocketAccept(socket_accept_t * sat);
		236
		237	struct sockaddr_storage * cloneSockAddr(struct sockaddr_storage * addr);
		238
		239
		240	int isAddrLocal(struct sockaddr_storage * addr);
		241	int compareAddresses(struct sockaddr_storage * one, struct sockaddr_storage * two);
		242	char * convertAddrToHostname(struct sockaddr_storage *addr);
		243
		244	void getLocalHostAddresses(struct sockaddr_storage *** arrOfAddr, int * numAddr);
		245
		246	void freeAddressList(struct sockaddr_storage ** arrOfAddr, int numAddr);
		247
		248	int convertHostnameToAddrs(char hostname, struct sockaddr_storage ** outResult, int *outNumResults);
		249
		250	struct sockaddr_storage * getSelfAddrOfSocket(SOCKET ConnSocket);
		251
		252	void printSockAddrStorage(struct sockaddr_storage *inAddr);
		253
		254	SOCKET connectToHostWithHostname(char * hostnameOrIp, int port, struct addrinfo ** sockAddrOut );
		255
201	#ifdef __cplusplus	256	#ifdef __cplusplus
202	}	257	}
203	#endif	258	#endif

Lines 126-131 Link Here

(-)src-native-new/src/transport/RASocket/RASocket.c (-4 / +10 lines)
126	* @returns 0 - create server was successful.	126	* @returns 0 - create server was successful.
127	* <>0 - create failed, call ra_getlastErrorMajor/Minor	127	* <>0 - create failed, call ra_getlastErrorMajor/Minor
128	* to get the failure details.	128	* to get the failure details.
		129	* IPV4-ONLY
129	*/	130	*/
130	int ra_createBoundUDPServer(short portNum,	131	int ra_createBoundUDPServer(short portNum,
131	ra_serverInfo_t *result) {	132	ra_serverInfo_t *result) {
Lines 380-387 Link Here
380	* @returns 0 - create server was successful.	381	* @returns 0 - create server was successful.
381	* <>0 - create failed, call ra_getlastErrorMajor/Minor	382	* <>0 - create failed, call ra_getlastErrorMajor/Minor
382	* to get the failure details.	383	* to get the failure details.
		384	* IPV4-ONLY
383	*/	385	*/
384
385	int ra_createTCPServer(unsigned short portNum,	386	int ra_createTCPServer(unsigned short portNum,
386	ra_serverInfo_t *result) {	387	ra_serverInfo_t *result) {
387		388
Lines 660-665 Link Here
660	* @returns 0 - connect was successful	661	* @returns 0 - connect was successful
661	* <0 - connect failed, can ra_getLastErrorMajor/Minor	662	* <0 - connect failed, can ra_getLastErrorMajor/Minor
662	* to get the failure details.	663	* to get the failure details.
		664	* IPV4-ONLY
663	*/	665	*/
664	int ra_connectToTCPServer(ra_uint_t remoteIP,	666	int ra_connectToTCPServer(ra_uint_t remoteIP,
665	unsigned short remotePortNum,	667	unsigned short remotePortNum,
Lines 828-833 Link Here
828	* The number of characters written to the parameter buffer (excluding	830	* The number of characters written to the parameter buffer (excluding
829	* null terminator character. Otherwise, -1 if a severe error occurred.	831	* null terminator character. Otherwise, -1 if a severe error occurred.
830	* Call ra_getLastErrorMajor/Minor() to determine the error conditions.	832	* Call ra_getLastErrorMajor/Minor() to determine the error conditions.
		833	* IPV4-ONLY
831	*/	834	*/
832	short ra_getFormattedLocalIPAddress(char *ipAddressBuffer){	835	short ra_getFormattedLocalIPAddress(char *ipAddressBuffer){
833		836
Lines 886-891 Link Here
886	* -1 - severe error occured getting the IP address. Call	889	* -1 - severe error occured getting the IP address. Call
887	* ra_getLastErrorMajor/Minor to determine the	890	* ra_getLastErrorMajor/Minor to determine the
888	* error conditions.	891	* error conditions.
		892	* IPV4-ONLY
889	*/	893	*/
890	long ra_getLocalIPAddress() {	894	long ra_getLocalIPAddress() {
891	char localhost[MAX_HOST_NAME_LENGTH];	895	char localhost[MAX_HOST_NAME_LENGTH];
Lines 916-921 Link Here
916		920
917	return result;	921	return result;
918	}	922	}
		923
919		924
920	/ GET_LOCAL_IP_ADDRESSES *****************************************	925	/ GET_LOCAL_IP_ADDRESSES *****************************************
921	* Get all the IP addresses associated with this physical host.	926	* Get all the IP addresses associated with this physical host.
Lines 927-932 Link Here
927	* -1 - severe error occured getting the IP address. Call	932	* -1 - severe error occured getting the IP address. Call
928	* ra_getLastErrorMajor/Minor to determine the	933	* ra_getLastErrorMajor/Minor to determine the
929	* error conditions.	934	* error conditions.
		935	* IPV4-ONLY
930	*/	936	*/
931	short ra_getLocalIPAddresses(ra_IPAddresses_t *addr) {	937	short ra_getLocalIPAddresses(ra_IPAddresses_t *addr) {
932	char localhost[MAX_HOST_NAME_LENGTH];	938	char localhost[MAX_HOST_NAME_LENGTH];
Lines 1092-1098 Link Here
1092	WORD wVersionRequested;	1098	WORD wVersionRequested;
1093	WSADATA wsaData;	1099	WSADATA wsaData;
1094	int err;	1100	int err;
1095	wVersionRequested = MAKEWORD(1, 1);	1101	wVersionRequested = MAKEWORD(2, 2);
1096		1102
1097	err = WSAStartup(wVersionRequested, &wsaData);	1103	err = WSAStartup(wVersionRequested, &wsaData);
1098		1104
Lines 1109-1116 Link Here
1109	/* 1.1 in wVersion since that is the version we */	1115	/* 1.1 in wVersion since that is the version we */
1110	/* requested. */	1116	/* requested. */
1111		1117
1112	if ( LOBYTE( wsaData.wVersion ) != 1 \|\|	1118	if ( LOBYTE( wsaData.wVersion ) != 2 \|\|
1113	HIBYTE( wsaData.wVersion ) != 1 ) {	1119	HIBYTE( wsaData.wVersion ) != 2 ) {
1114	/* Tell the user that we couldn't find a useable */	1120	/* Tell the user that we couldn't find a useable */
1115	/* winsock.dll. */	1121	/* winsock.dll. */
1116	ra_setLastError(SOCKET_INITIALIZE_FAILED, err);	1122	ra_setLastError(SOCKET_INITIALIZE_FAILED, err);

Lines 25-31 Link Here

(-)src-native-new/src/transport/transportSupport/TransportSupport.def (-5 / +23 lines)
25	ipcMemWrite @22	25	ipcMemWrite @22
26	ipcFlushToFunc @23	26	ipcFlushToFunc @23
27	ipcStopFlushing @24	27	ipcStopFlushing @24
28	getTargetHostInfo @25	28	convertHostnameToAddrs @25
29	setHandleInherited @26	29	setHandleInherited @26
30	isSocketValid @27	30	isSocketValid @27
31	destroyNamedPipe @28	31	destroyNamedPipe @28
Lines 39-56 Link Here
39	ipcMemWriteWithDIME @36	39	ipcMemWriteWithDIME @36
40	isValidTPTPBlock @37	40	isValidTPTPBlock @37
41	getPeerName @38	41	getPeerName @38
42	convertIPAddressStringToArray @39	42	convertIPAddressStringToArrayIPv4M @39
43	convertIPAddressStringToUlong @40
44	getSocketIPString @41	43	getSocketIPString @41
45	ipcFlushToFD @42	44	ipcFlushToFD @42
46	tptp_checkHost @43	45	tptp_checkHost @43
47	openNonCriticalWriteOnlyNamedPipe @44	46	openNonCriticalWriteOnlyNamedPipe @44
48	getPeerIPString @45	47	getPeerIPString @45
49	convertIPAddressUlongToString @46	48	convertIPAddressUlongToStringIPv4M @46
50	getSocketPort @47	49	getSocketPort @47
51	ipcStopFlusher @48	50	ipcStopFlusher @48
52	ipcCloseMem @49	51	ipcCloseMem @49
53	isMemOpen @50	52	isMemOpen @50
54	ipcMemDetach @51	53	ipcMemDetach @51
55	closeSocket @52	54	closeSocket @52
56		55	getHostInfoIPv4M @53
		56	convertIPAddressStringToUlongIPv4M @54
		57	getSocketIPStringIPv4M @55
		58	freeAddressList @56
		59	getTargetHostInfoIPv4M @57
		60	getPeerAddrOfSocket @58
		61	getByteFormatFromSockAddr @59
		62	getSockAddrFromByteFormat @60
		63	connectToHostWithAddr @61
		64	setSockaddrStoragePort @62
		65	connectToTCPServerAddr @63
		66	connectToTCPServerIPv4M @64
		67	acceptSocketConnections @65
		68	initSocketAccept @66
		69	cloneSockAddr @67
		70	getLocalHostAddresses @68
		71	tptp_checkHostIPv6 @69
		72	getSelfAddrOfSocket @70
		73	printSockAddrStorage @71
		74	connectToHostWithHostname @72

Lines 323-329 Link Here

(-)src-native-new/src/transport/transportSupport/TransportSupport.c (-6 / +137 lines)
323	return (isValid) ;	323	return (isValid) ;
324	}	324	}
325		325
326		326	/* IPV4-ONLY */
327	long tptp_getLocalIPAddress() {	327	long tptp_getLocalIPAddress() {
328	char localhost[MAX_HOST_NAME_LENGTH];	328	char localhost[MAX_HOST_NAME_LENGTH];
329	struct hostent *hpLocal;	329	struct hostent *hpLocal;
Lines 352-358 Link Here
352	return result;	352	return result;
353	}	353	}
354		354
355	short tptp_getLocalIPAddresses(tptp_IPAddresses_t *addr) {	355	short tptp_getLocalIPAddressesIPv4M(tptp_IPAddresses_t *addr) {
356	char localhost[MAX_HOST_NAME_LENGTH];	356	char localhost[MAX_HOST_NAME_LENGTH];
357	struct hostent *hpLocal;	357	struct hostent *hpLocal;
358	int count, i;	358	int count, i;
Lines 399-405 Link Here
399	return 0;	399	return 0;
400	}	400	}
401		401
402	int isLocalHost(char* name) {	402	int isLocalHostIPv4M(char* name) {
403	tptp_IPAddresses_t localAddresses;	403	tptp_IPAddresses_t localAddresses;
404	struct hostent *he;	404	struct hostent *he;
405	unsigned char addr, cur;	405	unsigned char addr, cur;
Lines 412-418 Link Here
412		412
413	addr = he->h_addr_list[0];	413	addr = he->h_addr_list[0];
414		414
415	if(tptp_getLocalIPAddresses(&localAddresses) != 0) return 0;	415	if(tptp_getLocalIPAddressesIPv4M(&localAddresses) != 0) return 0;
416		416
417	res = 0;	417	res = 0;
418	len = localAddresses.addressLength;	418	len = localAddresses.addressLength;
Lines 432-437 Link Here
432	return res;	432	return res;
433	}	433	}
434		434
		435	/** IPV4-ONLY */
435	BOOL tptp_checkHost(network_list_t list, unsigned char address) {	436	BOOL tptp_checkHost(network_list_t list, unsigned char address) {
436	network_list_node_t *current;	437	network_list_node_t *current;
437		438
Lines 464-470 Link Here
464	/* We need to continuously recheck the IP address of the local machine as this can change	465	/* We need to continuously recheck the IP address of the local machine as this can change
465	on modern operating systems without a reboot	466	on modern operating systems without a reboot
466	*/	467	*/
467	if(tptp_getLocalIPAddresses(&localAddresses)==0) {	468	if(tptp_getLocalIPAddressesIPv4M(&localAddresses)==0) {
468	int len=localAddresses.addressLength;	469	int len=localAddresses.addressLength;
469	unsigned char *current;	470	unsigned char *current;
470	current=localAddresses.addresses;	471	current=localAddresses.addresses;
Lines 545-551 Link Here
545	aliases++;	546	aliases++;
546	}	547	}
547		548
548	if (isLocalHost(hostnameAllowed) && isLocalHost(hostnameEntry)) {	549	if (isLocalHostIPv4M(hostnameAllowed) && isLocalHostIPv4M(hostnameEntry)) {
549	return entry->allow ? TRUE : FALSE;	550	return entry->allow ? TRUE : FALSE;
550	}	551	}
551	}	552	}
Lines 556-558 Link Here
556		557
557	return FALSE;	558	return FALSE;
558	}	559	}
		560
		561	BOOL tptp_checkHostIPv6(network_list_t list, struct sockaddr_storage addr) {
		562	network_list_node_t *current;
		563	int x = 0;
		564	unsigned char * ipaddr;
		565	int family = 0;
		566	int r = 0;
		567
		568	//If the list or host address is not specified then return TRUE.
		569	//this means configuration is not specified.
		570	if (list == NULL) {
		571	return TRUE;
		572	}
		573
		574	if (addr == NULL) {
		575	return TRUE;
		576	}
		577
		578	current = list->head;
		579
		580	/* Look at the host list in order and find a matching rule */
		581	while(current) {
		582	network_t *entry=current->entry;
		583	/* Is this an allow rule */
		584
		585	switch(entry->wildcard) {
		586
		587	case TPTP_HW_ALL:
		588	if(entry->allow) {
		589	return TRUE;
		590	}
		591	return FALSE;
		592	break;
		593	case TPTP_HW_LOCAL:
		594
		595	if(isAddrLocal(addr)) {
		596	if(entry->allow) {
		597	return TRUE;
		598	}
		599	return FALSE;
		600	}
		601	break;
		602	/* We are currently going to ignore UNKNOWN, and KNOWN posibilities */
		603	case TPTP_HW_UNKNOWN:
		604	break;
		605	case TPTP_HW_KNOWN:
		606	break;
		607	case TPTP_HW_MAX_VALUE:
		608	break;
		609	case TPTP_HW_NET:
		610	{
		611	getByteFormatFromSockAddr(addr, (void **)&ipaddr, &family);
		612	if(entry->netAndMaskAreIpv4 && addr->ss_family == PF_INET) {
		613	/* Check to see if the host is OK based upon net and mask. If the mask and the remote address
		614	and-ed together equal the net then it is a match */
		615	if((entry->mask[0] & ipaddr[0]) == entry->net[0]
		616	&& (entry->mask[1] & ipaddr[1]) == entry->net[1]
		617	&& (entry->mask[2] & ipaddr[2]) == entry->net[2]
		618	&& (entry->mask[3] & ipaddr[3]) == entry->net[3]) {
		619	if(entry->allow) {
		620	return TRUE;
		621	}
		622	return FALSE;
		623	}
624	} else if(!entry->netAndMaskAreIpv4 && addr->ss_family == PF_INET6){
625
626	r = 1;
627	for(x = 0; x < 16; x++) {
628	if( (entry->maskipv6[x] & ipaddr[x]) == entry->netipv6[x]) {
629	// No mismatch, this is good.
630	} else {
631	// We've found a mismatch. Set false and break.
632	r = 0;
633	break;
634	}
635	}
636	if(r) {
637	if(entry->allow) {
638	return TRUE;
639	}
640	return FALSE;
641	}
642	}
643
644	}
645	break;
646	case TPTP_HW_NAMED:
647	{
648	char *hostname;
649
650	struct sockaddr_storage ** addrs;
651	int numAddrs = 0;
652	int x = 0;
653
654	// Convert the config host name to a list of addresses and compare them
655	convertHostnameToAddrs(entry->hostname, &addrs, &numAddrs);
656	for(x = 0; x < numAddrs; x++) {
657	if(compareAddresses(addr, addrs[x])) {
658	freeAddressList(addrs, numAddrs);
659
660	if(entry->allow) {
661	return TRUE;
662	}
663	return FALSE;
664
665	}
666	}
667	freeAddressList(addrs, numAddrs);
668
669	if(isAddrLocal(addr)) {
670	return (entry->allow) ? TRUE : FALSE;
671	}
672
673	hostname = convertAddrToHostname(addr);
674
675	if(strcasecmp(hostname, entry->hostname) == 0) {
676	tptp_free(hostname);
677	return (entry->allow) ? TRUE : FALSE;
678	}
679
680	tptp_free(hostname);
681
682	}
683	break;
684	}
685	current=current->next;
686	}
687
688	return FALSE;
689	}

Lines 155-179 Link Here

(-)src-native-new/src/shared/TPTPLogUtils/TPTPCBE.cpp (-11 / +2 lines)
155	if ( formattedLocalIPAddress[0] == '\0' )	155	if ( formattedLocalIPAddress[0] == '\0' )
156	{	156	{
157	char hostname[CBE_HOSTNAME_SIZE+1];	157	char hostname[CBE_HOSTNAME_SIZE+1];
158	struct hostent *host;
159		158
160	// TODO: Make WSAStartup call on Windows	159	// TODO: Make WSAStartup call on Windows
161		160
162	if ( gethostname(hostname, CBE_HOSTNAME_SIZE) == 0 )	161	if ( gethostname(hostname, CBE_HOSTNAME_SIZE) == 0 )
163	{	162	{
164	host = gethostbyname(hostname);	163	sprintf(formattedLocalIPAddress, "%s", hostname);
165	if(host == NULL)
166	{
167	sprintf(formattedLocalIPAddress, "%s", hostname);
168	}
169	else
170	{
171	sprintf(formattedLocalIPAddress, "%s", host->h_name);
172	}
173	}	164	}
174	else	165	else
175	{	166	{
176	sprintf(formattedLocalIPAddress, "127.0.0.1");	167	sprintf(formattedLocalIPAddress, "localhost");
177	}	168	}
178	}	169	}
179		170

Lines 576-581 Link Here

(-)src-native-new/src/client/TCPDataServer.cpp (-4 / +66 lines)
576		576
577		577
578		578
		579
		580	/**
		581	*********************************************************
		582	*
		583	* @brief
		584	* Given a hostname, get the current host IP address. An array of sockaddr_storages are stored in outResult, and the size
		585	* of that array is stored in outNumResults.
		586	* @return
		587	* the IP address number
		588	*
		589	*********************************************************/
		590	/*
		591	void TCPDataServer::getIPAddresses(char hostname, struct sockaddr_storage ** outResult, int *outNumResults) {
		592	int RetVal;
		593	int i;
		594
		595	struct addrinfo Hints, AddrInfo, AI;
		596
		597	int Family = PF_UNSPEC; // Give us both the IPv4 and IPv6 addresses
		598	int SocketType = SOCK_STREAM; // TCP only
		599
		600	struct sockaddr_storage ** result;
		601
		602	int rc = 0 ;
		603
		604	rc = initForSocketCalls();
		605	if(rc != 0) {
		606	*outNumResults = 0;
		607	}
		608
		609	result = (struct sockaddr_storage *)tptp_malloc(sizeof(struct sockaddr_storage ) * 128);
		610
		611	memset(&Hints, 0, sizeof (Hints));
		612	Hints.ai_family = Family;
		613	Hints.ai_socktype = SocketType;
		614
		615	// This was originally in the code, but it prevents lookups of host names, e.g. www.google.com. It only works with numeric hosts.
		616	// Hints.ai_flags = AI_NUMERICHOST;
		617
		618	RetVal = getaddrinfo(hostname, NULL, &Hints, &AddrInfo);
		619
		620	for (i = 0, AI = AddrInfo; AI != NULL; AI = AI->ai_next, i++) {
		621	result[i] = cloneSockAddr((struct sockaddr_storage *)AI->ai_addr);
		622	}
		623	freeaddrinfo(AddrInfo);
		624
		625	*outResult = result;
		626	*outNumResults = i;
		627
		628	return RetVal;
		629	}*/
		630
		631
579	/**	632	/**
580	*********************************************************	633	*********************************************************
581	*	634	*
Lines 586-592 Link Here
586	* the IP address number	639	* the IP address number
587	*	640	*
588	*********************************************************/	641	*********************************************************/
589		642	/*
590	unsigned long TCPDataServer::getLocalIPAddress() {	643	unsigned long TCPDataServer::getLocalIPAddress() {
591	struct hostent *hpLocal = NULL;	644	struct hostent *hpLocal = NULL;
592	unsigned long result = 0 ;	645	unsigned long result = 0 ;
Lines 595-601 Link Here
595	rc = initForSocketCalls() ;	648	rc = initForSocketCalls() ;
596	if (rc == 0)	649	if (rc == 0)
597	{	650	{
598	hpLocal = getHostInfo() ;	651	hpLocal = getHostInfoIPv4M() ;
599		652
600	if (hpLocal != NULL)	653	if (hpLocal != NULL)
601	memcpy(&result, hpLocal->h_addr_list[0], sizeof(long));	654	memcpy(&result, hpLocal->h_addr_list[0], sizeof(long));
Lines 605-612 Link Here
605		658
606	return result;	659	return result;
607	}	660	}
		661	*/
608		662
609		663	#define MAX_HOST_NAME_LENGTH 128
610		664
611	void TCPDataServer::connect()	665	void TCPDataServer::connect()
612	{	666	{
Lines 614-622 Link Here
614	char buffer[1024] ;	668	char buffer[1024] ;
615	int bufferLength = 1024 ;	669	int bufferLength = 1024 ;
616	int bytesRead = 0 ;	670	int bytesRead = 0 ;
		671
		672	char hostname[MAX_HOST_NAME_LENGTH];
		673
		674	// Get the local host informantion
		675	if (gethostname(hostname,MAX_HOST_NAME_LENGTH) < 0) {
		676	TPTP_LOG_DEBUG_MSG("Error: Unable to resolve local host name.");
		677	return;
		678	}
617		679
618	/* go make connection */	680	/* go make connection */
619	rc = connectToTCPServer(getLocalIPAddress(), _port, &_sock) ;	681	rc = connectToTCPServer(hostname, _port, &_sock) ;
620		682
621	if (rc != 0)	683	if (rc != 0)
622	{	684	{