/**********************************************************************************/
/* scol v 4                                                                       */
/*                                                                                */
/* proxyhttp.c                                                                    */
/*                                                                                */
/* proxy http management (authentication, authorization, ...)                     */
/*                                                                                */
/* cryonetworks, loïc berthelot, jull 2001                                        */
/**********************************************************************************/


// Modifications History
//
//$ LB (23/08/2001) : add uname and pword fields in ProxyHttpData_t struct in order to
//                    make proxy http authentication works with the wininet lib
//
//$ LB (03/09/2001) : TODO TO DO : LINUX-NOX : this package is not functionnal.... 


#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>

#include <sys/types.h>
#include <sys/socket.h>

#include "../../kernel/include/kernel.h"
#include "../../kernel/scolobj.h"
#include "../../kernel/include/socket.h"
#include "../../kernel/net/inet.h"
//$ LB : add base64
#include "../../kernel/base64.h"
#include "../../kernel/include/proxyhttp.h"
#include "../../kernel/scol.h"
#include "../../kernel/listlab.h"
#include "../../kernel/fifo.h"








/* TODO TO DO
#define HTTP_ERROR_PROXY_AUTHENTICATION_NEEDED "407"



#define PROXYHTTP_LOCK_FREE                0x00
#define PROXYHTTP_LOCK_PROCESSING_REQUESTS 0x01
#define PROXYHTTP_LOCK_RUNNING_DIALOG      0x02
*/




int 
_PROXYHTTP_SendAuthInfos (mmachine m, int networkAPI, int scolsuper, int channel, int handle);












/*********************************************************************************************************/
/*********************************************************************************************************/
/**                                                                                                     **/
/**                                                                                                     **/
/**          D A T A                                                                                    **/
/**                                                                                                     **/
/**                                                                                                     **/
/*********************************************************************************************************/
/*********************************************************************************************************/




/****************************************/
/*                                      */
/* ProxyData_t                          */
/*                                      */
/* define the set of data needed to     */
/* manage the http authentication       */
/*                                      */
/****************************************/
/* TODO TO DO
typedef struct ProxyHttpData_t
{
	int  lock;                // one of the PROXYHTTP_LOCK values

	int  authorization;       // 1 if informations are already stored
	char *userid;             // proxy http authentication infos <=> base64 (uname:pword)
	char *uname;              
	char *pword;

	char firewall[256];       // proxy ip, printed in the user dialog
	char domain[256];         // proxy domain, printed in the user dialog

	mmachine mmachine;

} ProxyHttpData_t;

static ProxyHttpData_t ProxyHttpData;
*/



/*****************************************/
/*                                       */
/* ProxyHttpRequest_t                    */
/*                                       */
/* used to store a request, waiting for  */
/* the authentication information to     */
/* come.                                 */
/*                                       */
/*****************************************/
/* TODO TO DO
typedef struct ProxyHttpRequest_t
{
	int  networkAPI; // PROXYHTTP_SCOL_NETWORK_API   or   PROXYHTTP_WININET_NETWORK_API
	int  scolsuper;	 // 1 if the request came from the main machine.
	int  channel;    // channel which the authorization will be given to
	int  handle;     // handle of inet object 
			 //     <=> if networkAPI == PROXYHTTP_SCOL_NETWORK_API : socket number for the request (handler system of inetobj
	                 //     <=> if networkAPI == PROXYHTTP_WININET_NETWORK_API : threadid used to identify the transfert struct of inet obj
	int  force;      // 1 if the client machine wants the main machine force the infos dialog
} ProxyHttpRequest_t;
*/




/**************************************************************/
/*                                                            */
/* ProxyHttpFifo_t                                            */
/*                                                            */
/* list of request that are waiting for                       */
/* authentication.                                            */
/* A dialog is gonna ask the user to enter his authentication */
/* infos. Because he can valid the dialog whenever he wants,  */
/* we need to store all the request 'til we get the infos.    */
/*                                                            */
/**************************************************************/
/* TODO TO DO
typedef struct ProxyHttpFifo_t
{
	ProxyHttpRequest_t** requests;      // dynamic tab of request
	int size;                           // dynamic size of tab
	int processState;                   // one of the PROXYHTTP_PROCESS values
} ProxyHttpFifo_t;

static ProxyHttpFifo_t ProxyHttpFifo;
*/




















