C:/fscan/HTTPCore/HTTP.cpp

Go to the documentation of this file.

/*
 * TODO:
 * Revisar el soporte de proxy HTTP con autenticacion ("Proxy-Authorization" + "Proxy-Authenticate")
 * Implementation of the AutoRedirect303 feature (y mirar que hacer con 302 y 301 )
 * Segregar SendHTTPRequest() en BuildHTTPRequest() y despues una llamada a DispatchHTTPRequest(). 
   Esto permitiría definir un SendAsyncHTTPRequest() y definir un Callback para la petición.
*/

#include "HTTPCore.h"
#include "CallBack.h"
#include "Threading.h"



/*******************************************************************************
 ************************** Functions not exported *****************************
 *******************************************************************************/

static char*            GetServerVersion(HTTP_DATA *response);
static unsigned int     IschallengeSupported(char *headers);
static PREQUEST         ParseReturnedBuffer(HTTPHANDLE HTTPHandle, PHTTP_DATA request, PHTTP_DATA response, char *url);

/*******************************************************************************
 *************************** Local definitions to this module ******************
 *******************************************************************************/
unsigned int AutoRedirect303             = 1;
const char       UserAgent[]                     = "User-Agent: Mozilla/5.0 (FHScan Core 1.1)\r\n";
PHHANDLE         GlobalHTTPCoreApiOptions = NULL;

/*******************************************************************************/
/************************** GLOBAL HTTP CORE FUNCTIONS *************************/
/*******************************************************************************/

/*******************************************************************************/
int             InitHTTPApi(void)
{
        int ret = InitHTTPApiCore();
        if ( ret == 1 )
        {
                GlobalHTTPCoreApiOptions = (PHHANDLE)malloc(sizeof(struct _hhandle));
                memset((void*)GlobalHTTPCoreApiOptions,0,sizeof(struct _hhandle));
        }
        return (ret);
}
/*******************************************************************************/
/*******************************************************************************/
void    CloseHTTPApi(void)
{
        CloseHTTPApiCore();
        if (GlobalHTTPCoreApiOptions)
        {
                free(GlobalHTTPCoreApiOptions);
                GlobalHTTPCoreApiOptions = NULL;
        }
        CloseHTTPConnectionHandle((HTTPHANDLE)GlobalHTTPCoreApiOptions);
        GlobalHTTPCoreApiOptions = NULL;
}
/*******************************************************************************/

/*******************************************************************************/
int SetHTTPAPIConfig(int opt, char *parameter)
{
        return(SetHTTPConfig(GlobalHTTPCoreApiOptions,opt,parameter));
}
/*******************************************************************************/

/*******************************************************************************/
char *GetHTTPAPIConfig( int opt)
{
        return(GetHTTPConfig(GlobalHTTPCoreApiOptions,opt));
}
/*******************************************************************************/

 /*******************************************************************************/
