Gerald Richter > HTTP-Webdav-0.1.18-0.17.1 > HTTP::Webdav

Download:
HTTP-Webdav-0.1.18-0.17.1.tar.gz

Dependencies

Annotate this POD

View/Report Bugs
Module Version: 0.1.18-0.17.1   Source  

NAME ^

HTTP::Webdav - Perl interface to Neon HTTP and WebDAV client library

SYNOPSIS ^

  use HTTP::Webdav ;

  $sess = HTTP::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 -> 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 -> simple_propfind ("/dav", NE_DEPTH_ONE, undef, \&callback) ;

  print "Status: ", $sess -> get_error , "\n" ;

DESCRIPTION ^

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. HTTP::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 HTTP::Webdav::Util. (Maybe some of these function will move to other classes in the future)

The clases are

HTTP::Webdav

Main class which holds a http session

HTTP::Webdav::MultiStatus

Class to handle 207 responses

HTTP::Webdav::Hip

Interface to XML parser for properties

HTTP::Webdav::Lock

Holds a lock

HTTP::Webdav::LockSession

Holds a lock session

HTTP::Webdav::Propfind

Class to access the result of a PROPFIND

HTTP::Webdav::Propset

Class to acess properties of one resource

HTTP::Webdav::Request

Low level interface to http request

HTTP::Webdav::MD5

MD5 checksum

HTTP::Webdav::SSL

SSL support

HTTP::Webdav::Socket

Low level socket access

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.

CALLBACKS ^

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 HTTP::Webdav internal use. Example:

  sub datehdr

    {
    my ($userdata, $value) = @_ ;
    $userdata -> {date} = $value ;
    } 

  $sess = HTTP::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" ;

C-DATASTRUCTURS ^

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.

Functions ^

Methods of HTTP::Webdav ^

int = $session -> DESTROY ()

Arguments
$session

ne_session *

int = $session -> acl_set (uri,entries,numentries)

Set the ACL for the given resource to the list of ACL entries.

Arguments
$session

ne_session *

uri

<string>

entries

ne_acl_entry *

entries = { apply => enum, type => enum, principal => <string>, read => <integer>, read_acl => <integer>, write => <integer>, write_acl => <integer>, read_cuprivset => <integer>, };

numentries

<integer>

int = $session -> close_connection ()

Prematurely force the connection to be closed for the given session.

Arguments
$session

ne_session *

$session -> cookie_register (cache)

Register cookie handling for given session using given cache.

Arguments
$session

ne_session *

cache

ne_cookie_cache *

cache = { cookies => ne_cookie *, };

int = $session -> copy (overwrite,depth,src,dest)

Copy resource from src to dest URIs. If src identifies a collection resource, depth may be NE_DEPTH_ZERO to request that the collection and its properties are to be copied, or NE_DEPTH_INFINITE to request that the collection and its contents are to be copied.

Arguments
$session

ne_session *

overwrite

<integer>

depth

<integer>

src

<string>

dest

<string>

$session -> decide_proxy (use_proxy)

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 ne_session_proxy.

This function MUST be called before calling ne_session_server.

Arguments
$session

ne_session *

Callback function: use_proxy

int = use_proxy (userdata,scheme,hostname)

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.

userdata

void *

scheme

<string>

hostname

<string>

int = $session -> delete (uri)

Delete resource at uri.

Arguments
$session

ne_session *

uri

<string>

$session -> forget_auth ()

Clear any stored authentication details for the given session.

Arguments
$session

ne_session *

int = $session -> get (uri,fd)

Return resource at uri, writing response body to f

Arguments
$session

ne_session *

uri

<string>

fd

<integer>

const char * = $session -> get_error ()

Arguments
$session

ne_session *

int = $session -> get_range (uri,range,fd)

Arguments
$session

ne_session *

uri

<string>

range

ne_content_range *

range = { start => <integer>, end => <integer>, total => <integer>, };

fd

<integer>

const char * = $session -> get_scheme ()

Returns the URL scheme being used for the current session. Does NOT include a trailing ':'. Example returns: "http" or "https".

Arguments
$session

ne_session *

const char * = $session -> get_server_hostport ()

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)

Arguments
$session

ne_session *

int = $session -> getmodtime (uri,modtime)

Retrieve modification time of resource at uri, place in *modtime. (uses HEAD)

Arguments
$session

ne_session *

uri

<string>

modtime

time_t *

$session -> hook_create_request (fn)

Arguments
$session

ne_session *

Callback function: fn

fn (userdata,$request,method,uri)

Hook called when a create is created.

userdata

void *

req

ne_request *

method

<string>

uri

<string>

$session -> hook_destroy_request (fn)

Arguments
$session

ne_session *

Callback function: fn

fn (userdata)

Hook called when the function is destroyed.

userdata

void *

$session -> hook_destroy_session (fn)

Hook called when the session is destroyed.

Arguments
$session

ne_session *

Callback function: fn

fn (userdata)

Hook called when the function is destroyed.

userdata

void *

$session -> hook_post_send (fn)

Arguments
$session

ne_session *

Callback function: fn

int = fn (userdata,status)

Hook called after the request is sent. May return: NE_OK everything is okay NE_RETRY try sending the request again. anything else signifies an error, and the request is failed. The return code is passed back the _dispatch caller, so the session error must also be set appropriately (ne_set_error).

userdata

void *

status

const ne_status *