/*********************************************************************************************************/
/*********************************************************************************************************/
/**                                                                                                     **/
/**                                                                                                     **/
/**          D A T A     I N I T I A L I Z A T I O N                                                    **/
/**                                                                                                     **/
/**                                                                                                     **/
/*********************************************************************************************************/
/*********************************************************************************************************/



/*****************************************/
/*                                       */
/* Proxy Http Data Initialization        */
/*                                       */
/*****************************************/
/* TODO TO DO
static int ProxyHttpDataInit = 0;

void _PROXYHTTP_DATA_Init ()
{
	ProxyHttpDataInit = 1;
	ProxyHttpData.lock = 0;
	ProxyHttpData.authorization = 0;
	ProxyHttpData.userid = NULL;
	ProxyHttpData.mmachine = NULL;
	ProxyHttpData.firewall[0] = '\0';
	ProxyHttpData.domain[0] = '\0';
}
*/



/*******************************************/
/*                                         */
/* Proxy Http Fifo Initialization          */
/*                                         */
/*******************************************/
/* TODO TO DO
static int ProxyHttpFifoInit = 0;

void _PROXYHTTP_FIFO_Init ()
{
	ProxyHttpFifoInit = 1;
	ProxyHttpFifo.requests = NULL;      // dynamic tab of request
	ProxyHttpFifo.size = 0;             // dynamic size of tab
	ProxyHttpFifo.processState = 0;     // one of the PROXYHTTP_PROCESS values
}
*/




















/*********************************************************************************************************/
/*********************************************************************************************************/
/**                                                                                                     **/
/**                                                                                                     **/
/**          I N T E R N A L    B O D Y                                                                 **/
/**                                                                                                     **/
/**          REQUESTS FIFO MANAGEMENT                                                                   **/
/**                                                                                                     **/
/**                                                                                                     **/
/*********************************************************************************************************/
/*********************************************************************************************************/







/************************************************************************************************/
/*                                                                                              */
/* void _PROXYHTTP_FIFO_Add (int networkAPI, int scolsuper, int channel, int handle, int force) */
/*                                                                                              */
/* add a request to fifo, waiting for authentication                                            */
/*                                                                                              */
/************************************************************************************************/
/* TODO TO DO
void _PROXYHTTP_FIFO_Add (int networkAPI, int scolsuper, int channel, int handle, int force)
{
	// increase fifo size
	ProxyHttpFifo.requests = (ProxyHttpRequest_t **) realloc (ProxyHttpFifo.requests, 
								 (ProxyHttpFifo.size+1)* sizeof (ProxyHttpRequest_t *));

	// alloc mem. for the new element
	ProxyHttpFifo.requests[ProxyHttpFifo.size] = (ProxyHttpRequest_t*) malloc (sizeof (ProxyHttpRequest_t));

	// fill the new element with data
	ProxyHttpFifo.requests[ProxyHttpFifo.size]->networkAPI = networkAPI;
	ProxyHttpFifo.requests[ProxyHttpFifo.size]->scolsuper  = scolsuper;
	ProxyHttpFifo.requests[ProxyHttpFifo.size]->channel    = channel;
	ProxyHttpFifo.requests[ProxyHttpFifo.size]->handle     = handle;
	ProxyHttpFifo.requests[ProxyHttpFifo.size]->force      = force;

	// update fifo size value
	ProxyHttpFifo.size++;
}
*/





/*********************************************************************************************************/
/*                                                                                                       */
/* void _PROXYHTTP_FIFO_Extract (int *networkAPI, int *scolsuper, int *channel, int* handle, int* force) */
/*                                                                                                       */
/* extract a request from the fifo, and store the data into the buffers                                  */
/* given as parameters.                                                                                  */
/*                                                                                                       */
/* return 0 if ok, non-zero code if error (fifo is empty...)                                             */
/*                                                                                                       */
/*********************************************************************************************************/
/* TODO TO DO
int _PROXYHTTP_FIFO_Extract (int *networkAPI, int *scolsuper, int *channel, int* handle, int* force)
{
int i;

	if (ProxyHttpFifo.size == 0)
		return -1;

	// update fifo size value
	ProxyHttpFifo.size--;

	// store the data
	*networkAPI = ProxyHttpFifo.requests [0]->networkAPI;
	*scolsuper  = ProxyHttpFifo.requests [0]->scolsuper;
	*channel    = ProxyHttpFifo.requests [0]->channel;
	*handle     = ProxyHttpFifo.requests [0]->handle;
	*force      = ProxyHttpFifo.requests [0]->force;

	for (i=0; i < ProxyHttpFifo.size; i++)
		*(ProxyHttpFifo.requests[i]) = *(ProxyHttpFifo.requests[i+1]);

	// free the mem.
	free (ProxyHttpFifo.requests[ProxyHttpFifo.size]);

	return 0;
}
*/







