Attachment #84612 for bug #195644

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

Lines 470-474 Link Here

(-)src-native-new/src/transport/transportSupport/TransportSupportSocket.c (+18 lines)
470	return ( send(sock, buffer, byteCount, 0) ) ;	470	return ( send(sock, buffer, byteCount, 0) ) ;
471	}	471	}
472		472
		473	#ifdef __linux__
		474	int closeSocket (int socket) {
		475	struct linger linger;
		476	int rc;
473		477
		478	linger.l_onoff = 1;
		479	linger.l_linger = 0;
474		480
		481	rc = setsockopt(socket, SOL_SOCKET, SO_LINGER, (const char*) &linger,
		482	sizeof(linger));
		483
		484	close (socket);
		485
		486	return rc;
		487	}
		488	#else
		489	int closeSocket (int socket) {
		490	return closeThisSocket(socket);
		491	}
		492	#endif

Lines 52-55 Link Here

(-)src-native-new/src/transport/transportSupport/TransportSupport.def (+1 lines)
52	ipcCloseMem @49	52	ipcCloseMem @49
53	isMemOpen @50	53	isMemOpen @50
54	ipcMemDetach @51	54	ipcMemDetach @51
		55	closeSocket @52
55		56

Lines 99-102 Link Here

(-)src-native-new/src/shared/TPTPUtil/TPTUtil.def (-1 / +3 lines)
99	terminateXMLPlatformUtils	99	terminateXMLPlatformUtils
100	parseHostList	100	parseHostList
101	getExecutableName	101	getExecutableName
102	readStringFromBuffer	102	readStringFromBuffer
		103	vrfusrpwd
		104

Lines 27-32 Link Here

(-)src-native-new/src/shared/TPTPUtil/TPTPUtil.cpp (-78 / +150 lines)
27	#include <malloc.h>	27	#include <malloc.h>
28		28
29	#include "tptp/TPTPUtils.h"	29	#include "tptp/TPTPUtils.h"
		30	#include "tptp/TPTPConfig.h"
30		31
31	#ifdef _WIN32	32	#ifdef _WIN32
32	#include <sys/types.h>	33	#include <sys/types.h>
Lines 44-49 Link Here
44	#include <sys/types.h>	45	#include <sys/types.h>
45	#include <linux/stat.h> //for mode S_IXUSR	46	#include <linux/stat.h> //for mode S_IXUSR
46	#define STAT stat	47	#define STAT stat
		48	#include <signal.h>
		49	#include <sys/wait.h>
