now uses a tiny bit of the new library interface!

#include "http.h"

#include "file.h"

#include "ldap.h"

#include "writeout.h"

#define _MPRINTF_REPLACE /* use our functions only */

#include <curl/mprintf.h>

 * Start with some silly functions to make win32-systems survive

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

#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)

static void cleanup(void)

static void win32_cleanup(void)

{

  WSACleanup();

}

static int init(void)

static UrgError win32_init(void)

{

  WORD wVersionRequested;  

  WSADATA wsaData; 

  if (err != 0) 

    /* Tell the user that we couldn't find a useable */ 

    /* winsock.dll.     */ 

    return 1; 

    return URG_FAILED_INIT; 

  /* Confirm that the Windows Sockets DLL supports 1.1.*/ 

  /* Note that if the DLL supports versions greater */ 

    /* winsock.dll. */ 

    WSACleanup(); 

    return 1; 

    return URG_FAILED_INIT; 

  }

  return 0;

  return URG_OK;

}

/* The Windows Sockets DLL is acceptable. Proceed. */ 

#else

static int init(void) { return 0; }

static void cleanup(void) {}

static UrgError win32_init(void) { return URG_OK; }

#define win32_cleanup()

#endif

/*

 * This is the main global constructor for the lib. Call this before

 * _any_ libcurl usage. If this fails, *NO* libcurl functions may be

 * used, or havoc may be the result.

 */

UrgError curl_init(void)

{

  return win32_init();

}

/*

 * This is the main global destructor for the lib. Call this after

 * _all_ libcurl usage is done.

 */

void curl_free(void)

{

  win32_cleanup();

}

static UrgError _urlget(struct UrlData *data);

    free(data);

    /* winsock crap cleanup */

    cleanup();

    /* global cleanup */

    curl_free();

  }

}

typedef int (*func_T)(void);

typedef struct UrlData CURL;

UrgError curl_urlget(UrgTag tag, ...)

UrgError curl_open(CURL **curl, char *url)

