G:/ScriptBasic/source/extensions/curl/interface.c

Go to the documentation of this file.

/* FILE: curlintrfc.c

This file contains code the CURL interface

--GNU LGPL
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

NTLIBS: libcurl.lib ws2_32.lib
UXLIBS: -lcurl -lssl -lcrypto -ldl -lc

*/
#include <stdio.h>
#include <time.h>
#include <curl/curl.h>
#include "../../basext.h"

/*
Here you have to list all the CURL options that get char * parameter and are handles
transparently passed to CURL.

The macro is (re)defined
- in the string parameter declaration,
- initializing the parameters to NULL
- during parameter setting
- and release of memory when finish a curl handle.

That helps you to maintain new options because this is the only place where the name of
the new option is to be present.
*/
#define STRING_OPTIONS \
STRING_OPTION(PROXY)\
STRING_OPTION(URL)\
STRING_OPTION(USERPWD)\
STRING_OPTION(PROXYUSERPWD)\
STRING_OPTION(RANGE)\
STRING_OPTION(REFERER)\
STRING_OPTION(USERAGENT)\
STRING_OPTION(FTPPORT)\
STRING_OPTION(COOKIE)\
STRING_OPTION(SSLCERT)\
STRING_OPTION(SSLCERTPASSWD)\
STRING_OPTION(COOKIEFILE)\
STRING_OPTION(CUSTOMREQUEST)\
STRING_OPTION(INTERFACE)\
STRING_OPTION(KRB4LEVEL)\
STRING_OPTION(WRITEINFO)\
STRING_OPTION(CAINFO)\
STRING_OPTION(RANDOM_FILE)\
STRING_OPTION(EGDSOCKET)\

typedef struct _CurlConnection {
  CURL          *myConnection;
  FILE          *fp;        /* file pointer to file where we read from or store the result             */
  FILE          *hfp;       /* header file pointer where the header is stored                          */
  char          errorbuffer[CURL_ERROR_SIZE];
                            /* buffer to store the error messages from the underlying CURL system      */
  int           fWasPerform;
  char          *pszBuffer; /* buffer to store the downloaded file when not saved to disk              */
  unsigned long cbBuffer;   /* characters in the buffer                                                */
  unsigned long dwBuffer;   /* allocated size of the buffer                                            */
  unsigned long dwStepBf;   /* increase step when fubber is full                                       */
  char          *pszInText; /* the text to upload                                                      */
  unsigned long dwInText;   /* the length of the text                                                  */
  unsigned long cbInText;   /* the number of characters already sent up                                */

  pSupportTable pSt;        /* this is needed to get back to the interpreter
                               environment in the function buffercollect                               */


#define STRING_OPTION(X) char *psz##X;
STRING_OPTIONS
#undef STRING_OPTION

  char *pszPOSTFIELDS;
  struct _CurlConnection *next,*prev;
  struct curl_slist *pHeaderLines;
  struct curl_slist *pQuote;
  struct curl_slist *pPostQuote;
  struct HttpPost *firstitem, *lastitem;
  } CurlConnection,  *pCurlConnection;

typedef struct _CurlClass {
  void *HandleArray;
  pCurlConnection pFirstConnection;
  } CurlClass,*pCurlClass;

SUPPORT_MULTITHREAD

besVERSION_NEGOTIATE

  return (int)INTERFACE_VERSION;

besEND

besSUB_SHUTDOWN
  curl_global_cleanup();
besEND

besSUB_START
  pCurlClass pCurl;
  /* This macro increments the thread counter used to help to keep this library in memory 
     even those times when the process is idle and no ScriptBasic threads are running. */
  INC_THREAD_COUNTER
  /* A process level initialization of the module should take place in this function because
     the call-back support functions are not accessible when the  function DllMan or _init is
     called. On the other hand it has to initialize only once.
  */
  INITLOCK /* lock the init mutex */
  if( iFirst ){ /* if it was not initialized yet*/

    curl_global_init(CURL_GLOBAL_ALL);

    iFirst = 0;/* successful initialization was done*/
    }
  INITUNLO /* unlock the init mutex */

  besMODULEPOINTER = besALLOC(sizeof(CurlClass));
  if( besMODULEPOINTER == NULL )return 0;
  pCurl = (pCurlClass)besMODULEPOINTER;
  pCurl->pFirstConnection = NULL;
  pCurl->HandleArray = NULL;
  return COMMAND_ERROR_SUCCESS;