47	#include <ctype.h>	50	#include <ctype.h>
48	#endif	51	#endif
49		52
Lines 103-110 Link Here
103	tptp_list_t** paramList )	106	tptp_list_t** paramList )
104	{	107	{
105	try {	108	try {
106	char *tempnodename = 0;
107
108	//Initialize the XML parser	109	//Initialize the XML parser
109	DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(&chNull);	110	DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(&chNull);
110	DOMBuilder parser = ((DOMImplementationLS)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);	111	DOMBuilder parser = ((DOMImplementationLS)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
Lines 949-1020 Link Here
949	return ++endIdx; //Move past the closing delim for the value	950	return ++endIdx; //Move past the closing delim for the value
950	}	951	}
951		952
952	int getSocketConfigInfo( const char* config, SocketConfigInfo *socketInfo )	953	int getSocketConfigInfo(const char* config, SocketConfigInfo *socketInfo) {
953	{	954	tptp_param_t* param;
954	char* tagName=NULL;	955	tptp_node_t* node;
955	char* elementName=NULL;
956	char* elementValue=NULL;
957	int mstrIdx=0;
958	int nextIdx=0;
959	int endIdx = strlen(config);
960
961	nextIdx = getTagName(config, &tagName);
962	if ((nextIdx == -1) \|\| (tagName == NULL)) goto errorReturn; //Error: badly formed cmd
963
964	if (!isEqualString(tagName, "Configuration") ) goto errorReturn; //Error: Don't have a "Cmd"
965	mstrIdx += nextIdx;
966	mstrIdx++;
967	tptp_free(tagName); tagName=NULL;
968		956
969	socketInfo->securityEnabled = 0; // default	957	socketInfo->securityEnabled = 0; // default
		958	socketInfo->sslProviderLib = NULL;
		959	socketInfo->params = NULL;
970		960
971	while (1)	961	if (getXMLElements(config, &socketInfo->params) < 0) return -1;
972	{
973	nextIdx = getConfigElementName(&(config[mstrIdx]), &elementName);
974	if (isEqualString(elementName, "/Configuration")) break;
975
976	if ((nextIdx == -1) \|\| (elementName == NULL)) goto errorReturn; //Error: badly formed cmd
977	mstrIdx += nextIdx;
978
979	nextIdx = getConfigElementValue(&(config[mstrIdx]), &elementValue);
980	if ((nextIdx == -1) \|\| (elementValue == NULL)) goto errorReturn; //Error: badly formed cmd
981	mstrIdx += nextIdx;
982
983	nextIdx = skipConfigElementClose(&(config[mstrIdx]));
984	if (nextIdx == -1) goto errorReturn; //Error: badly formed cmd
985	mstrIdx += nextIdx;
986
987	if (isEqualString(elementName, "Port"))
988	{
989	socketInfo->portNumber = atoi(elementValue);
990	}
991	else if (isEqualString(elementName, "SecurityEnabled"))
992	{
993	socketInfo->securityEnabled = isEqualString(elementValue, "true");
994	}
995	else if (isEqualString(elementName, "Hosts Configuration"))
996	{
997	socketInfo->hostConfig = elementValue;
998	}
999	else if (isEqualString(elementName, "Allow host"))
1000	{
1001	socketInfo->allowHosts = elementValue;
1002	}
1003		962
1004	tptp_free(elementName); elementName=NULL;	963	for (node = socketInfo->params->head; node != 0; node = node->next) {
1005	tptp_free(elementValue); elementValue=NULL;	964	param = (tptp_param_t*) node->data;
		965	if (param == NULL) continue;
		966
		967	if (isEqualString(param->name, "Port")) {
		968	socketInfo->portNumber = atoi(param->value);
		969	}
		970	else if (isEqualString(param->name, "SecurityEnabled")) {
		971	socketInfo->securityEnabled = isEqualString(param->value, "true");
		972	}
		973	else if (isEqualString(param->name, "Hosts Configuration")) {
		974	socketInfo->hostConfig = param->value;
		975	}
		976	else if (isEqualString(param->name, "Allow host")) {
		977	socketInfo->allowHosts = param->value;
		978	}
		979	else if (isEqualString(param->name, "SSLproviderLib")) {
		980	socketInfo->sslProviderLib = param->value;
		981	}
1006	}	982	}
1007		983
1008	if (elementName) {tptp_free(elementName); elementName=NULL;}
1009	if (elementValue) {tptp_free(elementValue); elementValue=NULL;}
1010
1011	return 0;	984	return 0;
1012
1013	errorReturn:
1014	if (tagName != NULL) tptp_free(tagName);
1015	if (elementName != NULL) tptp_free(elementName);
1016	if (elementValue != NULL) tptp_free(elementValue);
1017	return -1; //TODO: replace with real error codes
1018	}	985	}
1019		986
1020	int getNamedPipeConfigInfo( const char* config, char **pipeName )	987	int getNamedPipeConfigInfo( const char* config, char **pipeName )
Lines 1263-1269 Link Here
1263	tptp_list_setNodeDestructor(*paramList, destroyParamNode);	1230	tptp_list_setNodeDestructor(*paramList, destroyParamNode);
1264	tptp_list_setNodeCopier(*paramList, copyParamNode);	1231	tptp_list_setNodeCopier(*paramList, copyParamNode);
1265		1232
1266	bool isCmdRoot = false;
1267	DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(&chNull);	1233	DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(&chNull);
1268	DOMBuilder parser = ((DOMImplementationLS)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);	1234	DOMBuilder parser = ((DOMImplementationLS)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
1269		1235
Lines 1281-1303 Link Here
1281	XERCES_CPP_NAMESPACE::DOMDocument doc = parser->parse(domBufIS);	1247	XERCES_CPP_NAMESPACE::DOMDocument doc = parser->parse(domBufIS);
1282	DOMTreeWalker* iter = doc->createTreeWalker(doc->getDocumentElement(),DOMNodeFilter::SHOW_ELEMENT,NULL,true);	1248	DOMTreeWalker* iter = doc->createTreeWalker(doc->getDocumentElement(),DOMNodeFilter::SHOW_ELEMENT,NULL,true);
1283		1249
1284	//Got the Node after the Root - The assumption here is that there is an encapsulating element around the
1285	//<Cmd></Cmd> tags
1286	char *roottag = XMLString::transcode(iter->getCurrentNode()->getNodeName());
1287	if(strcmp(roottag, "Cmd")==0)
1288	{
1289	isCmdRoot = true;
1290	}
1291	XMLString::release(&roottag);
1292	DOMNode *node;
1293	if(!isCmdRoot){node = iter->firstChild();}
1294
1295	DOMNode *curr = iter->getCurrentNode();	1250	DOMNode *curr = iter->getCurrentNode();
1296	if(curr != NULL)	1251	if(curr != NULL)
1297	{	1252	{
1298	char *tempparmval = "\0";	1253	char *tempparmval = "\0";
1299	tptp_param_t* newParam;	1254	tptp_param_t* newParam;
1300	char *tempparmname = XMLString::transcode(curr->getNodeName());	1255	char *tempparmname = XMLString::transcode(curr->getNodeName());
		1256
1301	newParam = initParamT(tempparmname, tempparmval);	1257	newParam = initParamT(tempparmname, tempparmval);
1302	tptp_list_add(paramList, (void)newParam);	1258	tptp_list_add(paramList, (void)newParam);
1303	addElementAttrs(curr, *paramList);	1259	addElementAttrs(curr, *paramList);
Lines 1727-1736 Link Here
1727	TPTPParserErrorHandler* tptp_dom_err = new TPTPParserErrorHandler();	1683	TPTPParserErrorHandler* tptp_dom_err = new TPTPParserErrorHandler();
1728	parser->setErrorHandler(tptp_dom_err);	1684	parser->setErrorHandler(tptp_dom_err);
1729		1685
1730	char* executable=NULL;
1731	char* path=NULL;
1732	char* location=NULL;
1733
1734	XERCES_CPP_NAMESPACE::DOMDocument doc = parser->parse(domBufIS);	1686	XERCES_CPP_NAMESPACE::DOMDocument doc = parser->parse(domBufIS);
1735		1687
1736	//Initialize the list to NULL... just so that we can check it later.	1688	//Initialize the list to NULL... just so that we can check it later.
Lines 1914-1916 Link Here
1914	return -1;	1866	return -1;
1915	}	1867	}
1916	}	1868	}
		1869
		1870	/*
		1871	* --------------------------------------------------------------------------------
		1872	* All the platform-dependent vrfusrpwd() functions below
		1873	* --------------------------------------------------------------------------------
		1874	*/
		1875
		1876	#if defined(_WIN32)
		1877	/*
		1878	* Windows/IA32 section, in-process authentication
		1879	*/
		1880	int vrfusrpwd(tptp_string userid, tptp_string password) {
		1881	HANDLE handle;
		1882	return LogonUser(userid, NULL, password, LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT, &handle) ? 1 : 0;
		1883	}
		1884	#elif defined(__MVS__)
		1885	/*
		1886	* OS/390 section, in-process authentication. BPX.DAEMON is needed.
		1887	*/
		1888	int vrfusrpwd(tptp_string userid, tptp_string password) {
		1889	return __passwd(userid, password, NULL) ? 0 : 1;
		1890	}
		1891	#elif defined(__OS400__)
		1892	/*
		1893	* OS/400 section, in-process authentication
		1894	*/
		1895	int vrfusrpwd(tptp_string userid, tptp_string password) {
		1896	struct error_code_t errorCode;
		1897	char profileHandle[12]; /* profile handle, required by QSYGETPH API */
		1898	char useridBuf[10] = " ";
		1899
		1900	/* In descrypted case, the password is in code page of 437 */
		1901	errorCode.bytesProvided = 64;
		1902	errorCode.bytesAvailable = 0;
		1903
		1904	if(userid[0] == '*') {
		1905	return 0;
		1906	}
		1907	else if(strlen(userid) > 10) {
		1908	return 0;
		1909	}
		1910	else {
		1911	int i;
		1912	for(i = 0; i < strlen(userid); i++) {
		1913	useridBuf[i] = toupper(userid[i]); /* change it all to upper case */
		1914	}
		1915	}
		1916
		1917	QSYGETPH(useridBuf, password, profileHandle, &errorCode, strlen(password), 37); /* CCSID of password is 37 (EBCDIC) */
		1918
		1919	if(errorCode.bytesAvailable > 0) {
		1920	char exc = (char)ra_malloc(sizeof(char) * 8);
		1921	BZERO(exc, 8);
		1922	strncpy(exc, errorCode.exceptionID, 7);
		1923	ra_free(exc);
		1924
		1925	return 0;
		1926	}
		1927	else {
		1928	return 1; /* authentication successful */
		1929	}
		1930	}
		1931	#else /* non-Windows, non-OS/400 */
		1932	/*
1933	* Launch a separate process to authenticate user name and password
1934	*/
1935	int vrfusrpwd(tptp_string userid, tptp_string password) {
1936	FILE *fp;
1937	int success = 0; // FALSE
1938	char *serverHome;
1939	char *authCmd;
1940	int authLen;
1941	int status;
1942	int rc=0;
1943
1944	struct sigaction ignoreHandler; /* Use this handler for bypassing pre-configured signal handler */
1945	struct sigaction oldHandler; /* Used to temporary storing the configured signal handler */
1946
1947	serverHome = getCacheEnv("default", "RASERVER_HOME");
1948	/* Do not pass user ID and password since they will be shown by running 'ps' */
1949	authLen = strlen(serverHome) + 1 + strlen("bin") + 1 + strlen("ChkPass") + 1; /* Bug 168705 : need a null at the end for strcat() */
1950	authCmd = (char)malloc(sizeof(char) authLen);
1951	BZERO(authCmd, authLen);
1952	strcpy(authCmd, serverHome);
1953	strcat(authCmd, "/");
1954	strcat(authCmd, "bin");
1955	strcat(authCmd, "/");
1956	strcat(authCmd, "ChkPass");
1957
1958	/* Disable default SIGCHLD handler since system() call doesn't work with user-supplied signal handlers */
1959	BZERO(&ignoreHandler, sizeof(struct sigaction));
1960	BZERO(&oldHandler, sizeof(struct sigaction));
1961
1962	ignoreHandler.sa_handler = SIG_DFL; /* Reset to default SIGCHLD handler */
1963	sigaction(SIGCHLD, &ignoreHandler, &oldHandler); /* Store the previous signal handler */
1964
1965	fp = popen(authCmd, "w");
1966	fprintf(fp, "%s\n", userid);
1967	fprintf(fp, "%s\n", password);
1968	status = pclose(fp);
1969	if(WIFEXITED(status)) {
1970	rc = WEXITSTATUS(status);
1971	}
1972
1973	if(rc == 100) { /* 100 indicates success */
1974	success = 1;
1975	}
1976	else {
1977	success = 0;
1978	}
1979
1980	/* Re-enable the user-specified SIGCHLD handler */
1981	sigaction(SIGCHLD, &oldHandler, NULL);
1982
1983	free(authCmd);
1984
1985	return success;
1986	}
1987
1988	#endif

Lines 75-83 Link Here

(-)src-native-new/src/shared/TPTPUtil/TPTPSupportUtils.c (-2 / +6 lines)
75	}	75	}
76		76
77	unsigned char* readStringFromBuffer(unsigned char buffer, char* str) {	77	unsigned char* readStringFromBuffer(unsigned char buffer, char* str) {
78	int len;	78	int len, padding;
79		79
80	buffer = readUINTFromBuffer(buffer, &len);	80	buffer = readUINTFromBuffer(buffer, &len);
		81
81	if (len == 0)	82	if (len == 0)
82	*str = NULL;	83	*str = NULL;
83	else {	84	else {
Lines 87-91 Link Here
87	buffer += len;	88	buffer += len;
88	}	89	}
89		90
90	return buffer;	91	padding = 4 - len%4;
		92	if (padding == 4) padding = 0;
		93
		94	return buffer + padding;
91	}	95	}