$session -> hook_pre_send (fn)

Arguments
$session

ne_session *

Callback function: fn

fn (userdata,$buffer)

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

userdata

void *

header

ne_buffer *

void * = $session -> hook_private (id)

Arguments
$session

ne_session *

id

<string>

$session -> hook_session_accessor (id,arg2,userdata)

Arguments
$session

ne_session *

id

<string>

arg2

ne_accessor_fn

Hook used to allow external access into hook processing.

userdata

void *

int = $session -> lock (lock)

Issue a LOCK request for the given lock. Requires that the uri, depth, type, scope, and timeout members of 'lock' are filled in. Optionally also the owner. On successful return, lock->token will contain the lock token.

Arguments
$session

ne_session *

lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

int = $session -> lock_discover (uri,result)

Perform lock discovery on the given URI. 'result' is called with the results (possibly >1 times).

Arguments
$session

ne_session *

uri

<string>

Callback function: result

result (userdata,lock,uri,status)

Callback for lock discovery. If 'lock' is NULL, something went wrong retrieving lockdiscover for the resource, look at 'status' for the details.

userdata

void *

lock

const struct ne_lock *

uri

<string>

status

const ne_status *

int = $session -> lock_refresh (lock)

Refresh a lock. Updates lock->timeout appropriately.

Arguments
$session

ne_session *

lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

$locksession = $session -> lock_register ()

Register the locking hooks with an ne_session. Owned locks persist for the duration of this session. The lock session lasts exactly as long as the corresponding ne_session. Once you call ne_session_destroy(sess), any use of the lock session has undefined results.

Arguments
$session

ne_session *

int = $session -> mkcol (uri)

Create a collection at uri, which MUST have a trailing slash.

Arguments
$session

ne_session *

uri

<string>

int = $session -> move (overwrite,src,dest)

Move resource from src to dest URI.

Arguments
$session

ne_session *

overwrite

<integer>

src

<string>

dest

<string>

int = $session -> options (uri,caps)

Determines server capabilities (using OPTIONS). Pass uri="*" to determine proxy server capabilities if using a proxy server.

Arguments
$session

ne_session *

uri

<string>

caps

ne_server_capabilities *

caps = { dav_class1 => unsigned int, dav_class2 => unsigned int, dav_executable => unsigned int, };

int = $session -> post (uri,fd,buffer)

Post using buffer as request-body: stream response into f

Arguments
$session

ne_session *

uri

<string>

fd

<integer>

buffer

<string>

$propfind = $session -> propfind_create (uri,depth)

Arguments
$session

ne_session *

uri

<string>

depth

<integer>

int = $session -> propnames (href,depth,results)

Retrieve property names for the resources at 'href'. 'results' callback is called for each resource. Use 'ne_propset_iterate' on the passed results object to retrieve the list of property names.

Arguments
$session

ne_session *

href

<string>

depth

<integer>

Callback function: results

results (userdata,href,$propset)

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 ne_propset_* to examine this object.

userdata

void *

href

<string>

results

const ne_prop_result_set *

int = $session -> proppatch (uri,items)

Arguments
$session

ne_session *

uri

<string>

items

const ne_proppatch_operation *

items = { name => const ne_propname *, type => enum, value => <string>, };

int = $session -> proxy (hostname,port)

Arguments
$session

ne_session *

hostname

<string>

port

<integer>

int = $session -> put (uri,fd)

Replace resource at uri, reading body from f

Arguments
$session

ne_session *

uri

<string>

fd

<integer>

int = $session -> put_if_unmodified (uri,fd,modtime)

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.

Arguments
$session

ne_session *

uri

<string>

fd

<integer>

modtime

time_t

int = $session -> read_file (uri,reader)

GET resource at uri, passing response body blocks to 'reader'

Arguments
$session

ne_session *

uri

<string>

Callback function: reader

reader (userdata,buf,len)

The 'reader' callback type

userdata

void *

buf

<string>

len

size_t

const char * = $session -> redirect_location ()

Return location of last redirect.

Arguments
$session

ne_session *

$session -> redirect_register (confirm,notify)

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.

Arguments
$session

ne_session *

Callback function: confirm

int = confirm (userdata,src,dest)

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

userdata

void *

src

<string>

dest

<string>

Callback function: notify

notify (userdata,src,dest)

Notify the user that a redirect has been automatically followed from URI 'src' to URI 'dest'

userdata

void *

src

<string>

dest

<string>

$request = $session -> request_create (method,uri)

Arguments
$session

ne_session *

method

<string>

uri

<string>

int = $session -> server (hostname,port)

Set the server or proxy server to be used for the session. Returns: NE_LOOKUP if the DNS lookup for hostname failed. NE_OK otherwise.

Note that if a proxy is being used, ne_session_proxy should be called BEFORE ne_session_server, so the DNS lookup can be skipped on the server.

Arguments
$session

ne_session *

hostname

<string>

port

<integer>

int = $session -> set_accept_secure_upgrade (acc_upgrade)

Arguments
$session

ne_session *

acc_upgrade

<integer>

$session -> set_error (errstring)

Set the error string for the session

Arguments
$session

ne_session *

errstring

<string>

$session -> set_expect100 (use_expect100)

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.)

Arguments
$session

ne_session *

use_expect100

<integer>

$session -> set_persist (persist)

Arguments
$session

ne_session *

persist

<integer>