HTTPHANDLE InitHTTPConnectionHandle(char *hostname, int port, int ssl)
{
        PHHANDLE HTTPHandle=NULL;
        struct sockaddr_in remote;

        remote.sin_addr.s_addr = inet_addr(GlobalHTTPCoreApiOptions->ProxyHost ? GlobalHTTPCoreApiOptions->ProxyHost : hostname);
        if (remote.sin_addr.s_addr == INADDR_NONE)
        {
                struct hostent *hostend=gethostbyname(GlobalHTTPCoreApiOptions->ProxyHost ? GlobalHTTPCoreApiOptions->ProxyHost : hostname);
                if (!hostend)
                {
                        return((HTTPHANDLE)NULL);
                }
                memcpy(&remote.sin_addr.s_addr, hostend->h_addr, 4);
        }
        HTTPHandle=(PHHANDLE)malloc(sizeof(struct _hhandle));
        memset(HTTPHandle,0,sizeof(struct _hhandle));
        HTTPHandle->target=remote.sin_addr.s_addr;
        strncpy(HTTPHandle->targetDNS, hostname ,sizeof(HTTPHandle->targetDNS));
        //printf("resuelto %s como %s\n",hostname,inet_ntoa(remote.sin_addr));
        HTTPHandle->port                        = port;
        HTTPHandle->NeedSSL                     = ssl;
        HTTPHandle->version                     = 1;
        HTTPHandle->AdditionalHeader= GlobalHTTPCoreApiOptions->AdditionalHeader ? _strdup(GlobalHTTPCoreApiOptions->AdditionalHeader) : NULL;
        HTTPHandle->UserAgent           = GlobalHTTPCoreApiOptions->UserAgent ? _strdup(GlobalHTTPCoreApiOptions->UserAgent) : NULL;
        HTTPHandle->ProxyHost           = GlobalHTTPCoreApiOptions->ProxyHost ? _strdup(GlobalHTTPCoreApiOptions->ProxyHost): NULL;
        HTTPHandle->ProxyPort           = GlobalHTTPCoreApiOptions->ProxyPort ? _strdup(GlobalHTTPCoreApiOptions->ProxyPort): NULL;
        HTTPHandle->lpProxyUserName = GlobalHTTPCoreApiOptions->lpProxyUserName ? _strdup(GlobalHTTPCoreApiOptions->lpProxyUserName): NULL;
        HTTPHandle->lpProxyPassword = GlobalHTTPCoreApiOptions->lpProxyPassword ? _strdup(GlobalHTTPCoreApiOptions->lpProxyPassword): NULL;
        HTTPHandle->DownloadBwLimit = GlobalHTTPCoreApiOptions->DownloadBwLimit ? _strdup(GlobalHTTPCoreApiOptions->DownloadBwLimit): NULL; 
        HTTPHandle->Cookie                      = NULL;
        HTTPHandle->conexion            = NULL;
        HTTPHandle->LastAuthenticationString=NULL;
        memset(HTTPHandle->LastRequestedUri,'\0',sizeof(HTTPHandle->LastRequestedUri));
        #ifdef _DBG_
        printf("resuelto %s como %s\n",hostname,inet_ntoa(remote.sin_addr));
        #endif
        
#ifdef __WIN32__RELEASE__
        HTTPHandle->ThreadID = GetCurrentThreadId();
#else
        HTTPHandle->ThreadID = pthread_self();
#endif

        return((HTTPHANDLE)HTTPHandle);

}
/*******************************************************************************/

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

char *GetHTTPConfig(HTTPHANDLE HTTPHandle,int opt)
{
        PHHANDLE phandle=(PHHANDLE)HTTPHandle;
        switch(opt)
        {
                case OPT_HTTP_MAXSPEED_DOWNLOAD:
                        return(NULL);
                        break;
                case OPT_HTTP_COOKIE:
                        return ( phandle->Cookie );
                        break;
                case OPT_HTTP_HEADER:
                        return ( phandle->AdditionalHeader );
                        break;
                case OPT_HTTP_USERAGENT:
                        return ( phandle->UserAgent);
                        break;
                case OPT_HTTP_PROXY_HOST:
                        return ( phandle->ProxyHost);
                        break;
                case OPT_HTTP_PROXY_PORT:
                        return(phandle->ProxyPort);
                        break;
                case OPT_HTTP_PROXY_USER:
                        return ( phandle->lpProxyUserName );
                        break;
                case OPT_HTTP_PROXY_PASS:
                        return ( phandle->lpProxyPassword );
                        break;
                case OPT_HTTP_PROTOCOL:
                        return(NULL);
                        break;
        }
        return(NULL);
}
/*******************************************************************************/

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

