strcat( req.headers, EOL );    if( ! http_webdav_server ) {	/* For non-WebDAV servers */	strcat( req.headers, "New-URI: " );	strcat( req.headers, to );	strcat( req.headers, EOL );    }    ret = http_request( &req );        if( ret == PROTO_OK && req.class != 2 ) {	ret = PROTO_ERROR;    }    http_request_end( &req );    return ret;}/* Deletes the specified resource on the server */int http_delete( const char *filename ) {    http_req_t req;    int ret;        http_request_init( &req, "DELETE", filename );    ret = http_request( &req );    if( ret == PROTO_OK && req.class != 2 )	ret = PROTO_ERROR;    http_request_end( &req );    return ret;}/* Deletes the specified resource on the server. * I wish we could do Depth: 0 with DELETE. */int dav_rmdir( const char *filename ) {    http_req_t req;    int ret;    char *dirname;        if( strlen( filename ) < 1 ) {	return PROTO_ERROR;    }    if( *(filename+strlen(filename)) != '/' ) {	dirname = malloc( strlen( filename ) + 2 );	strcpy( dirname, filename );	strcat( dirname, "/" );    } else {	dirname = strdup( filename );    }    http_request_init( &req, "DELETE", dirname );        ret = http_request( &req );    /* If we get a 207, something has gone wrong */    if( ret == PROTO_OK && ( (req.status == 207) || (req.class != 2) ) )	ret = PROTO_ERROR;    free( dirname );    http_request_end( &req );    return ret;}int http_mkdir_with_put( const char *realdir ) {    char filename[BUFSIZ];    http_req_t req;    int ret;    strcpy( filename, realdir );    strcat( filename, "SitecopyTempDirCreator.txt" );    http_request_init( &req, "PUT", filename );    /* Can't send Content-Type, would break digest auth entity     * digest code    strcat( req.headers, "Content-type: text/plain" EOL );     */        ret = http_request( &req );    if( ret == PROTO_OK && req.class == 2 ) {	http_request_end( &req );	http_request_init( &req, "DELETE", filename );	ret = http_request( &req );	if( ret != PROTO_OK || req.class != 2 )	    /* NEED an FE warning function here */            DEBUG( DEBUG_HTTP,		   "Can\'t delete the temporary file http://%s:%d%s",		   http_server_host.hostname, http_server_host.port,		   filename );	ret = PROTO_OK;    } else {	ret = PROTO_ERROR;    }    http_request_end( &req );    return ret;}int dav_mkcol( const char *dirname ) {    http_req_t req;    int ret;    char *realdir;    if( strlen( dirname ) < 1 ) {	strcpy( http_error, "Invalid directory name." );	return PROTO_ERROR;    }    if( *(dirname+strlen(dirname)-1) == '/' ) {	realdir = strdup( dirname );    } else {	/* +2 since one for \0, one for / */	realdir = malloc( strlen(dirname) + 2 );	strcpy( realdir, dirname );	strcat( realdir, "/" );    }        if( http_mkdir_works == 1 ) {	/* Use MKDIR, since we know it works */	http_request_init( &req, "MKDIR", realdir );	ret = http_request( &req );	if( ret == PROTO_OK && req.class != 2 )	    ret = PROTO_ERROR;    } else {	/* Try MKCOL first */	http_request_init( &req, "MKCOL", realdir );		ret = http_request( &req );		if( ret == PROTO_OK && req.class == 2 ) {	    /* MKCOL works -> MKDIR doesn't */	    http_mkdir_works = -1;	} else if( (http_mkdir_works > -1) && !http_webdav_server ) { 	    /* MKCOL failed, we're not on a DAV server, lets try MKDIR */	    http_request_end( &req );	    http_request_init( &req, "MKDIR", realdir );	    ret = http_request( &req );	    if( ret == PROTO_OK && req.class == 2 ) {		/* MKDIR does work */		http_mkdir_works = 1;		ret = PROTO_OK;	    } else { 		/* MKDIR doesn't work */		if( req.status == 501 ) {		    /* MKDIR definitely isn't implemented */		    http_mkdir_works = -1;		}		/* Try a dummy PUT/DELETE */		return http_mkdir_with_put( realdir );	    }	} else {	    ret = PROTO_ERROR;	}    }    free( realdir );    http_request_end( &req );    return ret;}int http_open( void ) {    if( http_use_proxy ) {	DEBUG( DEBUG_SOCKET, "Connecting to proxy at %s:%d...\n", 	       http_proxy_host.hostname, http_proxy_host.port );    } else {	DEBUG( DEBUG_SOCKET, "Connecting to server at %s:%d...\n", 	       http_server_host.hostname, http_server_host.port );    }    fe_connection( fe_connecting );    http_sock = socket_connect( http_remoteaddr, http_remoteport);    if( http_sock < 0 ) {	DEBUG( DEBUG_SOCKET, "Could not connect: %s\n", strerror( errno ) );	return PROTO_CONNECT;    }    DEBUG( DEBUG_SOCKET, "Connected.\n" );    fe_connection( fe_connected );    http_connected = true;    return PROTO_OK;}int http_close( void ) {    DEBUG( DEBUG_SOCKET, "Closing socket.\n" );    socket_close( http_sock );    http_connected = false;    DEBUG( DEBUG_SOCKET, "Socket closed.\n" );    return PROTO_OK;}int dav_mkref( const char *resref, const char *target ) {    http_req_t req;    int ret;    http_request_init( &req, "MKREF", resref );    strcat( req.headers, "Ref-Target: <" );    strcat( req.headers, target );    strcat( req.headers, ">" EOL );    ret = http_request( &req );    if( ret == PROTO_OK && req.class != 2 )	ret = PROTO_ERROR;        http_request_end( &req );    return ret;}int dav_chref( const char *resref, const char *target ) {    int ret;    /* Delete it */    ret = dav_rmref( resref );    if( ret != PROTO_OK ) 	return ret;    /* Then create it again */    ret = dav_mkref( resref, target );    return ret;}int dav_rmref( const char *resref ) {    http_req_t req;    int ret;        http_request_init( &req, "DELETE", resref );    strcat( req.headers, "No-Passthrough: 1" EOL );    ret = http_request( &req );    if( ret == PROTO_OK && req.class != 2 )	ret = PROTO_ERROR;        http_request_end( &req );    return ret;}#ifdef HAVE_LIBEXPAT/* TODO: Go read the XML specs again and use the correct terminology * for everything.   */XML_Parser dav_xml_parser;/* Parses the tag attributes, and handles XML namespaces.  * With a little bit of luck. * Return true on success. */static bool dav_xml_parsetag( struct dav_xml_state *state,		       const char *tag, const char **atts ) {    dav_xml_ns *ns;    int attn;    char *pnt;    const char *tag_prefix, *tag_suffix;    struct dav_xml_state *xmlt;    DEBUG( DEBUG_XML, "Parsing tag of name: [%s]\n", tag );    /* Parse the atts for namespace declarations */    for( attn = 0; atts[attn]!=NULL; attn+=2 ) {	DEBUG( DEBUG_XML, "Got attribute: [%s] = [%s]\n", atts[attn], atts[attn+1] );	if( strcasecmp( atts[attn], "xmlns" ) == 0 ) {	    /* New default namespace */	    state->default_ns = strdup( atts[attn+1] );	    DEBUG( DEBUG_XML, "New default namespace: %s\n", 		   state->default_ns );	} else if( strncasecmp( atts[attn], "xmlns:", 6 ) == 0 ) {	    /* New namespace scope */	    ns = malloc( sizeof( dav_xml_ns ) );	    ns->next = state->nspaces;	    state->nspaces = ns;	    ns->name = strdup( atts[attn]+6 ); /* skip the xmlns= */	    ns->value = strdup( atts[attn+1] );	    DEBUG( DEBUG_XML, "New namespace scope: %s -> %s\n",		   ns->name, ns->value );	}    }    /* Now check the tag name for a namespace scope */    pnt = strchr( tag, ':' );    tag_prefix = NULL;    tag_suffix = NULL;    if( pnt == NULL ) {	/* No scope - have we got a default? */	DEBUG( DEBUG_XML, "No scope found, searching for default.\n" );	for( xmlt = state; xmlt!=NULL; xmlt=xmlt->parent ) {	    if( xmlt->default_ns != NULL ) {		tag_prefix = xmlt->default_ns;		break;	    }	}	if( tag_prefix != NULL ) {	    DEBUG( DEBUG_XML, "Found default namespace [%s]\n", tag_prefix );	} else {	    DEBUG( DEBUG_XML, "No default namespace, using empty.\n" );	    tag_prefix = "";	}	tag_suffix = tag;    } else {	DEBUG( DEBUG_XML, "Got namespace scope. Trying to resolve..." );	/* Have a scope - resolve it */	for( xmlt = state; tag_prefix==NULL && xmlt!=NULL; xmlt=xmlt->parent ) {	    for( ns = xmlt->nspaces; ns!=NULL; ns=ns->next ) {		/* Just compare against the bit before the :		 * pnt points to the colon. */		if( strncasecmp( ns->name, tag, pnt-tag ) == 0 ) {		    /* Scope matched! Hoorah */		    tag_prefix = ns->value;		    /* end the search */		    break;		}	    }	}	if( tag_prefix != NULL ) {	    DEBUG( DEBUG_XML, "Resolved scope to [%s]\n", tag_prefix );	    /* The suffix is everything after the ':' */	    tag_suffix = pnt+1;	    if( *tag_suffix == '\0' ) {		DEBUG( DEBUG_XML, "No element name after ':'. Failed.\n" );		return false;	    }	} else {	    DEBUG( DEBUG_XML, "Smeg. We lost it somewhere.\n" );	    return false;	}    }    /* here, we have tag_suffix and tag_prefix */    DEBUG( DEBUG_XML, "prefix: [%s], suffix: [%s]\n", tag_prefix, tag_suffix );    pnt = state->tag_name = malloc( strlen(tag_prefix) + strlen(tag_suffix) +				    1 );    strcpy( pnt, tag_prefix );    strcat( pnt, tag_suffix );    DEBUG( DEBUG_XML, "You gave me: %s, and I gave you this: %s\n", tag, pnt );    return true;}/* This is the XML_StartElementHandler... called with the start of a * new element. */static void dav_xml_startelm( void *userdata, const char *tag, const char **atts ) {    struct dav_xmldoc *doc = (struct dav_xmldoc *)userdata;    struct dav_xml_state *s;    int n;    if( !doc->valid ) {	/* We've stopped parsing */	DEBUG( DEBUG_XML, "Parse died. Ignoring start of element: %s\n", tag );	return;    }    /* Set the new state */    s = malloc( sizeof(struct dav_xml_state) );    memset( s, 0, sizeof(struct dav_xml_state) );    s->parent = doc->current;    doc->current = s;    if( dav_xml_parsetag( s, tag, atts ) == false ) {	/* nooo, it bombed */	doc->valid = false;	return;    }    /* Map the name to a tag */    DEBUG( DEBUG_XML, "Mapping tag name... " );    s->tag = dav_xml_unknown;    for( n = 0; dav_xml_tagnames[n] != NULL; n++ ) {	if( strcasecmp( dav_xml_tagnames[n], s->tag_name ) == 0 ) {	    s->tag = n;	    break;	}    }    if( s->tag == dav_xml_unknown ) {	DEBUG( DEBUG_XML, "unknown tag, ignoring.\n" );	return;    }    DEBUG( DEBUG_XML, "mapped.\n" );    /* Normally, we don't want to collect cdata */    doc->want_cdata = false;    /* expat is not a validating parser - check the new tag     * is valid in the current context.     */    DEBUG( DEBUG_XML, "Checking context of tag (parent: %s)\n",	   dav_xml_tagnames[s->parent->tag] );    switch( s->parent->tag ) {    case dav_xml_root:	switch( s->tag ) {	case dav_xml_multistatus:	case dav_xml_response:	    break;	default:	    doc->valid = false;	    break;	}	break;    case dav_xml_multistatus:	switch( s->tag ) {	case dav_xml_response:	case dav_xml_responsedescription:	    break;	default:	    doc->valid = false;	    break;	}	break;    case dav_xml_response:	switch( s->tag ) {	case dav_xml_href:	case dav_xml_propstat:	case dav_xml_responsedescription:	case dav_xml_status:	    break;	default:	    doc->valid = false;	}	break;    default:	break;    }    if( doc->valid == false ) {