$session -> set_progress (progress)

Set a progress callback for the session.

Arguments
$session

ne_session *

Callback function: progress

progress (userdata,progress,total)

userdata

void *

progress

<integer>

total

<integer>

$session -> set_proxy_auth (callback)

Arguments
$session

ne_session *

Callback function: callback

int = callback (userdata,realm,username,password)

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.)

userdata

void *

realm

<string>

username

char **

password

char **

int = $session -> set_request_secure_upgrade (req_upgrade)

NOTE: don't bother using the two _secure_update functions yet. "secure upgrades" (RFC2817) are not currently supported by any HTTP servers.

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.

These return as per ne_set_secure.

Arguments
$session

ne_session *

req_upgrade

<integer>

int = $session -> set_secure (secure)

Arguments
$session

ne_session *

secure

<integer>

$session -> set_secure_context ($ssl)

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.

NB: ne_set_scure will return -1 if SSL is not supported by the library (i.e., it was not built against OpenSSL), or 0 if it is.

Arguments
$session

ne_session *

$ssl

nssl_context *

$session -> set_server_auth (callback)

Set callbacks to handle server and proxy authentication. userdata is passed as the first argument to the callback.

Arguments
$session

ne_session *

Callback function: callback

int = callback (userdata,realm,username,password)

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.)

userdata

void *

realm

<string>

username

char **

password

char **

$session -> set_status (status)

Set a status notification callback for the session, to report connection status.

Arguments
$session

ne_session *

Callback function: status

status (userdata,status,info)

userdata

void *

status

ne_conn_status

info

<string>

$session -> set_useragent (product)

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]*

Arguments
$session

ne_session *

product

<string>

int = $session -> simple_propfind (uri,depth,props,results)

Fetch properties for a resource (if depth == NE_DEPTH_ZERO), or a tree of resources (if depth == NE_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 NE_DEPTH_INFINITY, some servers may refuse the request.

Returns NE_*.

Arguments
$session

ne_session *

uri

<string>

depth

<integer>

props

const ne_propname *

props = { nspace => <string>, name => <string>, };

Callback function: results

results (userdata,href,$propset)

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 ne_propset_* to examine this object.

userdata

void *

href

<string>

results

const ne_prop_result_set *

int = $session -> simple_request ($request)

Dispatch a DAV request and handle a 207 error response appropriately

Arguments
$session

ne_session *

$request

ne_request *

int = $session -> unlock (lock)

Issue an UNLOCK request for the given lock

Arguments
$session

ne_session *

lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

int = $session -> version_pre_http11 ()

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.

Arguments
$session

ne_session *

Methods of HTTP::Webdav::Buffer ^

$buffer -> DESTROY ()

Destroys (deallocates) a buffer

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

$buffer -> altered ()

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

int = $buffer -> append (data,len)

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.

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

data

<string>

len

size_t

$buffer -> clear ()

Empties the contents of buf; makes the buffer zero-length.

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

char * = $buffer -> finish ()

Destroys a buffer, WITHOUT freeing the data, and returns the data.

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

int = $buffer -> grow (size)

Grows the ne_buffer to a minimum size. Returns 0 on success, non-zero on error

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

size

size_t

int = $buffer -> zappend (str)

Append a zero-terminated string 'str' to buf. Returns 0 on success, non-zero on error.

Arguments
$buffer

ne_buffer *

Hook called before the request is sent. 'header' is the raw HTTP header before the trailing CRLF is added: add in more here.

str

<string>

Methods of HTTP::Webdav::LockSession ^

$locksession -> add (lock)

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 ne_session which the lock session is tied to. Requests indicate to the locking layer which locks they might need using ne_lock_using_*, as described below.

Arguments
$locksession

ne_lock_session *

lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

struct ne_lock * = $locksession -> find (uri)

Find a lock in the session with given URI

Arguments
$locksession

ne_lock_session *

uri

<string>

int = $locksession -> iterate (func)

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.

Arguments
$locksession

ne_lock_session *

Callback function: func

func (lock,userdata)

lock

struct ne_lock *

userdata

void *

$locksession -> remove (lock)

Remove lock, which must have been previously added to the session using 'ne_lock_add' above.

Arguments
$locksession

ne_lock_session *

lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

Methods of HTTP::Webdav::MD5 ^

void * = $md5ctx -> finish_ctx (resbuf)

Arguments
$md5ctx

struct ne_md5_ctx *

resbuf

void *

$md5ctx -> init_ctx ()

Arguments
$md5ctx

struct ne_md5_ctx *

void * = $md5ctx -> read_ctx (resbuf)

Arguments
$md5ctx

const struct ne_md5_ctx *

resbuf

void *

Methods of HTTP::Webdav::MultiStatus ^

$multstatus -> DESTROY ()

Arguments
$multstatus

ne_207_parser *

void * = $multstatus -> get_current_propstat ()

Arguments
$multstatus

ne_207_parser *

void * = $multstatus -> get_current_response ()

Arguments
$multstatus

ne_207_parser *

$multstatus -> ignore_unknown ()

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.

Arguments
$multstatus

ne_207_parser *

$multstatus -> set_propstat_handlers (start,end)

Arguments
$multstatus

ne_207_parser *

start

ne_207_start_propstat

Callback function: end

end (userdata,propstat,status_line,status,description)

userdata

void *

propstat

void *

status_line

<string>

status

const ne_status *

description

<string>

$multstatus -> set_response_handlers (start,end)

Set the callbacks for the parser

Arguments
$multstatus

ne_207_parser *

start

ne_207_start_response

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.

Callback function: end

end (userdata,response,status_line,status,description)

userdata

void *

response

void *

status_line

<string>

status

const ne_status *

description

<string>

Methods of HTTP::Webdav::Propfind ^

$propfind -> DESTROY ()

Destroy a propfind handler after use.

Arguments
$propfind

ne_propfind_handler *

int = $propfind -> allprop (result)

Find all properties.

Returns NE_*.

Arguments
$propfind

ne_propfind_handler *

Callback function: result

result (userdata,href,$propset)

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 ne_propset_* to examine this object.

userdata

void *

href

<string>

results

const ne_prop_result_set *

void * = $propfind -> current_private ()

Retrieve the 'private' pointer for the current propset for the given handler, as returned by the ne_props_create_complex callback installed using 'ne_propfind_set_private'. If this callback was not registered, this function will return NULL.

Arguments
$propfind

ne_propfind_handler *

$hip = $propfind -> get_parser ()

Return the XML parser for the given handler (only need if you want to handle complex properties).

Arguments
$propfind

ne_propfind_handler *

$request = $propfind -> get_request ()

Return the request object for the given handler. You MUST NOT use ne_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).