int SetHTTPConfig(HTTPHANDLE HTTPHandle,int opt, char *parameter)
{
        PHHANDLE phandle=(PHHANDLE)HTTPHandle;
        if (!HTTPHandle) return(-1);

        switch (opt)
        {

         case OPT_HTTP_MAXSPEED_DOWNLOAD:
                 if (phandle->DownloadBwLimit) free(phandle->DownloadBwLimit);
                 if (parameter)
                 {                       
                         phandle->DownloadBwLimit = _strdup(parameter);
                 } else {
                         phandle->DownloadBwLimit = NULL;
                 }

                break;
         case OPT_HTTP_COOKIE:
                 if ( (parameter) && (*parameter) ){
                        if (phandle->Cookie)
                        {
                                free(phandle->Cookie);
                                phandle->Cookie= NULL;
                        }
                        if (strnicmp(parameter,"Cookie: ",8)==0) //Validate the cookie parameter
                        {
                                phandle->Cookie=_strdup(parameter);
                        } else //Add Cookie Header..
                        {
                                phandle->Cookie=(char*)malloc( 8 + strlen(parameter) +1 );
                                strcpy(phandle->Cookie,"Cookie: ");
                                strcpy(phandle->Cookie+8,parameter);
                        }
                 } else {
                         if (phandle->Cookie)
                         {
                                free(phandle->Cookie);
                                phandle->Cookie = NULL;
                         }
                 }
                break;

         case OPT_HTTP_HEADER:
                 if (phandle->AdditionalHeader) 
                 {
                         free(phandle->AdditionalHeader);                       
                 }
                 if ( (parameter) && (*parameter) && (strchr(parameter,':')) ) 
                 {
                         int len2 = (int) strlen(parameter);
                         if (memcmp(parameter+len2 -2,"\r\n",2)!=0) {
                                 phandle->AdditionalHeader = (char*)malloc(len2 +2 +1 );
                                 memcpy(phandle->AdditionalHeader,parameter,len2);
                                 memcpy(phandle->AdditionalHeader +len2,"\r\n\x00",3);
                         } else {
                                phandle->AdditionalHeader = _strdup(parameter);
                        }
                 }  else {
                         phandle->AdditionalHeader=NULL;
                 }
                break;

         case OPT_HTTP_USERAGENT:
                 if (phandle->UserAgent) {
                        free(phandle->UserAgent);
                 }
                 if (parameter) {                       
                        phandle->UserAgent= _strdup(parameter);
                } else {
                                phandle->UserAgent=NULL;
                }
                break;
         case OPT_HTTP_PROXY_HOST:
                if (phandle->ProxyHost) {
                        free(phandle->ProxyHost);
                        phandle->ProxyHost=NULL;
                }
                phandle->NeedSSL=0;
                if (parameter) {
                        struct sockaddr_in remote;
                        phandle->ProxyHost=_strdup(parameter);
                        remote.sin_addr.s_addr = inet_addr(phandle->ProxyHost);
                        if (remote.sin_addr.s_addr == INADDR_NONE)
                        {
                                struct hostent *hostend=gethostbyname(phandle->ProxyHost);
                                if (!hostend) return(-1);
                                memcpy(&remote.sin_addr.s_addr, hostend->h_addr, 4);
                        }
                        phandle->target=remote.sin_addr.s_addr;
                } else  {
                        struct sockaddr_in remote;
                        phandle->ProxyHost = NULL;
                        remote.sin_addr.s_addr = inet_addr(phandle->targetDNS);
                        if (remote.sin_addr.s_addr == INADDR_NONE)
                        {
                                struct hostent *hostend=gethostbyname(phandle->targetDNS);
                                if (!hostend) return(-1);
                                memcpy(&remote.sin_addr.s_addr, hostend->h_addr, 4);
                        }
                        phandle->target=remote.sin_addr.s_addr;
                }
                phandle->conexion=NULL;
                if (!phandle->ProxyPort) phandle->ProxyPort=_strdup("8080");
                break;

         case OPT_HTTP_PROXY_PORT:
                if (parameter) {
                        if (phandle->ProxyPort) free(phandle->ProxyPort);
                        phandle->ProxyPort=_strdup(parameter);
                } else {
                        free(phandle->ProxyPort);
                        phandle->ProxyPort=NULL;
                }
                break;

         case OPT_HTTP_PROXY_USER:
        if (phandle->lpProxyUserName) {
                        free(phandle->lpProxyUserName);
                }
                if (parameter) {
                        phandle->lpProxyUserName=_strdup(parameter);
                } else phandle->lpProxyUserName=NULL;
                break;

         case OPT_HTTP_PROXY_PASS:
                if (phandle->lpProxyPassword) {
                        free(phandle->lpProxyPassword);
                }
                if (parameter) {
                        phandle->lpProxyPassword=_strdup(parameter);
                } else phandle->lpProxyPassword=NULL;
                break;

         case OPT_HTTP_PROTOCOL:
                if (parameter) {
                        phandle->version=atoi(parameter);
                } else phandle->version=1;
        break;
         default:
        return(-1);

        }
    return(1);

}
/*******************************************************************************/

/*******************************************************************************/
void CloseHTTPConnectionHandle(HTTPHANDLE HTTPHandle){
        if (HTTPHandle) {
                if ((((PHHANDLE)HTTPHandle)->DownloadBwLimit)) free((((PHHANDLE)HTTPHandle)->DownloadBwLimit));
                if ((((PHHANDLE)HTTPHandle)->ProxyHost)) free((((PHHANDLE)HTTPHandle)->ProxyHost));
                if ((((PHHANDLE)HTTPHandle)->ProxyPort)) free((((PHHANDLE)HTTPHandle)->ProxyPort));
                if ((((PHHANDLE)HTTPHandle)->AdditionalHeader)) free((((PHHANDLE)HTTPHandle)->AdditionalHeader));
                if ((((PHHANDLE)HTTPHandle)->UserAgent)) free((((PHHANDLE)HTTPHandle)->UserAgent));
                if ((((PHHANDLE)HTTPHandle)->lpProxyUserName)) free((((PHHANDLE)HTTPHandle)->lpProxyUserName));
                if ((((PHHANDLE)HTTPHandle)->lpProxyPassword)) free((((PHHANDLE)HTTPHandle)->lpProxyPassword));
                if ((((PHHANDLE)HTTPHandle)->LastAuthenticationString)) free((((PHHANDLE)HTTPHandle)->LastAuthenticationString));
                free(HTTPHandle);
        }
}

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