Lines 196-203 Link Here

(-)src-native-new/include/tptp/TransportSupportSocket.h (-2 / +1 lines)
196		196
197	int getPeerName(SOCKET sock, unsigned char *pAddr);	197	int getPeerName(SOCKET sock, unsigned char *pAddr);
198		198
199		199	int closeSocket(int socket);
200
201		200
202	#ifdef __cplusplus	201	#ifdef __cplusplus
203	}	202	}

Lines 80-85 Link Here

(-)src-native-new/include/tptp/TPTPUtils.h (+4 lines)
80	char *hostConfig;	80	char *hostConfig;
81	char *allowHosts;	81	char *allowHosts;
82	int securityEnabled;	82	int securityEnabled;
		83	char *sslProviderLib;
		84	tptp_list_t* params;
83	} SocketConfigInfo;	85	} SocketConfigInfo;
84		86
85	/* Define the various types of host addressing wildcards and types */	87	/* Define the various types of host addressing wildcards and types */
Lines 268-273 Link Here
268		270
269	int parseHostList(const char initString, network_list_t *nList);	271	int parseHostList(const char initString, network_list_t *nList);
270		272
		273	int vrfusrpwd(tptp_string userid, tptp_string password);
		274
271	#ifdef __cplusplus	275	#ifdef __cplusplus
272	} /* Ends extern C */	276	} /* Ends extern C */
273	#endif	277	#endif

Lines 22-27 Link Here

(-)src-native-new/src/transport/socketTL/SocketListener.h (+9 lines)
22	#include "tptp/TPTPMessageHeader.h"	22	#include "tptp/TPTPMessageHeader.h"
23	#include "tptp/hashtable.h"	23	#include "tptp/hashtable.h"
24		24
		25	#include "SSLTypes.h"
		26
25	#define SOCKET_LISTENER_OBJECT_ID 20001	27	#define SOCKET_LISTENER_OBJECT_ID 20001
26		28
27	/** instance-specific data block */	29	/** instance-specific data block */
Lines 32-38 Link Here
32	tptp_object* cmo ;	34	tptp_object* cmo ;
33	transport_layer_data_t agentControllerDataBlk ;	35	transport_layer_data_t agentControllerDataBlk ;
34	processMessage_ptr_t processMessage;	36	processMessage_ptr_t processMessage;
		37	int securityEnabled;
		38	char* sslProviderLib;
35	tptp_object* nexto;	39	tptp_object* nexto;
		40	tptp_list_t* params;
36		41
37	/* hash table of connections for easy and fast search */	42	/* hash table of connections for easy and fast search */
38	HashTable * connectionTable ;	43	HashTable * connectionTable ;
Lines 197-202 Link Here
197	sendData_ptr_t pSendFunc ;	202	sendData_ptr_t pSendFunc ;
198	tptp_object* partner;	203	tptp_object* partner;
199	int connectionPartnerID ;	204	int connectionPartnerID ;
		205
		206	ssl_socket_t ssl_socket;
		207	BOOL secured;
		208	BOOL authenticated;
200		209
201	BOOL isForConsole ;	210	BOOL isForConsole ;
202		211




#endif

#include "SocketListener.h"
#include "SSLSupport.h"

#include "tptp/TransportSupport.h"
#include "tptp/TPTPSupportUtils.h"

#define DEFAULT_PORT_NUM  	10002
#define PROTO_VERSION	1

#define CONFIGURATION_HOME	"TPTP_AC_HOME"

#define CERTF "cert.pem"
#define KEYF  "key.pem"