/************************************************/
/*                                              */
/* void _PROXYHTTP_FIFO_Process (mmachine m)    */
/*                                              */
/* process the requests fifo, and reply to all  */
/* the requests stored in it.                   */
/*                                              */
/************************************************/
/* TODO TO DO
void _PROXYHTTP_FIFO_Process (mmachine m)
{
int networkAPI, scolsuper, channel, handle, force;

	while (_PROXYHTTP_FIFO_Extract (&networkAPI, &scolsuper, &channel, &handle, &force) != -1)
		_PROXYHTTP_SendAuthInfos (m, networkAPI, scolsuper, channel, handle);
}
*/





























/*********************************************************************************************************/
/*********************************************************************************************************/
/**                                                                                                     **/
/**                                                                                                     **/
/**          I N T E R N A L    B O D Y                                                                 **/
/**                                                                                                     **/
/**          PROXY HTTP AUTHENTICATION MANAGEMENT                                                       **/
/**                                                                                                     **/
/**                                                                                                     **/
/*********************************************************************************************************/
/*********************************************************************************************************/







/***************************************************************/
/* scol v 4                                                    */
/*                                                             */
/* int PROXYHTTP_Authorization (mmachine m, SOCKET scksys)     */
/*                                                             */
/* re-send the request, in adding the proxy authentication     */
/* challenge in the header.                                    */
/*                                                             */
/***************************************************************/
int PROXYHTTP_Authorization (mmachine m, SOCKET scksys)
{
/* TODO TO DO

char *req;     int reqSize;
char *newReq;  int mnewReq, newReqRealSize, newReqSize;
int useridSize;

char* insertIndex, *insertIndex2; int insertSize;
int k;

SOCKET sck;
unsigned long int x;
int mobj, ppmobj;



	
	if ( ((mobj=OBJfindTH(m,ObjInetType, scksys))==NIL) ||
		((mobj=MMfetch(m, mobj, OFFOBJMAG)>>1)==NIL) ) return 0;

	
	if ((k=MMpush (m, (mobj<<1)+1))) return k;
	ppmobj = MMgetPP (m);

	//
	// !! DON'T FORGET TO PULL THE MOBJ POINTER FROM THE STACK BEFORE RETURN 0
	//


	// get the current request
	req     = MMstartstr (m, MMfetch (m, mobj, OBJINET_REQUEST) >> 1);
	reqSize = MMsizestr (m, MMfetch (m, mobj, OBJINET_REQUEST) >> 1);

	useridSize = strlen (ProxyHttpData.userid);
	
	// get the size needed for the new request
	newReqRealSize = reqSize + strlen (PROXYHTTP_BASIC_AUTHORIZATION_FIELD) + useridSize + 2; // '+ 2' for "\r\n" characters
	newReqSize = (newReqRealSize + 4)>>2;

	// ask scol to alloc memory for the new request
	mnewReq = MMmalloc (m, newReqSize+1, TYPEBUF); if (mnewReq==NIL) return MERRMEM;


	MMsetsizestr (m, mnewReq, newReqRealSize);

	newReq = MMstartstr (m, mnewReq);


	// helpfull to insert authorization field
	if ((insertIndex = strstr (req, PROXYHTTP_BASIC_AUTHORIZATION_FIELD)) == NULL)
		if ((insertIndex = strstr (req, "Host:")) == NULL)
		{
			// MMechostr (MSKDEBUG, "PROXY HTTP WARNING : no entry point to insert the authentication field!\n");

			MMpull(m);
			return 0;
		}
		else insertIndex2 = insertIndex;
	else insertIndex2 = strstr(insertIndex, "\r\n") + 2;





	insertSize = insertIndex - req;
	// copy the begining of header
	memcpy (newReq, req, insertSize);


	// insert the authorization field
	memcpy (newReq+insertSize, PROXYHTTP_BASIC_AUTHORIZATION_FIELD, strlen (PROXYHTTP_BASIC_AUTHORIZATION_FIELD));
	insertSize+=strlen (PROXYHTTP_BASIC_AUTHORIZATION_FIELD);


	// with the userid
	memcpy (newReq+insertSize, ProxyHttpData.userid, useridSize);
	insertSize+=useridSize;


	memcpy (newReq+insertSize, "\r\n", 2);
	insertSize+=2;



	// and copy the rest of the request
	memcpy (newReq+insertSize, insertIndex2, reqSize - (insertIndex2 - req));
	insertSize+=reqSize - (insertIndex2 - req);


	*(newReq + insertSize) = '\0';


	if ((x = inet_addr(http_proxy_host)) == INADDR_NONE)
	{
		x = mygethost(http_proxy_host);
	}

	if ( (newReq==NULL) || (*newReq==0) ||
		(x==0) ||
		((sck = socket(AF_INET, SOCK_STREAM, 0))<0) ||
		(SCKaddsock(sck, SC_TYPINET))
		)
		return DINET_GETURL_ERROR;
	



   if (DINETGetURLconnect (&sck, newReq, x, http_proxy_port) != DINET_GETURL_SUCCESS)
		return DINET_GETURL_ERROR;

    // put the new socket as the new system handler of this object
    OBJsetHandsys (m, ObjInetType, scksys, sck);

	// MMechostr (MSKDEBUG, "\nPROXY HTTP : change socket %d to socket %d in order to authenticate the request\n", scksys, sck);

	mobj = MMgetbase (m, ppmobj, 0)>>1;

    // replace the old request of the objinet, by this new one
    MMstore (m, mobj, OBJINET_REQUEST, (mnewReq<<1) + 1); 


	// and you have to send all data again
	MMstore (m, mobj, OBJINET_REQPOS, 0);


	// reset the data reception buffer
	if ((k = Mpushstrbloc(m, ""))) return k;
	mobj = MMgetbase (m, ppmobj, 0)>>1;
	MMstore(m, mobj, OBJINET_INBUF, MMpull (m));

	MMpull(m);


*/
	return 0;
}