/*******************************************************************************/
static char *GetServerVersion(HTTP_DATA *response){
        char *server=NULL;
        if (response)
        {
                if (response->Header)
                {
                        if (response->HeaderSize)
                        {
                                server = GetHeaderValue(response->Header,"Server: ",0);
                                if ((!server) && (response->HeaderSize>=12) )
                                {
                                        //server=(char*)malloc(9);
                                        //sprintf(server,"HTTP/1.%c",response->Header[7]);
                                        //TODO: IMPLEMENT THIS IN NEXT RELEASE
                                }
                        }

                }
        }
        return( server ? server :_strdup("HTTP/1.0") );
}
/*****************************************************************************/

/*****************************************************************************/
static unsigned int IschallengeSupported(char *headers)
{
  char *AuthNeeded="WWW-Authenticate:";
  unsigned int ret=0;
  int i=0;
  char *auth;

  do {
    auth=GetHeaderValue(headers,AuthNeeded,i++);
        if (auth) {
                if (strnicmp (auth, "basic",  5) == 0) {
                   if (!(ret & BASIC_AUTH)) ret+=BASIC_AUTH;
                }  else
                if (strnicmp (auth, "digest", 6) == 0) {
                   if (!(ret & DIGEST_AUTH)) ret+=DIGEST_AUTH;
                } else
                if (strnicmp (auth, "ntlm",   4) == 0) {
                   if (!(ret & NTLM_AUTH)) ret+=NTLM_AUTH;
                } else
                if (strnicmp (auth, "Negotiate",   9) == 0) {
                   if (!(ret & NTLM_AUTH)) ret+=NEGOTIATE_AUTH;
        } else {
               if (!(ret & UNKNOWN_AUTH)) ret+=UNKNOWN_AUTH;
                }
                free(auth);
        }
  } while (auth) ;

  if (ret & BASIC_AUTH)         return(BASIC_AUTH);
  if (ret & DIGEST_AUTH)        return(DIGEST_AUTH);
  if (ret & NTLM_AUTH)          return(NTLM_AUTH);
  if (ret & NEGOTIATE_AUTH) return(NEGOTIATE_AUTH);

  return(ret);
}


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

/*******************************************************************************/
static PREQUEST ParseReturnedBuffer(HTTPHANDLE HTTPHandle, PHTTP_DATA request, PHTTP_DATA response, char *url)
{
        PHHANDLE RealHTTPHandle=(PHHANDLE)HTTPHandle;
        struct _request *data;
        char version[4];
        if (!response)
        {
                FreeHTTPData(request);
                return(NULL);
        }
        data=(struct _request*)malloc(sizeof(struct _request));
        memset((void*)data,'\0',sizeof(struct _request));
        strncpy(data->hostname,RealHTTPHandle->targetDNS,sizeof(data->hostname)-1);
        data->ip=RealHTTPHandle->target;
        data->port=RealHTTPHandle->port;
        data->NeedSSL = RealHTTPHandle->NeedSSL;
        data->request=request;
        data->response=response;
        data->server=GetServerVersion(response);
        if (response->HeaderSize>=12)
        {
                memcpy(version,response->Header+9,3);
                version[3]='\0';
                data->status=atoi(version);
        }
        data->challenge=IschallengeSupported(response->Header);

    if (data->challenge & DIGEST_AUTH)
    {
                if (RealHTTPHandle->LastAuthenticationString){
                        free(RealHTTPHandle->LastAuthenticationString);
                        RealHTTPHandle->LastAuthenticationString=NULL;
                }
                RealHTTPHandle->LastAuthenticationString=GetHeaderValue(response->Header,"WWW-Authenticate: Digest ",0);
        }

        strncpy(data->url,url,sizeof(data->url)-1);
        strncpy(((PHHANDLE)HTTPHandle)->LastRequestedUri,url,sizeof(((PHHANDLE)HTTPHandle)->LastRequestedUri));

        return(data);
}
/*******************************************************************************/
/*******************************************************************************/
static __inline void AddLine(char *lpBuffer, char *source, unsigned int *Buffersize)
{
    strncat(lpBuffer,source,*Buffersize);
        *Buffersize-=(unsigned int)strlen(source);
}
/*******************************************************************************/

