XML-RPC over libwww...

/*

  
  					W3C Sample Code Library libwww ANSI C File Streams


!
  Basic ANSI C Stream Content Copy Stream
!
*/

/*

This module contains a basic Content Copy Stream that can be used to
copy data objects to memory. See also the HTFSave module.

This module is implemented by IGHTWrite.c, and it
is derived from the W3C Sample Code Library.
*/

#ifndef IGHTWRITE_H
#define IGHTWRITE_H

#include "HTStream.h"
#include "HTReq.h"

/*
.
  Basic ANSI C Content Copy Stream
.

*/

#ifdef __cplusplus
extern "C" {            /* Assume C declarations for C++ */
#endif	/* __cplusplus */

extern HTStream * IGHTCopy_new(HTRequest *, int (*)(char *, int));

#ifdef __cplusplus
}
#endif	/* __cplusplus */

/*

*/

#endif	/* IGHTWRITE_H */

/*

  


*/

/*							       	    IGHTWrite.c
**	BASIC CONTENT COPIER STREAM
**
**	Derived from code which is (c) COPYRIGHT MIT 1995.
**	Please first read the full copyright statement in the file COPYRIGH.
**	@(#) $Id: HTFWrite.c,v 2.46 1999/02/22 22:10:11 frystyk Exp $
**
**	This version of the stream object just copies the stream contents.
**
**	Bugs:
**		strings written must be less than buffer size.
**
**      History:
**         PWI: Took example code and produced this...
**         HFN: wrote it
**         HWL: converted the caching scheme to be hierachical by taking
**              AL code from Deamon
**	   HFN: moved cache code to HTCache module
**
**	Idiosyncracies: This was modified under Borland C++ Builder 5
**			and uses a tabstop of two.So if my work looks
**			weird in vi you know why.
*/

/* Library include files */
#include "wwwsys.h"
#include "WWWUtil.h"
#include "WWWCore.h"

#include "IGHTWrite.h"					 /* Implemented here */

#define OUTBUF_SIZE		32768

struct _HTStream {
    const HTStreamClass *isa;
    char *		pc ;						/* Private Copy, (char *) 0 if empty */
    int len ;									/* Size of data in private copy */
    int CurBufSize ;					/* Size of private buffer */
    int (*Func)(char *, int) ;/* Callback function */
};

/* ------------------------------------------------------------------------- */
PRIVATE int IGHTCopy_MemSizeCheck(HTStream * me, int n)
{
	return (me->len + n) > me->CurBufSize ;
}

/* ------------------------------------------------------------------------- */
PRIVATE int IGHTCopy_Realloc (HTStream * me, int n)
{
	int NewSize = (((me->len + n) / OUTBUF_SIZE) * OUTBUF_SIZE) + OUTBUF_SIZE ;

	if ( (me->len + n) > me->CurBufSize )
  {
  	me->pc = me->pc ? malloc(NewSize) : realloc((void *)me->pc, NewSize) ;
	  if ( me->pc )
    	me->CurBufSize = NewSize ;
  }
  return me->pc ? HT_OK : HT_ERROR;
}
/* ------------------------------------------------------------------------- */

PRIVATE int IGHTCopy_put_character (HTStream * me, char c)
{
	if ( IGHTCopy_MemSizeCheck(me, 1) )
  	IGHTCopy_Realloc(me, 1) ;
  if ( me->pc )
  {
  	me->pc[me->len] = c ;
	  me->len++ ;
  }
  return me->pc ? HT_OK : HT_ERROR;
}

PRIVATE int IGHTCopy_put_string (HTStream * me, const char* s)
{
	int NewRequestedSize = strlen(s) + 1 ;

  if (*s)				             /* For vms :-( 10/04-94 */
  {
    if ( IGHTCopy_MemSizeCheck(me, NewRequestedSize) )
      IGHTCopy_Realloc(me, NewRequestedSize) ;
    if ( me->pc )
    {
      memcpy((void *)&me->pc[me->len], (void *)s, NewRequestedSize) ; /* don't forget to take the null */
	    me->len += NewRequestedSize ;
    }
  }
  return me->pc ? HT_OK : HT_ERROR;
}

PRIVATE int IGHTCopy_flush (HTStream * me)
{
#ifdef POINTLESS_AND_VICIOUS_FLUSH
  /* If the buffer is still being used, don't waste time forcing a re-malloc */ 
	if ( me->pc )
		free( me->pc ) ;
  me->CurBufSize = 0 ;
  me->pc = (char *) 0 ;
#endif /* POINTLESS_AND_VICIOUS_FLUSH */
  me->len = 0 ;
  return HT_OK ;
}

PRIVATE int IGHTCopy_write (HTStream * me, const char* s, int l)
{
  if ( IGHTCopy_MemSizeCheck(me, l) )
    IGHTCopy_Realloc(me, l) ;
  if ( me->pc )
  {
    memcpy((void *)&me->pc[me->len], (void *)s, l) ; /* don't forget to take the null */
    me->len += l ;
    me->Func(me->pc, me->len) ;
  }
  return me->pc ? HT_OK : HT_ERROR;
}

PRIVATE int IGHTCopy_free (HTStream * me)
{
  if (me)
  {
    IGHTCopy_flush(me);
    HT_FREE(me);
  }
  return HT_OK;
}

PRIVATE int IGHTCopy_abort (HTStream * me, HTList * e)
{
  HTTRACE(STREAM_TRACE, "FileWriter.. ABORTING...\n");
  if (me)
    IGHTCopy_free(me);
  return HT_ERROR;
}

PRIVATE const HTStreamClass IGHTCopy = /* As opposed to print etc */
{		
    "StreamContentCopy",
    IGHTCopy_flush,
    IGHTCopy_free,
    IGHTCopy_abort,
    IGHTCopy_put_character,
    IGHTCopy_put_string,
    IGHTCopy_write
};

//PUBLIC HTStream * IGHTCopy_new (HTRequest * request, int (*Func)(char *, int))
PUBLIC HTStream * IGHTCopy_new (HTRequest * request, int (*Func)(char *, int))
{
  HTStream * me = NULL;
  if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) // cdecl
      HT_OUTOFMEM("IGHTCopy_new");
  me->isa = &IGHTCopy;
  me->Func = Func ;
  return me;
}