/********************************************************/
/*                                                      */
/* int _PROXYHTTP_AccessDenied (mmachine m, int socket) */
/*                                                      */
/* the user has canceled authentication infos input.    */
/* http buffer with 407 error is returned to the        */
/* objinet callback.                                    */
/*                                                      */
/********************************************************/
/* TODO TO DO
int _PROXYHTTP_AccessDenied (mmachine m, int socket)
{
int k, mobj, leninbuf, ppinbuf;
char* inbuf;
char* token;
	



	// get inet object
	if ( ((mobj=OBJfindTH(m,ObjInetType,socket))==NIL) ||
			((mobj=MMfetch(m,mobj,OFFOBJMAG)>>1)==NIL) ) return 0;

	if ((k = MMpush (m, (mobj<<1)+1))) return k;
	if ((k = MMpush (m, MMfetch (m, MMget (m, 0) >> 1, OBJINET_INBUF)))) return k;


	inbuf = MMstartstr(m, MMget(m,0)>>1);

	if ((token = strstr (inbuf, "\r\n\r\n")))
	{
		leninbuf=MMsizestr(m,MMget(m,0)>>1);
		if ((k=MMpush(m,(token-inbuf+4)<<1))) return k;
		if ((k=MMpush(m,leninbuf<<1))) return k;
		if ((k=MBsubstr(m))) return k;
		mobj=MMget(m,1)>>1;
	}

    ppinbuf=MMgetPP(m);


	// make the 407 http error appear in inet callback
	if (OBJbeginreflex(m, ObjInetType, socket, INET_RFL_DATA) == 0)
	{
		if ((k = MMpush(m, MMgetbase(m,ppinbuf,0)))) return k;
		if ((k = MMpush(m, 0))) return k;
		if ((k = OBJcallreflex(m, 2))) return k;
	}

	MMpull(m);
	MMpull(m);


	// end of transmission
	if (OBJbeginreflex(m, ObjInetType, socket, INET_RFL_DATA) == 0)
	{
		if ((k = MMpush(m, NIL))) return k;
		if ((k = MMpush(m, 1<<1))) return k;
		OBJdelTH(m, ObjInetType, socket);
		if ((k = OBJcallreflex(m, 2))) return k;
	}



	return 0;
}
*/