/** thread status */
enum ThreadStatus { IDLE, RUNNING } ;


/*====================================================================*/
THREAD_USER_FUNC_RET_TYPE processClientRequest(LPVOID args) ;
THREAD_USER_FUNC_RET_TYPE doListening(LPVOID args) ;
THREAD_USER_FUNC_RET_TYPE doSecureListening(LPVOID args) ;
int   serveRequest(SOCKET serverSock, server_block_ptr_t pServerData) ;
int   serveSecureRequest(server_block_ptr_t pServerData) ;
int   sendThisMessage(server_block_t* pServerData, tptp_uint32 connectionID, tptp_uint32 cmdSize, tptp_string* pCmdBlock, BOOL shouldAddHeader) ;
int   addMessageHeader(char * pCmdBlock, int cmdSize, char * buffer, int *pBufferLength, unsigned int flags) ;
int   processCONNECTCall(request_block_ptr_t pBlk, char *pMsg, int flags) ;

int handleCONNECT(request_block_ptr_t pBlk, char *pMsg) ;

int handleCONNECT_DATA(request_block_ptr_t pBlk, char *pMsg) ;
int closeConnection(request_block_ptr_t pBlock);
int recvData(request_block_ptr_t pRdb, char *buffer, int length, int *bytesRead);
int writeData(request_block_ptr_t pBlock, char* buffer, int length); 
int setSSL(request_block_ptr_t pBlk);
int handleAUTHENTICATE(request_block_ptr_t pBlk, char *pMsg);

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


	addBasicMsgHeader(cmd, cmdLength, &buffer, &bufferLength, flags) ;
	/* send the response */
	writeData(pBlk, buffer, bufferLength);

	if (cmd) tptp_free(cmd);
	if (buffer) tptp_free(buffer);

	TPTP_LOG_DEBUG_MSG(pBlk->pServerData, "Socket: handle CONNECT request (Control channel).");
	pBlk->connectionType = CONTROL_CHANNEL ;

	if (pBlk->pServerData->securityEnabled && !pBlk->secured) {
		processCONNECTCall(pBlk, pMsg, CONNECTION_REFUSED | SECURITY_REQUIRED);
		return setSSL(pBlk); 
	}

	/* tell the agent controller about the new connection  */
	/*    and receive the assigned connection id           */
	pFunc = pBlk->pServerData->agentControllerDataBlk.addConnectionEntry ;
	pFunc(pBlk->pServerData->cmo, pBlk->pServerData->agentControllerDataBlk.transportID, 
			&(pBlk->connectionId));


	/* save the socket and the control block away */

	pTab = pBlk->pServerData->connectionTable ;
	tablePut(pTab, connId, (Entry_value_ptr_t) pBlk) ;

	if (pBlk->pServerData->securityEnabled && !pBlk->authenticated) {
		processCONNECTCall(pBlk, pMsg, CONNECTION_COMPLETE | AUTHENTICATION_FAILED);
	}
	else {
		processCONNECTCall(pBlk, pMsg, CONNECTION_COMPLETE);
		pBlk->authenticated = TRUE;
	}

	return 0 ;
}


	TPTP_LOG_DEBUG_MSG(pBlk->pServerData, "Socket: handle CONNECT_DATA/CONNECT_CONSOLE request (Data channel).");

	if (pBlk->pServerData->securityEnabled && !pBlk->secured) {
		processCONNECTCall(pBlk, pMsg, CONNECTION_REFUSED | SECURITY_REQUIRED);
		return setSSL(pBlk); 
	}

	pBlk->connectionType = DATA_CHANNEL ;

	/* tell the agent controller about the new connection  */


	pFunc = pBlk->pServerData->agentControllerDataBlk.addDataConnectionEntry ;
	pFunc(pBlk->pServerData->cmo, pBlk->pServerData->agentControllerDataBlk.transportID,
			pBlk->flags, &(pBlk->connectionId)) ;
			&(pBlk->connectionId)) ;

	/* save the socket and the control block away */
	/*   use the connection id as the index into the array for fast lookup */

 *********************************************************/