Arguments
$propfind

ne_propfind_handler *

int = $propfind -> named (prop,result)

Find properties named in a call to ne_propfind_set_flat and/or ne_propfind_set_complex.

Returns NE_*.

Arguments
$propfind

ne_propfind_handler *

prop

const ne_propname *

prop = { nspace => <string>, name => <string>, };

Callback function: result

result (userdata,href,$propset)

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 ne_propset_* to examine this object.

userdata

void *

href

<string>

results

const ne_prop_result_set *

$propfind -> set_private (creator,userdata)

Arguments
$propfind

ne_propfind_handler *

creator

ne_props_create_complex

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 'ne_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 'ne_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 'ne_propset_private'.

userdata

void *

Methods of HTTP::Webdav::Propset ^

int = $propset -> iterate (iterator)

Iterate over all the properties in 'set', calling 'iterator' for each, passing 'userdata' as the first argument to callback.

Returns: whatever value iterator returns.

Arguments
$propset

const ne_prop_result_set *

The 'ne_simple_propfind' interface. ***

ne_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 ne_prop_result_set *results)

Callback function: iterator

int = iterator (userdata,pname,value,status)

ne_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, ne_propset_iterate will return immediately with that value.

userdata

void *

pname

const ne_propname *

value

<string>

status

const ne_status *

const char * = $propset -> lang (pname)

Return language string of property (may be NULL).

Arguments
$propset

const ne_prop_result_set *

The 'ne_simple_propfind' interface. ***

ne_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 ne_prop_result_set *results)

pname

const ne_propname *

pname = { nspace => <string>, name => <string>, };

void * = $propset -> private ()

Returns the private pointer for the given propset.

Arguments
$propset

const ne_prop_result_set *

The 'ne_simple_propfind' interface. ***

ne_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 ne_prop_result_set *results)

const ne_status * = $propset -> status (propname)

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).

Arguments
$propset

const ne_prop_result_set *

The 'ne_simple_propfind' interface. ***

ne_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 ne_prop_result_set *results)

propname

const ne_propname *

propname = { nspace => <string>, name => <string>, };

const char * = $propset -> value (propname)

Get the value of a given property. Will return NULL if there was an error fetching this property on this resource. Call ne_propset_result to get the response-status if so.

Arguments
$propset

const ne_prop_result_set *

The 'ne_simple_propfind' interface. ***

ne_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 ne_prop_result_set *results)

propname

const ne_propname *

propname = { nspace => <string>, name => <string>, };

Methods of HTTP::Webdav::Request ^

$request -> DESTROY ()

Destroy memory associated with request pointer

Arguments
$request

ne_request *

$request -> add_depth_header (depth)

Adds a Depth: header to a request

Arguments
$request

ne_request *

depth

<integer>

$request -> add_request_header (name,value)

Adds a header to the request with given name and value.

Arguments
$request

ne_request *

name

<string>

value

<string>

$request -> add_response_body_reader (accpt,rdr)

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.

The acceptance callback is called once each time the request is sent: it may be sent >1 time because of authentication retries etc. For each time the acceptance callback is called, if it returns non-zero, blocks of the response body will be passed to the reader callback as the response is read. After all the response body has been read, the callback will be called with a 'len' argument of zero.

Arguments
$request

ne_request *

Callback function: accpt

int = accpt (userdata,$request,st)

'acceptance' callback type. Return non-zero to accept the response, else zero to ignore it.

userdata

void *

req

ne_request *

st

ne_status *

Callback function: rdr

rdr (userdata,buf,len)

The 'reader' callback type

userdata

void *

buf

<string>

len

size_t

$request -> add_response_header_catcher (hdl)

Add handler which is passed ALL header values regardless of name

Arguments
$request

ne_request *

Callback function: hdl

hdl (userdata,value)

The header handler callback type

userdata

void *

value

<string>

$request -> add_response_header_handler (name,hdl)

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").

Arguments
$request

ne_request *

name

<string>

Callback function: hdl

hdl (userdata,value)

The header handler callback type

userdata

void *

value