/*********************************************************/
/*                                                       */
/* int PROXYHTTP_SetAuthInfos (mmachine m, char* defcom) */
/*                                                       */
/* client machine receives authentication infos from     */
/* the main machine.                                     */
/*                                                       */
/*********************************************************/
int PROXYHTTP_SetAuthInfos (mmachine m, char* defcom)
{
/* TODO TO DO

int networkAPI, handle, processState;
char tmp[512];

	// get defcom data
	sscanf (defcom, "%s\t%d\t%d\t%d\t", &(tmp[0]), &networkAPI, &handle, &processState);


	// the user gave authentication infos
	if (processState == PROXYHTTP_PROCESS_AUTHORIZED)
	{
	char userid[256], uname[256], pword[256];

		sscanf (defcom, "%s\t%d\t%d\t%d\t%s\t%s\t%s\t", &(tmp[0]), &networkAPI, &handle, &processState, &(userid[0]), &(uname[0]), &(pword[0]));

		// store authentication infos
		if (ProxyHttpData.userid) free (ProxyHttpData.userid);
		ProxyHttpData.userid = (char*) malloc ((strlen(userid) + 1) * sizeof(char));
		strcpy (ProxyHttpData.userid, userid);

		if (ProxyHttpData.uname) free (ProxyHttpData.uname);
		ProxyHttpData.uname = (char*) malloc ((strlen(uname) + 1) * sizeof(char));
		strcpy (ProxyHttpData.uname, uname);

		if (ProxyHttpData.pword) free (ProxyHttpData.pword);
		ProxyHttpData.pword = (char*) malloc ((strlen(pword) + 1) * sizeof(char));
		strcpy (ProxyHttpData.pword, pword);

		// ok, authentication infos are now present on this machine
		ProxyHttpData.authorization = 1;
	}




       if (processState == PROXYHTTP_PROCESS_AUTHORIZED)
       {
	   SCKclose ((SOCKET)handle);
	   PROXYHTTP_Authorization (m, (SOCKET)handle);
       }
       else 
	   _PROXYHTTP_AccessDenied (m, (SOCKET)handle);


*/
	return 0;
}








/*****************************************************************************************************/
/*                                                                                                   */
/* int _PROXYHTTP_SendAuthInfos (mmachine m, int networkAPI, int scolsuper, int channel, int handle) */
/*                                                                                                   */
/* dialog callback. get the informations the user entered.                                           */
/*                                                                                                   */
/*****************************************************************************************************/
int _PROXYHTTP_SendAuthInfos (mmachine m, int networkAPI, int scolsuper, int channel, int handle)
{
/* TODO TO DO
char defcom [1024];
char tmp [512];
int p,k;
char *c;



	// build defcom
	sprintf (defcom, "%s\t%d\t%d\t%d\t", PROXYHTTP_DEFCOM_AUTHENTICATION, networkAPI, handle, ProxyHttpFifo.processState);

	

	if (ProxyHttpFifo.processState == PROXYHTTP_PROCESS_AUTHORIZED)
	{
		sprintf (tmp, "%s\t%s\t%s\t", ProxyHttpData.userid, ProxyHttpData.uname, ProxyHttpData.pword);
		strcat (defcom, tmp);
	}

	if (scolsuper)
		PROXYHTTP_SetAuthInfos(m, defcom);

	else
	{
		// save the current channel
		if (MMpush (m, MMgetglobal (m, OFFSCCUR))) return MERRMEM;
		k=0;

		// select the master channel
		MMsetglobal (m, OFFSCCUR, channel);

		// fill the buffer with defcom and data
		if (Mpushstring(m, defcom)) return MERRMEM;
		c    = (char*)MMstart(m, MMget(m,0)>>1);
		p    = strlen(c)+1;
		c[0] = (p-2)&255;
		c[1] = ((p-2)>>8)&255;


		// send the defcom
		k    = SCsendpile(m);


		// get the saved channel
		MMsetglobal(m,OFFSCCUR,MMpull(m));	
	}

*/
	return 0;
}






