Net::Webdav - Perl interface to Neon HTTP and WebDAV client library
use Net::Webdav ;
$sess = Net::Webdav -> new ;
$sess -> server ("www.ecos.de", 80) ;
$sess -> get ("/", STDOUT) ;
$sess -> put ("/dav/foo.htm", STDIN) ;
# remove property 'test3'
# set value of property 'test' to 'bar'
@props = (
{ name => {nspace => 'DAV:', name => 'test3'}, type => 1},
{ name => {nspace => 'DAV:', name => 'test'}, value => 'bar'},
) ;
$sess -> dav_proppatch ("/dav/foo.htm", \@props) ;
sub iterator
{
my ($userdata, $propname, $propvalue, $propstatus) = @_ ;
print "propfind userdata = $userdata nspace = $propname->{nspace} name = $propname->{name} value = $propvalue\n" ;
return 0 ;
}
sub callback
{
my ($userdata, $href, $results) = @_ ;
print "propfind callback userdata = $userdata href = $href\n" ;
$results -> iterate (\&iterator) ;
}
$sess -> dav_simple_propfind ("/dav", DAV_DEPTH_ONE, undef, \&callback) ;
print "Status: ", $sess -> get_error , "\n" ;
This is the Perl interface to the neon HTTP and WebDAV client library. Most of the documentation is automaticly generated from the C header files of neon. So it looks a little bit C-ish, but is better than nothing. See also the examples in the eg directory. If you not sure how it works consult the neon include files.
This document describes the function that are availabe. Net::Webdav::Constants includes the constants defined by neon.
The neon API is encapsultated in a number of Perl classes. Everything that doesn't fit in a class has gone to Net::Webdav::Util. (Maybe some of these function will move to other classes in the future)
The clases are
WARNING: This wrapper is alpha code, while neon is around for some time and stable to use, not all of the interface functions provided by this Perl module has been tested extensivly, but most of them should work without problems (At least they do it for me :-).
See in the eg directory for some examples.
Neon uses a lot off callbacks. Basicly there is no difference between using callbacks in Perl and C. The only thing that is different, is that the functions that sets the callbacks doesn't take the userdata argument, which is used in C to pass a pointer to the callback. Instead, the callback get the reference to the object that sets the callback, pass as the userdata argument. This object is a hashreference and you are free to store data in that hash. The only restriction is, that key starting with two underscores ('__') are reserved for Net::Webdav internal use. Example:
sub datehdr
{
my ($userdata, $value) = @_ ;
$userdata -> {date} = $value ;
}
$sess = Net::Webdav -> new ;
$sess -> server ("www.ecos.de", 80) ;
$request = $sess -> request_create ("HEAD", "/") ;
# install callback which gets only Date header
$request -> add_response_header_handler ('Date', \&datehdr) ;
$request -> begin_request ;
$request -> end_request ;
print "Date: $request->{date}\n" ;
The C-structures that neon uses are always mapped 1:1 into a Perl hash. The members of the Perl hash are shown in the argument list of the function between { and } The function argument lists, also list the C datatype to which it map, so you can checkout the neon docs and include files for more informations.
Add in hooks. 'cookie' will be passed to each call to the 'create' handler of the hooks. If 'free_hooks' is non-NULL, it will called when the session is destroyed, to free any data associated with 'cookie'.
**** Session Handling *****
Basic WebDAV methods: dav_copy: copy resoure from src to dest dav_move: move resource from src to dest -> if overwrite is non-zero, the destination resource will be overwritten if it exists. dav_delete: delete resource at uri dav_mkcol: create a collection at uri (uri MUST have a trailing slash).
**** Session Handling *****
**** Session Handling *****
Issue a LOCK request for the given lock.
**** Session Handling *****
Perform lock discovery on the given URI. 'result' is called with the results (possibly >1 times).
**** Session Handling *****
Callback for lock discovery. If 'lock' is NULL, something went wrong retrieving lockdiscover for the resource, look at 'status' for the details.
Register the locking hooks with an http_session. Owned locks persist for
the duration of this session. The lock session lasts exactly as long as the
corresponding http_session. Once you call
http_session_destroy(sess), any use of the lock session has
undefined results.
**** Session Handling *****
**** Session Handling *****
**** Session Handling *****
**** Session Handling *****
Retrieve property names for the resources at 'href'. 'results' callback is called for each resource. Use 'dav_propset_iterate' on the passed results object to retrieve the list of property names.
**** Session Handling *****
Callback for handling the results of fetching properties for a single resource (named by 'href'). The results are stored in the result set 'results': use dav_propset_* to examine this object.
**** Session Handling *****
items = { name => const dav_propname *, type => enum, value => <string>, };
Fetch properties for a resource (if depth == DAV_DEPTH_ZERO), or a tree of resources (if depth == DAV_DEPTH_ONE or _INFINITE).
Names of the properties required must be given in 'props', or if props is NULL, *all* properties are fetched.
'results' is called for each resource in the response, userdata is passed
as the first argument to the callback. It is important to note that the
callback is called as the response is read off the socket, so don't do
anything silly in it (e.g. sleep(100), or call any functions
which use this session).
Note that if 'depth' is DAV_DEPTH_INFINITY, some servers may refuse the request.
Returns HTTP_*.
**** Session Handling *****
props = { nspace => <string>, name => <string>, };
Callback for handling the results of fetching properties for a single resource (named by 'href'). The results are stored in the result set 'results': use dav_propset_* to examine this object.
Handle a simple WebDAV request.
Usage: 1. Create the request using http_request_create() 2.
Set any headers, the request body, whatever. 3. Call dav_simple_request to
dispatch and destroy the request.
(note the request IS destroyed by this function, don't do it yourself).
Returns HTTP_* as http_request_dispatch() would. If the
response is a 207, a user-friendly error message is written to the session
error buffer; e.g. DELETE /foo/ might give the error: /foo/bar: HTTP/1.1
423 Locked
**** Session Handling *****
Issue an UNLOCK request for the given lock
**** Session Handling *****
Register the callback for determining whether the proxy server should be used or not here. 'userdata' will be passed as the first argument to the callback. The callback is only called if a proxy server has been set up using http_session_proxy.
This function MUST be called before calling http_session_server.
**** Session Handling *****
Callback to determine whether the proxy server should be used or not for a request to the given hostname using the given scheme. Scheme will be ``http'' or ``https'' etc. Must return: Zero to indicate the proxy should NOT be used Non-zero to indicate the proxy SHOULD be used.
Finish an HTTP session
**** Session Handling *****
Clear any stored authentication details for the given session.
**** Session Handling *****
GET resource at uri, writing response body into f
**** Session Handling *****
**** Session Handling *****
**** Session Handling *****
range = { start => <integer>, end => <integer>, total
=> <integer>, };
Returns the URL scheme being used for the current session. Does NOT include a trailing ':'. Example returns: ``http'' or ``https''.
**** Session Handling *****
Returns the 'hostport' URI segment for the end-server, e.g. ``my.server.com:8080'' or ``www.server.com'' (port segment is ommitted if == 80)
**** Session Handling *****
Retrieve modification time of resource at uri, place in *modtime. (uses HEAD)
**** Session Handling *****
Return private data for the session
**** Session Handling *****
Determines server capabilities (using OPTIONS). Pass uri=``*'' to determine proxy server capabilities if using a proxy server.
**** Session Handling *****
caps = { => , dav_class1 => unsigned int, dav_class2 => unsigned int, dav_executable => unsigned int, };
Post using buffer as request-body: stream response into f
**** Session Handling *****
**** Session Handling *****
PUT resource at uri, reading request body from f
**** Session Handling *****
PUT resource at uri as above, only if it has not been modified since given modtime. If server is HTTP/1.1, uses If-Unmodified-Since header; guaranteed failure if resource is modified after 'modtime'. If server is HTTP/1.0, HEAD's the resource first to fetch current modtime; race condition if resource is modified between HEAD and PUT.
**** Session Handling *****
GET resource at uri, passing response body blocks to 'reader'
**** Session Handling *****
The 'reader' callback type
Return location of last redirect.
**** Session Handling *****
Register redirect handling for the given session. Some redirect responses will be automatically followed. If the redirect is automatically followed, the 'notify' callback is called. For redirects which are NOT automatically followed, the 'confirm' callback is called: if this returns zero, the redirect is ignored.
'confirm' may be passed as NULL: in this case, only automatic redirects are followed. 'notify' may also be passed as NULL, automatic redirects are still followed.
'userdata' is passed as the first argument to the confirm and notify callbacks.
**** Session Handling *****
Get confirmation from the user that a redirect from URI 'src' to URI 'dest' is acceptable. Should return: Non-Zero to FOLLOW the redirect Zero to NOT follow the redirect
Notify the user that a redirect has been automatically followed from URI 'src' to URI 'dest'
**** Session Handling *****
Set the server or proxy server to be used for the session. Returns: HTTP_LOOKUP if the DNS lookup for hostname failed. HTTP_OK otherwise.
Note that if a proxy is being used, http_session_proxy should be called BEFORE http_session_server, so the DNS lookup can be skipped on the server.
**** Session Handling *****
**** Session Handling *****
Set the error string for the session
**** Session Handling *****
Set protocol options for session: expect100: Defaults to OFF persist: Defaults to ON
expect100: When set, send the ``Expect: 100-continue'' request header with requests with bodies.
persist: When set, use a persistent connection. (Generally, you don't want to turn this off.)
**** Session Handling *****
**** Session Handling *****
Set a progress callback for the session.
**** Session Handling *****
**** Session Handling *****
The callback used to request the username and password in the given realm.
The username and password must be placed in malloc()-allocated
memory. Must return: 0 on success: *username
and *password must be non-NULL, and will be
free'd by the HTTP layer when necessary -1 to cancel (*username and *password are ignored.)
**** Session Handling *****
**** Session Handling *****
Using SSL/TLS connections:
Session settings: secure: Defaults to OFF secure_context: No callbacks, any protocol allowed. request_secure_upgrade: Defaults to OFF accept_secure_ugprade: Defaults to OFF
secure_context: When set, specifies the settings to use for secure connections, and any callbacks (see nsocket.h). The lifetime of the context object must be >= to the lifetime of the session object.
secure: When set, use a secure (SSL/TLS) connection to the origin server. This will tunnel (using CONNECT) through the proxy server if one is being used.
request_secure_upgrade: When set, notify the server with each request made that an upgrade to a secure connection is desired, if available.
accept_secure_upgrade: When set, allow a server-requested upgrade to a secure connection.
NB: the latter three function calls will return -1 if SSL is not supported by the library (i.e., it was not built against OpenSSL), or 0 if it is.
**** Session Handling *****
Set callbacks to handle server and proxy authentication. userdata is passed as the first argument to the callback.
**** Session Handling *****
The callback used to request the username and password in the given realm.
The username and password must be placed in malloc()-allocated
memory. Must return: 0 on success: *username
and *password must be non-NULL, and will be
free'd by the HTTP layer when necessary -1 to cancel (*username and *password are ignored.)
Set a status notification callback for the session, to report connection status.
**** Session Handling *****
Sets the user-agent string. neon/VERSION will be appended, to make the full header ``User-Agent: product neon/VERSION''. If this function is not called, the User-Agent header is not sent. The product string must follow the RFC2616 format, i.e. product = token [``/'' product-version] product-version = token where token is any alpha-numeric-y string [a-zA-Z0-9]*
**** Session Handling *****
Determine if next-hop server claims HTTP/1.1 compliance. Returns: 0 if next-hop server does NOT claim HTTP/1.1 compliance non-zero if next-hop server DOES claim HTTP/1.1 compliance Not that the ``next-hop'' server is the proxy server if one is being used, otherwise, the origin server.
**** Session Handling *****
Create a 207 parser
Return current parse line for errors
Destroys the parser. Any operations on it then have undefined results.
Parse the given block of input of length len. Block does not need to be NULL-terminated.
Push a handler onto the handler stack for the given list of elements. elements must be an array, with the last element .nspace being NULL. Callbacks are called in order: 1. validate_cb 2. startelm_cb 3. endelm_cb (then back to the beginning again). If any of the callbacks ever return non-zero, the parse will STOP. userdata is passed as the first argument to startelm_cb and endelm_cb.
Validate a new child element.
Called when a complete element is parsed
Add a handler which uses a mixed-mode cdata callback
Validate a new child element.
Called when a complete element is parsed
Set error message for parser
Returns non-zero if the parse was valid, zero if it failed (e.g., any of the callbacks return non-zero, the XML was not well-formed, etc). Use hip_xml_get_error to retrieve the error message if it failed.
Deep-copy a lock structure.
Free a lock structure
Add a lock to the given session. The lock will subsequently be submitted as required in an If: header with any requests created using the http_session which the lock session is tied to. Requests indicate to the locking layer which locks they might need using dav_lock_using_*, as described below.
Find a lock in the session with given URI
For each lock added to the session, call func, passing the lock and the given userdata. Returns the number of locks. func may be pass as NULL, in which case, can be used to simply return number of locks in the session.
Remove lock, which must have been previously added to the session using 'dav_lock_add' above.
Call this as the LAST thing before beginning parsing, to install a catch-all handler which means all unknown XML returned in the 207 response is ignored gracefully.
Set the callbacks for the parser
TODO: do we need to pass userdata to ALL of these? We could get away with
only passing the userdata to the start_'s and relying on the caller to send
it through as the _start return value if they need it.
Find all properties.
Returns HTTP_*.
Callback for handling the results of fetching properties for a single resource (named by 'href'). The results are stored in the result set 'results': use dav_propset_* to examine this object.
Retrieve the 'private' pointer for the current propset for the given handler, as returned by the dav_props_create_complex callback installed using 'dav_propfind_set_private'. If this callback was not registered, this function will return NULL.
Destroy a propfind handler after use.
Return the XML parser for the given handler (only need if you want to handle complex properties).
Return the request object for the given handler. You MUST NOT use http_set_request_body_* on this request object. (this call is only needed if for instance, you want to add extra headers to the PROPFIND request).
Find properties named in a call to dav_propfind_set_flat and/or dav_propfind_set_complex.
Returns HTTP_*.
prop = { nspace => <string>, name => <string>, };
Callback for handling the results of fetching properties for a single resource (named by 'href'). The results are stored in the result set 'results': use dav_propset_* to examine this object.
A ``complex property'' has a value which is structured XML. To handle complex properties, you must set up and register an XML handler which will understand the elements which make up such properties. The handler must be registered with the parser returned by 'dav_propfind_get_parser'.
To store the parsed value of the property, a 'private' structure is allocated in each propset (i.e. one per resource). When parsing the property value elements, for each new resource encountered in the response, the 'creator' callback is called to retrieve a 'private' structure for this resource.
Whilst in XML element callbacks you will have registered to handle complex properties, you can use the 'dav_propfind_current_private' call to retrieve the pointer to this private structure.
To retrieve this 'private' structure from the propset in the results
callback, simply call 'dav_propset_private'.
Iterate over all the properties in 'set', calling 'iterator' for each, passing 'userdata' as the first argument to callback.
Returns: whatever value iterator returns.
The 'dav_simple_propfind' interface. ***
dav_simple_propfind allows you to fetch a set of properties for a single resource, or a tree of resources. You set the operation going by passing these arguments:
- the session which should be used. - the URI and the depth of the operation (0, 1, infinite) - the names of the properties which you want to fetch - a results callback, and the userdata for the callback.
For each resource found, the results callback is called, passing you two things along with the userdata you passed in originally:
- the URI of the resource (const char *href) - the properties results set
(const dav_prop_result_set *results)
dav_propset_iterate iterates over a properties result set, calling the callback for each property in the set. userdata is passed as the first argument to the callback. value may be NULL, indicating an error occurred fetching this property: look at status for the error in that case.
If the iterator returns non-zero, dav_propset_iterate will return immediately with that value.
Return language string of property (may be NULL).
The 'dav_simple_propfind' interface. ***
dav_simple_propfind allows you to fetch a set of properties for a single resource, or a tree of resources. You set the operation going by passing these arguments:
- the session which should be used. - the URI and the depth of the operation (0, 1, infinite) - the names of the properties which you want to fetch - a results callback, and the userdata for the callback.
For each resource found, the results callback is called, passing you two things along with the userdata you passed in originally:
- the URI of the resource (const char *href) - the properties results set
(const dav_prop_result_set *results)
pname = { nspace => <string>, name => <string>, };
Returns the private pointer for the given propset.
The 'dav_simple_propfind' interface. ***
dav_simple_propfind allows you to fetch a set of properties for a single resource, or a tree of resources. You set the operation going by passing these arguments:
- the session which should be used. - the URI and the depth of the operation (0, 1, infinite) - the names of the properties which you want to fetch - a results callback, and the userdata for the callback.
For each resource found, the results callback is called, passing you two things along with the userdata you passed in originally:
- the URI of the resource (const char *href) - the properties results set (const dav_prop_result_set *results)
Returns the status structure for fetching the given property on this resource. This function will return NULL if the server did not return the property (which is a server error).
The 'dav_simple_propfind' interface. ***
dav_simple_propfind allows you to fetch a set of properties for a single resource, or a tree of resources. You set the operation going by passing these arguments:
- the session which should be used. - the URI and the depth of the operation (0, 1, infinite) - the names of the properties which you want to fetch - a results callback, and the userdata for the callback.
For each resource found, the results callback is called, passing you two things along with the userdata you passed in originally:
- the URI of the resource (const char *href) - the properties results set
(const dav_prop_result_set *results)
propname = { nspace => <string>, name => <string>, };
Get the value of a given property. Will return NULL if there was an error fetching this property on this resource. Call dav_propset_result to get the response-status if so.
The 'dav_simple_propfind' interface. ***
dav_simple_propfind allows you to fetch a set of properties for a single resource, or a tree of resources. You set the operation going by passing these arguments:
- the session which should be used. - the URI and the depth of the operation (0, 1, infinite) - the names of the properties which you want to fetch - a results callback, and the userdata for the callback.
For each resource found, the results callback is called, passing you two things along with the userdata you passed in originally:
- the URI of the resource (const char *href) - the properties results set
(const dav_prop_result_set *results)
propname = { nspace => <string>, name => <string>, };
Adds a header to the request with given name and value.
Add a response reader for the given request, with the given acceptance function. userdata is passed as the first argument to the acceptance + reader callbacks.
'acceptance' callback type. Return non-zero to accept the response, else zero to ignore it.
The 'reader' callback type
Add handler which is passed ALL header values regardless of name
The header handler callback type
Adds a response header handler for the given request. userdata is passed as the first argument to the header handler, and the 'value' is the header field value (i.e. doesn't include the ``Header-Name: '' part``).
The header handler callback type
Adds a Depth: header to a request
Indicate that this request will modify parent collection of given URI
Indicate that this request is of depth n on given uri
Destroy memory associated with request pointer
http_request_dispatch: Sends the given request, and reads the response.
Response-Status information can be retrieve with
http_get_status(req).
Returns: HTTP_OK if request sent + response read okay. HTTP_AUTH if user
authentication failed on origin server HTTP_AUTHPROXY if user
authentication failed on proxy server HTTP_SERVERAUTH server authentication
failed HTTP_PROXYAUTH proxy authentication failed HTTP_CONNECT could not
connect to server/proxy server HTTP_TIMEOUT connection timed out
mid-request HTTP_ERROR for other errors, and http_get_error()
should return a meaningful error string
NB: HTTP_AUTH and HTTP_AUTHPROXY mean that the USER supplied the wrong username/password. SERVER/PROXYAUTH mean that, after the server has accepted a valid username/password, the server/proxy did not authenticate the response message correctly.
Return private data for a new request
'buffer' will be sent as the request body with given request.
Callback is called to provide blocks of request body.
Callback for providing request body blocks.
Before each time the body is provided, the callback will be called once with buflen == 0. The body may have to be provided >1 time per request (for authentication retries etc.).
Must return: 0 < x <= buflen => buffer contains x bytes of body data. or 0 => ignore 'buffer' contents, end of body.
Contents of stream will be sent as the request body with the given request. Returns: 0 on okay. non-zero if could not determine length of file.
Returns: 0 -> User accepts the certificate non-zero -> user does NOT accept the certificate.
For PEM-encoded client certificates: use the given client certificate and private key file. Returns: 0 if certificate is read okay, non-zero otherwise.
For decoding the private key file, the callback above will be used to prompt for the password. If no callback has been set, then the OpenSSL default will be used: the prompt appears on the terminal.
Callback for retrieving the private key password. Filename will be the filename of the private key file. Must return: 0 on success. buf must be filled in with the password. non-zero if the user cancelled the prompt.
FIXME: this is inconsistent with the HTTP authentication callbacks.
Blocks waiting for data on the given socket for the given time. Returns: SOCK_* on error, SOCK_TIMEOUT on no data within timeout, 0 if data arrived on the socket.
Closes the socket and frees the nsocket object.
Reads a chunk of data.
Sends the given block of data down the nsocket
Returns the file descriptor used for the socket
Ctx is OPTIONAL. If it is NULL, defaults are used.
sock_peek is recv() with a timeout of SOCKET_TIMEOUT. Returns:
SOCK_* on error, 0 on no data to read (due to EOF), >0 length of data
read into buffer.
sock_read is read() with a timeout of SOCKET_TIMEOUT. Returns:
SOCK_* on error, 0 on no data to read (due to EOF), >0 length of data
read into buffer.
Read from socket, passing each block read to reader callback. Pass userdata as first argument to reader callback.
If length is -1, keep going till EOF is returned. SOCK_CLOSED is never returned in this case.
Otherwise, read exactly 'length' bytes. If EOF is encountered before length bytes have been read, and SOCK_CLOSED will be returned.
Returns: 0 on success, SOCK_* on error (SOCK_CLOSED is a special case, as above)
Reads a line from given nsocket
Sends the null-terminated string down the given nsocket
Sends the given line to given socket, CRLF appended
An acceptance function which only accepts 207 responses
status = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };
Initialise the parser
An 'acceptance' callback which only accepts 2xx-class responses. Ignores userdata.
st = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };
An acceptance callback which accepts all responses. Ignores userdata.
st = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };
Sets (*http_content_type)userdata appropriately. Caller must free ->value after use
Stock header handlers: 'duplicate': *(char **)userdata =
strdup(value) 'numeric': *(int *)userdata =
atoi(value) e.g. int mynum;
http_add_response_header_handler(myreq, ``Content-Length'',
http_handle_numeric_handler, &mynum); ... arranges mynum to be set to
the value of the Content-Length header.
Parser for strings which follow the Status-Line grammar from RFC2616. Returns: 0 on success, *s will be filled in. -1 on parse error.
s = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };
Create a new HTTP session
Return current date/time in RFC1123 format
Returns time from date/time in RFC1123 format
Returns an ne_malloc-allocated UTF-8 decode copy of 'str'. Returns NULL if any of the characters in 'str' are non-8-bit.
Returns an ne_malloc-allocated UTF-8 encoded copy of 'str'.
Initialize i18n in neon
neon_version_check(1, 3) => -1 I am: 0.10 -
neon_version_check(0, 9) => 0
Returns a user-visible version string like: ``neon 0.2.0: Standalone build, OpenSSL support''
Append 'len' bytes of 'data' to buf. 'data' does not need to be zero-terminated. The resultant string will have a zero-terminator, either way. Returns 0 on success, non-zero on error.
Empties the contents of buf; makes the buffer zero-length.
Create a new sbuffer. Returns NULL on error
Returns contents of buffer at current point in time. NOTE: if the buffer is modified with _concat, _append etc, this value may no longer be correct.
Destroys (deallocates) a buffer
Destroys a buffer, WITHOUT freeing the data, and returns the data.
Grows the sbuffer to a minimum size. Returns 0 on success, non-zero on error
Returns size of data in buffer, equiv to
strlen(sbuffer_data(buf))
Append a zero-terminated string 'str' to buf. Returns 0 on success, non-zero on error.
Not as good as accept(2), missing parms 2+3. Addings parms 2+3
would probably mean passing socklen_t as an int then casting internally,
since we don't really want to autogenerate the header file to be correct
for the build platform.
Netscape's prompts on getting a certificate which it doesn't recognize the CA for: 1. Hey, I don't recognize the CA for this cert. 2. Here is the certificate: for foo signed by BLAH, using encryption level BLEE 3. Allow: accept for this session only, don't accept accept forever
Returns the standard TCP port for the given service
Reads readlen bytes from fd and writes to socket. (Not all in one go, obviously). If readlen == -1, then it reads from srcfd until EOF. Returns number of bytes written to destfd, or SOCK_* on error.
Returns an absolute URI from a possibly-relative 'uri', using given scheme + hostport segment. Returns malloc-allocated string on success, or NULL on malloc failure.
Returns abspath segment in (absolute) uri
Escapes the abspath segment of a URI. Returns malloc-allocated string on success, or NULL on malloc failure.
Returns non-zero if child is a child of parent
Returns strcmp-like value giving comparison between a and b, ignoring trailing-slashes.
Returns non-zero if uri has a trailing slash character
Returns parent of path
Parse 'uri' and place parsed segments in *parsed.
Un-escapes a URI. Returns malloc-allocated URI on success, or NULL on failure (malloc failure or invalid %<HEX><HEX> sequence).
Constants are defined in Net::Webdav::Constants, to get them imported say
use Net::Webdav::Constants ;
User authentication failed on proxy
User authentication failed on proxy
Could not connect to server
Generic error; use http_get_error(session) for message
The precondition failed
Name lookup failed
Proxy authentication failed
See http_redirect.h
Retry request (http_end_request ONLY)
Server authentication failed
Connection timed out
For any problems, suggestion or feedback, please use the neon mailing list
post to: neon@webdav.org subscribe: http://mailman.webdav.org/mailman/listinfo/neon/
Copyright (c) 2001 Gerald Richter / ecos gmbh (www.ecos.de)
You may distribute under the terms of either the GNU General Public License or the Artistic License, as specified in the Perl README file.
THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
Gerald Richter / ecos <richter@dev.ecos.de>