int handleDISCONNECT(request_block_ptr_t pBlk, char *pMsg)
{

	TPTP_LOG_DEBUG_MSG(pBlk->pServerData, "Socket: handle DISCONNECT request.");
	if (pBlk->connectionType == DATA_CHANNEL)
	{
		/* pass the command to the agent controller to be processed */
		removeConnectionEntry_ptr_t pRemoveFunc = 
			pBlk->pServerData->agentControllerDataBlk.removeDataConnectionEntry;

		pRemoveFunc(pBlk->pServerData->cmo, pBlk->connectionId);
	}
	else
	{
		/* pass the command to the agent controller to be processed */
		removeDataConnectionEntry_ptr_t pDataRemoveFunc = 
			pBlk->pServerData->agentControllerDataBlk.removeConnectionEntry;

		pDataRemoveFunc(pBlk->pServerData->cmo, pBlk->connectionId);
	}

	return 0 ;

	/* read in the payload length */
	pMsg = readUINTFromBuffer(pMsg, pPayLoadLength) ;

	if ((flags & CONNECT) != 0)	{
	{
		handleCONNECT(pBlk, pMsg) ;

		/* prevent it from forwarding to the AC */
		pMsg = NULL ;
	}
	else if (((flags & CONNECT_DATA) != 0) || ((flags & CONNECT_CONSOLE) != 0))
		     ((flags & CONNECT_CONSOLE) != 0))
	{
		if ((flags & CONNECT_CONSOLE) != 0)
			pBlk->isForConsole = TRUE;

		/* prevent it from forwarding to the AC */
		pMsg = NULL ;
	}
	else if (pBlk->pServerData->securityEnabled && !pBlk->secured) {  
		pMsg = NULL ;
	}
	else if ((flags & AUTHENTICATE) != 0) {
		handleAUTHENTICATE(pBlk, pMsg) ;
		pMsg = NULL ;
	} 
	else if (pBlk->pServerData->securityEnabled && !pBlk->authenticated) {
		processCONNECTCall(pBlk, pMsg, AUTHENTICATION_FAILED);
		pMsg = NULL ;
	}
	else
	{
		if (flags != 0)


		/* Another message might come in while we're processing
		 *    so we read until the pipe is empty                 */
		while ( (rc = recvData(pRdb, buffer, bufferLength, &bytesRead)) > 0)
		{
			TPTP_LOG_DEBUG_MSG1(pRdb->pServerData, "Socket processClientRequest: Read %d bytes.", bytesRead) ;


	pRequestDataBlock->pServerData = pServerData ;
	pRequestDataBlock->connectionId = 0 ;
	pRequestDataBlock->connectionType = 0 ;
	
	pRequestDataBlock->ssl_socket = NULL;
	pRequestDataBlock->authenticated = FALSE;
	pRequestDataBlock->secured = FALSE;

	pRequestDataBlock->isForConsole = FALSE ;
	

	return ( rc ) ;
}

/**
 *********************************************************
 *
 * @brief
 *    main running thread that accepts connection,
 *    set up the environment and process it in a new separate thread
 *
 * @return
 *    0 - Success
 *    nonzero - Error.
 *********************************************************/
int serveSecureRequest(server_block_ptr_t pServerData) {
	int      rc = 0 ;
	request_block_ptr_t pRequestDataBlock = NULL;
	TID threadId;
	HANDLE threadHandle;
	ssl_socket_t ssl_socket;

	/* initial status before the thread is running */
	pServerData->threadStatus = RUNNING ;

	/* accept and process one connection at a time */
	while (pServerData->threadStatus == RUNNING) {
        ssl_socket = ssl_accept(); 
		if (ssl_socket == NULL) break;

		/* set up the data block for each request */
		pRequestDataBlock = getInitRequestDataBlock(0, pServerData);
		pRequestDataBlock->ssl_socket = ssl_socket;

		/* go create a new thread to process each incoming connection request */
		rc = tptpStartThread(processClientRequest, (LPVOID) pRequestDataBlock, &threadId, &threadHandle);
	}

	return rc;
}

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

 *********************************************************
 *
 * @brief
 *    place to set up listening incoming secure requests
 *
 * @return
 *    0 - Success
 *    nonzero - Error.
 *********************************************************/
THREAD_USER_FUNC_RET_TYPE doSecureListening(LPVOID args) {
	server_block_ptr_t  pServerData = (server_block_ptr_t) args;

	/* ready to accept incoming connection requests */
	serveSecureRequest(pServerData);

	return 0;
}

/**
 *********************************************************
 *
 * @brief
 *    create a socket listener instance
 *
 * @return

 *********************************************************/
tptp_int32 createSocketListener(tptp_object* cmo, transport_layer_data_t * pTransportData, tptp_object* tlo) 
{
	server_block_t* pServerData;
	SocketConfigInfo socketInfo;
	int rc;

	rc = initForSocketCalls() ;
	if (rc != 0) {
		if (pTransportData->logEventEntry) 
			pTransportData->logEventEntry(cmo, "Socket TL", pTransportData->transportID, __FILE__, __LINE__, TPTP_FATAL, "Unable to initialize socket library.");
			
		return rc;
	}

	/* prepare the globally available server data block */
	pServerData = (server_block_ptr_t) malloc(sizeof(server_block_t)) ;
	pServerData->cmo = cmo;
	pServerData->threadStatus = 0 ;
	pServerData->agentControllerDataBlk = *pTransportData ;

	/* allocate connection table */
	pServerData->connectionTable = tableCreate();

	rc = getSocketConfigInfo(pTransportData->configurationData, &socketInfo);
	if (rc != -1) 
	{
		pServerData->port = socketInfo.portNumber;
		pServerData->securityEnabled = socketInfo.securityEnabled;
		pServerData->sslProviderLib = socketInfo.sslProviderLib; 
		pServerData->params = socketInfo.params; 
	} 
	else 
	{
		pServerData->port = DEFAULT_PORT_NUM;
		pServerData->securityEnabled = FALSE; 
		pServerData->sslProviderLib = NULL; 
		pServerData->params = NULL; 
	}

	tlo->data = pServerData;
	tlo->objectID = SOCKET_LISTENER_OBJECT_ID;

	TPTP_LOG_DEBUG_MSG(pServerData, "createTransportListener (socket)") ;
	}
	else
	{
		if ( pTransportData->logEventEntry )
		{
			pTransportData->logEventEntry( cmo, "Socket TL", pTransportData->transportID, __FILE__, __LINE__, TPTP_FATAL, "Unable to initialize socket library." );
		}
	}

	return rc;
}

/**

	pServerData->threadStatus = IDLE ;

	/* stop accepting connection */
	if (pServerData->securityEnabled) {
		ssl_reset();
	} else {
		sock = pServerData->serverSock ;
		rc = closeSocket(sock) ;
	}

	/* free the connection table */
    tableDelete( pServerData->connectionTable );

	TPTP_LOG_DEBUG_MSG(pServerData, "startTransportListener (socket)") ;

	/* create new thread to listen for incoming connection requests */
	if (pServerData->securityEnabled) {
	 	if (ssl_init(pServerData)) return -1;
		rc = tptpStartThread(doSecureListening,(LPVOID) pServerData, &threadId, &threadHandle);
	}
	else {
		rc = tptpStartThread(doListening,(LPVOID) pServerData, &threadId, &threadHandle);
	}

	return rc;
}

int closeConnection(request_block_ptr_t pBlock) {
	int rc=0;
	if (pBlock == NULL) return -1;

	if (pBlock->ssl_socket != NULL) {
		rc = ssl_close(pBlock->ssl_socket);  
		pBlock->ssl_socket = NULL; 
	}
	else {
  		rc = closeSocket(pBlock->clientSock);
  	}
	
  	pBlock->secured = FALSE;
  	pBlock->authenticated = FALSE;
  	
  	return rc;
}