<string>

int = $request -> begin_request ()

Arguments
$request

ne_request *

ne_decompress * = $request -> decompress_reader (accpt,rdr)

Call this to register a 'reader' callback which will be passed blocks of response body (if the 'acceptance' callback is successful). If the response body is returned compressed by the server, this reader will receive UNCOMPRESSED blocks.

Returns pointer to context object which must be passed to ne_decompress_destroy after the request has been dispatched, to free any internal state.

Arguments
$request

ne_request *

Callback function: accpt

int = accpt (userdata,$request,st)

'acceptance' callback type. Return non-zero to accept the response, else zero to ignore it.

userdata

void *

req

ne_request *

st

ne_status *

Callback function: rdr

rdr (userdata,buf,len)

The 'reader' callback type

userdata

void *

buf

<string>

len

size_t

int = $request -> dispatch ()

ne_request_dispatch: Sends the given request, and reads the response. Response-Status information can be retrieve with ne_get_status(req).

Returns: NE_OK if request sent + response read okay. NE_AUTH if user authentication failed on origin server NE_AUTHPROXY if user authentication failed on proxy server NE_SERVERAUTH server authentication failed NE_PROXYAUTH proxy authentication failed NE_CONNECT could not connect to server/proxy server NE_TIMEOUT connection timed out mid-request NE_ERROR for other errors, and ne_get_error() should return a meaningful error string

NB: NE_AUTH and NE_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.

Arguments
$request

ne_request *

int = $request -> end_request ()

Arguments
$request

ne_request *

$session = $request -> get_session ()

Returns pointer to session associated with request.

Arguments
$request

ne_request *

const ne_status * = $request -> get_status ()

Arguments
$request

ne_request *

void * = $request -> hook_private (id)

Arguments
$request

ne_request *

id

<string>

$request -> hook_request_accessor (id,arg2,userdata)

Arguments
$request

ne_request *

id

<string>

arg2

ne_accessor_fn

Hook used to allow external access into hook processing.

userdata

void *

$request -> lock_using_parent (uri)

Indicate that this request will modify parent collection of given URI

Arguments
$request

ne_request *

uri

<string>

$request -> lock_using_resource (uri,depth)

Indicate that this request is of depth n on given uri

Arguments
$request

ne_request *

uri

<string>

depth

<integer>

ssize_t = $request -> read_response_block (buffer,buflen)

Arguments
$request

ne_request *

buffer

<string>

buflen

size_t

$request -> set_request_body_buffer (buffer,size)

'buffer' will be sent as the request body with given request.

Arguments
$request

ne_request *

buffer

<string>

size

size_t

int = $request -> set_request_body_fd (fd)

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.

Arguments
$request

ne_request *

fd

<integer>

$request -> set_request_body_provider (size,provider)

Callback is called to provide blocks of request body.

Arguments
$request

ne_request *

size

size_t

Callback function: provider

ssize_t = provider (userdata,buffer,buflen)

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.).

The callback must return: <0 : error, abort. 0 : ignore 'buffer' contents, end of body. 0 < x <= buflen : buffer contains x bytes of body data.

userdata

void *

buffer

<string>

buflen

size_t

Methods of HTTP::Webdav::SSL ^

$ssl -> DESTROY ()

Arguments
$ssl

nssl_context *

$ssl -> disable_sslv2 ()

Arguments
$ssl

nssl_context *

$ssl -> disable_sslv3 ()

Arguments
$ssl

nssl_context *

$ssl -> disable_tlsv1 ()

Arguments
$ssl

nssl_context *

int = $ssl -> set_client_cert (certfile,keyfile)

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.

Arguments
$ssl

nssl_context *

certfile

<string>

keyfile

<string>

$ssl -> set_key_prompt (prompt)

Arguments
$ssl

nssl_context *

Callback function: prompt

int = prompt (userdata,filename,buf,buflen)

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.

userdata

void *

filename

<string>

buf

<string>

buflen

<integer>

Methods of HTTP::Webdav::Socket ^

int = $socket -> block (timeout)

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.

Arguments
$socket

nsocket *

timeout

<integer>

$socket -> call_progress (progress,total)

Arguments
$socket

nsocket *

progress

<integer>

total

<integer>

int = $socket -> close ()

Closes the socket and frees the nsocket object.

Arguments
$socket

nsocket *

int = $socket -> fullread (buffer,buflen)

Reads a chunk of data.

Arguments
$socket

nsocket *

buffer

<string>

buflen

<integer>

int = $socket -> fullwrite (data,length)

Sends the given block of data down the nsocket

Arguments
$socket

nsocket *

data

<string>

length

size_t

const char * = $socket -> get_error ()

Arguments
$socket

nsocket *

int = $socket -> get_fd ()

Returns the file descriptor used for the socket

Arguments
$socket

nsocket *

const char * = $socket -> get_version ()

Arguments
$socket

nsocket *

int = $socket -> make_secure ($ssl)

Ctx is OPTIONAL. If it is NULL, defaults are used.

Arguments
$socket

nsocket *

$ssl

nssl_context *

int = $socket -> peek (buffer,count)

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.

Arguments
$socket

nsocket *

buffer

<string>

count

size_t

int = $socket -> read (buffer,count)

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.

Arguments
$socket

nsocket *

buffer

<string>

count

size_t

int = $socket -> readfile_blocked (length,reader)

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)

Arguments
$socket

