htdav.c

www工具包. 这是W3C官方支持的www支撑库. 其中提供通用目的的客户端的WebAPI: complete HTTP/1.1 (with caching, pipelining, PUT, POS

            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;
        }
    }
}



/* --------------------------------------------------------------------------*/
/*                            LOCK REQUESTS                                  */
/* --------------------------------------------------------------------------*/


/*
** LOCK REQUESTS
** 
** LOCK requests may create a lock specified by "lockinfo" XML element
** on the Request URI. LOCK request should have a XML request entity body,
** which contains "owner" XML element, or the request should be a lock
** refresh request.
** Headers:
**      If header is mandatory for lock refresh request
**      Depth header may be "0" or "infinity" (default: infinity)
**      Timeout header may be used
*/

PUBLIC BOOL HTLOCKDocumentAnchor (HTRequest * request, 
                                  HTAnchor * dst,
                                  HTParentAnchor * xmlbody,
                                  HTDAVHeaders * headers) {
    
    if (request && dst) {
        /* set method and request-URI */
        HTRequest_setMethod (request,METHOD_LOCK);
        HTRequest_setAnchor (request,dst);
        HTTRACE (PROT_TRACE,"HTDAV.... Method set to LOCK\n");

        /* set headers */
        HTTRACE (PROT_TRACE,"HTDAV.... Seting default Headers \n");
        HTRequest_addCacheControl (request,"no-cache","");
        HTRequest_addEnHd (request,HT_E_CONTENT_ENCODING);
        HTRequest_addEnHd (request,HT_E_CONTENT_LENGTH);
        HTRequest_addGnHd (request,HT_G_PRAGMA_NO_CACHE);
 
        if (headers) { /* WebDAV specific headers */
            HTTRACE (PROT_TRACE,"HTDAV.... Setting WebDAV headers \n");
            if (headers->If)
                HTRequest_addExtraHeader (request,"If",headers->If);

            if (headers->Depth) { /* Depth: 0 or infinity only */
                if (!strcasecomp(headers->Depth,"0") || 
                            !strcasecomp(headers->Depth,"infinity"))
                    HTRequest_addExtraHeader (request,"Depth",headers->Depth);
            }

            if (headers->Timeout)
                HTRequest_addExtraHeader (request,"Timeout",headers->Timeout);
        }

        /* set body - if there is no body, we expect that is a lock refresh */
        if (xmlbody) {
            HTTRACE (PROT_TRACE,"HTDAV.... Setting Entity Body \n");
            HTRequest_setEntityAnchor (request,xmlbody); 
            HTRequest_setPostCallback(request, HTEntity_callback);
        }

        return HTLoad (request,NO);
    }
    return NO;
}


/*
** LOCK the URI indicated by HTAnchor *dst using the informations
** in xmlbody string. 
*/ 
PUBLIC BOOL HTLOCKAnchor (HTRequest * request,
                          HTAnchor * dst,
                          char * xmlbody,
                          HTDAVHeaders * headers) {

    if (request && dst) {
        HTParentAnchor * src = NULL;
        if (xmlbody) {
            src = HTTmpAnchor(NULL);
            HTAnchor_setDocument(src, xmlbody);
            HTAnchor_setFormat(src, HTAtom_for ("text/xml"));
            HTAnchor_setLength(src, strlen(xmlbody));
        }
        return (HTLOCKDocumentAnchor (request,dst,src,headers));
    }
    return NO;
}


/*
** LOCK the resource indicated by an absolute URI, using the informations
** in xmlbody string.
*/ 
PUBLIC BOOL HTLOCKAbsolute (HTRequest * request,
                            const char * uri,
                            char * xmlbody,
                            HTDAVHeaders * headers){
    if (request && uri && *uri) {
        HTAnchor *dst = HTAnchor_findAddress (uri);
        HTParentAnchor *src = NULL;

        if (xmlbody) {
            src = HTTmpAnchor(NULL);
            HTAnchor_setDocument(src, xmlbody);
            HTAnchor_setFormat(src, HTAtom_for ("text/xml"));
            HTAnchor_setLength(src, strlen(xmlbody));
        }
 
        return (HTLOCKDocumentAnchor (request,dst,src,headers));
    }
    return NO;
}


/*
** LOCK the resource indicated by a relative URI, which is made
** absolute by using the base anchor.
*/
PUBLIC BOOL HTLOCKRelative (HTRequest * request,
                            const char * relative,
                            HTParentAnchor * base,
                            char * xmlbody,
                            HTDAVHeaders * headers){
    BOOL status = NO;
    if (request && relative && base) {
         char * base_uri = HTAnchor_address ((HTAnchor *)base);
         char * full_uri = HTParse(relative,base_uri,PARSE_ACCESS|PARSE_HOST| \
                                                 PARSE_PATH|PARSE_PUNCTUATION);

         status = HTLOCKAbsolute (request,full_uri,xmlbody,headers);
         HT_FREE (full_uri);
         HT_FREE (base_uri);
    }
    return status;
}