/**

	tptp_getWriteLock( & pBlock->locker );

	/* go send the message */
	bytesSent = writeData(pBlock, pSendBuffer, bufferLength);
	if (bytesSent < 0)
	{
		TPTP_LOG_ERROR_MSG1(pServerData, "Socket: Failed to send data on connection ID %d", connectionID);

	if (pBlock == NULL) return -1;

	/* go send the message */
	bytesSent = writeData(pBlock, pDataBlock, dataSize); 
	if (bytesSent < 0)
	{
		TPTP_LOG_ERROR_MSG1(pServerData,"Socket: Failed to send data on connection ID %d", connectionID);

	return (forwardDataToPartner(pBlk, dataLen, pBuffer)) ;
}

/**
  *********************************************************
  *
  * @brief
  *    handle the AUTHENTICATE request
  *
  *********************************************************/
int handleAUTHENTICATE(request_block_ptr_t pBlk, char *pMsg) {
	char *name=NULL, *psw=NULL;
	BOOL success;

	pMsg = readStringFromBuffer(pMsg, &name);
	pMsg = readStringFromBuffer(pMsg, &psw);

	if (name != NULL && psw != NULL) {
		success = vrfusrpwd(name, psw) > 0;
	}
	else{
		success = FALSE;
	}
			
	if (success) {			
		TPTP_LOG_DEBUG_MSG1(pBlk->pServerData, "User %s is authenticated", name);
	}
	else if (name != NULL) {
		TPTP_LOG_DEBUG_MSG1(pBlk->pServerData, "User %s is not authenticated", name);
	}
	else {
		TPTP_LOG_DEBUG_MSG(pBlk->pServerData, "User <null> is not authenticated");
	}
 
	pBlk->authenticated = success;
	if (success) {
	 	processCONNECTCall(pBlk, pMsg, AUTHENTICATION_SUCCESSFUL);
	}
	else {
		processCONNECTCall(pBlk, pMsg, AUTHENTICATION_FAILED);
	}

	if (name != NULL) tptp_free(name);
	if (psw != NULL) tptp_free(psw);
	
	return 0 ;
}

int setSSL(request_block_ptr_t pBlk) {
	int err = ssl_handshake(pBlk->ssl_socket); 
	if (err) {
		TPTP_LOG_DEBUG_MSG(pBlk->pServerData, "SSL: ssl_handshake error");
		ssl_close(pBlk->ssl_socket);
		pBlk->ssl_socket = NULL;
	}
	else {
		pBlk->secured = TRUE;
	}

	return err;	
}

int recvData(request_block_ptr_t pRdb, char *buffer, int length, int *bytesRead) {
	int result;

	if (pRdb->pServerData->securityEnabled) {
		 result = ssl_read(pRdb->ssl_socket, buffer, length);
		 *bytesRead = result;
	}
	else {
		result = readFromSocket(pRdb->clientSock, buffer, length, bytesRead);
	}
		
	return result;
}

int writeData(request_block_ptr_t pBlock, char* buffer, int length) { 
	if (pBlock->pServerData->securityEnabled) {
		return ssl_write(pBlock->ssl_socket, buffer, length);
	}
	else {
		return writeToSocket(pBlock->clientSock, buffer, length);
	}
}
#endif

Lines 105-110 Link Here

(-)src-native-new/src/transport/socketTL/SocketTL.dsp (+8 lines)
105	SOURCE=.\socketTL.def	105	SOURCE=.\socketTL.def
106	# PROP Exclude_From_Build 1	106	# PROP Exclude_From_Build 1
107	# End Source File	107	# End Source File
		108	# Begin Source File
		109
		110	SOURCE=.\SSLSupport.c
		111	# End Source File
108	# End Group	112	# End Group
109	# Begin Group "Header Files"	113	# Begin Group "Header Files"
110		114
Lines 121-126 Link Here
121		125
122	SOURCE=.\SocketTLLog.h	126	SOURCE=.\SocketTLLog.h
123	# End Source File	127	# End Source File
		128	# Begin Source File
		129
		130	SOURCE=.\SSLSupport.h
		131	# End Source File
124	# End Group	132	# End Group
125	# Begin Group "Resource Files"	133	# Begin Group "Resource Files"
126		134




#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "SSLTypes.h"
#include "SSLSupport.h"
#include "SocketTLLog.h"
#include "tptp/TPTPUtils.h"
#include "tptp/tptpSSLProvider.h"

/* Resolved SSL functions */
static ssl_provider_accept_t ssl_provider_accept; 
static ssl_provider_handshake_t ssl_provider_handshake; 
static ssl_provider_read_t ssl_provider_read; 
static ssl_provider_write_t ssl_provider_write; 
static ssl_provider_close_t ssl_provider_close; 
static ssl_provider_reset_t ssl_provider_reset; 
static ssl_provider_reset_t ssl_provider_reset; 
static ssl_provider_getValue_t ssl_provider_getValue; 
static ssl_provider_setValue_t ssl_provider_setValue; 
static ssl_provider_getName_t ssl_provider_getName; 

int ssl_init(server_block_ptr_t pServerData) {
	tptp_param_t* param;
	tptp_node_t*  node;
	log_service_t* logService;

	DLL_REFERENCE sslLibrary;
	ssl_provider_init_t ssl_provider_init;
	int rc;

	if (!pServerData->securityEnabled) return 0;

	if (pServerData->sslProviderLib == NULL) {
		TPTP_LOG_ERROR_MSG(pServerData, "No ssl provider library supplied");
		return -1;
	}

	sslLibrary = LOAD_LIBRARY(pServerData->sslProviderLib);
	if (sslLibrary == NULL) {
		TPTP_LOG_ERROR_MSG1(pServerData, "Unable to find ssl provider library %s", pServerData->sslProviderLib);
		return -1;
	}

	ssl_provider_init = (ssl_provider_init_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_INIT);
	ssl_provider_accept = (ssl_provider_accept_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_ACCEPT); 
	ssl_provider_handshake = (ssl_provider_handshake_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_HANDSHAKE); 
	ssl_provider_read = (ssl_provider_read_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_READ); 
	ssl_provider_write = (ssl_provider_write_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_WRITE); 
	ssl_provider_close = (ssl_provider_close_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_CLOSE); 
	ssl_provider_reset = (ssl_provider_reset_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_RESET); 
	ssl_provider_getValue = (ssl_provider_getValue_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_GET_VALUE); 
	ssl_provider_setValue = (ssl_provider_setValue_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_SET_VALUE); 
	ssl_provider_getName = (ssl_provider_getName_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_GET_PROVIDER_NAME); 
	
    /* Check to make sure we found everything */ 
    if (ssl_provider_init &&
    	ssl_provider_accept &&
    	ssl_provider_handshake &&
    	ssl_provider_read &&
    	ssl_provider_write &&
    	ssl_provider_close &&
    	ssl_provider_reset &&
    	ssl_provider_getValue &&
    	ssl_provider_setValue &&
    	ssl_provider_getName) {

		for (node = pServerData->params->head; node != 0; node = node->next) {
			param = (tptp_param_t*) node->data;
			if (param != NULL && param->name != NULL && param->value != NULL) {
				ssl_setValue(param->name, param->value);
			}
		}
    	
    	logService = (log_service_t*) tptp_malloc(sizeof(log_service_t));
    	logService->cmo = pServerData->cmo;
    	logService->logEventEntry = pServerData->agentControllerDataBlk.logEventEntry;
    	
		rc = (*ssl_provider_init)(logService, pServerData->port);
		if (rc) {
			TPTP_LOG_ERROR_MSG1(pServerData, "Unable to initialize ssl provider %s", pServerData->sslProviderLib);
		} else {
			TPTP_LOG_DEBUG_MSG1(pServerData, "SSL provider \"%s\" successfully initialized", ssl_getProviderName());
		}
    } 
	else {
		TPTP_LOG_ERROR_MSG1(pServerData, "Unable to resolve ssl provider library %s", pServerData->sslProviderLib);
		rc = -1;
	}
	
	return rc;
}

ssl_socket_t ssl_accept() {
	return (ssl_provider_accept == NULL) ? NULL : (*ssl_provider_accept)();
}

int ssl_handshake(ssl_socket_t ssl_socket) {
	return (ssl_socket == NULL || ssl_provider_handshake == NULL) ? -1 : (*ssl_provider_handshake)(ssl_socket);
}

int ssl_read(ssl_socket_t ssl_socket, char* buffer, int length) {
	return (ssl_socket == NULL || ssl_provider_read == NULL) ? -1 : (*ssl_provider_read)(ssl_socket, buffer, length);
}

int ssl_write(ssl_socket_t ssl_socket, char* buffer, int length) {
	return (ssl_socket == NULL || ssl_provider_write == NULL) ? -1 : (*ssl_provider_write)(ssl_socket, buffer, length);
}

int ssl_close(ssl_socket_t ssl_socket) {
	return (ssl_socket == NULL || ssl_provider_close == NULL) ? -1 : (*ssl_provider_close)(ssl_socket);
}

int ssl_reset() {
	return (ssl_provider_reset == NULL) ? -1 : (*ssl_provider_reset)();
}

char* ssl_getValue(const char* name) {
	return (ssl_provider_getValue == NULL) ? NULL : (*ssl_provider_getValue)(name);
}

void ssl_setValue(const char* name, const char* value) {
	if (ssl_provider_setValue != NULL) (*ssl_provider_setValue)(name, value);
}

char* ssl_getProviderName() {
	return (ssl_provider_getName == NULL) ? NULL : (*ssl_provider_getName)();
}




#ifndef SSLSUPPORT_H
#define SSLSUPPORT_H

#include "SocketListener.h"
#include "SSLTypes.h"

extern int ssl_init(server_block_ptr_t pServerData);
extern ssl_socket_t ssl_accept();
extern int ssl_handshake(ssl_socket_t ssl_socket);
extern int ssl_read(ssl_socket_t ssl_socket, char* buffer, int length);
extern int ssl_write(ssl_socket_t ssl_socket, char* buffer, int length);
extern int ssl_close(ssl_socket_t ssl_socket);
extern int ssl_reset();
extern char* ssl_getValue(const char* name);
extern void ssl_setValue(const char* name, const char* value);
extern char* ssl_getProviderName();

#endif




#ifndef _SSLTypes_H
#define _SSLTypes_H

typedef void* ssl_socket_t;

/* Function names to be imported */
#define SSL_INIT 		"sslInit"
#define SSL_ACCEPT 		"sslAccept"
#define SSL_HANDSHAKE 	"sslHandshake"
#define SSL_READ 		"sslRead"
#define SSL_WRITE 		"sslWrite"
#define SSL_CLOSE 		"sslClose"
#define SSL_RESET 		"sslReset"
#define SSL_GET_VALUE 	"sslGetValue"
#define SSL_SET_VALUE 	"sslSetValue"
#define SSL_GET_PROVIDER_NAME "sslGetProviderName"

/* SSL function types */
typedef int (*ssl_provider_init_t)();
typedef ssl_socket_t (*ssl_provider_accept_t)();
typedef int (*ssl_provider_handshake_t)();
typedef int (*ssl_provider_read_t)();
typedef int (*ssl_provider_write_t)();
typedef int (*ssl_provider_close_t)();
typedef int (*ssl_provider_reset_t)();
typedef char* (*ssl_provider_getValue_t)(const char*);
typedef void (*ssl_provider_setValue_t)(const char*, const char*);
typedef char* (*ssl_provider_getName_t)();

#endif




#ifndef _TPTP_SSL_PROVIDER_H
#define _TPTP_SSL_PROVIDER_H

typedef struct {
  	tptp_object* cmo;
  	logEventEntry_ptr_t logEventEntry;
} log_service_t;

/*
 * Interface functions for SSL provider
 */
int sslInit(log_service_t *logService, int port);

void* sslAccept();
int sslHandshake(void* handle);
int sslRead(void* handle, char* buffer, int length);
int sslWrite(void* handle, char* buffer, int length);
int sslClose(void* handle);
int sslReset();
char* sslGetProviderName();
char* sslGetValue(const char* name);
void sslSetValue(const char* name, const char* value);

#endif

Return to bug 195644

Added Link Here

(-)src-native-new/src/transport/socketTL/SSLSupport.c (+128 lines)
1	#include <stdio.h>
2	#include <stdlib.h>
3	#include <string.h>
4
5	#include "SSLTypes.h"
6	#include "SSLSupport.h"
7	#include "SocketTLLog.h"
8	#include "tptp/TPTPUtils.h"
9	#include "tptp/tptpSSLProvider.h"
10
11	/* Resolved SSL functions */
12	static ssl_provider_accept_t ssl_provider_accept;
13	static ssl_provider_handshake_t ssl_provider_handshake;
14	static ssl_provider_read_t ssl_provider_read;
15	static ssl_provider_write_t ssl_provider_write;
16	static ssl_provider_close_t ssl_provider_close;
17	static ssl_provider_reset_t ssl_provider_reset;
18	static ssl_provider_reset_t ssl_provider_reset;
19	static ssl_provider_getValue_t ssl_provider_getValue;
20	static ssl_provider_setValue_t ssl_provider_setValue;
21	static ssl_provider_getName_t ssl_provider_getName;
22
23	int ssl_init(server_block_ptr_t pServerData) {
24	tptp_param_t* param;
25	tptp_node_t* node;
26	log_service_t* logService;
27
28	DLL_REFERENCE sslLibrary;
29	ssl_provider_init_t ssl_provider_init;
30	int rc;
31
32	if (!pServerData->securityEnabled) return 0;
33
34	if (pServerData->sslProviderLib == NULL) {
35	TPTP_LOG_ERROR_MSG(pServerData, "No ssl provider library supplied");
36	return -1;
37	}
38
39	sslLibrary = LOAD_LIBRARY(pServerData->sslProviderLib);
40	if (sslLibrary == NULL) {
41	TPTP_LOG_ERROR_MSG1(pServerData, "Unable to find ssl provider library %s", pServerData->sslProviderLib);
42	return -1;
43	}
44
45	ssl_provider_init = (ssl_provider_init_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_INIT);
46	ssl_provider_accept = (ssl_provider_accept_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_ACCEPT);
47	ssl_provider_handshake = (ssl_provider_handshake_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_HANDSHAKE);
48	ssl_provider_read = (ssl_provider_read_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_READ);
49	ssl_provider_write = (ssl_provider_write_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_WRITE);
50	ssl_provider_close = (ssl_provider_close_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_CLOSE);
51	ssl_provider_reset = (ssl_provider_reset_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_RESET);
52	ssl_provider_getValue = (ssl_provider_getValue_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_GET_VALUE);
53	ssl_provider_setValue = (ssl_provider_setValue_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_SET_VALUE);
54	ssl_provider_getName = (ssl_provider_getName_t) RESOLVE_ENTRY_POINT(sslLibrary, SSL_GET_PROVIDER_NAME);
55
56	/* Check to make sure we found everything */
57	if (ssl_provider_init &&
58	ssl_provider_accept &&
59	ssl_provider_handshake &&
60	ssl_provider_read &&
61	ssl_provider_write &&
62	ssl_provider_close &&
63	ssl_provider_reset &&
64	ssl_provider_getValue &&
65	ssl_provider_setValue &&
66	ssl_provider_getName) {
67
68	for (node = pServerData->params->head; node != 0; node = node->next) {
69	param = (tptp_param_t*) node->data;
70	if (param != NULL && param->name != NULL && param->value != NULL) {
71	ssl_setValue(param->name, param->value);
72	}
73	}
74
75	logService = (log_service_t*) tptp_malloc(sizeof(log_service_t));
76	logService->cmo = pServerData->cmo;
77	logService->logEventEntry = pServerData->agentControllerDataBlk.logEventEntry;
78
79	rc = (*ssl_provider_init)(logService, pServerData->port);
80	if (rc) {
81	TPTP_LOG_ERROR_MSG1(pServerData, "Unable to initialize ssl provider %s", pServerData->sslProviderLib);
82	} else {
83	TPTP_LOG_DEBUG_MSG1(pServerData, "SSL provider \"%s\" successfully initialized", ssl_getProviderName());
84	}
85	}
86	else {
87	TPTP_LOG_ERROR_MSG1(pServerData, "Unable to resolve ssl provider library %s", pServerData->sslProviderLib);
88	rc = -1;
89	}
90
91	return rc;
92	}
93
94	ssl_socket_t ssl_accept() {
95	return (ssl_provider_accept == NULL) ? NULL : (*ssl_provider_accept)();
96	}
97
98	int ssl_handshake(ssl_socket_t ssl_socket) {
99	return (ssl_socket == NULL \|\| ssl_provider_handshake == NULL) ? -1 : (*ssl_provider_handshake)(ssl_socket);
100	}
101
102	int ssl_read(ssl_socket_t ssl_socket, char* buffer, int length) {
103	return (ssl_socket == NULL \|\| ssl_provider_read == NULL) ? -1 : (*ssl_provider_read)(ssl_socket, buffer, length);
104	}
105
106	int ssl_write(ssl_socket_t ssl_socket, char* buffer, int length) {
107	return (ssl_socket == NULL \|\| ssl_provider_write == NULL) ? -1 : (*ssl_provider_write)(ssl_socket, buffer, length);
108	}
109
110	int ssl_close(ssl_socket_t ssl_socket) {
111	return (ssl_socket == NULL \|\| ssl_provider_close == NULL) ? -1 : (*ssl_provider_close)(ssl_socket);
112	}
113
114	int ssl_reset() {
115	return (ssl_provider_reset == NULL) ? -1 : (*ssl_provider_reset)();
116	}
117
118	char* ssl_getValue(const char* name) {
119	return (ssl_provider_getValue == NULL) ? NULL : (*ssl_provider_getValue)(name);
120	}
121
122	void ssl_setValue(const char* name, const char* value) {
123	if (ssl_provider_setValue != NULL) (*ssl_provider_setValue)(name, value);
124	}
125
126	char* ssl_getProviderName() {
127	return (ssl_provider_getName == NULL) ? NULL : (*ssl_provider_getName)();
128	}

Added Link Here

(-)src-native-new/src/transport/socketTL/SSLSupport.h (+18 lines)
1	#ifndef SSLSUPPORT_H
2	#define SSLSUPPORT_H
3
4	#include "SocketListener.h"
5	#include "SSLTypes.h"
6
7	extern int ssl_init(server_block_ptr_t pServerData);
8	extern ssl_socket_t ssl_accept();
9	extern int ssl_handshake(ssl_socket_t ssl_socket);
10	extern int ssl_read(ssl_socket_t ssl_socket, char* buffer, int length);
11	extern int ssl_write(ssl_socket_t ssl_socket, char* buffer, int length);
12	extern int ssl_close(ssl_socket_t ssl_socket);
13	extern int ssl_reset();
14	extern char* ssl_getValue(const char* name);
15	extern void ssl_setValue(const char* name, const char* value);
16	extern char* ssl_getProviderName();
17
18	#endif

Added Link Here

(-)src-native-new/src/transport/socketTL/SSLTypes.h (+30 lines)
1	#ifndef _SSLTypes_H
2	#define _SSLTypes_H
3
4	typedef void* ssl_socket_t;
5
6	/* Function names to be imported */
7	#define SSL_INIT "sslInit"
8	#define SSL_ACCEPT "sslAccept"
9	#define SSL_HANDSHAKE "sslHandshake"
10	#define SSL_READ "sslRead"
11	#define SSL_WRITE "sslWrite"
12	#define SSL_CLOSE "sslClose"
13	#define SSL_RESET "sslReset"
14	#define SSL_GET_VALUE "sslGetValue"
15	#define SSL_SET_VALUE "sslSetValue"
16	#define SSL_GET_PROVIDER_NAME "sslGetProviderName"
17
18	/* SSL function types */
19	typedef int (*ssl_provider_init_t)();
20	typedef ssl_socket_t (*ssl_provider_accept_t)();
21	typedef int (*ssl_provider_handshake_t)();
22	typedef int (*ssl_provider_read_t)();
23	typedef int (*ssl_provider_write_t)();
24	typedef int (*ssl_provider_close_t)();
25	typedef int (*ssl_provider_reset_t)();
26	typedef char* (ssl_provider_getValue_t)(const char);
27	typedef void (ssl_provider_setValue_t)(const char, const char*);
28	typedef char* (*ssl_provider_getName_t)();
29
30	#endif

Added Link Here

(-)src-native-new/include/tptp/tptpSSLProvider.h (+24 lines)
1	#ifndef _TPTP_SSL_PROVIDER_H
2	#define _TPTP_SSL_PROVIDER_H
3
4	typedef struct {
5	tptp_object* cmo;
6	logEventEntry_ptr_t logEventEntry;
7	} log_service_t;
8
9	/*
10	* Interface functions for SSL provider
11	*/
12	int sslInit(log_service_t *logService, int port);
13
14	void* sslAccept();
15	int sslHandshake(void* handle);
16	int sslRead(void* handle, char* buffer, int length);
17	int sslWrite(void* handle, char* buffer, int length);
18	int sslClose(void* handle);
19	int sslReset();
20	char* sslGetProviderName();
21	char* sslGetValue(const char* name);
22	void sslSetValue(const char* name, const char* value);
23
24	#endif