besEND

besSUB_FINISH
  pCurlClass pCurl;
  pCurlConnection pCon;

  pCurl = (pCurlClass)besMODULEPOINTER;
  if( pCurl != NULL ){
    for( pCon = pCurl->pFirstConnection ; pCon ; pCon = pCon->next ){
      if( pCon->pHeaderLines ){
        curl_slist_free_all(pCon->pHeaderLines);
        pCon->pHeaderLines = NULL;
        }
      if( pCon->pQuote ){
        curl_slist_free_all(pCon->pQuote);
        pCon->pQuote = NULL;
        }
      if( pCon->pPostQuote ){
        curl_slist_free_all(pCon->pPostQuote);
        pCon->pQuote = NULL;
        }
      if( pCon->firstitem ){
        curl_formfree(pCon->firstitem);
        pCon->firstitem = pCon->lastitem = NULL;
        }
      curl_easy_cleanup(pCon->myConnection);
      }
    besHandleDestroyHandleArray(pCurl->HandleArray);
    }
  return 0;
besEND

#define GET_CURL_HANDLE \
  pCurl = (pCurlClass)besMODULEPOINTER;\
  Argument = besARGUMENT(1);\
  besDEREFERENCE(Argument);\
  if( ! Argument )return EX_ERROR_TOO_FEW_ARGUMENTS;\
  pCon = besHandleGetPointer(pCurl->HandleArray,besGETLONGVALUE(Argument));\
  if( pCon == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;


besFUNCTION(sb_curl_init)
  pCurlClass pCurl;
  pCurlConnection pCon;
  long res;

  pCurl = besMODULEPOINTER;

  /* allocate the space to store the new connection */
  pCon = besALLOC(sizeof(CurlConnection));
  if( pCon == NULL )return COMMAND_ERROR_MEMORY_LOW;

  /* get the connection */
  pCon->myConnection = curl_easy_init();
  if( pCon->myConnection == NULL ){
    besFREE(pCon);
    return COMMAND_ERROR_MEMORY_LOW;
    }

  pCon->fp           = NULL; /* no output file opened                                           */
  pCon->hfp          = NULL; /* no input file opened                                            */
  pCon->fWasPerform  = 0;    /* no perform was done yet (check before calling curl_easy_getinfo */
  pCon->pHeaderLines = NULL; /* no extra header lines                                           */
  pCon->pQuote       = NULL; /* no QUOTE commands for FTP                                       */
  pCon->pPostQuote   = NULL; /* no post QUOTE commands for FTP                                  */
  pCon->firstitem    = NULL; /* POST parameters first item                                      */
  pCon->lastitem     = NULL; /* POST parameters last item                                       */

  pCon->pszBuffer    = NULL; /* no buffer is allocated by default                               */
  pCon->dwBuffer     = 0;    /* as I said: no buffer is allocated by default                    */
  pCon->cbBuffer     = 0;    /* there is zero number of chars in the nonallocated buffer        */
  pCon->dwStepBf     = 0;    /* by default allocate space as bytes come                         */
  pCon->pszInText    = NULL; /* no text is stored for upload                                    */
  pCon->dwInText     = 0;    /* as I said: you know                                             */
  pCon->cbInText     = 0;    /* no bytes were sent from the nonexistent infile text             */

  pCon->pSt          = pSt;

#define STRING_OPTION(X) pCon->psz##X = NULL;
STRING_OPTIONS
#undef STRING_OPTION
  pCon->pszPOSTFIELDS = NULL;

  memset(pCon->errorbuffer,0,CURL_ERROR_SIZE);
  res = curl_easy_setopt(pCon->myConnection, CURLOPT_ERRORBUFFER, pCon->errorbuffer);
  if( res )return 0x00081100+res;

  /* link the new connection tot he head of the list of connections */
  pCon->next               = pCurl->pFirstConnection;
  pCon->prev               = NULL;
  if( pCon->next )
    pCon->next->prev       = pCon;
  pCurl->pFirstConnection  = pCon;

  besALLOC_RETURN_LONG;
  LONGVALUE(besRETURNVALUE) = besHandleGetHandle(pCurl->HandleArray,pCon);
  return COMMAND_ERROR_SUCCESS;

besEND

static size_t buffersend(char *buffer, size_t size, size_t count, pCurlConnection pCon){
  unsigned long dwChunkSize;

  dwChunkSize = size*count;
  if( dwChunkSize > pCon->dwInText - pCon->cbInText )dwChunkSize = pCon->dwInText - pCon->cbInText;
  memcpy(buffer,pCon->pszInText,dwChunkSize);
  pCon->cbInText += dwChunkSize;
  return dwChunkSize;
  }

besFUNCTION(sb_curl_option)
  pCurlClass pCurl;
  pCurlConnection pCon;
  VARIABLE Argument;
  char *pszOption;
  long value;
  long res;
  struct curl_slist *pNewList;

  GET_CURL_HANDLE
  /* get the option name */
  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
  Argument = besCONVERT2STRING(Argument);

#define CHECK_OPTION(X) if( STRLEN(Argument) == strlen(#X) && memcmp(STRINGVALUE(Argument),#X,strlen(#X)) == 0 )

  CHECK_OPTION(FILE){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    if( pCon->fp )besFCLOSE(pCon->fp);
    pCon->fp = besFOPEN(pszOption,"wb");
    if( pCon->fp == NULL )return COMMAND_ERROR_FILE_CANNOT_BE_OPENED;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_FILE,pCon->fp);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_WRITEFUNCTION,pSt->fwrite);
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(HEADERFILE){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    if( pCon->hfp )besFCLOSE(pCon->hfp);
    pCon->hfp = besFOPEN(pszOption,"wb");
    if( pCon->hfp == NULL )return COMMAND_ERROR_FILE_CANNOT_BE_OPENED;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_WRITEHEADER,pCon->hfp);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_HEADERFUNCTION,pSt->fwrite);
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(INFILE){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    if( pCon->fp )besFCLOSE(pCon->fp);
    besFREE(pCon->pszInText);

    /* if there was any previous but not used string: do not loose memory! */
    pCon->pszInText = NULL;
    pCon->cbInText = 0;
    pCon->dwInText = 0;

    pCon->fp = besFOPEN(pszOption,"rb");
    if( pCon->fp == NULL )return COMMAND_ERROR_FILE_CANNOT_BE_OPENED;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_INFILE,pCon->fp);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_READFUNCTION,pSt->fread);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_INFILESIZE,besSIZE(pszOption));
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(INTEXT){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    Argument = besCONVERT2STRING(Argument);
    if( pCon->fp )besFCLOSE(pCon->fp);

    /* if there was any previous but not used string: do not loose memory! */
    besFREE(pCon->pszInText);
    pCon->pszInText = NULL;
    pCon->cbInText = 0;
    pCon->dwInText = 0;

    pCon->pszInText = besALLOC(STRLEN(Argument));
    if( pCon->pszInText == NULL )return COMMAND_ERROR_MEMORY_LOW;
    pCon->dwInText = STRLEN(Argument);
    memcpy(pCon->pszInText,STRINGVALUE(Argument),pCon->dwInText);
    pCon->cbInText = 0;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_INFILE,pCon);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_READFUNCTION,buffersend);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_INFILESIZE,pCon->dwInText);
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(POSTFIELDS){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    Argument = besCONVERT2STRING(Argument);
    pCon->pszPOSTFIELDS = besALLOC(STRLEN(Argument));
    if( pCon->pszPOSTFIELDS == NULL )return COMMAND_ERROR_MEMORY_LOW;
    memcpy(pCon->pszPOSTFIELDS,STRINGVALUE(Argument),STRLEN(Argument));
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_POSTFIELDS,pCon->pszPOSTFIELDS);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_POSTFIELDSIZE,STRLEN(Argument));
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(CLOSEPOLICY){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    Argument = besCONVERT2STRING(Argument);
    if( STRLEN(Argument) == 3 && memcmp(STRINGVALUE(Argument),"OLD",3) == 0 ){
      value = CURLCLOSEPOLICY_OLDEST;
      }else
    if( STRLEN(Argument) == 5 && memcmp(STRINGVALUE(Argument),"FRESH",5) == 0 ){
      value = CURLCLOSEPOLICY_LEAST_RECENTLY_USED;
      }else return COMMAND_ERROR_ARGUMENT_RANGE;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_CLOSEPOLICY,value);
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(TIMECONDITION){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    Argument = besCONVERT2STRING(Argument);
    if( STRLEN(Argument) == 10 && memcmp(STRINGVALUE(Argument),"IFMODSINCE",10) == 0 ){
      value = TIMECOND_IFMODSINCE;
      }else
    if( STRLEN(Argument) == 12 && memcmp(STRINGVALUE(Argument),"IFUNMODSINCE",12) == 0 ){
      value = TIMECOND_IFUNMODSINCE;
      }else return COMMAND_ERROR_ARGUMENT_RANGE;
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_TIMECONDITION,value);
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;
    return 0x00081100+res;
    }

  CHECK_OPTION(HTTPHEADER){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    pNewList = curl_slist_append(pCon->pHeaderLines,pszOption);
    besFREE(pszOption);
    if( pNewList == NULL ){
      curl_slist_free_all(pCon->pHeaderLines);
      pCon->pHeaderLines = NULL;
      return COMMAND_ERROR_MEMORY_LOW;
      }
    pCon->pHeaderLines = pNewList;
    return COMMAND_ERROR_SUCCESS;
    }

  CHECK_OPTION(QUOTE){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    pNewList = curl_slist_append(pCon->pQuote,pszOption);
    besFREE(pszOption);
    if( pNewList == NULL ){
      curl_slist_free_all(pCon->pQuote);
      pCon->pQuote = NULL;
      return COMMAND_ERROR_MEMORY_LOW;
      }
    pCon->pQuote = pNewList;
    return COMMAND_ERROR_SUCCESS;
    }

  CHECK_OPTION(POSTQUOTE){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    pNewList = curl_slist_append(pCon->pPostQuote,pszOption);
    besFREE(pszOption);
    if( pNewList == NULL ){
      curl_slist_free_all(pCon->pPostQuote);
      pCon->pPostQuote = NULL;
      return COMMAND_ERROR_MEMORY_LOW;
      }
    pCon->pPostQuote = pNewList;
    return COMMAND_ERROR_SUCCESS;
    }

  /* delete all gathered HTTP header lines that may have remained from the previous network action */
  CHECK_OPTION(NOHTTPHEADER){
    curl_slist_free_all(pCon->pHeaderLines);
    pCon->pHeaderLines = NULL;
    return COMMAND_ERROR_SUCCESS;
    }

  /* delete all previously gathered FTP quote commands */
  CHECK_OPTION(NOQUOTE){
    curl_slist_free_all(pCon->pQuote);
    pCon->pQuote = NULL;
    return COMMAND_ERROR_SUCCESS;
    }

  /* delete all previously gathered FTP post quote commands */
  CHECK_OPTION(NOPOSTQUOTE){
    curl_slist_free_all(pCon->pPostQuote);
    pCon->pPostQuote = NULL;
    return COMMAND_ERROR_SUCCESS;
    }

  CHECK_OPTION(HTTPPOST){
    Argument = besARGUMENT(3);
    besDEREFERENCE(Argument);
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
    besCONVERT2ZCHAR(Argument,pszOption);
    curl_formparse(pszOption,&(pCon->firstitem),&(pCon->lastitem));
    besFREE(pszOption);
    return COMMAND_ERROR_SUCCESS;
    }

  CHECK_OPTION(BUFFER_SIZE){
    value=0;
    if( besARGNR >= 3 ){
      Argument = besARGUMENT(3);
      besDEREFERENCE(Argument);
      value = besGETLONGVALUE(Argument);
      }
    pCon->dwStepBf = value;
    return COMMAND_ERROR_SUCCESS;
    }