void PROXYHTTP_ProcessAuthInfos()
{
/* TODO TO DO

	// indicate the dialog has returned and that the requests fifo is going to be processed
	// <=> DON'T WRITE IN OR EXTRACT FROM THE FIFO WHEN THIS LOCK IS PUT ON (well, indeed, that's the use of this lock value! :)
	ProxyHttpData.lock = PROXYHTTP_LOCK_PROCESSING_REQUESTS;

	// process fifo, and reply to all defcom stored in it
	_PROXYHTTP_FIFO_Process(ProxyHttpData.mmachine);

	// all right, now we can do it again, if it's necessary
	ProxyHttpData.lock = PROXYHTTP_LOCK_FREE;
*/
}










/************************************************/
/*                                              */
/* LRESULT CALLBACK _PROXYHTTP_ReadAuthInfos    */
/*                                              */
/* dialog callback. get the informations the    */
/* user entered.                                */
/*                                              */
/************************************************/
/*
LRESULT CALLBACK _PROXYHTTP_ReadAuthInfos (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{

	switch (msg)
	{
		// dialog initialization
		case WM_INITDIALOG:
			// set texts
			SetDlgItemText (hDlg, IDC_Firewall, (LPCTSTR)ProxyHttpData.firewall);
			SetDlgItemText (hDlg, IDC_Domain, (LPCTSTR)ProxyHttpData.domain);
			
			//SetFocus (hDlg);
			//SetForegroundWindow (hDlg);
			SetFocus (hDlg);
			return TRUE;

		// dialog validation
		case WM_COMMAND:
			if (LOWORD(wParam) == IDOK)
			{
			char uname[256];
			char pword[256];
			char tmp[512];
			int useridSize;


				// get the values the user entered
				GetDlgItemText (hDlg, IDC_Uname, (LPTSTR)uname, 255);
				GetDlgItemText (hDlg, IDC_Pword, (LPTSTR)pword, 255);

				// encode and store the informations
				sprintf (tmp, "%s:%s", uname, pword);
				useridSize = _base64_getEncodedSize (strlen(tmp));

				//$ LB (23/08/2001) : store the uname field
				if (ProxyHttpData.uname) free (ProxyHttpData.uname);
				ProxyHttpData.uname = (char*) malloc ((strlen (uname)+1) * sizeof(char));
				strcpy (ProxyHttpData.uname, uname);

				//$ LB (23/08/2001) : store the pword field
				if (ProxyHttpData.pword) free (ProxyHttpData.pword);
				ProxyHttpData.pword = (char*) malloc ((strlen (pword)+1) * sizeof(char));
				strcpy (ProxyHttpData.pword, pword);


				if (ProxyHttpData.userid) free (ProxyHttpData.userid);
				ProxyHttpData.userid = (char*) malloc ((useridSize+1) * sizeof(char));
				if (base64_encode (ProxyHttpData.userid, &useridSize, tmp, strlen (tmp)) != BASE64_SUCCESS)
					return FALSE;

				* (ProxyHttpData.userid + useridSize) = '\0';

				ProxyHttpData.authorization = 1;
				ProxyHttpFifo.processState = PROXYHTTP_PROCESS_AUTHORIZED;

				EndDialog(hDlg, 1);
			}
			else if (LOWORD(wParam) == IDCANCEL)
			{
				ProxyHttpFifo.processState = PROXYHTTP_PROCESS_CANCELED;
				EndDialog(hDlg, 0);
			}

			return TRUE;
			break;
	}
    return FALSE;

}
*/








/*******************************************/
/*                                         */
/* int _PROXYHTTP_DialogAuthInfos          */
/*                                         */
/* ask the user for the informations about */
/* proxy http authentication (dialog box)  */
/*                                         */
/*******************************************/
/*
DWORD _PROXYHTTP_DialogAuthInfos (mmachine m)
{


	// open dialog box
	DialogBox (scolDllInstance, MAKEINTRESOURCE(IDD_PROXYHTTP_AUTHENTICATION), NULL, (DLGPROC) _PROXYHTTP_ReadAuthInfos);


	
	ProxyHttpData.mmachine = m;
	PostMessage( hscol, WM_USER, PROXYHTTP_PROCESS_AUTHORIZATIONS, 0);

    ExitThread(0);
	return 0;	
}
*/









/*****************************************************/
/*                                                   */
/* PROXYHTTP_GetAuthInfos (mmachine m, char *defcom) */
/*                                                   */
/* asks the user the http authentication infos,      */
/* if needed, and send them onto the master ch.      */
/*                                                   */
/*****************************************************/