/* --------------------------------------------------------------------------*/
/*                            UNLOCK REQUESTS                                */
/* --------------------------------------------------------------------------*/

/*
** UNLOCK REQUEST
**
** UNLOCK request removes the lock identified by Lock-Token header from
** the Request-URI.
** Headers:
**      Lock-Token header must be present
*/
PUBLIC BOOL HTUNLOCKAnchor (HTRequest * request,
                            HTAnchor * dst,
                            HTDAVHeaders * headers) {
    if (request && dst) {
        /* set method and request-uri */
        HTRequest_setMethod (request,METHOD_UNLOCK);
        HTRequest_setAnchor (request,dst);
        HTTRACE (PROT_TRACE,"HTDAV.... Method set to UNLOCK\n");

        /* set headers */
        HTTRACE (PROT_TRACE,"HTDAV.... Setting default Headers \n");
        HTRequest_addCacheControl (request, "no-cache","");
        HTRequest_addEnHd (request,HT_E_CONTENT_ENCODING);
        HTRequest_addEnHd (request,HT_E_CONTENT_LENGTH);
        HTRequest_addGnHd (request,HT_G_PRAGMA_NO_CACHE);
 
        if (headers && headers->LockToken) {
            HTTRACE (PROT_TRACE,"HTDAV.... Seting Lock-Token \n");
            if (headers->LockToken == NULL) {
                HTTRACE (PROT_TRACE,"HTDAV.... FAILED Lock-Token is NULL\n");
                return NO;
            }
            HTRequest_addExtraHeader (request,"Lock-Token",headers->LockToken);

            return HTLoad (request,NO);
        }
    }
    return NO;
}


/*
** UNLOCK the resource indicated by an absolute URI, using the lock tocken
** defined in HTDAVHeaders * headers parameter.
*/
PUBLIC BOOL HTUNLOCKAbsolute (HTRequest * request,
                              const char * uri,
                              HTDAVHeaders * headers) {
 
    if (request && uri && *uri) {
        HTAnchor *dst = HTAnchor_findAddress (uri);
        return HTUNLOCKAnchor (request,dst,headers);
    }
    return NO;
}


/*
** UNLOCK the resource indicated by a relative URI, which is made
** absolute by using the base anchor.
*/
PUBLIC BOOL HTUNLOCKRelative (HTRequest * request,
                              const char * relative,
                              HTParentAnchor * base,
                              HTDAVHeaders * headers) {
    BOOL status = NO;
    if (request && relative && base) {
         char * base_uri = HTAnchor_address ((HTAnchor *)base);
         char * full_uri = HTParse (relative,base_uri,PARSE_ACCESS|PARSE_HOST| \
                                                 PARSE_PATH|PARSE_PUNCTUATION);

         status = HTUNLOCKAbsolute (request,full_uri,headers);
         HT_FREE (full_uri);
         HT_FREE (base_uri);
    }
    return status;
}


/* --------------------------------------------------------------------------*/
/*                            PROPFIND REQUESTS                              */
/* --------------------------------------------------------------------------*/


/*
** PROPFIND Requests
** PROPFIND requests returns properties defined for the resource.
** The request may contain xml message body with a "propfind" element,
** which may include an "allprop" element (to get all properties), a
** "propname" element (the name of all properties defined), and a "prop"
** element containing the desired properties.
** Headers:
**      Depth header may be "0", "1" or "infinity".
*/
PUBLIC BOOL HTPROPFINDDocumentAnchor (HTRequest * request,
                                      HTAnchor * dst,
                                      HTParentAnchor * xmlbody,
                                      HTDAVHeaders * headers) {
 
    if (request && dst) {
        /* set method and request-URI */
        HTRequest_setMethod (request,METHOD_PROPFIND);
        HTRequest_setAnchor (request,dst);
        HTTRACE (PROT_TRACE,"HTDAV.... Method set to PROPFIND\n");
 
        /* set headers */
        HTTRACE (PROT_TRACE,"HTDAV.... Seting default Headers \n");
        HTRequest_addCacheControl (request,"no-cache","");
        HTRequest_addGnHd (request,HT_G_PRAGMA_NO_CACHE);
 
        if (headers) { /* WebDAV specific headers */
            HTTRACE (PROT_TRACE,"HTDAV.... Setting WebDAV headers \n");
            if (headers->Depth) /* only Depth header may be used */
                if (!strcasecomp(headers->Depth,"0") || /* values 0, 1 */
                    !strcasecomp(headers->Depth,"1") || /* or infinity */
                    !strcasecomp(headers->Depth,"infinity"))
                        HTRequest_addExtraHeader(request,"Depth",headers->Depth);
        }

        /* set body - if there is a body */
        if (xmlbody) {
            HTTRACE (PROT_TRACE,"HTDAV.... Setting WebDAV Entity Request Body \n");
            HTRequest_setEntityAnchor (request,xmlbody); 
            HTRequest_setPostCallback (request, HTEntity_callback);
        }

        return HTLoad (request,NO);
    }

    return NO;
}