#define STRING_OPTION(X) \
  CHECK_OPTION(X){\
    Argument = besARGUMENT(3);\
    besDEREFERENCE(Argument);\
    if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;\
    if( pCon->psz##X )besFREE(pCon->psz##X);\
    besCONVERT2ZCHAR(Argument,pCon->psz##X);\
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_##X,pCon->psz##X);\
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;\
    return 0x00081100+res;\
    }
STRING_OPTIONS
#undef STRING_OPTION

#define HANDLE_FLAG(X)\
  CHECK_OPTION(X){\
    value=1;\
    if( besARGNR >= 3 ){\
      Argument = besARGUMENT(3);\
      besDEREFERENCE(Argument);\
      value = besGETLONGVALUE(Argument);\
      }\
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_##X,value);\
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;\
    return 0x00081100+res;\
    }

#define HANDLE_LONG(X)\
  CHECK_OPTION(X){\
    value=0;\
    if( besARGNR >= 3 ){\
      Argument = besARGUMENT(3);\
      besDEREFERENCE(Argument);\
      value = besGETLONGVALUE(Argument);\
      }\
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_##X,value);\
    if( res == CURLE_OK ) return COMMAND_ERROR_SUCCESS;\
    return 0x00081100+res;\
    }

HANDLE_FLAG(HTTPPROXYTUNNEL)
HANDLE_FLAG(VERBOSE)
HANDLE_FLAG(NOPROGRESS)
HANDLE_FLAG(NOBODY)
HANDLE_FLAG(FAILONERROR)
HANDLE_FLAG(UPLOAD)
HANDLE_FLAG(POST)
HANDLE_FLAG(FTPLISTONLY)
HANDLE_FLAG(FTPAPPEND)
HANDLE_FLAG(NETRC)
HANDLE_FLAG(FOLLOWLOCATION)
HANDLE_FLAG(TRANSFERTEXT)
HANDLE_FLAG(PUT)
HANDLE_FLAG(HEADER)
HANDLE_FLAG(SSL_VERIFYPEER)
HANDLE_FLAG(FILETIME)
HANDLE_FLAG(FRESH_CONNECT)
HANDLE_FLAG(FORBID_REUSE)
HANDLE_FLAG(HTTPGET)
HANDLE_FLAG(CRLF)

HANDLE_LONG(TIMEOUT)
HANDLE_LONG(LOW_SPEED_LIMIT)
HANDLE_LONG(LOW_SPEED_TIME)
HANDLE_LONG(RESUME_FROM)
HANDLE_LONG(SSLVERSION)
HANDLE_LONG(TIMEVALUE)
HANDLE_LONG(MAXREDIRS)
HANDLE_LONG(MAXCONNECTS)
HANDLE_LONG(CONNECTTIMEOUT)
HANDLE_LONG(PROXYPORT)

  besCONVERT2ZCHAR(Argument,pszOption);
  sprintf(pCon->errorbuffer,"CURL Error in 'curl::option'. Unkown option \"%s\"",pszOption);
  besFREE(pszOption);
  return 0x00081001;
besEND

static size_t buffercollect(char *buffer,size_t size,size_t count,pCurlConnection pCon){
  long dwChunkSize;
  pSupportTable pSt;
  char *pszNewBuffer;
  unsigned long dwNewSize;

  /* set the pSt variable so we can easily use the bes macros */
  pSt = pCon->pSt;

  dwChunkSize = size*count;

  /* if the buffer can not store the new chunk then reallocate it */
  if( dwChunkSize+pCon->cbBuffer > pCon->dwBuffer ){
    dwNewSize = pCon->dwBuffer+pCon->dwStepBf;
    if( dwNewSize < dwChunkSize+pCon->cbBuffer )dwNewSize = dwChunkSize+pCon->cbBuffer;
    pszNewBuffer = besALLOC(dwNewSize);
    if( pszNewBuffer == NULL )return 0;
    pCon->dwBuffer = dwNewSize;
    /* copy the characters that were already read into the new buffer */
    memcpy(pszNewBuffer,pCon->pszBuffer,pCon->cbBuffer);
    besFREE(pCon->pszBuffer);
    pCon->pszBuffer = pszNewBuffer;
    }

  memcpy(pCon->pszBuffer+pCon->cbBuffer,buffer,dwChunkSize);
  pCon->cbBuffer += dwChunkSize;
  return dwChunkSize;
  }

besFUNCTION(sb_curl_perform)
  pCurlClass pCurl;
  pCurlConnection pCon;
  VARIABLE Argument;
  int res;

  GET_CURL_HANDLE

  /* if there were header lines specified then apply them. */
  if( pCon->pHeaderLines ){
    curl_easy_setopt(pCon->myConnection,CURLOPT_HTTPHEADER,pCon->pHeaderLines);
    }

  if( pCon->pQuote ){
    curl_easy_setopt(pCon->myConnection,CURLOPT_QUOTE,pCon->pQuote);
    }

  if( pCon->pPostQuote ){
    curl_easy_setopt(pCon->myConnection,CURLOPT_POSTQUOTE,pCon->pPostQuote);
    }

  if( pCon->firstitem ){
    curl_easy_setopt(pCon->myConnection,CURLOPT_HTTPPOST,pCon->firstitem);
    }

  /* if there was no file specified for the download than we have to return the result as string */
  if( pCon->fp == NULL ){
    res = curl_easy_setopt(pCon->myConnection,CURLOPT_FILE,pCon);
    if( res == CURLE_OK )res = curl_easy_setopt(pCon->myConnection,CURLOPT_WRITEFUNCTION,buffercollect);
    }

  res = curl_easy_perform(pCon->myConnection);

  /* if there was no download file specified and there is some downloaded string then we have to return it */
  if( pCon->cbBuffer > 0 ){
    besALLOC_RETURN_STRING(pCon->cbBuffer);
    memcpy(STRINGVALUE(besRETURNVALUE),pCon->pszBuffer,STRLEN(besRETURNVALUE));
    besFREE(pCon->pszBuffer);
    pCon->pszBuffer = NULL;
    pCon->dwBuffer = 0;
    pCon->cbBuffer = 0;
    }

  if( pCon->pszInText ){
    besFREE(pCon->pszInText);
    pCon->pszInText = NULL;
    pCon->cbInText = 0;
    pCon->dwInText = 0;
    }

  if( res == CURLE_OK ){
    pCon->fWasPerform = 1;
    return COMMAND_ERROR_SUCCESS;
    }

  return 0x00081100+res;;

besEND

besFUNCTION(sb_curl_info)
  pCurlClass pCurl;
  pCurlConnection pCon;
  VARIABLE Argument;
  int res;
  char *pszOption;
  long lOption;
  double dOption;

  GET_CURL_HANDLE

  if(  ! pCon->fWasPerform ){
    sprintf(pCon->errorbuffer,"CURL Error: no successful curl::perform was called before curl::info");
    return 0x00081002;
    }
  /* get the option name */
  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_ARGUMENT_RANGE;
  Argument = besCONVERT2STRING(Argument);

#define CHECK_INFOPT_SZ(X) if( STRLEN(Argument) == strlen(#X) && memcmp(STRINGVALUE(Argument),#X,strlen(#X)) == 0 ){\
    res = curl_easy_getinfo(pCon->myConnection,CURLINFO_##X,&pszOption);\
    besALLOC_RETURN_STRING(strlen(pszOption));\
    memcpy(STRINGVALUE(besRETURNVALUE),pszOption,STRLEN(besRETURNVALUE));\
    return COMMAND_ERROR_SUCCESS;\
    }
#define CHECK_INFOPT_L(X) if( STRLEN(Argument) == strlen(#X) && memcmp(STRINGVALUE(Argument),#X,strlen(#X)) == 0 ){\
    res = curl_easy_getinfo(pCon->myConnection,CURLINFO_##X,&lOption);\
    besALLOC_RETURN_LONG;\
    LONGVALUE(besRETURNVALUE) = lOption;\
    return COMMAND_ERROR_SUCCESS;\
    }
#define CHECK_INFOPT_D(X) if( STRLEN(Argument) == strlen(#X) && memcmp(STRINGVALUE(Argument),#X,strlen(#X)) == 0 ){\
    res = curl_easy_getinfo(pCon->myConnection,CURLINFO_##X,&dOption);\
    besALLOC_RETURN_DOUBLE;\
    DOUBLEVALUE(besRETURNVALUE) = dOption;\
    return COMMAND_ERROR_SUCCESS;\
    }

CHECK_INFOPT_SZ(EFFECTIVE_URL)
CHECK_INFOPT_L (HTTP_CODE)
CHECK_INFOPT_L (FILETIME)
CHECK_INFOPT_D (TOTAL_TIME)
CHECK_INFOPT_D (NAMELOOKUP_TIME)
CHECK_INFOPT_D (CONNECT_TIME)
CHECK_INFOPT_D (PRETRANSFER_TIME)
CHECK_INFOPT_D (SIZE_UPLOAD)
CHECK_INFOPT_D (SIZE_DOWNLOAD)
CHECK_INFOPT_D (SPEED_DOWNLOAD)
CHECK_INFOPT_D (SPEED_UPLOAD)
CHECK_INFOPT_L (HEADER_SIZE)
CHECK_INFOPT_L (REQUEST_SIZE)
CHECK_INFOPT_L (SSL_VERIFYRESULT)
CHECK_INFOPT_D (CONTENT_LENGTH_DOWNLOAD)
CHECK_INFOPT_D (CONTENT_LENGTH_UPLOAD)

  besCONVERT2ZCHAR(Argument,pszOption);
  sprintf(pCon->errorbuffer,"CURL Error in 'curl::info'. Unkown info type \"%s\"",pszOption);
  besFREE(pszOption);
  return 0x00081003;

besEND

besFUNCTION(sb_curl_finish)
  pCurlClass pCurl;
  pCurlConnection pCon;
  VARIABLE Argument;

  GET_CURL_HANDLE

  curl_easy_cleanup(pCon->myConnection);

  if( pCon->pHeaderLines ){
    curl_slist_free_all(pCon->pHeaderLines);
    pCon->pHeaderLines = NULL;
    }

  if( pCon->pQuote ){
    curl_slist_free_all(pCon->pQuote);
    pCon->pQuote = NULL;
    }

  if( pCon->pPostQuote ){
    curl_slist_free_all(pCon->pPostQuote);
    pCon->pPostQuote = NULL;
    }

  if( pCon->firstitem ){
    curl_formfree(pCon->firstitem);
    pCon->firstitem = pCon->lastitem = NULL;
    }

  if( pCon->fp )besFCLOSE(pCon->fp);

  /* unlink the handle from the list */
  if( pCon->prev )
    pCon->prev->next       = pCon->next;
  else
    pCurl->pFirstConnection = pCon->next;

  if( pCon->next )
    pCon->next->prev     = pCon->prev;

#define STRING_OPTION(X) if( pCon->psz##X )besFREE(pCon->psz##X);
STRING_OPTIONS
#undef STRING_OPTION
  if( pCon->pszPOSTFIELDS )besFREE(pCon->pszPOSTFIELDS);

  /* free the connection hanlde structure */
  besFREE(pCon);

besEND

besFUNCTION(sb_curl_error)
  pCurlClass pCurl;
  pCurlConnection pCon;
  VARIABLE Argument;

  GET_CURL_HANDLE

  besALLOC_RETURN_STRING(strlen(pCon->errorbuffer));
  memcpy(STRINGVALUE(besRETURNVALUE),pCon->errorbuffer,STRLEN(besRETURNVALUE));
besEND


besFUNCTION(sb_curl_escape)
  VARIABLE Argument;
  char *s;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  /* undef argument returns undef */
  if( Argument == NULL )return COMMAND_ERROR_SUCCESS;
  Argument = besCONVERT2STRING(Argument);
  if( STRLEN(Argument) == 0 ){
    besALLOC_RETURN_STRING(1);
    STRLEN(besRETURNVALUE) = 0;
    }
  s = curl_escape(STRINGVALUE(Argument),STRLEN(Argument));
  if( s == NULL )return COMMAND_ERROR_MEMORY_LOW;
  besALLOC_RETURN_STRING(strlen(s));
  memcpy(STRINGVALUE(besRETURNVALUE),s,STRLEN(besRETURNVALUE));
  free(s);
besEND

besFUNCTION(sb_curl_unescape)
  VARIABLE Argument;
  char *s;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  /* undef argument returns undef */
  if( Argument == NULL )return COMMAND_ERROR_SUCCESS;
  Argument = besCONVERT2STRING(Argument);
  if( STRLEN(Argument) == 0 ){
    besALLOC_RETURN_STRING(1);
    STRLEN(besRETURNVALUE) = 0;
    }
  s = curl_unescape(STRINGVALUE(Argument),STRLEN(Argument));
  if( s == NULL )return COMMAND_ERROR_MEMORY_LOW;
  besALLOC_RETURN_STRING(strlen(s));
  memcpy(STRINGVALUE(besRETURNVALUE),s,STRLEN(besRETURNVALUE));
  free(s);
besEND

besFUNCTION(sb_curl_getdate)
  VARIABLE Argument;
  char *s;
  time_t t;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  besCONVERT2ZCHAR(Argument,s);
  t = time(&t);
  t = curl_getdate(s,&t);
  besALLOC_RETURN_LONG;
  LONGVALUE(besRETURNVALUE) = t;

besEND

besFUNCTION(sb_curl_version)
  char *s;

  s = curl_version();  
  besALLOC_RETURN_STRING(strlen(s));
  memcpy(STRINGVALUE(besRETURNVALUE),s,STRLEN(besRETURNVALUE));

besEND

besDLL_MAIN

besSUB_PROCESS_START
  INIT_MULTITHREAD
  return 1;
besEND

besSUB_PROCESS_FINISH
  FINISH_MULTITHREAD
besEND

START_FUNCTION_TABLE(CURL_SLFST)

EXPORT_MODULE_FUNCTION(shutmodu)
EXPORT_MODULE_FUNCTION(bootmodu)
EXPORT_MODULE_FUNCTION(versmodu)
EXPORT_MODULE_FUNCTION(sb_curl_error)
EXPORT_MODULE_FUNCTION(sb_curl_finish)
EXPORT_MODULE_FUNCTION(sb_curl_option)
EXPORT_MODULE_FUNCTION(sb_curl_perform)
EXPORT_MODULE_FUNCTION(sb_curl_init)
EXPORT_MODULE_FUNCTION(sb_curl_info)
EXPORT_MODULE_FUNCTION(sb_curl_version)
EXPORT_MODULE_FUNCTION(sb_curl_getdate)
EXPORT_MODULE_FUNCTION(sb_curl_escape)
EXPORT_MODULE_FUNCTION(sb_curl_unescape)
EXPORT_MODULE_FUNCTION(_init)
EXPORT_MODULE_FUNCTION(_fini)

END_FUNCTION_TABLE

---