int PROXYHTTP_GetAuthInfos (mmachine m, char *defcom)
{
/* TODO TO DO
DWORD dwThreadId; 
int channel, networkAPI, scolsuper, handle, force;
char defcomName[512];
char tmp[512];



	if (!ProxyHttpDataInit)
		_PROXYHTTP_DATA_Init();

	if (!ProxyHttpFifoInit)
		_PROXYHTTP_FIFO_Init();


	channel = MMgetglobal (m, OFFSCCUR);


	// get defcom data
	sscanf (defcom, "%s\t%d\t%d\t%d\t%d\t", (char*) defcomName, &networkAPI, &scolsuper, &handle, &force);
	sprintf (tmp, "%s\t%d\t%d\t%d\t%d\t", (char*) defcomName, networkAPI, scolsuper, handle, force);
	{
	char* data = defcom + strlen (tmp);
	char* ptr = strstr (data, "\t");

		// store the proxy ip (only to print it on the dialog)
		memcpy (ProxyHttpData.firewall, data, ptr - data);
		ProxyHttpData.firewall[ptr - data] = '\0';

		data = ptr+1;
		ptr = strstr (data, "\t");

		//store the proxy domain name (only to print it on the dialog)
		memcpy (ProxyHttpData.domain, data, ptr- data);
		ProxyHttpData.domain[ptr - data] = '\0';
	}




	

	// if another defcom has engage the dialog, wait for it
	if (ProxyHttpData.lock == PROXYHTTP_LOCK_RUNNING_DIALOG)
		_PROXYHTTP_FIFO_Add ( networkAPI, scolsuper, channel, handle, force);


	// if the user force the demand, or if the demand has never been done, 
	// engage dialog process, but wait for the previous one to end
	else
	if ((force) || (!force && !PROXYHTTP_IsAuthorized()))
	{
		// wait for previous thread to end
		while (ProxyHttpData.lock != PROXYHTTP_LOCK_FREE)
		{
			Sleep (500);
		}



		// store the defcom data
		_PROXYHTTP_FIFO_Add (networkAPI, scolsuper, channel, handle, force);

		// indicate you engage dialog <=> no other dialog could be engage then
		ProxyHttpData.lock = PROXYHTTP_LOCK_RUNNING_DIALOG;

		// dialog in a thread
		if (CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) _PROXYHTTP_DialogAuthInfos, 
				m, 0, &dwThreadId) == NULL) 
		{

			ProxyHttpData.lock = PROXYHTTP_LOCK_FREE;
			return -1;		
		}
		
	}

	// else send directly the infos
	else
		_PROXYHTTP_SendAuthInfos (m, networkAPI, scolsuper, channel, handle);

TODO TO DO */	
	return 0;
}










/*************************************************************************************/
/*                                                                                   */
/* int PROXYHTTP_AskAuthInfos (mmachine m, int networkAPI, int handle, int force)    */
/*                                                                                   */
/* make the client machine ask the main machine the informations                     */
/* about http authentication.                                                        */
/*                                                                                   */
/* char* networkAPI <=> PROXYHTTP_SCOL_NETWORK_API or PROXYHTTP_WININET_NETWORK_API  */
/*                                                                                   */
/* int handle       <=> if PROXYHTTP_SCOL_NETWORK_API                                */
/*                         <=> SOCKET sck                                            */
/*					else if PROXYHTTP_WININET_NETWORK_API                            */
/*						   <=> DWORD threadid                                        */
/*                                                                                   */
/* int force   <=> 1 to make the scol engine force the dialog,                       */
/*                 0 let it determine if the dialog is necessary                     */
/*                                                                                   */
/*************************************************************************************/
int PROXYHTTP_AskAuthInfos (mmachine m, int networkAPI, int handle, int force)
{
/* TODO TO DO

int p,k;
char defcom[512];
char *c;


	// defcom
	sprintf(defcom, "%s\t%d\t%d\t%d\t%d\t%s\t%s\t", PROXYHTTP_DEFCOM_AUTHENTICATION_REQUEST, networkAPI, ScolSuper, handle, force, ProxyHttpData.firewall, ProxyHttpData.domain);


	if (ScolSuper)
		PROXYHTTP_GetAuthInfos (m, defcom);

	else
	{
		// save the current channel
		if (MMpush (m, MMgetglobal (m, OFFSCCUR))) return MERRMEM;
		k=0;

		// select the master channel
		if (!SCselectcanal(m, socklife))
		{
			// fill the buffer with defcom and data
			if (Mpushstring(m, defcom)) return MERRMEM;
			c    = (char*)MMstart(m, MMget(m,0)>>1);
			p    = strlen(c)+1;
			c[0] = (p-2)&255;
			c[1] = ((p-2)>>8)&255;


			// send the defcom
			k    = SCsendpile(m);
		} 

		// get the saved channel
		MMsetglobal(m,OFFSCCUR,MMpull(m));	
	}

*/
	return 0;
}