{

  va_list arg;

  func_T param_func = (func_T)0;

  long param_long = 0;

  void *param_obj = NULL;

  UrgError res;

  char *cookiefile;

  struct UrlData *data;

  /* this is for the lame win32 socket crap */

  if(init())

    return URG_FAILED_INIT;

  /* We don't yet support specifying the URL at this point */

  data = (struct UrlData *)malloc(sizeof(struct UrlData));

  /* Very simple start-up: alloc the struct, init it with zeroes and return */

  CURL *data = (CURL *)malloc(sizeof(CURL));

  if(data) {

    memset(data, 0, sizeof(struct UrlData));

    /* Let's set some default values: */

    data->out = stdout; /* default output to stdout */

    data->in  = stdin;  /* default input from stdin */

    data->err  = stderr;  /* default stderr to stderr */

    data->firstsocket = -1; /* no file descriptor */

    data->secondarysocket = -1; /* no file descriptor */

    /* use fwrite as default function to store output */

    data->fwrite = (size_t (*)(char *, size_t, size_t, FILE *))fwrite;

    /* use fread as default function to read input */

    data->fread = (size_t (*)(char *, size_t, size_t, FILE *))fread;

    data->infilesize = -1; /* we don't know any size */

    data->current_speed = -1; /* init to negative == impossible */

    va_start(arg, tag);

    while(tag != URGTAG_DONE) {

      /* PORTING NOTE:

	 Ojbect pointers can't necessarily be casted to function pointers and

	 therefore we need to know what type it is and read the correct type

	 at once. This should also correct problems with different sizes of

	 the types.

         */

      if(tag < URGTYPE_OBJECTPOINT) {

	/* This is a LONG type */

	param_long = va_arg(arg, long);

    memset(data, 0, sizeof(CURL));

    *curl = data;

    return URG_OK;

  }

      else if(tag < URGTYPE_FUNCTIONPOINT) {

	/* This is a object pointer type */

	param_obj = va_arg(arg, void *);

  /* this is a very serious error */

  return URG_OUT_OF_MEMORY;

}

      else

	param_func = va_arg(arg, func_T );

      /* printf("tag: %d\n", tag); */

typedef unsigned int CURLoption;

UrgError curl_setopt(CURL *curl, CURLoption option, ...)

{

  struct UrlData *data = curl;

  va_list param;

  char *cookiefile;

      switch(tag) {

#ifdef MULTIDOC

      case URGTAG_MOREDOCS:

        data->moredoc = (struct MoreDoc *)param_obj;

        break;

#endif

  va_start(param, option);

  switch(option) {

  case URGTAG_TIMECONDITION:

        data->timecondition = (long)param_long;

    data->timecondition = va_arg(param, long);

    break;

  case URGTAG_TIMEVALUE:

        data->timevalue = (long)param_long;

    data->timevalue = va_arg(param, long);

    break;

  case URGTAG_SSLVERSION:

        data->ssl_version = (int)param_long;

    data->ssl_version = va_arg(param, long);

    break;

  case URGTAG_COOKIEFILE:

        cookiefile = (char *)param_obj;

    cookiefile = (char *)va_arg(param, void *);

    if(cookiefile) {

      data->cookies = cookie_init(cookiefile);

    }

    break;

  case URGTAG_WRITEHEADER:

	data->writeheader = (FILE *)param_obj;

    data->writeheader = (FILE *)va_arg(param, FILE *);

    break;

  case URGTAG_COOKIE:

	data->cookie = (char *)param_obj;

    data->cookie = va_arg(param, char *);

    break;

  case URGTAG_ERRORBUFFER:

        data->errorbuffer = (char *)param_obj;

    data->errorbuffer = va_arg(param, char *);

    break;

  case URGTAG_FILE:

        data->out = (FILE *)param_obj;

    data->out = va_arg(param, FILE *);

    break;

  case URGTAG_FTPPORT:

        data->ftpport = (char *)param_obj;

    data->ftpport = va_arg(param, char *);

    break;

  case URGTAG_HTTPHEADER:

	data->headers = (struct HttpHeader *)param_obj;

    data->headers = va_arg(param, struct HttpHeader *);

    break;

  case URGTAG_CUSTOMREQUEST:

	data->customrequest = (char *)param_obj;

    data->customrequest = va_arg(param, char *);

    break;

  case URGTAG_HTTPPOST:

	data->httppost = (struct HttpPost *)param_obj;

    data->httppost = va_arg(param, struct HttpPost *);

    break;

  case URGTAG_INFILE:

        data->in = (FILE *)param_obj;

    data->in = va_arg(param, FILE *);

    break;

  case URGTAG_INFILESIZE:

        data->infilesize = (long)param_long;

    data->infilesize = va_arg(param, long);

    break;

  case URGTAG_LOW_SPEED_LIMIT:

	data->low_speed_limit=(long)param_long;

    data->low_speed_limit=va_arg(param, long);

    break;

  case URGTAG_LOW_SPEED_TIME:

	data->low_speed_time=(long)param_long;

    data->low_speed_time=va_arg(param, long);

    break;

  case URGTAG_URL:

        data->url = (char *)param_obj;

    data->url = va_arg(param, char *);

    break;

  case URGTAG_PORT:

    /* this typecast is used to fool the compiler to NOT warn for a

       "cast from pointer to integer of different size" */

        data->port = (unsigned short)((long)param_long);

    data->port = (unsigned short)(va_arg(param, long));

    break;

  case URGTAG_POSTFIELDS:

        data->postfields = (char *)param_obj;

    data->postfields = va_arg(param, char *);

    break;

  case URGTAG_PROGRESSMODE:

        data->progress.mode = (long)param_long;

    data->progress.mode = va_arg(param, long);

    break;

  case URGTAG_REFERER:

        data->referer = (char *)param_obj;

    data->referer = va_arg(param, char *);

    break;

  case URGTAG_PROXY:

        data->proxy = (char *)param_obj;

    data->proxy = va_arg(param, char *);

    break;

  case URGTAG_FLAGS:

        data->conf = (long)param_long;

    data->conf = va_arg(param, long);

    break;

  case URGTAG_TIMEOUT:

        data->timeout = (long)param_long;

    data->timeout = va_arg(param, long);

    break;

  case URGTAG_USERAGENT:

        data->useragent = (char *)param_obj;

    data->useragent = va_arg(param, char *);

    break;

  case URGTAG_USERPWD:

        data->userpwd = (char *)param_obj;

    data->userpwd = va_arg(param, char *);

    break;

  case URGTAG_POSTQUOTE:

        data->postquote = (struct curl_slist *)param_obj;

    data->postquote = va_arg(param, struct curl_slist *);

    break;

  case URGTAG_PROXYUSERPWD:

        data->proxyuserpwd = (char *)param_obj;

    data->proxyuserpwd = va_arg(param, char *);

    break;

  case URGTAG_RANGE:

        data->range = (char *)param_obj;

    data->range = va_arg(param, char *);

    break;

  case URGTAG_RESUME_FROM:

	data->resume_from = (long)param_long;

    data->resume_from = va_arg(param, long);

    break;

  case URGTAG_STDERR:

	data->err = (FILE *)param_obj;

    data->err = va_arg(param, FILE *);

    break;

  case URGTAG_WRITEFUNCTION:

        data->fwrite = (size_t (*)(char *, size_t, size_t, FILE *))param_func;

    data->fwrite = va_arg(param, void *);

    break;

  case URGTAG_WRITEINFO:

        data->writeinfo = (char *)param_obj;

    data->writeinfo = va_arg(param, char *);

    break;

  case URGTAG_READFUNCTION:

        data->fread = (size_t (*)(char *, size_t, size_t, FILE *))param_func;

    data->fread = va_arg(param, void *);

    break;

  case URGTAG_SSLCERT:

	data->cert = (char *)param_obj;

    data->cert = va_arg(param, char *);

    break;

  case URGTAG_SSLCERTPASSWD:

	data->cert_passwd = (char *)param_obj;

    data->cert_passwd = va_arg(param, char *);

    break;

  case URGTAG_CRLF:

	data->crlf = (long)param_long;

    data->crlf = va_arg(param, long);

    break;

  case URGTAG_QUOTE:

        data->quote = (struct curl_slist *)param_obj;

    data->quote = va_arg(param, struct curl_slist *);

    break;

      case URGTAG_DONE: /* done with the parsing, fall through */

        continue;

  default:

    /* unknown tag and its companion, just ignore: */

        break;

    return URG_READ_ERROR; /* correct this */

  }

  return URG_OK;

}

typedef int (*func_T)(void);

UrgError curl_urlget(UrgTag tag, ...)

{

  va_list arg;

  func_T param_func = (func_T)0;

  long param_long = 0;

  void *param_obj = NULL;

  UrgError res;

  struct UrlData *data;

  /* this is for the lame win32 socket crap */

  if(curl_init())

    return URG_FAILED_INIT;

  /* We use curl_open() with undefined URL so far */

  res = curl_open(&data, NULL);

  if(res == URG_OK) {

    /* data is now filled with good-looking zeroes */

    /* Let's set some default values: */

    curl_setopt(data, URGTAG_FILE, stdout); /* default output to stdout */

    curl_setopt(data, URGTAG_INFILE, stdin);  /* default input from stdin */

    curl_setopt(data, URGTAG_STDERR, stderr);  /* default stderr to stderr! */

    data->firstsocket = -1; /* no file descriptor */

    data->secondarysocket = -1; /* no file descriptor */

    /* use fwrite as default function to store output */

    data->fwrite = (size_t (*)(char *, size_t, size_t, FILE *))fwrite;

    /* use fread as default function to read input */

    data->fread = (size_t (*)(char *, size_t, size_t, FILE *))fread;

    data->infilesize = -1; /* we don't know any size */

    data->current_speed = -1; /* init to negative == impossible */

    va_start(arg, tag);

    while(tag != URGTAG_DONE) {

      /* PORTING NOTE:

	 Ojbect pointers can't necessarily be casted to function pointers and

	 therefore we need to know what type it is and read the correct type

	 at once. This should also correct problems with different sizes of

	 the types.

         */

      if(tag < URGTYPE_OBJECTPOINT) {

	/* This is a LONG type */

	param_long = va_arg(arg, long);

        curl_setopt(data, tag, param_long);

      }

      else if(tag < URGTYPE_FUNCTIONPOINT) {

	/* This is a object pointer type */

	param_obj = va_arg(arg, void *);

        curl_setopt(data, tag, param_obj);

      }

      else {

	param_func = va_arg(arg, func_T );

        curl_setopt(data, tag, param_func);

      }

      /* printf("tag: %d\n", tag); */

      tag = va_arg(arg, UrgTag);

    }