PUBLIC BOOL HTPROPFINDAnchor (HTRequest * request,
                              HTAnchor * dst,
                              const char * xmlbody,
                              HTDAVHeaders * headers) {
    if (request && dst) {
        HTParentAnchor * body = NULL;
        if (xmlbody) {    
            body = HTTmpAnchor(NULL);
            HTAnchor_setDocument(body, (void *)xmlbody);
            HTAnchor_setFormat(body, HTAtom_for ("text/xml"));
            HTAnchor_setLength(body, strlen(xmlbody));        
        }
        return HTPROPFINDDocumentAnchor (request,dst,body,headers);
    }

    return NO;
}


/*
** This PROPFIND request returns the properties of the resource 
** indicated by the absolute URI (parameter uri). 
*/
PUBLIC BOOL HTPROPFINDAbsolute (HTRequest * request,
                                const char * uri,
                                const char * xmlbody,
                                HTDAVHeaders * headers) {
    if (request && uri && *uri) {
        HTAnchor *dst = HTAnchor_findAddress (uri);
        return HTPROPFINDAnchor (request,dst,xmlbody,headers);
    }
    return NO;
}


/*
** This PROPFIND request returns the properties of the resource 
** indicated by a relative URI, which is made absolute by using 
** the base anchor.
*/
PUBLIC BOOL HTPROPFINDRelative (HTRequest * request, 
                                const char * relative,
                                HTParentAnchor * base,
                                const char * xmlbody,
                                HTDAVHeaders * headers) {
    BOOL status = NO;
    if (request && relative && base) {
         char * base_uri = HTAnchor_address ((HTAnchor *)base);
         char * full_uri = HTParse(relative,base_uri,PARSE_ACCESS|PARSE_HOST| \
                                                 PARSE_PATH|PARSE_PUNCTUATION);

         status = HTPROPFINDAbsolute (request,full_uri,xmlbody,headers);
         HT_FREE (full_uri);
         HT_FREE (base_uri);
    }
    return status;
}



/* --------------------------------------------------------------------------*/
/*                            PROPPATCH REQUESTS                             */
/* --------------------------------------------------------------------------*/


/*
** PROPPATCH Requests
** PROPPATCH requests sets/removes the properties values for the resource.
** The request must contain a xml message body with a "propertyupdate" element,
** which may include an "set" element (to set the properties value) or
** a "remove" element (to remove the properties).
** Headers: (the RFC is not very clair about it)
**      If header, indicating a state token for the resource.
*/
PUBLIC BOOL HTPROPPATCHDocumentAnchor (HTRequest * request,
                                      HTAnchor * dst,
                                      HTParentAnchor * xmlbody,
                                      HTDAVHeaders * headers) {
        
    if (request && dst && xmlbody) {

        /* set method and request-URI */
        HTRequest_setMethod (request,METHOD_PROPPATCH);
        HTRequest_setAnchor (request,dst);
        HTTRACE (PROT_TRACE,"HTDAV.... Method set to PROPPATCH\n");

        /* set headers */
        HTTRACE (PROT_TRACE,"HTDAV.... Seting default Headers \n");
        HTRequest_addCacheControl (request,"no-cache","");
        HTRequest_addGnHd (request,HT_G_PRAGMA_NO_CACHE);

        if (headers) { /* WebDAV specific headers*/
            HTTRACE (PROT_TRACE,"HTDAV.... Setting WebDAV headers \n");
            if (headers->If) 
                HTRequest_addExtraHeader (request,"If",headers->If);
        }

        /* set body - mandatory! */
        HTTRACE (PROT_TRACE,"HTDAV.... Setting Entity Body \n");
        HTRequest_setEntityAnchor (request,xmlbody); 
        HTRequest_setPostCallback (request, HTEntity_callback);

        return HTLoad (request,NO);
    }
    return NO;