/*
** Libwww extension test file
**
** This program shows how to use the extension methods available in Libwww.
** Through these methods (METHOD_EXT_0 to METHOD_EXT_6), applications may
** register (by calling HTMethod_setExtensionMethod) new methods, that may be
** unknown for the Libwww, and use them for its request. See HTMethod.html for
** details.
**
** More libwww samples can be found at "http://www.w3.org/Library/Examples/"
**
** Copyright © 1995-1998 World Wide Web Consortium, (Massachusetts
** Institute of Technology, Institut National de Recherche en
** Informatique et en Automatique, Keio University). All Rights
** Reserved. This program is distributed under the W3C's Software
** Intellectual Property License. This program 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 W3C License http://www.w3.org/Consortium/Legal/ for more
** details.
**
**
** Authors:
** MKP Manuele Kirsch Pinheiro (Manuele.Kirsch_Pinheiro@inrialpes.fr,
** manuele@inf.ufrgs.br)
** _ Project CEMT (INRIA Rhone-Alpes,France / UFRGS-II,Brazil) _
**
** History:
** fev, 2002 created MKP
**
** $Id: myext2.c,v 1.2 2002/05/30 18:08:56 kirschpi Exp $
*/
#include "WWWLib.h"
#include "WWWInit.h"
#include "WWWApp.h"
#include "WWWXML.h"
#include "WWWHTTP.h"
#ifndef W3C_VERSION
#define W3C_VERSION "Unspecified"
#endif
#define APP_NAME "MyExt"
#define APP_VERSION "4.0"
#if defined(__svr4__)
#define CATCH_SIG
#endif
/*
** error codes for use in error_callback filter
*/
#define ERR_UNKNOWN 0x0
#define ERR_FATAL 0x1
#define ERR_NON_FATAL 0x2
#define ERR_WARN 0x4
#define ERR_INFO 0x8
/*
** Some compilers, like MSVC, doesn't know STDIN_FILENO
*/
#ifndef STDIN_FILENO
#define STDIN_FILENO fileno(stdin)
#endif
/* commands */
#define VIEW 1
#define SET 2
#define DEL 3
#define PROPPATCH METHOD_EXT_0
#define PROPFIND METHOD_EXT_1
/*
** Our stream
*/
struct _HTStream {
const HTStreamClass * isa;
HTStream * target;
HTRequest * request;
int version;
BOOL endHeader;
BOOL transparent;
};
/*
** Command line structure
*/
typedef struct _CmdLine {
int cmd; /* command */
char *url; /* url */
char *prop; /* property name */
char *ns; /* property namespace */
char *val; /* property val */
} CmdLine;
/*
** Request context
*/
typedef struct _Context {
int depth;
} Context;
/*
** Application context
*/
typedef struct _App {
HTRequest * console_request;
HTEvent * console_event;
HTList * active; /* List of active contexts */
} App;
/*
** Callback functions
*/
PRIVATE HTEventCallback console_parser;
PRIVATE HTNetAfter request_terminater;
PRIVATE HTNetAfter error_callback;
PRIVATE int printer (const char * fmt, va_list pArgs);
PRIVATE int tracer (const char * fmt, va_list pArgs);
/*
** Prototypes
*/
PRIVATE CmdLine * CmdLine_new (const char *buffer);
PRIVATE BOOL CmdLine_delete (CmdLine * me);
PRIVATE App * App_new (void);
PRIVATE BOOL App_delete (App * me);
PRIVATE void Context_new (HTRequest * request, App * app);
PRIVATE void Context_delete (Context * ctx);
PRIVATE HTRequest * Request_new (App * app,HTMethod method);
PRIVATE BOOL Request_delete (App * app, HTRequest * request);
PRIVATE int request_terminater (HTRequest * request, HTResponse * response,
void * param, int status);
PRIVATE int console_parser (SOCKET s, void * param, HTEventType type);
PRIVATE int error_callback (HTRequest * request, HTResponse * response,
void * param, int status);
PRIVATE int mypcbf (HTRequest * request, HTStream * target);
PRIVATE App * Init (void);
PRIVATE void my_get_document (App *app, CmdLine * line);
PRIVATE char * create_body (CmdLine *line);
/* --------------------------------------------------------------------------*/
/* ------------------------------------------------------------------------- */
/* EXPAT HANDLERS */
/* ------------------------------------------------------------------------- */
PRIVATE void XML_startElement (void * userData,
const XML_Char * name,
const XML_Char ** atts)
{
int *depth = (int *)userData;
int i=0;
if (name) {
HTPrint ("\n");
for (i=0;i<(*depth);i++)
HTPrint (" ");
HTPrint("%s ", name);
for (i = 0; atts[i]; i += 2)
HTPrint(" %s='%s'", atts[i], atts[i + 1]);
}
*depth += 1;
}
PRIVATE void XML_endElement (void * userData,
const XML_Char * name)
{
int *depth = (int *)userData;
*depth -= 1;
}
PRIVATE void XML_characterData (void * userData,
const XML_Char * s,
int len)
{
int i=0;
if (len>1) {
HTPrint (": ");
for (i=0;i<len;i++) HTPrint ("%c",s[i]);
if (s[i-2]!='\n') HTPrint ("\n");
}
else {
if (s[0]!='\n' && s[0]!=' ') HTPrint (": %c\n",s[0]);
}
return;
}
PRIVATE void XML_processingInstruction (void * userData,
const XML_Char * target,
const XML_Char * data)
{
return;
}
PRIVATE void XML_default (void * userData,
const XML_Char * s,
int len)
{
return;
}
PRIVATE void XML_unparsedEntityDecl (void * userData,
const XML_Char * entityName,
const XML_Char * base,
const XML_Char * systemId,
const XML_Char * publicId,
const XML_Char * notationName)
{
return;
}
PRIVATE void XML_notationDecl (void * userData,
const XML_Char * notationName,
const XML_Char * base,
const XML_Char * systemId,
const XML_Char * publicId)
{
return;
}
PRIVATE int XML_externalEntityRef (XML_Parser parser,
const XML_Char * openEntityNames,
const XML_Char * base,
const XML_Char * systemId,
const XML_Char * publicId)
{
return 0;
}
PRIVATE int XML_unknownEncoding (void * encodingHandlerData,
const XML_Char * name,
XML_Encoding * info)
{
return 0;
}
/* ------------------------------------------------------------------------- */
/* HTXML STREAM HANDLERS */
/* ------------------------------------------------------------------------- */
PRIVATE void HTXML_setHandlers (XML_Parser me, HTRequest *request)
{
XML_SetElementHandler(me, XML_startElement, XML_endElement);
XML_SetCharacterDataHandler(me, XML_characterData);
XML_SetProcessingInstructionHandler(me, XML_processingInstruction);
XML_SetDefaultHandler(me, XML_default);
XML_SetUnparsedEntityDeclHandler(me, XML_unparsedEntityDecl);
XML_SetNotationDeclHandler(me, XML_notationDecl);
XML_SetExternalEntityRefHandler(me, XML_externalEntityRef);
XML_SetUnknownEncodingHandler(me, XML_unknownEncoding, NULL);
if (request && HTRequest_context(request)) {
XML_SetUserData(me, &(((Context *)(HTRequest_context(request)))->depth) );
}
}
PRIVATE void HTXML_newInstance (HTStream * me,
HTRequest * request,
HTFormat target_format,
HTStream * target_stream,
XML_Parser xmlparser,
void * context)
{
/*HTPrint ("MyExt: HTXML_newInstance\n");*/
if (me && xmlparser) {
if (request && HTRequest_method(request)==PROPFIND)
HTXML_setHandlers(xmlparser,request);
}
}
/* ------------------------------------------------------------------------- *
** New/Delete functions *
** ------------------------------------------------------------------------- */
/*
** CmdLine_new: creates a command line object
** A command line has this syntax : <command> <url> [propname:namespace][= value]
** A command is v (view), s (set) or d (delete)
** An example : s http://foo.bar/ name:http://host/mydtd.dtd = my_file
*/
PRIVATE CmdLine * CmdLine_new (const char *buffer) {
char *line = (char *)buffer;
char *url, *ns, *prop, *val;
char *rurl, *rns, *rprop, *rval;
int cmd;
int i,j,len;
CmdLine *res = NULL;
BOOL status = YES;
url = ns = prop = val = NULL;
rurl = rns = rprop = rval = NULL;
len = strlen (line);
cmd = 0;
i = j = 0;
/*--- get command ---*/
while (line[i]==' ' && i<len) i++;
switch (line[i++]) {
case 'v':
case 'V': cmd = VIEW;
break;
case 's':
case 'S': cmd = SET;
break;
case 'd':
case 'D': cmd = DEL;
break;
default: status = NO; /* wrong command - error */
}
/*--- get url ---*/
while (status && line[i]==' ' && i<len) i++;
if (status && i<len) url = &line[i];
else status = NO; /* no url - error */
j = i; /* search url ending position */
while (status && line[i]!=' ' && line[i]!='\n' && i<len) i++;
/* alloc url return string */
if (status && (rurl = HT_CALLOC ((i-j+1),sizeof(char)))!=NULL) {
strncpy (rurl,url,i-j);
rurl[i-j]='\0';
}
else status = NO;
if (status && cmd!=VIEW) {
/*--- get property name ---*/
while (line[i]==' ' && i<len) i++;
if (status && i<len) prop = &line[i];
else status = NO; /* no property - error */
j = i; /* search prop ending position */
while (status && line[i]!=':' && i<len) i++;
/* alloc prop return string */
if (status && i<len && (rprop = HT_CALLOC ((i-j+1),sizeof(char)))!=NULL) {
strncpy (rprop,prop,i-j);
rprop[i-j]='\0';
}
else status = NO;
/*--- get property namespace ---*/
i++;
if (status && i<len)
ns = &line[i];
else status = NO; /* no property namespace - error */
j = i; /* search ns ending position */
while (status && line[i]!=' ' && line[i]!='=' && line[i]!='\n' && i<len) i++;
/* alloc ns return string */
if (status && (rns = HT_CALLOC ((i-j+1),sizeof(char)))!=NULL) {
strncpy (rns,ns,i-j);
rns[i-j]='\0';
}
else status = NO;
if (status && cmd==SET) {
/*--- get property value ---*/
while (line[i]!='=' && i<len) i++;
i++; /* jump = */
while (line[i]==' ' && i<len) i++;
if (i<len)
val = &line[i];
else status = NO; /* no property value - error */
j = i; /* search val ending position */
while (status && line[i]!='\n' && i<len) i++;
/* alloc val return string */
if (status && (rval = HT_CALLOC ((i-j+1),sizeof(char)))!=NULL) {
strncpy (rval,val,i-j);
rval[i-j]='\0';
}
else status = NO;
}
}
if (status && (res = HT_CALLOC (1,sizeof(CmdLine))) != NULL ) {
res->cmd = cmd;
res->url = rurl;
res->prop = rprop;
res->ns = rns;
res->val = rval;
}
else {
if (rurl) HT_FREE(rurl);
if (rprop) HT_FREE(rprop);
if (rns) HT_FREE(rns);
if (rval) HT_FREE(rval);
res = NULL;
}
return res;
}
/*
** CmdLine_delete : removes a command line object
*/
PRIVATE BOOL CmdLine_delete (CmdLine * me) {
if (me) {
if (me->url) free (me->url);
if (me->prop) free (me->prop);
if (me->ns) free (me->ns);
if (me->val) free (me->val);
free (me);
return YES;
}
return NO;
}
/*
** App_new : creates a new application context
** Returns : App * application context
*/
PRIVATE App * App_new (void) {
App * me = NULL;
if ((me = (App *) HT_CALLOC(1, sizeof(App))) == NULL)
HT_OUTOFMEM("App_new");
/* setting everybody */
me->console_request = HTRequest_new();
me->console_event = HTEvent_new(console_parser, me, HT_PRIORITY_MAX, -1);
me->active = HTList_new();
/* Register stdin as our console */
if (isatty(STDIN_FILENO))
HTEventList_register(STDIN_FILENO, HTEvent_READ, me->console_event);
/* Add our own request terminate handler */
HTNet_addAfter(request_terminater, NULL, me, HT_ALL, HT_FILTER_LAST);
HTPrint ("MyExt: Application context created\n");
/* Set Extension method 0 to PROPPATCH and 1 to PROPFIND */
HTPrint ("MyExt: Setting method %x to PROPPATCH\n",PROPPATCH);
if (!HTMethod_setExtensionMethod (PROPPATCH, "PROPPATCH",YES)) {
HTPrint ("MyExt: ERROR _ Unable to set extension method");
exit(1);
}
HTPrint ("MyExt: Setting method %x to PROPFIND\n",PROPFIND);
if (!HTMethod_setExtensionMethod (PROPFIND, "PROPFIND",NO)) {
HTPrint ("MyExt: ERROR _ Unable to set extension method");
exit(1);
}
HTPrint ("Enter: <command> <url> [propname:namespace][= valor]\n");
HTPrint (" or Q to exit \n");
HTPrint ("command := v (view), s (set) or d (delete)\n");
HTPrint ("examples : s http://foo.bar/ propertyname:http://foo.bar/foodtd.dtd = property_value\n");
HTPrint (" d http://foo.bar/ propertyname:http://foo.bar/foodtd.dtd \n");
HTPrint (" v http://foo.bar/\n");
HTPrint (">\n ");
return me;
}
/*
** App_delete : removes an application context object
** Parameter : App * app application context to be removed
** Returns : BOOL YES - operation succed
** NO - operation failed
*/
PRIVATE BOOL App_delete (App * me) {
HTRequest * req = NULL;
HTPrint ("MyExt: Removing application context\n");
if (me) {
/* killing any remaining active requests */
HTNet_killAll();
/* freeing all remaining request objects */
while (!HTList_isEmpty(me->active)) {
req = (HTRequest *) HTList_nextObject (me->active);
if (req) Request_delete (me,req);
}
/* clean up everything */
HTRequest_delete(me->console_request);
HTEvent_delete (me->console_event);
HTList_free (me->active);
/* clean up extension method */
HTPrint ("Removing extension methods\n");
if (HTMethod_deleteExtensionMethod (PROPPATCH) && HTMethod_deleteExtensionMethod (PROPFIND))
HTPrint ("MyExt: Extension methods deleted \n");
HT_FREE(me);
/* stopping event loop */
HTEventList_stopLoop();
/* Terminate libwww */
HTProfile_delete();
return YES;
}
return NO;
}
/*
** Context_new : creates a new request context
** Parameters : HTRequest * request
** App * app
*/
PRIVATE void Context_new (HTRequest * request, App * app) {
Context * ctx = NULL;
if ( (ctx = (Context *) HT_CALLOC(1, sizeof(Context))) == NULL ) {
App_delete (app);
HT_OUTOFMEM("Contect_new");
}
/*HTPrint ("MyExt: Setting request context...\n");*/
ctx->depth = 0;
HTRequest_setContext(request,ctx);
}
/*
** Context_delete : removes the request context
** Parameters : Context * ctx
*/
PRIVATE void Context_delete (Context * ctx) {
if (ctx) {
/*HTPrint ("MyExt: Removing request context...\n");*/
HT_FREE (ctx);
}
}
/*
** Request_new : creates a new request
** Parameters : App * app application context
** Returns : HTRequest *
*/
PRIVATE HTRequest * Request_new (App * app, HTMethod method)
{
HTRequest * request = HTRequest_new();
HTPrint ("MyExt: creating a new request\n");
HTRequest_addConnection(request,"close","");
/* setting request format */
HTRequest_setOutputFormat(request, HTAtom_for ("text/xml"));
HTRequest_setOutputFormat(request, WWW_SOURCE);
/* method */
/* HTPrint ("MyExt: Setting method in the request\n"); */
HTRequest_setMethod (request,method);
/* some headers */
HTRequest_addExtraHeader (request,"Depth","0");
HTRequest_addCacheControl (request, "no-cache","");
HTRequest_addGnHd (request,HT_G_PRAGMA_NO_CACHE);
/* set local filters */
HTRequest_addAfter (request,error_callback, NULL, app, \
HT_ERROR, HT_FILTER_LAST, NO);
if (!app->active) app->active = HTList_new();
HTList_addObject(app->active, request);
HTRequest_setFlush(request, YES);
/* register XML callback */
HTXMLCallback_registerNew (HTXML_newInstance, NULL);
return request;
}
/*
** Request_delete : removes a request
** Parameters : App * app application context
** HTRequest * request
** Returns : BOOL YES if operation succeed
** NO if operation failed
*/
PRIVATE BOOL Request_delete (App * app, HTRequest * request)
{
/* HTPrint ("MyExt: removing request\n"); */
if (app && app->active && request) {
HTPrint ("MyExt: Request deleted \n");
HTList_removeObject(app->active, request);
HTRequest_delete(request);
return YES;
}
return NO;
}
/* ------------------------------------------------------------------------- *
** Global/local Filters *
** ------------------------------------------------------------------------- */
/*
** printer : output messages function
*/
PRIVATE int printer (const char * fmt, va_list pArgs) {
return (vfprintf(stderr, fmt, pArgs));
}
/*
** trace : trace messages function
*/
PRIVATE int tracer (const char * fmt, va_list pArgs) {
return (vfprintf(stderr, fmt, pArgs));
}
/*
** console_parser : treats the user's interaction on the console
** Function's type : HTEventCallback
*/
PRIVATE int console_parser (SOCKET s, void * param, HTEventType type)
{
App * app = (App *) param;
char buf[2048];
CmdLine * line;
/* reading console */
if (!fgets(buf, sizeof(buf), stdin)) {
HTPrint ("Error reading stdin\n");
return HT_ERROR;
}
if (toupper(buf[0]) == 'Q') { /* Quit the program */
App_delete(app);
exit (0);
}
else { /* take the target address */
HTPrint ("MyExt: Console readed **%s**\n",buf);
if ( (line = CmdLine_new (buf))==NULL ) {
HTPrint ("Wrong command line\n");
return HT_ERROR;
}
my_get_document (app,line);
}
return HT_OK;
}
/*
** request_terminater : global filter to delete the requests
** Funtion's type : HTNetAfter
*/
PRIVATE int request_terminater (HTRequest * request, HTResponse * response,
void * param, int status)
{
App * app = (App *) param;
Context * ctx = NULL;
/* HTPrint ("MyExt: GLOBAL FILTER (request_terminater)\n"); */
if (status/100 == 2) HTPrint ("MyExt: SUCCED!\n");
if (response) HTPrint ("\tReason %s\n",(HTResponse_reason(response))? \
HTResponse_reason(response):"NULL");
HTPrint ("\tStatus %d\n",status);
ctx = (Context *) HTRequest_context(request);
/*HTPrint ("MyExt: context object deleted\n");*/
Context_delete (ctx);
Request_delete(app, request);
HTPrint ("Ready!\n");
HTPrint ("Enter: <command> <url> [propname:namespace][= valor]\n");
HTPrint (" or Q to exit\n");
HTPrint ("> ");
return HT_OK;
}
/*
** error_callback : global after filter to treat the request's errors
** Function's type : HTNetAfter
*/
PRIVATE int error_callback (HTRequest * request, HTResponse * response,
void * param, int status) {
App * app = (App *) param;
HTList * error_list = NULL;
HTError * error = NULL;
HTPrint ("MyExt: ERROR CALLBACK\n");
HTPrint ("\tapp %s \n\trequest %s \n\tresponse %s \n\tstatus %d\n", \
(app)?"OK":"NULL",(request)?"OK":"NULL",\
(response)?"OK":"NULL",status);
if (request) {
error_list = HTRequest_error (request);
while (error_list && (error = (HTError *) HTList_nextObject(error_list))) {
HTPrint ("\tError location %s\n",HTError_location(error));
switch (HTError_severity(error)) {
case ERR_UNKNOWN :
HTPrint ("\tSeverity : UNKNOWN\n");
break;
case ERR_FATAL :
HTPrint ("\tSeverity : FATAL\n");
break;
case ERR_NON_FATAL :
HTPrint ("\tSeverity : NON FATAL\n");
break;
case ERR_WARN :
HTPrint ("\tSeverity : WARN\n");
break;
case ERR_INFO :
HTPrint ("\tSeverity : INFO\n");
break;
default :
HTPrint ("\tSeverity : %Xd\n",HTError_severity(error));
break;
}
}
}
return HT_OK;
}
/* --------------------------------------------------------------------------*/
/* ENTITY CALLBACK */
/* --------------------------------------------------------------------------*/
/*
** Entity Callback
*/
PRIVATE int mypcbf (HTRequest * request, HTStream * target)
{
HTParentAnchor * entity = HTRequest_entityAnchor(request);
HTTRACE(APP_TRACE, "Posting Data from MY callback function\n");
if (!request || !entity || !target) return HT_ERROR;
{
BOOL chunking = NO;
int status;
char * document = (char *) HTAnchor_document(entity);
int len = HTAnchor_length(entity);
if (!document) {
HTTRACE(PROT_TRACE, "Posting Data No document\n");
return HT_ERROR;
}
/*
** If the length is unknown (-1) then see if the document is a text
** type and in that case take the strlen. If not then we don't know
** how much data we can write and must stop
*/
if (len < 0) {
HTFormat actual = HTAnchor_format(entity);
HTFormat tmplate = HTAtom_for("text/*");
if (HTMIMEMatch(tmplate, actual)) {
len = strlen(document); /* Naive! */
chunking = YES;
} else {
HTTRACE(PROT_TRACE, "Posting Data Must know the length of document %p\n" _
document);
return HT_ERROR;
}
}
/* Send the data down the pipe */
status = (*target->isa->put_block)(target, document, len);
if (status == HT_WOULD_BLOCK) {
HTTRACE(PROT_TRACE, "Posting Data Target WOULD BLOCK\n");
return HT_WOULD_BLOCK;
} else if (status == HT_PAUSE) {
HTTRACE(PROT_TRACE, "Posting Data Target PAUSED\n");
return HT_PAUSE;
} else if (chunking && status == HT_OK) {
HTTRACE(PROT_TRACE, "Posting Data Target is SAVED using chunked\n");
return (*target->isa->put_block)(target, "", 0);
} else if (status == HT_LOADED || status == HT_OK) {
HTTRACE(PROT_TRACE, "Posting Data Target is SAVED\n");
(*target->isa->flush)(target);
return HT_LOADED;
} else if (status > 0) { /* Stream specific return code */
HTTRACE(PROT_TRACE, "Posting Data. Target returns %d\n" _ status);
return status;
} else { /* we have a real error */
HTTRACE(PROT_TRACE, "Posting Data Target ERROR %d\n" _ status);
return status;
}
}
}
/* ------------------------------------------------------------------------- *
** Other Functions *
** ------------------------------------------------------------------------- */
/*
** Init : application initialization
** Returns : App * application context
*/
PRIVATE App * Init (void) {
App * app = NULL;
HTPrint ("MyExt: starting application\n");
/* Initiate libwww */
HTProfile_newHTMLNoCacheClient(APP_NAME, APP_VERSION);
HTTP_setConnectionMode(HTTP_11_NO_PIPELINING);
app = App_new();
/* Gotta set up our own traces */
HTPrint_setCallback(printer);
HTTrace_setCallback(tracer);
#if 0
HTSetTraceMessageMask("sapol");
#endif
HTEventList_newLoop();
return app;
}
/*
** my_get_document: retrives the document
** Parameters: App * app application context
** char * dst URL destiny
*/
PRIVATE void my_get_document (App *app, CmdLine * line) {
HTRequest * request = NULL;
HTAnchor * dst = NULL;
char * full_dst;
char * cwd;
char * body = create_body(line);
cwd = HTGetCurrentDirectoryURL();
full_dst = HTParse (line->url,cwd,PARSE_ALL);
dst = HTAnchor_findAddress (full_dst);
/* HTPrint ("MyExt: loading document\n");*/
request = Request_new (app, (line->cmd==VIEW)?PROPFIND:PROPPATCH);
HTRequest_setAnchor (request,dst);
/* set body */
if (body) {
HTPrint ("MyExt: Setting entity message body to %s\n",body,strlen(body));
if (line->cmd==VIEW) { /* set message body */
HTRequest_setMessageBody (request,body);
HTRequest_setMessageBodyLength (request,strlen(body));
HTRequest_setMessageBodyFormat (request,HTAtom_for("text/xml"));
}
else {
HTParentAnchor *entity = HTTmpAnchor(NULL);
HTAnchor_setDocument(entity, body);
HTAnchor_setFormat(entity, HTAtom_for ("text/xml"));
HTAnchor_setLength(entity, strlen(body));
HTRequest_setEntityAnchor (request,entity);
/* HTPrint ("MyExt: Entity format %s length %d\n", \
HTAtom_name(HTAnchor_format(entity)), \
HTAnchor_length(entity));
*/
/* if we do not register our own PostCallback, libwww will not
* send the request entity body */
HTRequest_setPostCallback(request, mypcbf);
}
}
if ( request && (HTLoad (request,NO))) {
/* HTPrint ("MyExt: setting context\n");*/
Context_new (request,app);
}
else
HTPrint ("MyExt: load failed\n");
/* HTParentAnchor entity keep using it - do not delete! */
/* HT_FREE (body); */
CmdLine_delete (line);
}
PRIVATE char * create_body (CmdLine * line) {
char * body = NULL;
char buf [2048];
if (line) {
strcpy (buf,"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
if (line->cmd==VIEW) {
strcat (buf,"<D:propfind xmlns:D=\"DAV:\"> ");
strcat (buf,"<D:allprop/> </D:propfind>");
}
else {
strcat (buf,"<D:propertyupdate xmlns:D=\"DAV:\">\n");
if (line->cmd==SET) strcat (buf," <D:set>\n");
else if (line->cmd==DEL) strcat (buf," <D:remove>\n");
else return NULL; /* invalid command */
strcat (buf," <D:prop>\n");
strcat (buf," <ns:");
if (line->prop && line->ns) {
strcat (buf,line->prop);
strcat (buf," xmlns:ns=\"");
strcat (buf,line->ns);
strcat (buf,"\">");
}
else return NULL; /* no property or property namespace */
if (line->cmd==SET) {
strcat (buf,(line->val)?line->val:"");
}
strcat (buf,"</ns:");
strcat (buf,line->prop);
strcat (buf,">\n");
strcat (buf," </D:prop>\n");
strcat (buf,(line->cmd==SET)?" </D:set>\n":" </D:remove>\n");
strcat (buf,"</D:propertyupdate>");
}
StrAllocCopy (body,buf);
}
return body;
}
/* ******************************************************************** */
int main (int argc, char ** argv)
{
App * app = NULL;
app = Init();
return 0;
}
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to myext2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / Examples