/*******************************************************************************/
char *GetHeaderValue(char *headers,char *value,int n)
{
    char *base,*end;
    end=base=headers;
    if ( (headers) && (value) )
        {
        unsigned int valuelen= (unsigned int) strlen(value);
        while (*end) {
            if (*end=='\n')
                        {
                                if (strnicmp(base,value,valuelen)==0)
                {
                                        if (n==0)
                    {
                        base  = base + valuelen;
                        while  (*base==' ') { base++; }
                                                int len = end-base;
                                                //assert(end-base < 1024 );
                                                char *header=(char*)malloc(len+1);
                                                memcpy(header,base,len);
                                                if (header[len-1]=='\r')
                                                {
                                                        header[len-1]='\0';
                                                } else {
                                                        header[len]='\0';
                                                }
                                                return (header);
                    } else
                    {
                        n--;
                    }
                }
                                base=end+1;
            }
                        end++;
        }
    }
    return(NULL);
}
/*******************************************************************************/

/*******************************************************************************/
char *GetHeaderValueByID(char *headers, unsigned int id)
{
        char *base, *end;
        base = end=headers;

        #define HEADER_ID_NOT_FOUND NULL

   if (headers)
        {
                while (*end)
                {
                        if  (*end=='\n')
                        {
                                if (id==0)
                                {
                                        if ( (end - base)==1) {
                        return(HEADER_ID_NOT_FOUND);
                                        }
                                        char *p=(char *) malloc(end - base +1);
                                        memcpy(p,base,end-base);
                                        p[end-base]='\0';
                                        if (p[end-base-1]=='\r')
                                                p[end-base-1]='\0';
                                        return(p);
                                }
                                id--;
                                base=end+1;
                        }
                        end++;
                }
        }
        return (HEADER_ID_NOT_FOUND);
}
/*******************************************************************************/

/*******************************************************************************/
PHTTP_DATA AddHeader(PHTTP_DATA request,char *Header)
{
        int NewSize= (int) strlen(Header);

        request->Header=(char*)realloc(request->Header, request->HeaderSize + NewSize +1);
        memcpy(request->Header + request->HeaderSize -2, Header,NewSize);
        memcpy(request->Header + request->HeaderSize -2 + NewSize,"\r\n",2);
        request->HeaderSize+=NewSize;
        request->Header[request->HeaderSize]='\0';

    return(request);

}

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

/*******************************************************************************/
PHTTP_DATA RemoveHeader(PHTTP_DATA request, char *Header)
{
        char *base,*end;
        base = end=request->Header;

        if ( (request) && (request->Header) && (Header) )
        {
        int HeaderLen= (int) strlen(Header);
                while (*end) {
                        if (*end=='\n')
                        {
                                if (strnicmp(base,Header,HeaderLen)==0)
                                {
                                        end=strchr(base,'\n');
                                        memcpy(request->Header + (base - request->Header),end+1,strlen(end+1)+1);
                                        request->Header=(char *)realloc(request->Header,request->HeaderSize - (end - base +1) +1 );
                                        request->HeaderSize = (int) strlen(request->Header);//request->HeaderSize - (end - base -1) ;
                                        break;
                                }
                                base=end+1;
                        }
                        end++;
                }
        }
        return(request);

}
/*******************************************************************************/

/*******************************************************************************/
void *FreeRequest(PREQUEST data) {
   if (data)
   {
       FreeHTTPData(data->request);
       FreeHTTPData(data->response);
          if (data->server) free(data->server);
      free(data);
   }
   return(NULL);
}
/*******************************************************************************/

PREQUEST SendRawHttpRequest(HTTPHANDLE HTTPHandle,char *headers, char *postdata)
{
        PREQUEST                DATA;
        PHTTP_DATA              request,response;

        request=InitHTTPData(headers,postdata);
        response=DispatchHTTPRequest((PHHANDLE)HTTPHandle,request);
        DATA=ParseReturnedBuffer( HTTPHandle, request,response,"/TODO"); //manually parse the request buffer to extract URI

        return(DATA);
}
/*******************************************************************************/