nsocket *

length

<integer>

Callback function: reader

reader (userdata,buf,len)

userdata

void *

buf

<string>

len

size_t

int = $socket -> readline (line,len)

Reads a line from given nsocket

Arguments
$socket

nsocket *

line

<string>

len

<integer>

$socket -> register_progress (cb)

Arguments
$socket

nsocket *

Callback function: cb

cb (userdata,progress,total)

userdata

void *

progress

<integer>

total

<integer>

int = $socket -> send_string (string)

Sends the null-terminated string down the given nsocket

Arguments
$socket

nsocket *

string

<string>

int = $socket -> sendline (line)

Sends the given line to given socket, CRLF appended

Arguments
$socket

nsocket *

line

<string>

Methods of HTTP::Webdav::Util ^

int = HTTP::Webdav::Util::accept_207 (userdata,$request,status)

An acceptance function which only accepts 207 responses

Arguments
userdata

void *

$request

ne_request *

status

ne_status *

Hook called after the request is sent. May return: NE_OK everything is okay NE_RETRY try sending the request again. anything else signifies an error, and the request is failed. The return code is passed back the _dispatch caller, so the session error must also be set appropriately (ne_set_error).

status = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };

int = HTTP::Webdav::Util::accept_2xx (userdata,$request,st)

An 'acceptance' callback which only accepts 2xx-class responses. Ignores userdata.

Arguments
userdata

void *

$request

ne_request *

st

ne_status *

Hook called after the request is sent. May return: NE_OK everything is okay NE_RETRY try sending the request again. anything else signifies an error, and the request is failed. The return code is passed back the _dispatch caller, so the session error must also be set appropriately (ne_set_error).

st = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };

int = HTTP::Webdav::Util::accept_always (userdata,$request,st)

An acceptance callback which accepts all responses. Ignores userdata.

Arguments
userdata

void *

$request

ne_request *

st

ne_status *

Hook called after the request is sent. May return: NE_OK everything is okay NE_RETRY try sending the request again. anything else signifies an error, and the request is failed. The return code is passed back the _dispatch caller, so the session error must also be set appropriately (ne_set_error).

st = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };

time_t = HTTP::Webdav::Util::asctime_parse (date)

Parses asctime date string

Arguments
date

<string>

$buffer = HTTP::Webdav::Util::buffer_create ()

Create a new ne_buffer. Returns NULL on error

Arguments

$buffer = HTTP::Webdav::Util::buffer_create_sized (size)

Create a new ne_buffer of given minimum size. Returns NULL on error

Arguments
size

size_t

void * = HTTP::Webdav::Util::calloc (len)

Arguments
len

size_t

HTTP::Webdav::Util::content_type_handler (userdata,value)

Sets (*ne_content_type)userdata appropriately. Caller must free ->value after use

Arguments
userdata

void *

value

<string>

HTTP::Webdav::Util::debug_init (stream,mask)

Arguments
stream

<filehandle>

mask

<integer>

int = HTTP::Webdav::Util::decompress_destroy (ctx)

Free's up internal state. Returns non-zero if errors occured during decompression: the session error string will have the error.

Arguments
ctx

ne_decompress *

HTTP::Webdav::Util::duplicate_header (userdata,value)

Stock header handlers: 'duplicate': *(char **)userdata = strdup(value) 'numeric': *(int *)userdata = atoi(value) e.g. int mynum; ne_add_response_header_handler(myreq, "Content-Length", ne_handle_numeric_handler, &mynum); ... arranges mynum to be set to the value of the Content-Length header.

Arguments
userdata

void *

value

<string>

HTTP::Webdav::Util::handle_numeric_header (userdata,value)

Arguments
userdata

void *

value

<string>

time_t = HTTP::Webdav::Util::httpdate_parse (date)

Parse an HTTP-date as per RFC2616

Arguments
date

<string>

time_t = HTTP::Webdav::Util::iso8601_parse (date)

Returns time from date/time using the subset of the ISO8601 format referenced in RFC2518 (e.g as used in the creationdate property in the DAV: namespace).

Arguments
date

<string>

struct ne_lock * = HTTP::Webdav::Util::lock_copy (lock)

Deep-copy a lock structure.

Arguments
lock

const struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

HTTP::Webdav::Util::lock_free (lock)

Free a lock structure

Arguments
lock

struct ne_lock *

lock = { uri => <string>, depth => <integer>, type => <integer>, scope => <integer>, token => <string>, owner => <string>, timeout => long, prev => void *, next => void *, };

void * = HTTP::Webdav::Util::md5_buffer (buffer,len,resblock)

Arguments
buffer

<string>

len

size_t

resblock

void *

HTTP::Webdav::Util::md5_process_block (buffer,len,$md5ctx)

Arguments
buffer

const void *

len

size_t

$md5ctx

struct ne_md5_ctx *

HTTP::Webdav::Util::md5_process_bytes (buffer,len,$md5ctx)

Arguments
buffer

const void *

len

size_t

$md5ctx

struct ne_md5_ctx *

int = HTTP::Webdav::Util::md5_stream (stream,resblock)

Arguments
stream

<filehandle>

resblock

void *

HTTP::Webdav::Util::neon_i18n_init ()

Initialize i18n in neon

Arguments

void * = HTTP::Webdav::Util::null_accessor (userdata)

an accessor which simply returns the userdata.

Arguments
userdata