/******************************************************************/
/*                                                                */
/* int PROXYHTTP_IsAuthorized ()                                  */
/*                                                                */
/* returns 1 if the scol machine has already got the http         */
/* authentication infos, 0 if not                                 */ 
/*                                                                */
/******************************************************************/
int PROXYHTTP_IsAuthorized ()
{
/* TODO TO DO

	if (!ProxyHttpDataInit)
		_PROXYHTTP_DATA_Init();

	if (!ProxyHttpFifoInit)
		_PROXYHTTP_FIFO_Init();

	return ProxyHttpData.authorization;
*/ return 0;
}





/******************************************************************/
/*                                                                */
/* int PROXYHTTP_IsAuthorizationRejected (char* request)          */
/*                                                                */
/* returns 1 if the scol machine has already got the http         */
/* authentication infos, 0 if not                                 */ 
/*                                                                */
/******************************************************************/
int PROXYHTTP_IsAuthorizationRejected (char* request)
{
/* TODO TO DO
	if (strstr (request, PROXYHTTP_BASIC_AUTHORIZATION_FIELD) != NULL)
		return 1;

*/
	return 0;
}











/******************************************************************/
/*                                                                */
/* int PROXYHTTP_IsAuthenticated (char* header, int headerSize)   */
/*                                                                */
/* check if a 407 HTTP error is contained in the header of proxy  */
/* http message.                                                  */
/*                                                                */
/* returns 1 if 407 error, 0 if not.                              */
/*                                                                */
/******************************************************************/
int PROXYHTTP_IsAuthenticated (char* header, int headerSize)
{
/* TODO TO DO
char* index, *index2;
char errorCode[4];
int challengeSize, domainSize;
char challenge[1024];

	sprintf (challenge, "%s%s", PROXYHTTP_AUTHENTICATION_CHALLENGE_FIELD, PROXYHTTP_BASIC_CHALLENGE);


	// get the HTTP code
	index = strstr (header, " ");

	if (index >= header+headerSize)
		return 0;

	memcpy (errorCode, index+1, 3);
	errorCode[3] = '\0';

	// it's a 407 error code
	if (!strcmp (errorCode, HTTP_ERROR_PROXY_AUTHENTICATION_NEEDED))
	{
		// we only manage the Basic authentication challenge
		if ((index = strstr (header, challenge)))
			if (index < (header+headerSize))
				if ((index2 = strstr (index, "\r\n")))
				{
					// store the proxy domain name included in the request header
					challengeSize = strlen(challenge);
					domainSize = index2 - index - challengeSize;
					memcpy (&(ProxyHttpData.domain[0]), index + challengeSize, domainSize);
					if (ProxyHttpData.domain[domainSize - 1] == '\"')
						ProxyHttpData.domain[domainSize - 1] = '\0';
						else ProxyHttpData.domain[domainSize] = '\0';


					// store the proxy host name
					strcpy (&(ProxyHttpData.firewall[0]), http_proxy_host);
				}
				return 1;
	}			
	
*/
	return 0;
}





char* PROXYHTTP_GetUname ()
{
/* TODO TO DO
	if (!PROXYHTTP_IsAuthorized())
		return NULL;

	return ProxyHttpData.uname;
*/ return NULL;
}


char* PROXYHTTP_GetPword ()
{
/* TODO TO DO
	if (!PROXYHTTP_IsAuthorized())
		return NULL;

	return ProxyHttpData.pword;
*/ return NULL;
}



char* PROXYHTTP_GetUserID()
{
/* TODO TO DO
	if (!PROXYHTTP_IsAuthorized())
		return NULL;

	return ProxyHttpData.userid;
*/ return NULL;
}