/*******************************************************************************/
PREQUEST SendHttpRequest(
        HTTPHANDLE HTTPHandle,
        char *VHost,
        char *HTTPMethod,
        char *url,
        char *Postdata,
        char *lpUsername,
        char *lpPassword,
        int AuthMethod)
{
        char                    tmp[MAX_POST_LENGHT+1]="";
        char                    lpBuffer[MAX_POST_LENGHT+1]="";
        unsigned int    lpSize=MAX_POST_LENGHT;
        PREQUEST                DATA;
        PHHANDLE                RealHTTPHandle=(PHHANDLE)HTTPHandle;
        PHTTP_DATA              request=NULL, response=NULL;// = InitHTTPData();

        if ( (!url) || (*url=='\0') ){ //Bad url
                return ( NULL);
        }

        if ( (RealHTTPHandle->ProxyHost) && (!RealHTTPHandle->NeedSSL) )
        {
        snprintf(lpBuffer,lpSize-1,"%s http://%s:%i%s HTTP/1.%i\r\n",HTTPMethod,RealHTTPHandle->targetDNS,RealHTTPHandle->port,url,((PHHANDLE)HTTPHandle)->version);
        } else
        {
                if ( (strncmp(HTTPMethod,"GET",3)!=0) || (!Postdata) || (!*Postdata) ) {
                        snprintf(lpBuffer,lpSize-1,"%s %s HTTP/1.%i\r\n",HTTPMethod,url,((PHHANDLE)HTTPHandle)->version);
                } else {
                        snprintf(lpBuffer,lpSize-1,"GET %s?%s HTTP/1.%i\r\n",url,Postdata,((PHHANDLE)HTTPHandle)->version);
                }
        }
        lpSize-=(unsigned int)strlen(lpBuffer);

        if (VHost)      {
                snprintf(tmp,sizeof(tmp)-1,"Host: %s\r\n",VHost);
        } else {
                snprintf(tmp,sizeof(tmp)-1,"Host: %s\r\n",((PHHANDLE)HTTPHandle)->targetDNS);
        }
        AddLine(lpBuffer,tmp,&lpSize);

        if (RealHTTPHandle->UserAgent) {
                AddLine(lpBuffer,RealHTTPHandle->UserAgent,&lpSize);
        } else {
                AddLine(lpBuffer,(char*)UserAgent,&lpSize);
        }

        if (RealHTTPHandle->AdditionalHeader) {
                AddLine(lpBuffer,RealHTTPHandle->AdditionalHeader,&lpSize);
        }
        if (RealHTTPHandle->Cookie) {
                sprintf(tmp,"%s\r\n",RealHTTPHandle->Cookie);
                AddLine(lpBuffer,tmp,&lpSize);
        }

        if (RealHTTPHandle->ProxyHost) {
                AddLine(lpBuffer,"Proxy-Connection: keep-alive\r\n",&lpSize);
        } else {
                AddLine(lpBuffer,"Connection: keep-alive\r\n",&lpSize);
        }


        if  (  (strncmp(HTTPMethod,"GET",3)!=0) && (Postdata) && (*Postdata) )
        {
                snprintf(tmp,sizeof(tmp)-1,"Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %i\r\n",strlen(Postdata));
                AddLine(lpBuffer,tmp,&lpSize);
        }


        if ( (AuthMethod) && (lpUsername) && (lpPassword) )
        {
                struct _request *tmpdata=NULL;
//        char *tmpdataBuffer;
        switch (AuthMethod)
        {
            case BASIC_AUTH:
                            char RawUserPass[750];
                            char EncodedUserPass[1000];
                            snprintf(RawUserPass,sizeof(RawUserPass),"%s:%s",lpUsername,lpPassword);
                            memset(EncodedUserPass,'\0',sizeof(EncodedUserPass));
                            Base64Encode((unsigned char *)EncodedUserPass,(unsigned char*)RawUserPass,(int)strlen(RawUserPass));
                            snprintf(tmp,sizeof(tmp)-1,"Authorization: Basic %s\r\n",EncodedUserPass);
                AddLine(lpBuffer,tmp,&lpSize);
                break;
            case DIGEST_AUTH:
                            //Search for cached nonce in memory.
                            char *AuthenticationHeader;
                            if ( (*RealHTTPHandle->LastRequestedUri) && (strcmp(RealHTTPHandle->LastRequestedUri,url)==0) && (RealHTTPHandle->LastAuthenticationString!=NULL) )
                            {
                                    //printf("Reusing realm: %s\n",RealHTTPHandle->LastAuthenticationString );
                            } else
                                {
                                        //Send another request to check if authentication is required and get www-authenticate header
                                        char     tmplpBuffer[MAX_POST_LENGHT+1];
                                        unsigned int    tmplpSize=lpSize;
                                        strncpy(tmplpBuffer,lpBuffer,sizeof(tmplpBuffer)-1);

                                        //Append end of request CLRF
                                        strncat(tmplpBuffer,"\r\n",tmplpSize);tmplpSize-=2;

                                        if  (  (strncmp(HTTPMethod,"GET",3)!=0) && (Postdata) )//Add optional POST HEADER
                                        {
                                                AddLine(tmplpBuffer,Postdata,&lpSize);
                                                //strncat(tmplpBuffer,Postdata,lpSize);
                                        }
                                        request=InitHTTPData(tmplpBuffer,NULL);
                                        response=DispatchHTTPRequest((PHHANDLE)HTTPHandle,request);
                                        tmpdata=ParseReturnedBuffer( HTTPHandle, request,response,url);//, tmpdataBuffer,ReturnedDataSize);
                                        if (!tmpdata) return(NULL);

                                        if (tmpdata->status!=401) {
                                                return(tmpdata);
                                        }
                                        if (RealHTTPHandle->LastAuthenticationString) free(RealHTTPHandle->LastAuthenticationString);
                                        RealHTTPHandle->LastAuthenticationString=GetHeaderValue(tmpdata->response->Header,"WWW-Authenticate: Digest ",0);
                                }

                            AuthenticationHeader=CreateDigestAuth(RealHTTPHandle->LastAuthenticationString,lpUsername,lpPassword,HTTPMethod,url,0);
                                if (AuthenticationHeader)
                                {

                                        FreeRequest(tmpdata);
                                        tmpdata=NULL;
                                        memset(tmp,'\0',sizeof(tmp));
                                        strncpy(tmp,AuthenticationHeader,sizeof(tmp)-1); free(AuthenticationHeader);
                                        AddLine(lpBuffer,tmp,&lpSize);
                                } else
                                {
#ifdef _DBG_
                                        sprintf(tmp,"AUTH DIGEST FAILED Host %s - path: %s, DATA:%s\n",RealHTTPHandle->targetDNS,url,RealHTTPHandle->LastAuthenticationString);
                                        printf("%s\n",tmp);
#endif
                    if (RealHTTPHandle->LastAuthenticationString) {
                        free(RealHTTPHandle->LastAuthenticationString);
                        RealHTTPHandle->LastAuthenticationString=NULL;
                    }
                                        //return(tmpdata);
                            }

                break;
            case NTLM_AUTH:
            case NEGOTIATE_AUTH:
                            unsigned char buf2[4096];
                            unsigned char buf1[4096];
                            char     tmplpBuffer[MAX_POST_LENGHT+1];
                            unsigned int tmplpSize=lpSize;
                            strncpy(tmplpBuffer,lpBuffer,sizeof(tmplpBuffer)-1);
                #ifdef _DBG_
                                sprintf(tmp,"path: %s - host: %s\n",url,RealHTTPHandle->targetDNS);
                                        printf("DBG: %s\n",tmp);
                #endif
                            memset(buf1,'\0',sizeof(buf1));
                            memset(buf2,'\0',sizeof(buf2));

                //NTLM message type 1
                            BuildAuthRequest((tSmbNtlmAuthRequest*)buf2,0,NULL,NULL);

                #ifdef _DBG_
                    printf("CLIENT MSG1\n");
//                    DumpMem(buf2,SmbLength((tSmbNtlmAuthResponse*)buf2));
                #endif
                            to64frombits(buf1, buf2, SmbLength((tSmbNtlmAuthResponse*)buf2));
                            snprintf(tmp,sizeof(tmp)-1,"Authorization: NTLM %s\r\n",buf1);

                            //Append authorization header
                            strncat(tmplpBuffer,tmp,tmplpSize);
                            tmplpSize-=(unsigned int)strlen(tmp);

                            //Append end of request CLRF
                            AddLine(tmplpBuffer,"\r\n",&tmplpSize);

                                //Add optional POST HEADER
                            if  (  (strncmp(HTTPMethod,"GET",3)!=0) && (Postdata) )
                            {
                                    strncat(tmplpBuffer,Postdata,lpSize);
                            }
                            //Send Initial Request
                #ifdef _DBG_
                                        printf("ENVIANDO: %s\n",tmplpBuffer);
                #endif
                                request=InitHTTPData(tmplpBuffer,NULL);
                                response=DispatchHTTPRequest((PHHANDLE)HTTPHandle,request);
                            tmpdata=ParseReturnedBuffer( HTTPHandle, request,response,url);

                            if (!tmpdata)  return(NULL);

                                if (tmpdata->status==401)
                            {
                                    //Parse NTLM Message Type 2
        //                tmpdata->response
                                        char *response=GetHeaderValue(tmpdata->response->Header,"WWW-Authenticate: NTLM ",0);
                                        if (!response) {
                    #ifdef _DBG_
                                                printf("WWW-Authenticate: NTLM Header not Found\n");
                                        #endif
                                            strncpy(tmpdata->url,url,sizeof(tmpdata->url)-1);
                        //tmpdata->url=_strdup(url);
                                            return(tmpdata);
                                    }
                                    //Build NTLM Message Type 3
                    #ifdef _DBG_
                                                    printf("Obtenido: !%s!\n",response);
                    #endif
                                    from64tobits((char *)&buf1[0], response);

                    #ifdef _DBG_
                        printf("SERVER MSG2\n");
//                        DumpMem(buf1,0x100);
                        dumpAuthChallenge(0,(tSmbNtlmAuthChallenge*)buf1);
                    #endif
                                    buildAuthResponse((tSmbNtlmAuthChallenge*)buf1,(tSmbNtlmAuthResponse*)buf2,0,lpUsername,lpPassword,NULL,NULL);
                    #ifdef _DBG_
                        printf("CLIENT MSG3\n");
//                        DumpMem(buf2,SmbLength((tSmbNtlmAuthResponse*)buf2));
                    #endif

                                    to64frombits(buf1, buf2, SmbLength((tSmbNtlmAuthResponse*)buf2));
                                    snprintf(tmp,sizeof(tmp)-1,"Authorization: NTLM %s\r\n",buf1);
                    #ifdef _DBG_
                        printf("Enviando: !%s!",tmp);
                    #endif
                                    free(response);
                                        //tmpdata=
                                        FreeRequest(tmpdata);
                            } else {
                                    //strcpy(tmpdata->hostname,((PHHANDLE)HTTPHandle)->hostname);
                                        //strncpy(tmpdata->url,url,sizeof(tmpdata->url));
                                    return(tmpdata);
                                }
                AddLine(lpBuffer,tmp,&lpSize);
                                break;
                        }
        }



        strncat(lpBuffer,"\r\n",lpSize);
        lpSize-=2;

        request=InitHTTPData(lpBuffer,NULL);
        //Optional Post Data
        if  (  (strncmp(HTTPMethod,"GET",3)!=0) && (Postdata) ) {
        free(request->Data);
                request->Data=_strdup(Postdata);
                request->DataSize= (unsigned int) strlen(Postdata);
        }

        response=DispatchHTTPRequest(RealHTTPHandle,request);

        DATA=ParseReturnedBuffer(RealHTTPHandle, request, response, url);


        if ( (!AuthMethod) && (lpUsername) && (lpPassword) && (DATA) && (DATA->challenge))
        {
                #ifdef _DBG_
                printf("**********REAUTH**********\n");
                #endif
                struct _request *AUTHDATA=SendHttpRequest(
                        HTTPHandle,
                        VHost,
                        HTTPMethod,
                        url,
                        Postdata,
                        lpUsername,
                        lpPassword,
                        DATA->challenge);
                if (AUTHDATA)
                {
                        FreeRequest(DATA);
                        return(AUTHDATA);
                }
        }

        /*
        if (DATA) {
                if ( (DATA->status==303) && (AutoRedirect303) && (DATA->response) && (DATA->response->HeaderSize) )  {
            char *location= GetHeaderValue(DATA->response->Header,"Location: ",1);
                        if (location) {
                                if (*location) {
                                        char Redirecthost[1000];
                                        unsigned int Redirectport;
                                        char RedirectURL[1000];
                                        int ssl;
                                        if ( (Redirectport == RealHTTPHandle->port) && (RealHTTPHandle->NeedSSL == ssl) ) {

                                        }

                                        FreeRequest(DATA);
                                        DATA =SendHttpRequest(
                                                HTTPHandle,
                                                Redirecthost,
                                                "GET",
                                                RedirectURL,
                                                NULL,
                                                lpUsername,
                                                lpPassword,
                                                DATA->challenge);
                                }

                                free(location);
                        }

                }
        }

        */
 /*
        if (DATA->challenge)
        {
                if (lpUsername) strncpy(DATA->lpUserName,lpUsername,sizeof(DATA->UserName)-1);
                if (lpPassword) strncpy(DATA->lpPassword,lpPassword,sizeof(DATA->Password)-1);
        }
*/
    return(DATA);
}
/*******************************************************************************************/

/*******************************************************************************************/
int CancelHttpRequest(HTTPHANDLE HTTPHandle, int what)
{
        return ( HTTPCoreCancelHTTPRequest(HTTPHandle, what));
}
/*******************************************************************************************/

---