void *

int = HTTP::Webdav::Util::parse_statusline (status_line,s)

Parser for strings which follow the Status-Line grammar from RFC2616. Returns: 0 on success, *s will be filled in. -1 on parse error.

Arguments
status_line

<string>

s

ne_status *

Hook called after the request is sent. May return: NE_OK everything is okay NE_RETRY try sending the request again. anything else signifies an error, and the request is failed. The return code is passed back the _dispatch caller, so the session error must also be set appropriately (ne_set_error).

s = { major_version => <integer>, minor_version => <integer>, code => <integer>, klass => <integer>, reason_phrase => <string>, };

void * = HTTP::Webdav::Util::realloc (ptr,len)

Arguments
ptr

void *

len

size_t

time_t = HTTP::Webdav::Util::rfc1036_parse (date)

Arguments
date

<string>

char * = HTTP::Webdav::Util::rfc1123_date (anytime)

Return current date/time in RFC1123 format

Arguments
anytime

time_t

time_t = HTTP::Webdav::Util::rfc1123_parse (date)

Returns time from date/time in RFC1123 format

Arguments
date

<string>

$session = HTTP::Webdav::Util::session_create ()

Create a new HTTP session

Arguments

char * = HTTP::Webdav::Util::shave (str,whitespace)

Return portion of 'str' with any characters in 'whitespace' shaved off the beginning and end. Modifies str.

Arguments
str

<string>

whitespace

<string>

$socket = HTTP::Webdav::Util::sock_accept (listener)

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.

Arguments
listener

<integer>

$ssl = HTTP::Webdav::Util::sock_create_ssl_context ()

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

Arguments

HTTP::Webdav::Util::sock_exit ()

Shutdown the socket library.

Arguments

int = HTTP::Webdav::Util::sock_init ()

Initialize the socket library. If you don't do this, SSL WILL NOT WORK. Returns 0 on success, or non-zero on screwed up SSL library.

Arguments

int = HTTP::Webdav::Util::sock_name_lookup (hostname,addr)

Do a name lookup on given hostname, writes the address into given address buffer. Return -1 on failure.

Arguments
hostname

<string>

addr

struct in_addr *

int = HTTP::Webdav::Util::sock_service_lookup (name)

Returns the standard TCP port for the given service

Arguments
name

<string>

int = HTTP::Webdav::Util::sock_transfer (fd,$socket,readlen)

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.

Arguments
fd

<integer>

$socket

nsocket *

readlen

<integer>

char * = HTTP::Webdav::Util::strdup (s)

Arguments
s

<string>

char * = HTTP::Webdav::Util::strndup (s,n)

Arguments
s

<string>

n

size_t

int = HTTP::Webdav::Util::supports_ssl ()

Returns non-zero if neon has support for SSL.

Arguments

char * = HTTP::Webdav::Util::uri_absolute (uri,scheme,hostport)

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.

Arguments
uri

<string>

scheme

<string>

hostport

<string>

const char * = HTTP::Webdav::Util::uri_abspath (uri)

Returns abspath segment in (absolute) uri

Arguments
uri

<string>

char * = HTTP::Webdav::Util::uri_abspath_escape (abs_path)

Escapes the abspath segment of a URI. Returns malloc-allocated string on success, or NULL on malloc failure.

Arguments
abs_path

<string>

int = HTTP::Webdav::Util::uri_childof (parent,child)

Returns non-zero if child is a child of parent

Arguments
parent

<string>

child

<string>

int = HTTP::Webdav::Util::uri_compare (a,b)

Returns strcmp-like value giving comparison between a and b, ignoring trailing-slashes.

Arguments
a

<string>

b

<string>

HTTP::Webdav::Util::uri_free (parsed)

Arguments
parsed

struct uri *

int = HTTP::Webdav::Util::uri_has_trailing_slash (uri)

Returns non-zero if uri has a trailing slash character

Arguments
uri

<string>

char * = HTTP::Webdav::Util::uri_parent (path)

Returns parent of path

Arguments
path

<string>

int = HTTP::Webdav::Util::uri_parse (uri,parsed,defaults)

Parse 'uri' and place parsed segments in *parsed.

Arguments
uri

<string>

parsed

struct uri *

defaults

const struct uri *

char * = HTTP::Webdav::Util::uri_unescape (uri)

Un-escapes a URI. Returns malloc-allocated URI on success, or NULL on failure (malloc failure or invalid %<HEX><HEX> sequence).

Arguments
uri

<string>

char * = HTTP::Webdav::Util::utf8_decode (str)

Returns an ne_malloc-allocated UTF-8 decode copy of 'str'. Returns NULL if any of the characters in 'str' are non-8-bit.

Arguments
str

<string>

char * = HTTP::Webdav::Util::utf8_encode (str)

Returns an ne_malloc-allocated UTF-8 encoded copy of 'str'.

Arguments
str

<string>

int = HTTP::Webdav::Util::version_minimum (major,minor)

Returns non-zero if the neon API compiled in is less than major.minor. i.e. I am: 1.2 - neon_version_check(1, 3) => -1 I am: 0.10 - neon_version_check(0, 9) => 0

Arguments
major

<integer>

minor

<integer>

const char * = HTTP::Webdav::Util::version_string ()

Returns a human-readable version string like: "neon 0.2.0: Library build, OpenSSL support"

Arguments

$hip = HTTP::Webdav::Util::xml_create ()

Initialise the parser

Arguments

HTTP::Webdav::Util::xml_parse_v (userdata,block,len)

As above, casting (ne_xml_parser *)userdata internally. (This function can be passed to ne_add_response_body_reader)

Arguments
userdata

void *

block

<string>

len

size_t

Methods of HTTP::Webdav::XML ^

$hip -> DESTROY ()

Destroys the parser. Any operations on it then have undefined results.

Arguments
$hip

ne_xml_parser *

int = $hip -> currentline ()

Return current parse line for errors

Arguments
$hip

ne_xml_parser *

const char * = $hip -> get_error ()

Arguments
$hip

ne_xml_parser *

$multstatus = $hip -> ne_207_create ()

Create a 207 parser

Arguments
$hip

ne_xml_parser *

$hip -> parse (block,len)

Parse the given block of input of length len. Block does not need to be NULL-terminated.

Arguments
$hip

ne_xml_parser *

block

<string>

len

size_t

$hip -> push_handler (elements,validate_cb,startelm_cb,endelm_cb)

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.

Arguments
$hip

ne_xml_parser *

elements

const struct ne_xml_elm *

Callback function: validate_cb

int = validate_cb (userdata,parent,child)

Validate a new child element.

userdata

void *

parent

ne_xml_elmid

child

ne_xml_elmid

Callback function: startelm_cb

int = startelm_cb (userdata,elm,atts)

userdata

void *

elm

const struct ne_xml_elm *

atts

const char **

Callback function: endelm_cb

int = endelm_cb (userdata,s,cdata)

Called when a complete element is parsed

userdata

void *

s

const struct ne_xml_elm *

cdata

<string>

$hip -> push_mixed_handler (elements,validate_cb,startelm_cb,cdata_cb,endelm_cb)

Add a handler which uses a mixed-mode cdata callback

Arguments
$hip

ne_xml_parser *

elements

const struct ne_xml_elm *

Callback function: validate_cb

int = validate_cb (userdata,parent,child)

Validate a new child element.

userdata

void *

parent

ne_xml_elmid

child

ne_xml_elmid

Callback function: startelm_cb

int = startelm_cb (userdata,elm,atts)

userdata

void *

elm

const struct ne_xml_elm *

atts

const char **

Callback function: cdata_cb

cdata_cb (userdata,s,cdata,len)

userdata

void *

s

const struct ne_xml_elm *

cdata

<string>

len

<integer>

Callback function: endelm_cb

int = endelm_cb (userdata,s,cdata)

Called when a complete element is parsed

userdata

void *

s

const struct ne_xml_elm *

cdata

<string>

$hip -> set_error (msg)

Set error message for parser

Arguments
$hip

ne_xml_parser *

msg

<string>

int = $hip -> valid ()

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 ne_xml_get_error to retrieve the error message if it failed.

Arguments
$hip

ne_xml_parser *

Constants ^

Constants are defined in HTTP::Webdav::Constants, to get them imported say

use HTTP::Webdav::Constants ;

HTTP_QUOTES

HTTP_WHITESPACE

NE_ACL_H

NE_ALLOC_H

NE_AUTH

 User authentication failed on proxy 

NE_AUTHPROXY

 User authentication failed on proxy 

NE_AUTH_H

NE_BASIC_H

NE_COMPRESS_H

NE_CONNECT

 Could not connect to server 

NE_COOKIES_H

NE_DBG_FLUSH

NE_DBG_HTTP

NE_DBG_HTTPAUTH

NE_DBG_HTTPBASIC

NE_DBG_HTTPBODY

NE_DBG_HTTPPLAIN

NE_DBG_LOCKS

NE_DBG_SOCKET

NE_DBG_XML

NE_DBG_XMLPARSE

NE_DEPTH_INFINITE

NE_DEPTH_ONE

NE_DEPTH_ZERO

NE_ELM_207_UNUSED

NE_ELM_207_first

NE_ELM_UNUSED

NE_ELM_href

NE_ELM_multistatus

NE_ELM_prop

NE_ELM_propstat

NE_ELM_response

NE_ELM_responsedescription

NE_ELM_root

NE_ELM_status

NE_ELM_unknown

NE_ERROR

 Generic error; use ne_get_error(session) for message 

NE_FAILED

 The precondition failed 

NE_LOCKS_H

NE_LOOKUP

 Name lookup failed 

NE_OK

NE_PROPS_H

NE_PROXYAUTH

 Proxy authentication failed 

NE_REDIRECT

 See ne_redirect.h 

NE_REDIRECT_H

NE_REQUEST_H

NE_RETRY

 Retry request (ne_end_request ONLY) 

NE_SERVERAUTH

 Server authentication failed 

NE_SESSION_H

NE_SOCKET_H

NE_STRING_H

NE_TIMEOUT

 Connection timed out 

NE_TIMEOUT_INFINITE

NE_TIMEOUT_INVALID

NE_URI_H

NE_UTILS_H

NE_XML_CDATA

NE_XML_COLLECT

NE_XML_DECLINE

NE_XML_H

NE_XML_INVALID

NE_XML_MIXED

NE_XML_UTF8DECODE

NE_XML_VALID

http://www.webdav.org/neon/

SUPPORT ^

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 ^

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.

AUTHOR ^

Gerald Richter / ecos <richter@dev.ecos.de>

syntax highlighting: