libneon: headers diff between 0.24.7 and 0.25.0 versions

	ne_alloc.h	ne_alloc.h
	/*	/*
	Replacement memory allocation handling etc.	Replacement memory allocation handling etc.

	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 35	skipping to change at line 35
	#ifdef WIN32	#ifdef WIN32
	#include <stdlib.h>	#include <stdlib.h>
	#else	#else
	#include <sys/types.h>	#include <sys/types.h>
	#endif	#endif

	#include "ne_defs.h"	#include "ne_defs.h"

	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS


		typedef void (*ne_oom_callback_fn)(void);

	/* Set callback which is called if malloc() returns NULL. */	/* Set callback which is called if malloc() returns NULL. */

	void ne_oom_callback(void (*callback)(void));	void ne_oom_callback(ne_oom_callback_fn callback);

	#ifndef NEON_MEMLEAK	#ifndef NEON_MEMLEAK
	/* Replacements for standard C library memory allocation functions,	/* Replacements for standard C library memory allocation functions,
	* which never return NULL. If the C library malloc() returns NULL,	* which never return NULL. If the C library malloc() returns NULL,
	* neon will abort(); calling an OOM callback beforehand if one is	* neon will abort(); calling an OOM callback beforehand if one is
	* registered. The C library will only ever return NULL if the	* registered. The C library will only ever return NULL if the
	* operating system does not use optimistic memory allocation. */	* operating system does not use optimistic memory allocation. */

	void *ne_malloc(size_t size);	void *ne_malloc(size_t size) ne_attribute_malloc;
	void *ne_calloc(size_t size);	void *ne_calloc(size_t size) ne_attribute_malloc;
	void ne_realloc(void ptr, size_t s);	void ne_realloc(void ptr, size_t s) ne_attribute_malloc;
	char ne_strdup(const char s);	char ne_strdup(const char s) ne_attribute_malloc;
	char ne_strndup(const char s, size_t n);	char ne_strndup(const char s, size_t n) ne_attribute_malloc;
	#define ne_free free	#define ne_free free
	#endif	#endif

	/* Handy macro to free things: takes an lvalue, and sets to NULL	/* Handy macro to free things: takes an lvalue, and sets to NULL
	* afterwards. */	* afterwards. */
	#define NE_FREE(x) do { if ((x) != NULL) ne_free((x)); (x) = NULL; } while (0)	#define NE_FREE(x) do { if ((x) != NULL) ne_free((x)); (x) = NULL; } while (0)

	END_NEON_DECLS	END_NEON_DECLS

	#endif /* NE_ALLOC_H */	#endif /* NE_ALLOC_H */

End of changes. 4 change blocks.
	7 lines changed or deleted	9 lines changed or added

	ne_basic.h	ne_basic.h
	/*	/*
	HTTP/1.1 methods	HTTP/1.1 methods

	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 39	skipping to change at line 39
	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS

	/* Perform a GET request on resource at 'path', writing the entity	/* Perform a GET request on resource at 'path', writing the entity
	* body which is returned to 'fd'. */	* body which is returned to 'fd'. */
	int ne_get(ne_session sess, const char path, int fd);	int ne_get(ne_session sess, const char path, int fd);

	/* Perform a PUT request on resource at 'path', reading the entity	/* Perform a PUT request on resource at 'path', reading the entity
	* body to submit from 'fd'. */	* body to submit from 'fd'. */
	int ne_put(ne_session sess, const char path, int fd);	int ne_put(ne_session sess, const char path, int fd);


	#ifndef NEON_NODAV

	#define NE_DEPTH_ZERO (0)	#define NE_DEPTH_ZERO (0)
	#define NE_DEPTH_ONE (1)	#define NE_DEPTH_ONE (1)
	#define NE_DEPTH_INFINITE (2)	#define NE_DEPTH_INFINITE (2)

	/* For ne_copy and ne_move:	/* For ne_copy and ne_move:
	*	*
	* If a resource exists at "dest" and overwrite is zero, the operation	* If a resource exists at "dest" and overwrite is zero, the operation
	* will fail; if overwrite is non-zero, any existing resource will	* will fail; if overwrite is non-zero, any existing resource will
	* be over-written.	* be over-written.
	*/	*/

	skipping to change at line 72	skipping to change at line 70
	const char src, const char dest);	const char src, const char dest);

	/* Delete resource at 'path'. */	/* Delete resource at 'path'. */
	int ne_delete(ne_session sess, const char path);	int ne_delete(ne_session sess, const char path);
	/* Create a collection at 'path', which MUST have a trailing slash. */	/* Create a collection at 'path', which MUST have a trailing slash. */
	int ne_mkcol(ne_session sess, const char path);	int ne_mkcol(ne_session sess, const char path);

	/* Adds a Depth: header to a request */	/* Adds a Depth: header to a request */
	void ne_add_depth_header(ne_request *req, int depth);	void ne_add_depth_header(ne_request *req, int depth);


	#endif /* NEON_NODAV */

	/* PUT resource at location 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.
	*/
	int ne_put_if_unmodified(ne_session *sess,
	const char *path, int fd, time_t modtime);

	/* Retrieve modification time of resource at location 'path', place in	/* Retrieve modification time of resource at location 'path', place in
	* modtime. (uses HEAD) /	* modtime. (uses HEAD) /
	int ne_getmodtime(ne_session sess, const char path, time_t *modtime);	int ne_getmodtime(ne_session sess, const char path, time_t *modtime);

	typedef struct {	typedef struct {
	const char type, subtype;	const char type, subtype;
	const char *charset;	const char *charset;
	char *value;	char *value;
	} ne_content_type;	} ne_content_type;


	/* Sets (*ne_content_type)userdata appropriately.	/* Retrieve the content-type of the response; returns zero if response
	* Caller must free ->value after use */	* had valid content-type, in which case all fields in *ctype are set
	void ne_content_type_handler(void userdata, const char value);	* (and never NULL); the caller must free(ctype->value) after use.
		* Returns non-zero on error, in which case ctype is not altered. /
		int ne_get_content_type(ne_request req, ne_content_type ctype);

	/* Server capabilities: */	/* Server capabilities: */
	typedef struct {	typedef struct {
	unsigned int dav_class1; /* True if Class 1 WebDAV server */	unsigned int dav_class1; /* True if Class 1 WebDAV server */
	unsigned int dav_class2; /* True if Class 2 WebDAV server */	unsigned int dav_class2; /* True if Class 2 WebDAV server */
	unsigned int dav_executable; /* True if supports the 'executable'	unsigned int dav_executable; /* True if supports the 'executable'
	* property a. la. mod_dav */	* property a. la. mod_dav */
	} ne_server_capabilities;	} ne_server_capabilities;

	/* Determines server capabilities (using OPTIONS). Pass 'path' as "*"	/* Determines server capabilities (using OPTIONS). Pass 'path' as "*"

End of changes. 4 change blocks.
	17 lines changed or deleted	6 lines changed or added

	ne_defs.h	ne_defs.h
	/*	/*
	Standard definitions for neon headers	Standard definitions for neon headers

	Copyright (C) 2003, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 2003-2004, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 38	skipping to change at line 38
	# define BEGIN_NEON_DECLS /* empty */	# define BEGIN_NEON_DECLS /* empty */
	# define END_NEON_DECLS /* empty */	# define END_NEON_DECLS /* empty */
	#endif	#endif

	/* define ssize_t for Win32 */	/* define ssize_t for Win32 */
	#if defined(WIN32) && !defined(ssize_t)	#if defined(WIN32) && !defined(ssize_t)
	#define ssize_t int	#define ssize_t int
	#endif	#endif

	#ifdef __GNUC__	#ifdef __GNUC__

		#if __GNUC__ >= 3
		#define ne_attribute_malloc __attribute__((malloc))
		#else
		#define ne_attribute_malloc
		#endif
	#define ne_attribute(x) __attribute__(x)	#define ne_attribute(x) __attribute__(x)
	#else	#else
	#define ne_attribute(x)	#define ne_attribute(x)

		#define ne_attribute_malloc
	#endif	#endif

End of changes. 3 change blocks.
	1 lines changed or deleted	7 lines changed or added

	ne_request.h	ne_request.h
	/*	/*
	HTTP Request Handling	HTTP Request Handling

	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 42	skipping to change at line 42
	#define NE_ERROR (1) /* Generic error; use ne_get_error(session) for messag e */	#define NE_ERROR (1) /* Generic error; use ne_get_error(session) for messag e */
	#define NE_LOOKUP (2) /* Server or proxy hostname lookup failed */	#define NE_LOOKUP (2) /* Server or proxy hostname lookup failed */
	#define NE_AUTH (3) /* User authentication failed on server */	#define NE_AUTH (3) /* User authentication failed on server */
	#define NE_PROXYAUTH (4) /* User authentication failed on proxy */	#define NE_PROXYAUTH (4) /* User authentication failed on proxy */
	#define NE_CONNECT (5) /* Could not connect to server */	#define NE_CONNECT (5) /* Could not connect to server */
	#define NE_TIMEOUT (6) /* Connection timed out */	#define NE_TIMEOUT (6) /* Connection timed out */
	#define NE_FAILED (7) /* The precondition failed */	#define NE_FAILED (7) /* The precondition failed */
	#define NE_RETRY (8) /* Retry request (ne_end_request ONLY) */	#define NE_RETRY (8) /* Retry request (ne_end_request ONLY) */
	#define NE_REDIRECT (9) /* See ne_redirect.h */	#define NE_REDIRECT (9) /* See ne_redirect.h */


	/* FIXME: remove this */
	#define EOL "\r\n"

	/* Opaque object representing a single HTTP request. */	/* Opaque object representing a single HTTP request. */
	typedef struct ne_request_s ne_request;	typedef struct ne_request_s ne_request;

	/*** Request Handling ***/	/*** Request Handling ***/

	/* Create a request in session 'sess', with given method and path.	/* Create a request in session 'sess', with given method and path.
	* 'path' must conform to the 'abs_path' grammar in RFC2396, with an	* 'path' must conform to the 'abs_path' grammar in RFC2396, with an
	* optional "? query" part, and MUST be URI-escaped by the caller. */	* optional "? query" part, and MUST be URI-escaped by the caller. */
	ne_request ne_request_create(ne_session sess,	ne_request ne_request_create(ne_session sess,
	const char method, const char path);	const char method, const char path);


	/* 'buffer' will be sent as the request body with given request. */	/* The request body will be taken from 'size' bytes of 'buffer'. */
	void ne_set_request_body_buffer(ne_request req, const char buffer,	void ne_set_request_body_buffer(ne_request req, const char buffer,
	size_t size);	size_t size);


	/* Send the contents of a file as the request body; 'fd' must be a	/* The request body will be taken from 'length' bytes read from the
	* file descriptor of an open, seekable file. Current file offset of	* file descriptor 'fd', starting from file offset 'offset'. */
	* fd is not retained (and ignored: the file is read from the the	void ne_set_request_body_fd(ne_request *req, int fd,
	* first byte). Returns:	off_t offset, off_t length);
	* 0 on okay.
	* non-zero if could not determine length of file. */	#ifdef NE_LFS
	int ne_set_request_body_fd(ne_request *req, int fd);	/* Alternate version of ne_set_request_body_fd taking off64_t
		* offset type for systems supporting _LARGEFILE64_SOURCE. */
		void ne_set_request_body_fd64(ne_request *req, int fd,
		off64_t offset, off64_t length);
		#endif

	/* "Pull"-based request body provider: a callback which is invoked to	/* "Pull"-based request body provider: a callback which is invoked to
	* provide blocks of request body on demand.	* provide blocks of request body on demand.
	*	*
	* Before each time the body is provided, the callback will be called	* 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	* once with buflen == 0. The body may have to be provided >1 time
	* per request (for authentication retries etc.).	* per request (for authentication retries etc.).
	*	*

	* The callback must return:	* For a call with buflen == 0, the callback must return zero on success
	* <0 : error, abort request.	* or non-zero on error; the session error string must be set on error.
		* For a call with buflen > 0, the callback must return:
		* <0 : error, abort request; session error string must be
		set.
	* 0 : ignore 'buffer' contents, end of body.	* 0 : ignore 'buffer' contents, end of body.
	* 0 < x <= buflen : buffer contains x bytes of body data. */	* 0 < x <= buflen : buffer contains x bytes of body data. */
	typedef ssize_t (ne_provide_body)(void userdata,	typedef ssize_t (ne_provide_body)(void userdata,
	char *buffer, size_t buflen);	char *buffer, size_t buflen);


	/* Install a callback which is invoked as needed to provide request	/* Install a callback which is invoked as needed to provide the
	* body blocks. Total request body is 'size' bytes: the callback MUST	* request body, a block at a time. The total size of the request
	* ensure it returns in total exactly 'size' bytes each time the	* body is 'length'; the callback must ensure that it returns no more
	* request body is provided. */	* than 'length' bytes in total. */
	void ne_set_request_body_provider(ne_request *req, size_t size,	void ne_set_request_body_provider(ne_request *req, off_t length,
	ne_provide_body provider, void *userdata);	ne_provide_body provider, void *userdata);


	/* Handling response bodies... you provide TWO callbacks:	#ifdef NE_LFS
		/* Duplicate version of ne_set_request_body_provider, taking an off64_t
		* offset. */
		void ne_set_request_body_provider64(ne_request *req, off64_t length,
		ne_provide_body provider, void *userdat
		a);
		#endif

		/* Handling response bodies; two callbacks must be provided:
	*	*
	* 1) 'acceptance' callback: determines whether you want to handle the	* 1) 'acceptance' callback: determines whether you want to handle the
	* response body given the response-status information, e.g., if you	* response body given the response-status information, e.g., if you
	* only want 2xx responses, say so here.	* only want 2xx responses, say so here.
	*	*
	* 2) 'reader' callback: passed blocks of the response-body as they	* 2) 'reader' callback: passed blocks of the response-body as they
	* arrive, if the acceptance callback returned non-zero. */	* arrive, if the acceptance callback returned non-zero. */

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

	typedef int (*ne_accept_response)(	typedef int (ne_accept_response)(void userdata, ne_request *req,
	void userdata, ne_request req, const ne_status *st);	const ne_status *st);

	/* An 'acceptance' callback which only accepts 2xx-class responses.	/* An 'acceptance' callback which only accepts 2xx-class responses.
	* Ignores userdata. */	* Ignores userdata. */
	int ne_accept_2xx(void userdata, ne_request req, const ne_status *st);	int ne_accept_2xx(void userdata, ne_request req, const ne_status *st);

	/* An acceptance callback which accepts all responses. Ignores	/* An acceptance callback which accepts all responses. Ignores
	* userdata. */	* userdata. */
	int ne_accept_always(void userdata, ne_request req, const ne_status *st);	int ne_accept_always(void userdata, ne_request req, const ne_status *st);


	/* Callback for reading a block of data. */	/* Callback for reading a block of data. Returns zero on success, or
	typedef void (ne_block_reader)(void userdata, const char *buf, size_t len	* non-zero on error. If returning an error, the response will be
	);	* aborted and the callback will not be invoked again. The request
		* dispatch (or ne_read_response_block call) will fail with NE_ERROR;
		* the session error string should have been set by the callback. */
		typedef int (ne_block_reader)(void userdata, const char *buf, size_t len)
		;

	/* Add a response reader for the given request, with the given	/* Add a response reader for the given request, with the given
	* acceptance function. userdata is passed as the first argument to	* acceptance function. userdata is passed as the first argument to
	* the acceptance + reader callbacks.	* the acceptance + reader callbacks.
	*	*
	* The acceptance callback is called once each time the request is	* The acceptance callback is called once each time the request is
	* sent: it may be sent >1 time because of authentication retries etc.	* sent: it may be sent >1 time because of authentication retries etc.
	* For each time the acceptance callback is called, if it returns	* For each time the acceptance callback is called, if it returns
	* non-zero, blocks of the response body will be passed to the reader	* 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	* callback as the response is read. After all the response body has
	* been read, the callback will be called with a 'len' argument of	* been read, the callback will be called with a 'len' argument of
	* zero. */	* zero. */
	void ne_add_response_body_reader(ne_request *req, ne_accept_response accpt,	void ne_add_response_body_reader(ne_request *req, ne_accept_response accpt,
	ne_block_reader reader, void *userdata);	ne_block_reader reader, void *userdata);


	/* Handle response headers. Each handler is associated with a specific	/* Retrieve the value of the response header field with given name;
	* header field (indicated by name). The handler is then passed the	* returns NULL if no response header with given name was found. The
	* value of this header field. */	* return value is valid only until the next call to either
		* ne_request_create or ne_begin_request for this request. */
	/* The header handler callback type */	const char ne_get_response_header(ne_request req, const char *name);
	typedef void (ne_header_handler)(void userdata, const char *value);

	/* 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").
	*/
	void ne_add_response_header_handler(ne_request req, const char name,
	ne_header_handler hdl, void *userdata);

	/* Add handler which is passed ALL header values regardless of name */
	void ne_add_response_header_catcher(ne_request *req,
	ne_header_handler hdl, void *userdata);


	/* Stock header handlers:	/* Iterator interface for response headers: if passed a NULL cursor,
	* 'duplicate': (char *)userdata = strdup(value)	* returns the first header; if passed a non-NULL cursor pointer,
	* 'numeric': (int )userdata = atoi(value)	* returns the next header. The return value is a cursor pointer: if
	* e.g.	* it is non-NULL, name and value are set to the name and value of
	* int mynum;	* the header field. If the return value is NULL, no more headers are
	* ne_add_response_header_handler(myreq, "Content-Length",	* found, name and value are undefined.
	* ne_handle_numeric_handler, &mynum);	*
	* ... arranges mynum to be set to the value of the Content-Length header.	* The order in which response headers is returned is undefined. Both
	*/	* the cursor and name/value pointers are valid only until the next
	void ne_duplicate_header(void userdata, const char value);	* call to either ne_request_destroy or ne_begin_request for this
	void ne_handle_numeric_header(void userdata, const char value);	* request. */
		void ne_response_header_iterate(ne_request req, void *cursor,
		const char name, const char value);

	/* Adds a header to the request with given name and value. */	/* Adds a header to the request with given name and value. */
	void ne_add_request_header(ne_request req, const char name,	void ne_add_request_header(ne_request req, const char name,
	const char *value);	const char *value);
	/* Adds a header to the request with given name, using printf-like	/* Adds a header to the request with given name, using printf-like
	* format arguments for the value. */	* format arguments for the value. */
	void ne_print_request_header(ne_request req, const char name,	void ne_print_request_header(ne_request req, const char name,
	const char *format, ...)	const char *format, ...)
	ne_attribute((format(printf, 3, 4)));	ne_attribute((format(printf, 3, 4)));

	/* ne_request_dispatch: Sends the given request, and reads the	/* ne_request_dispatch: Sends the given request, and reads the

	* response. Response-Status information can be retrieve with	* response. Returns:
	* ne_get_status(req).	* - NE_OK if the request was sent and response read successfully
	*	* - NE_AUTH, NE_PROXYAUTH for a server or proxy server authentication err
	* NE_OK if request sent + response read okay.	or
	* NE_AUTH user not authorised on server	* - NE_CONNECT if connection could not be established
	* NE_PROXYAUTH user not authorised on proxy server	* - NE_TIMEOUT if an timeout occurred sending or reading from the server
	* NE_CONNECT could not connect to server/proxy server	* - NE_ERROR for other fatal dispatch errors
	* NE_TIMEOUT connection timed out mid-request	* On any error, the session error string is set. On success or
	* NE_ERROR for other errors, and ne_get_error() should	* authentication error, the actual response-status can be retrieved using
	* return a meaningful error string	* ne_get_status(). */
	*/
	int ne_request_dispatch(ne_request *req);	int ne_request_dispatch(ne_request *req);

	/* Returns a pointer to the response status information for the given	/* Returns a pointer to the response status information for the given
	* request; pointer is valid until request object is destroyed. */	* request; pointer is valid until request object is destroyed. */
	const ne_status ne_get_status(const ne_request req) ne_attribute((const)) ;	const ne_status ne_get_status(const ne_request req) ne_attribute((const)) ;

	/* Returns pointer to session associated with request. */	/* Returns pointer to session associated with request. */

	ne_session ne_get_session(const ne_request req);	ne_session ne_get_session(const ne_request req) ne_attribute((const));

	/* Destroy memory associated with request pointer */	/* Destroy memory associated with request pointer */
	void ne_request_destroy(ne_request *req);	void ne_request_destroy(ne_request *req);

	/* "Caller-pulls" request interface. This is an ALTERNATIVE interface	/* "Caller-pulls" request interface. This is an ALTERNATIVE interface
	* to ne_request_dispatch: either use that, or do all this yourself:	* to ne_request_dispatch: either use that, or do all this yourself:
	*	*
	* caller must call:	* caller must call:
	* 1. ne_begin_request (fail if returns non-NE_OK)	* 1. ne_begin_request (fail if returns non-NE_OK)
	* 2. while(ne_read_response_block(...) > 0) ... loop ...;	* 2. while(ne_read_response_block(...) > 0) ... loop ...;
	* (fail if ne_read_response_block returns <0)	* (fail if ne_read_response_block returns <0)
	* 3. ne_end_request	* 3. ne_end_request
	*	*
	* ne_end_request and ne_begin_request both return an NE_* code; if	* ne_end_request and ne_begin_request both return an NE_* code; if
	* ne_end_request returns NE_RETRY, you must restart the loop from (1)	* ne_end_request returns NE_RETRY, you must restart the loop from (1)
	* above. */	* above. */
	int ne_begin_request(ne_request *req);	int ne_begin_request(ne_request *req);
	int ne_end_request(ne_request *req);	int ne_end_request(ne_request *req);


	/* Read a block of the response. buffer must be at least 128 bytes.	/* Read a block of the response into the passed buffer of size 'buflen'.
	* 'buflen' must be length of buffer.
	*	*
	* Returns:	* Returns:
	* <0 - error, stop reading.	* <0 - error, stop reading.
	* 0 - end of response	* 0 - end of response
	* >0 - number of bytes read into buffer.	* >0 - number of bytes read into buffer.
	*/	*/
	ssize_t ne_read_response_block(ne_request req, char buffer, size_t buflen );	ssize_t ne_read_response_block(ne_request req, char buffer, size_t buflen );


		/* Read response blocks until end of response; exactly equivalent to
		* calling ne_read_response_block() until it returns 0. Returns
		* non-zero on error. */
		int ne_discard_response(ne_request *req);

		/* Read response blocks until end of response, writing content to the
		* given file descriptor. Returns NE_ERROR on error. */
		int ne_read_response_to_fd(ne_request *req, int fd);

		/* If 'flag' is non-zer, enable the HTTP/1.1 "Expect: 100-continue"
		* feature for the request, which allows the server to send an error
		* response before the request body is sent. This should only be used
		* if the server is known to support the feature (not all HTTP/1.1
		* servers do); the request will time out and fail otherwise. */
		void ne_set_request_expect100(ne_request *req, int flag);

	/** Request hooks handling ***/	/** Request hooks handling ***/

	typedef void (ne_free_hooks)(void cookie);	typedef void (ne_free_hooks)(void cookie);

	/* Hook called when a create is created; passed the request method,	/* Hook called when a create is created; passed the request method,
	* and the string used as the Request-URI (which may be an abs_path,	* and the string used as the Request-URI (which may be an abs_path,
	* or an absoluteURI, depending on whether an HTTP proxy is in	* or an absoluteURI, depending on whether an HTTP proxy is in
	* use). */	* use). */
	typedef void (ne_create_request_fn)(ne_request req, void *userdata,	typedef void (ne_create_request_fn)(ne_request req, void *userdata,
	const char method, const char requri) ;	const char method, const char requri) ;

End of changes. 15 change blocks.
	67 lines changed or deleted	87 lines changed or added

	ne_session.h	ne_session.h
	/*	/*
	HTTP session handling	HTTP session handling

	Copyright (C) 1999-2003, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 30	skipping to change at line 30
	*/	*/

	#ifndef NE_SESSION_H	#ifndef NE_SESSION_H
	#define NE_SESSION_H 1	#define NE_SESSION_H 1

	#include <sys/types.h>	#include <sys/types.h>

	#include "ne_ssl.h"	#include "ne_ssl.h"
	#include "ne_uri.h" /* for ne_uri */	#include "ne_uri.h" /* for ne_uri */
	#include "ne_defs.h"	#include "ne_defs.h"

		#include "ne_socket.h"

	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS

	typedef struct ne_session_s ne_session;	typedef struct ne_session_s ne_session;

	/* Create a session to the given server, using the given scheme. If	/* Create a session to the given server, using the given scheme. If
	* "https" is passed as the scheme, SSL will be used to connect to the	* "https" is passed as the scheme, SSL will be used to connect to the
	* server. */	* server. */
	ne_session ne_session_create(const char scheme,	ne_session ne_session_create(const char scheme,
	const char *hostname, unsigned int port);	const char *hostname, unsigned int port);

	skipping to change at line 52	skipping to change at line 53
	void ne_session_destroy(ne_session *sess);	void ne_session_destroy(ne_session *sess);

	/* Prematurely force the connection to be closed for the given	/* Prematurely force the connection to be closed for the given
	* session. */	* session. */
	void ne_close_connection(ne_session *sess);	void ne_close_connection(ne_session *sess);

	/* Set the proxy server to be used for the session. */	/* Set the proxy server to be used for the session. */
	void ne_session_proxy(ne_session *sess,	void ne_session_proxy(ne_session *sess,
	const char *hostname, unsigned int port);	const char *hostname, unsigned int port);


	/* Set protocol options for session:	/* Disable use of persistent connection if 'flag' is non-zero, else
	* expect100: Defaults to OFF	* enable (the default). */
	* persist: Defaults to ON	void ne_set_persist(ne_session *sess, int flag);
	*
	* expect100: When set, send the "Expect: 100-continue" request header	/* Bypass the normal name resolution; force the use of specific set of
	* with requests with bodies.	* addresses for this session, addrs[0]...addrs[n-1]. The addrs array
	*	* must remain valid until the session is destroyed. */
	* persist: When set, use a persistent connection. (Generally,	void ne_set_addrlist(ne_session sess, const ne_inet_addr *addrs, size_t n
	* you don't want to turn this off.)	);
	* */
	void ne_set_expect100(ne_session *sess, int use_expect100);
	void ne_set_persist(ne_session *sess, int persist);

	/* Progress callback. */	/* Progress callback. */
	typedef void (ne_progress)(void userdata, off_t progress, off_t total);	typedef void (ne_progress)(void userdata, off_t progress, off_t total);

	/* Set a progress callback for the session. */	/* Set a progress callback for the session. */
	void ne_set_progress(ne_session *sess,	void ne_set_progress(ne_session *sess,
	ne_progress progress, void *userdata);	ne_progress progress, void *userdata);

	/* Store an opaque context for the session, 'priv' is returned by a	/* Store an opaque context for the session, 'priv' is returned by a
	* call to ne_session_get_private with the same ID. */	* call to ne_session_get_private with the same ID. */

End of changes. 3 change blocks.
	13 lines changed or deleted	11 lines changed or added

	ne_socket.h	ne_socket.h
	/*	/*
	socket handling interface	socket handling interface

	Copyright (C) 1999-2003, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 39	skipping to change at line 39

	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS

	#define NE_SOCK_ERROR (-1)	#define NE_SOCK_ERROR (-1)
	/* Read/Write timed out */	/* Read/Write timed out */
	#define NE_SOCK_TIMEOUT (-2)	#define NE_SOCK_TIMEOUT (-2)
	/* Socket was closed */	/* Socket was closed */
	#define NE_SOCK_CLOSED (-3)	#define NE_SOCK_CLOSED (-3)
	/* Connection was reset (e.g. server crashed) */	/* Connection was reset (e.g. server crashed) */
	#define NE_SOCK_RESET (-4)	#define NE_SOCK_RESET (-4)

	/* Secure connection was subject to possible truncation attack. */	/* Secure connection was closed without proper SSL shutdown. */
	#define NE_SOCK_TRUNC (-5)	#define NE_SOCK_TRUNC (-5)

	/* ne_socket represents a TCP socket. */	/* ne_socket represents a TCP socket. */
	typedef struct ne_socket_s ne_socket;	typedef struct ne_socket_s ne_socket;

	/* ne_sock_addr represents an address object. */	/* ne_sock_addr represents an address object. */
	typedef struct ne_sock_addr_s ne_sock_addr;	typedef struct ne_sock_addr_s ne_sock_addr;

	#ifndef NE_INET_ADDR_DEFINED	#ifndef NE_INET_ADDR_DEFINED
	typedef struct ne_inet_addr_s ne_inet_addr;	typedef struct ne_inet_addr_s ne_inet_addr;
	#endif	#endif

	/* While neon itself doesn't require per-process global	/* While neon itself doesn't require per-process global
	* initialization, some platforms do, and so does the OpenSSL	* initialization, some platforms do, and so does the OpenSSL
	* library. */	* library. */
	int ne_sock_init(void);	int ne_sock_init(void);

	/* Shutdown any underlying libraries. */	/* Shutdown any underlying libraries. */
	void ne_sock_exit(void);	void ne_sock_exit(void);


	/* Resolve the given hostname. 'flags' are currently ignored. Hex	/* Resolve the given hostname. 'flags' must be zero. Hex
	* string IPv6 addresses (e.g. `::1') may be enclosed in brackets	* string IPv6 addresses (e.g. `::1') may be enclosed in brackets
	* (e.g. `[::1]'). */	* (e.g. `[::1]'). */
	ne_sock_addr ne_addr_resolve(const char hostname, int flags);	ne_sock_addr ne_addr_resolve(const char hostname, int flags);

	/* Returns zero if name resolution was successful, non-zero on	/* Returns zero if name resolution was successful, non-zero on
	* error. */	* error. */
	int ne_addr_result(const ne_sock_addr *addr);	int ne_addr_result(const ne_sock_addr *addr);

	/* Returns the first network address associated with the 'addr'	/* Returns the first network address associated with the 'addr'
	* object. Undefined behaviour if ne_addr_result returns non-zero for	* object. Undefined behaviour if ne_addr_result returns non-zero for

	skipping to change at line 105	skipping to change at line 105
	/* Create a network address from raw byte representation (in network	/* Create a network address from raw byte representation (in network
	* byte order) of given type. 'raw' must be four bytes for an IPv4	* byte order) of given type. 'raw' must be four bytes for an IPv4
	* address, 16 bytes for an IPv6 address. May return NULL if address	* address, 16 bytes for an IPv6 address. May return NULL if address
	* type is not supported. */	* type is not supported. */
	ne_inet_addr ne_iaddr_make(ne_iaddr_type type, const unsigned char raw);	ne_inet_addr ne_iaddr_make(ne_iaddr_type type, const unsigned char raw);

	/* Compare two network addresses i1 and i2; return non-zero if they	/* Compare two network addresses i1 and i2; return non-zero if they
	* are not equal. */	* are not equal. */
	int ne_iaddr_cmp(const ne_inet_addr i1, const ne_inet_addr i2);	int ne_iaddr_cmp(const ne_inet_addr i1, const ne_inet_addr i2);


		/* Returns the type of the given network address. */
		ne_iaddr_type ne_iaddr_typeof(const ne_inet_addr *ia);

	/* Prints the string representation of network address 'ia' into the	/* Prints the string representation of network address 'ia' into the
	* 'buffer', which is of size 'bufsiz'. Returns 'buffer'. */	* 'buffer', which is of size 'bufsiz'. Returns 'buffer'. */
	char ne_iaddr_print(const ne_inet_addr ia, char *buffer, size_t bufsiz);	char ne_iaddr_print(const ne_inet_addr ia, char *buffer, size_t bufsiz);

	/* Free a network address created using ne_iaddr_make. */	/* Free a network address created using ne_iaddr_make. */
	void ne_iaddr_free(ne_inet_addr *addr);	void ne_iaddr_free(ne_inet_addr *addr);

	/* Create a TCP socket; returns NULL on error. */	/* Create a TCP socket; returns NULL on error. */
	ne_socket *ne_sock_create(void);	ne_socket *ne_sock_create(void);


	skipping to change at line 156	skipping to change at line 159
	int ne_sock_fullwrite(ne_socket sock, const char data, size_t count);	int ne_sock_fullwrite(ne_socket sock, const char data, size_t count);

	/* Reads an LF-terminated line into 'buffer', and NUL-terminate it.	/* Reads an LF-terminated line into 'buffer', and NUL-terminate it.
	* At most 'len' bytes are read (including the NUL terminator).	* At most 'len' bytes are read (including the NUL terminator).
	* Returns:	* Returns:
	* NE_SOCK_* on error,	* NE_SOCK_* on error,
	* >0 number of bytes read (including NUL terminator)	* >0 number of bytes read (including NUL terminator)
	*/	*/
	ssize_t ne_sock_readline(ne_socket sock, char buffer, size_t len);	ssize_t ne_sock_readline(ne_socket sock, char buffer, size_t len);


	/* Read exactly 'len' bytes into buffer; returns 0 on success, SOCK_*	/* Read exactly 'len' bytes into buffer; returns 0 on success,
	* on error. */	* NE_SOCK_* on error. */
	ssize_t ne_sock_fullread(ne_socket sock, char buffer, size_t len);	ssize_t ne_sock_fullread(ne_socket sock, char buffer, size_t len);

	/* Accept a connection on listening socket 'fd'. */	/* Accept a connection on listening socket 'fd'. */
	int ne_sock_accept(ne_socket *sock, int fd);	int ne_sock_accept(ne_socket *sock, int fd);

	/* Returns the file descriptor used for socket 'sock'. */	/* Returns the file descriptor used for socket 'sock'. */
	int ne_sock_fd(const ne_socket *sock);	int ne_sock_fd(const ne_socket *sock);

	/* Close the socket, and destroy the socket object. Returns non-zero	/* Close the socket, and destroy the socket object. Returns non-zero
	* on error. */	* on error. */
	int ne_sock_close(ne_socket *sock);	int ne_sock_close(ne_socket *sock);

	/* Return current error string for socket. */	/* Return current error string for socket. */
	const char ne_sock_error(const ne_socket sock);	const char ne_sock_error(const ne_socket sock);

	/* Set read timeout for socket. */	/* Set read timeout for socket. */
	void ne_sock_read_timeout(ne_socket *sock, int timeout);	void ne_sock_read_timeout(ne_socket *sock, int timeout);


	/* Returns the standard TCP port for the given service, or zero if	/* Negotiate an SSL connection on socket as an SSL server, using given
	* none is known. */	* SSL context. */
	int ne_service_lookup(const char *name);	int ne_sock_accept_ssl(ne_socket sock, ne_ssl_context ctx);

	/* Enable SSL with an already-negotiated SSL socket. */
	void ne_sock_switch_ssl(ne_socket sock, void ssl);

	/* Perform an SSL negotiation on 'sock', using given context. */
	int ne_sock_connect_ssl(ne_socket sock, ne_ssl_context ctx);


	/* Return SSL socket object in use for 'sock'. */	/* Negotiate an SSL connection on socket as an SSL client, using given
	typedef struct ne_ssl_socket_s ne_ssl_socket;	* SSL context. The 'userdata' parameter is associated with the
	ne_ssl_socket ne_sock_sslsock(ne_socket sock);	* underlying SSL library's socket structure for use in callbacks.
		* Returns zero on success, or non-zero on error. */
		int ne_sock_connect_ssl(ne_socket sock, ne_ssl_context ctx,
		void *userdata);

	END_NEON_DECLS	END_NEON_DECLS

	#endif /* NE_SOCKET_H */	#endif /* NE_SOCKET_H */

End of changes. 7 change blocks.
	17 lines changed or deleted	17 lines changed or added

	ne_string.h	ne_string.h
	/*	/*
	String utility functions	String utility functions

	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 60	skipping to change at line 60

	/* A base64 encoder: converts 'len' bytes of 'text' to base64.	/* A base64 encoder: converts 'len' bytes of 'text' to base64.
	* Returns malloc-allocated buffer; caller must free(). */	* Returns malloc-allocated buffer; caller must free(). */
	char ne_base64(const unsigned char text, size_t len);	char ne_base64(const unsigned char text, size_t len);

	/* Base64 decoder; decodes NUL-terminated base64-encoded string	/* Base64 decoder; decodes NUL-terminated base64-encoded string
	* 'data', places malloc-allocated raw data in '*out', returns length,	* 'data', places malloc-allocated raw data in '*out', returns length,
	* or zero on decode error (in which case out is undefined). /	* or zero on decode error (in which case out is undefined). /
	size_t ne_unbase64(const char data, unsigned char *out);	size_t ne_unbase64(const char data, unsigned char *out);


	/* OBSOLETE INTERFACES */
	char *split_string(const char str, const char seperator,
	const char quotes, const char whitespace);
	char *split_string_c(const char str, const char seperator,
	const char quotes, const char whitespace, int *count
	);
	char *pair_string(const char str, const char compsep, const char kvsep,
	const char quotes, const char whitespace);
	void split_string_free(char **components);
	void pair_string_free(char **pairs);
	/*** END OF OBSOLETE INTERFACES */

	/* String buffer handling. (Strings are zero-terminated still). A	/* String buffer handling. (Strings are zero-terminated still). A
	* string buffer ne_buffer * which grows dynamically with the	* string buffer ne_buffer * which grows dynamically with the
	* string. */	* string. */

	typedef struct {	typedef struct {
	char data; / contents: null-terminated string. */	char data; / contents: null-terminated string. */
	size_t used; /* used bytes in buffer */	size_t used; /* used bytes in buffer */
	size_t length; /* length of buffer */	size_t length; /* length of buffer */
	} ne_buffer;	} ne_buffer;


	skipping to change at line 106	skipping to change at line 95
	void ne_buffer_destroy(ne_buffer *buf);	void ne_buffer_destroy(ne_buffer *buf);

	/* Append a NUL-terminated string 'str' to buf. */	/* Append a NUL-terminated string 'str' to buf. */
	void ne_buffer_zappend(ne_buffer buf, const char str);	void ne_buffer_zappend(ne_buffer buf, const char str);

	/* Append 'len' bytes of 'data' to buf. 'data' does not need to be	/* Append 'len' bytes of 'data' to buf. 'data' does not need to be
	* NUL-terminated. The resultant string will have a NUL-terminator,	* NUL-terminated. The resultant string will have a NUL-terminator,
	* either way. */	* either way. */
	void ne_buffer_append(ne_buffer buf, const char data, size_t len);	void ne_buffer_append(ne_buffer buf, const char data, size_t len);


		/* Append a literal constant string 'str' to buffer 'buf'. */
		#define ne_buffer_czappend(buf, str) \
		ne_buffer_append((buf), (str), sizeof((str)) - 1)

	/* Empties the contents of buf; makes the buffer zero-length. */	/* Empties the contents of buf; makes the buffer zero-length. */
	void ne_buffer_clear(ne_buffer *buf);	void ne_buffer_clear(ne_buffer *buf);

	/* Grows the ne_buffer to a minimum size. */	/* Grows the ne_buffer to a minimum size. */
	void ne_buffer_grow(ne_buffer *buf, size_t size);	void ne_buffer_grow(ne_buffer *buf, size_t size);

	void ne_buffer_altered(ne_buffer *buf);	void ne_buffer_altered(ne_buffer *buf);

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

	skipping to change at line 135	skipping to change at line 128
	#define ne_strnzcpy(dest, src, n) do { \	#define ne_strnzcpy(dest, src, n) do { \
	strncpy(dest, src, n-1); dest[n-1] = '\0'; } while (0)	strncpy(dest, src, n-1); dest[n-1] = '\0'; } while (0)

	/* Return malloc-allocated concatenation of all NUL-terminated string	/* Return malloc-allocated concatenation of all NUL-terminated string
	* arguments, up to a terminating NULL. */	* arguments, up to a terminating NULL. */
	char ne_concat(const char str, ...);	char ne_concat(const char str, ...);

	#define NE_ASC2HEX(x) (((x) <= '9') ? ((x) - '0') : (tolower((x)) + 10 - 'a '))	#define NE_ASC2HEX(x) (((x) <= '9') ? ((x) - '0') : (tolower((x)) + 10 - 'a '))
	#define NE_HEX2ASC(x) ((char) ((x) > 9 ? ((x) - 10 + 'a') : ((x) + '0')))	#define NE_HEX2ASC(x) ((char) ((x) > 9 ? ((x) - 10 + 'a') : ((x) + '0')))


		/* Wrapper for snprintf: always NUL-terminates returned buffer, and
		* returns strlen(str). */
		size_t ne_snprintf(char str, size_t size, const char fmt, ...)
		ne_attribute((format(printf, 3, 4)));

		/* Wrapper for vsnprintf. */
		size_t ne_vsnprintf(char str, size_t size, const char fmt, va_list ap)
		ne_attribute((format(printf, 3, 0)));

	END_NEON_DECLS	END_NEON_DECLS

	#endif /* NE_STRING_H */	#endif /* NE_STRING_H */

End of changes. 4 change blocks.
	13 lines changed or deleted	14 lines changed or added

	ne_uri.h	ne_uri.h
	/*	/*

	HTTP URI handling	URI manipulation routines.
	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 29	skipping to change at line 29

	*/	*/

	#ifndef NE_URI_H	#ifndef NE_URI_H
	#define NE_URI_H	#define NE_URI_H

	#include "ne_defs.h"	#include "ne_defs.h"

	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS


	/* Un-escapes a path. Returns malloc-allocated path on success, or	/* Return a copy of a path string with anything other than
	* NULL on an invalid %<HEX><HEX> sequence. */	* "unreserved" and the forward-slash character percent-encoded
	char ne_path_unescape(const char uri);	* according to the URI encoding rules. Returns a malloc-allocated
		* string and never NULL. */
		char ne_path_escape(const char path);


	/* Escapes the a path segment: returns malloc-allocated string on	/* Return a decoded copy of a percent-encoded path string. Returns
	* success, or NULL on malloc failure. */	* malloc-allocated path on success, or NULL if the string contained
	char ne_path_escape(const char abs_path);	* any syntactically invalid percent-encoding sequences. */
		char ne_path_unescape(const char epath);

	/* Returns malloc-allocated parent of path, or NULL if path has no	/* Returns malloc-allocated parent of path, or NULL if path has no
	* parent (such as "/"). */	* parent (such as "/"). */
	char ne_path_parent(const char path);	char ne_path_parent(const char path);

	/* Returns strcmp-like value giving comparison between p1 and p2,	/* Returns strcmp-like value giving comparison between p1 and p2,
	* ignoring trailing-slashes. */	* ignoring trailing-slashes. */
	int ne_path_compare(const char p1, const char p2);	int ne_path_compare(const char p1, const char p2);

	/* Returns non-zero if child is a child of parent */	/* Returns non-zero if child is a child of parent */

	skipping to change at line 64	skipping to change at line 67

	typedef struct {	typedef struct {
	char *scheme;	char *scheme;
	char *host;	char *host;
	unsigned int port;	unsigned int port;
	char *path;	char *path;
	char *authinfo;	char *authinfo;
	} ne_uri;	} ne_uri;

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

	* Returns zero on success, non-zero on parse error. Fields of *parsed	* Returns zero on success, non-zero on parse error. On successful or
	* are malloc'ed, structure should be free'd with uri_free on	* error return, all the 'char ' fields of parsed are either set to
	* successful return. Any unspecified URI fields are set to NULL or 0	* NULL, or point to malloc-allocated NUL-terminated strings.
	* appropriately in parsed. /	* ne_uri_free can be used to free the structure after use.*/
	int ne_uri_parse(const char uri, ne_uri parsed);	int ne_uri_parse(const char uri, ne_uri parsed);

	/* Turns a URI structure back into a string. String is	/* Turns a URI structure back into a string. String is

	* malloc-allocated, and must be free'd by the caller. */	* malloc-allocated, and must be freed by the caller. */
	char ne_uri_unparse(const ne_uri uri);	char ne_uri_unparse(const ne_uri uri);

	/* Compares URIs u1 and u2, returns non-zero if they are found to be	/* Compares URIs u1 and u2, returns non-zero if they are found to be
	* non-equal. The sign of the return value is <0 if 'u1' is less than	* non-equal. The sign of the return value is <0 if 'u1' is less than
	* 'u2', or >0 if 'u2' is greater than 'u1'. */	* 'u2', or >0 if 'u2' is greater than 'u1'. */
	int ne_uri_cmp(const ne_uri u1, const ne_uri u2);	int ne_uri_cmp(const ne_uri u1, const ne_uri u2);


	/* Free URI object. */	/* Frees any non-NULL fields of parsed URI structure *parsed. All
		* fields are then zero-initialized. */
	void ne_uri_free(ne_uri *parsed);	void ne_uri_free(ne_uri *parsed);

	END_NEON_DECLS	END_NEON_DECLS

	#endif /* NE_URI_H */	#endif /* NE_URI_H */

End of changes. 6 change blocks.
	14 lines changed or deleted	18 lines changed or added

	ne_utils.h	ne_utils.h
	/*	/*
	HTTP utility functions	HTTP utility functions

	Copyright (C) 1999-2002, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 46	skipping to change at line 46

	BEGIN_NEON_DECLS	BEGIN_NEON_DECLS

	/* Returns a human-readable version string like:	/* Returns a human-readable version string like:
	* "neon 0.2.0: Library build, OpenSSL support"	* "neon 0.2.0: Library build, OpenSSL support"
	*/	*/
	const char *ne_version_string(void);	const char *ne_version_string(void);

	/* Returns non-zero if library version is not of major version	/* Returns non-zero if library version is not of major version
	* 'major', or if minor version is not greater than or equal to	* 'major', or if minor version is not greater than or equal to

	* 'minor'. */	* 'minor'. For neon versions with major == 0, all minor versions are
		* presumed to be incompatible. */
	int ne_version_match(int major, int minor);	int ne_version_match(int major, int minor);


	/* Returns non-zero if neon has support for SSL. */	#define NE_FEATURE_SSL (1) /* SSL/TLS support */
	int ne_supports_ssl(void);	#define NE_FEATURE_ZLIB (2) /* zlib compression in compress interface */
		#define NE_FEATURE_IPV6 (3) /* IPv6 is supported in resolver */
	/* Use replacement snprintf's if trio is being used. */	#define NE_FEATURE_LFS (4) /* large file support */
	#ifdef NEON_TRIO	#define NE_FEATURE_SOCKS (5) /* SOCKSv5 support */
	#define ne_snprintf trio_snprintf
	#define ne_vsnprintf trio_vsnprintf
	#else
	#define ne_snprintf snprintf
	#define ne_vsnprintf vsnprintf
	#endif


	#ifndef WIN32	/* Returns non-zero if neon has support for given feature code
	#undef min	* NE_FEATURE_. /
	#define min(a,b) ((a)<(b)?(a):(b))	int ne_has_support(int feature);
	#endif

	/* CONSIDER: mutt has a nicer way of way of doing debugging output... maybe	/* CONSIDER: mutt has a nicer way of way of doing debugging output... maybe
	* switch to like that. */	* switch to like that. */

	#ifndef NE_DEBUGGING	#ifndef NE_DEBUGGING
	#define NE_DEBUG if (0) ne_debug	#define NE_DEBUG if (0) ne_debug
	#else /* DEBUGGING */	#else /* DEBUGGING */
	#define NE_DEBUG ne_debug	#define NE_DEBUG ne_debug
	#endif /* DEBUGGING */	#endif /* DEBUGGING */


End of changes. 4 change blocks.
	17 lines changed or deleted	11 lines changed or added

	ne_xml.h	ne_xml.h
	/*	/*
	neon XML parser interface	neon XML parser interface

	Copyright (C) 1999-2003, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2004, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 89	skipping to change at line 89
	ne_xml_parser *ne_xml_create(void);	ne_xml_parser *ne_xml_create(void);

	/* Push a new handler on the stack of parser 'p'. 'cdata' and/or	/* Push a new handler on the stack of parser 'p'. 'cdata' and/or
	* 'endelm' may be NULL; startelm must be non-NULL. */	* 'endelm' may be NULL; startelm must be non-NULL. */
	void ne_xml_push_handler(ne_xml_parser *p,	void ne_xml_push_handler(ne_xml_parser *p,
	ne_xml_startelm_cb *startelm,	ne_xml_startelm_cb *startelm,
	ne_xml_cdata_cb *cdata,	ne_xml_cdata_cb *cdata,
	ne_xml_endelm_cb *endelm,	ne_xml_endelm_cb *endelm,
	void *userdata);	void *userdata);


	/* Returns non-zero if the parse was valid, zero if it failed (e.g.,	/* ne_xml_failed returns non-zero if there was an error during
	* any of the callbacks failed, the XML was not well-formed, etc).	* parsing, or zero if the parse completed successfully. The return
	* Use ne_xml_get_error to retrieve the error message if it failed. */	* value is equal to that of the last ne_xml_parse call for this
	int ne_xml_valid(ne_xml_parser *p);	* parser. */
		int ne_xml_failed(ne_xml_parser *p);

		/* Set error string for parser: the string may be truncated. */
		void ne_xml_set_error(ne_xml_parser p, const char msg);

		/* Return the error string (never NULL). After ne_xml_failed returns
		* >0, this will describe the parse error. Otherwise it will be a
		* default error string. */
		const char ne_xml_get_error(ne_xml_parser p);

	/* Destroy the parser object. */	/* Destroy the parser object. */
	void ne_xml_destroy(ne_xml_parser *p);	void ne_xml_destroy(ne_xml_parser *p);


	/* Parse the given block of input of length len. Block does not need	/* Parse the given block of input of length len. Parser must be
	* to be NUL-terminated. */	* called with len=0 to signify the end of the document (for that
	void ne_xml_parse(ne_xml_parser p, const char block, size_t len);	* case, the block argument is ignored). Returns zero on success, or
		* non-zero on error: for an XML syntax error, a positive number is
		* returned; if parsing is aborted by a caller-supplied callback, that
		* callback's return value is returned. */
		int ne_xml_parse(ne_xml_parser p, const char block, size_t len);

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

	void ne_xml_parse_v(void userdata, const char block, size_t len);	int ne_xml_parse_v(void userdata, const char block, size_t len);

	/* Return current parse line for errors */	/* Return current parse line for errors */
	int ne_xml_currentline(ne_xml_parser *p);	int ne_xml_currentline(ne_xml_parser *p);


	/* Set error string for parser. */
	void ne_xml_set_error(ne_xml_parser p, const char msg);

	/* Return the error string for the parser and never NULL. */
	const char ne_xml_get_error(ne_xml_parser p);

	/* From a start_element callback which was passed 'attrs' using given	/* From a start_element callback which was passed 'attrs' using given
	* parser, return attribute of given name and namespace. If nspace is	* parser, return attribute of given name and namespace. If nspace is
	* NULL, no namespace resolution is performed. */	* NULL, no namespace resolution is performed. */
	const char ne_xml_get_attr(ne_xml_parser parser,	const char ne_xml_get_attr(ne_xml_parser parser,
	const char *attrs, const char nspace,	const char *attrs, const char nspace,
	const char *name);	const char *name);

	/* Return the encoding of the document being parsed. May return NULL	/* Return the encoding of the document being parsed. May return NULL
	* if no encoding is defined or if the XML declaration has not yet	* if no encoding is defined or if the XML declaration has not yet
	* been parsed. */	* been parsed. */

End of changes. 5 change blocks.
	15 lines changed or deleted	22 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	ne_207.h	ne_207.h
	/*	/*
	WebDAV 207 multi-status response handling	WebDAV 207 multi-status response handling

	Copyright (C) 1999-2003, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 1999-2004, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 57	skipping to change at line 57
	typedef void ne_207_start_response(void userdata, const char *href);	typedef void ne_207_start_response(void userdata, const char *href);
	typedef void ne_207_end_response(void userdata, void response,	typedef void ne_207_end_response(void userdata, void response,
	const ne_status *status,	const ne_status *status,
	const char *description);	const char *description);

	/* Similarly, start and end callbacks for each propstat within the	/* Similarly, start and end callbacks for each propstat within the
	* response. The return value of the 'start_response' callback for	* response. The return value of the 'start_response' callback for
	* the response in which this propstat is contains is passed as the	* the response in which this propstat is contains is passed as the
	* 'response' parameter. The return value of each 'start_propstat' is	* 'response' parameter. The return value of each 'start_propstat' is
	* passed as the 'propstat' parameter' to the corresponding	* passed as the 'propstat' parameter' to the corresponding

	* 'end_propstat' callback. */	* 'end_propstat' callback. If the start_propstat callback returns
		* NULL, parsing is aborted (the XML parser error must be set by the
		* callback). */
	typedef void ne_207_start_propstat(void userdata, void *response);	typedef void ne_207_start_propstat(void userdata, void *response);
	typedef void ne_207_end_propstat(void userdata, void propstat,	typedef void ne_207_end_propstat(void userdata, void propstat,
	const ne_status *status,	const ne_status *status,
	const char *description);	const char *description);

	typedef struct ne_207_parser_s ne_207_parser;	typedef struct ne_207_parser_s ne_207_parser;

	/* Create 207 parser an add the handlers the the given parser's	/* Create 207 parser an add the handlers the the given parser's
	* handler stack. */	* handler stack. */
	ne_207_parser ne_207_create(ne_xml_parser parser, void *userdata);	ne_207_parser ne_207_create(ne_xml_parser parser, void *userdata);

End of changes. 2 change blocks.
	2 lines changed or deleted	4 lines changed or added

	ne_compress.h	ne_compress.h
	/*	/*

	Compressed HTPT request/response Handling	Compressed HTTP response handling
	Copyright (C) 2001, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 2001-2004, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 36	skipping to change at line 36

	typedef struct ne_decompress_s ne_decompress;	typedef struct ne_decompress_s ne_decompress;

	/* Call this to register a 'reader' callback which will be passed	/* Call this to register a 'reader' callback which will be passed
	* blocks of response body (if the 'acceptance' callback is	* blocks of response body (if the 'acceptance' callback is
	* successful). If the response body is returned compressed by the	* successful). If the response body is returned compressed by the
	* server, this reader will receive UNCOMPRESSED blocks.	* server, this reader will receive UNCOMPRESSED blocks.
	*	*
	* Returns pointer to context object which must be passed to	* Returns pointer to context object which must be passed to
	* ne_decompress_destroy after the request has been dispatched, to	* ne_decompress_destroy after the request has been dispatched, to

	* free any internal state. */	* free any internal state. If an error occurs during decompression,
		* the request will be aborted and session error string set. */
	ne_decompress ne_decompress_reader(ne_request req, ne_accept_response acc pt,	ne_decompress ne_decompress_reader(ne_request req, ne_accept_response acc pt,
	ne_block_reader rdr, void *userdata);	ne_block_reader rdr, void *userdata);


	/* Free's up internal state. Returns non-zero if errors occured during	/* Destroys decompression state. */
	* decompression: the session error string will have the error. */	void ne_decompress_destroy(ne_decompress *ctx);
	int ne_decompress_destroy(ne_decompress *ctx);

	#endif /* NE_COMPRESS_H */	#endif /* NE_COMPRESS_H */

End of changes. 3 change blocks.
	6 lines changed or deleted	6 lines changed or added

	ne_ssl.h	ne_ssl.h
	/*	/*
	SSL/TLS abstraction layer for neon	SSL/TLS abstraction layer for neon

	Copyright (C) 2003-2004, Joe Orton <joe@manyfish.co.uk>	Copyright (C) 2003-2005, Joe Orton <joe@manyfish.co.uk>

	This library is free software; you can redistribute it and/or	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	skipping to change at line 68	skipping to change at line 68
	* caller. */	* caller. */
	char ne_ssl_cert_export(const ne_ssl_certificate cert);	char ne_ssl_cert_export(const ne_ssl_certificate cert);

	/* Import a certificate from a base64-encoded string as returned by	/* Import a certificate from a base64-encoded string as returned by
	* ne_ssl_cert_export(). Returns a certificate object or NULL if	* ne_ssl_cert_export(). Returns a certificate object or NULL if
	* 'data' was not valid. */	* 'data' was not valid. */
	ne_ssl_certificate ne_ssl_cert_import(const char data);	ne_ssl_certificate ne_ssl_cert_import(const char data);

	/* Returns the identity of the certificate, or NULL if none is given.	/* Returns the identity of the certificate, or NULL if none is given.
	* For a server certificate this will be the hostname of the server to	* For a server certificate this will be the hostname of the server to

	* whom the cert was issued. */	* whom the cert was issued. String returned is UTF-8-encoded. */
	const char ne_ssl_cert_identity(const ne_ssl_certificate cert);	const char ne_ssl_cert_identity(const ne_ssl_certificate cert);

	/* Return the certificate of the entity which signed certificate	/* Return the certificate of the entity which signed certificate
	* 'cert'. Returns NULL if 'cert' is self-signed or the issuer	* 'cert'. Returns NULL if 'cert' is self-signed or the issuer
	* certificate is not available. */	* certificate is not available. */
	const ne_ssl_certificate ne_ssl_cert_signedby(const ne_ssl_certificate ce rt);	const ne_ssl_certificate ne_ssl_cert_signedby(const ne_ssl_certificate ce rt);

	/* Returns the distinguished name of the certificate issuer. */	/* Returns the distinguished name of the certificate issuer. */
	const ne_ssl_dname ne_ssl_cert_issuer(const ne_ssl_certificate cert);	const ne_ssl_dname ne_ssl_cert_issuer(const ne_ssl_certificate cert);


	skipping to change at line 117	skipping to change at line 117
	/* A client certificate (and private key). */	/* A client certificate (and private key). */
	typedef struct ne_ssl_client_cert_s ne_ssl_client_cert;	typedef struct ne_ssl_client_cert_s ne_ssl_client_cert;

	/* Read a client certificate and private key from a PKCS12 file;	/* Read a client certificate and private key from a PKCS12 file;
	* returns NULL if the file could not be parsed. If the client cert	* returns NULL if the file could not be parsed. If the client cert
	* is encrypted, it must be decrypted before use. */	* is encrypted, it must be decrypted before use. */
	ne_ssl_client_cert ne_ssl_clicert_read(const char filename);	ne_ssl_client_cert ne_ssl_clicert_read(const char filename);

	/* Returns the "friendly name" given for the client cert, or NULL if	/* Returns the "friendly name" given for the client cert, or NULL if
	* none given. This can be called before or after the client cert has	* none given. This can be called before or after the client cert has

	* been decrypted. Returns a NUL-terminated string. */	* been decrypted. Returns a NUL-terminated, UTF-8-encoded string. */
	const char ne_ssl_clicert_name(ne_ssl_client_cert ccert);	const char ne_ssl_clicert_name(const ne_ssl_client_cert ccert);

	/* Returns non-zero if client cert is encrypted. */	/* Returns non-zero if client cert is encrypted. */
	int ne_ssl_clicert_encrypted(const ne_ssl_client_cert *ccert);	int ne_ssl_clicert_encrypted(const ne_ssl_client_cert *ccert);

	/* Decrypt the encrypted client cert using given password. Returns	/* Decrypt the encrypted client cert using given password. Returns
	* non-zero on failure, in which case, the function can be called	* non-zero on failure, in which case, the function can be called
	* again with a different password. For a ccert on which _encrypted()	* again with a different password. For a ccert on which _encrypted()
	* returns 0, calling _decrypt results in undefined behaviour. */	* returns 0, calling _decrypt results in undefined behaviour. */
	int ne_ssl_clicert_decrypt(ne_ssl_client_cert ccert, const char password) ;	int ne_ssl_clicert_decrypt(ne_ssl_client_cert ccert, const char password) ;

	/* Return the actual certificate part of the client certificate (never	/* Return the actual certificate part of the client certificate (never
	* returns NULL). */	* returns NULL). */
	const ne_ssl_certificate ne_ssl_clicert_owner(const ne_ssl_client_cert cc ert);	const ne_ssl_certificate ne_ssl_clicert_owner(const ne_ssl_client_cert cc ert);

	/* Deallocate memory associated with a client certificate. */	/* Deallocate memory associated with a client certificate. */
	void ne_ssl_clicert_free(ne_ssl_client_cert *ccert);	void ne_ssl_clicert_free(ne_ssl_client_cert *ccert);


	/* An SSL context; only necessary when interfacing with ne_socket.h. */	/* SSL context object. The interfaces to manipulate an SSL context
		* are only needed when interfacing directly with ne_socket.h. */
	typedef struct ne_ssl_context_s ne_ssl_context;	typedef struct ne_ssl_context_s ne_ssl_context;


		/* Context creation modes: */
		#define NE_SSL_CTX_CLIENT (0) /* client context */
		#define NE_SSL_CTX_SERVER (1) /* default server context */
		#define NE_SSL_CTX_SERVERv2 (2) /* SSLv2-specific server context */

	/* Create an SSL context. */	/* Create an SSL context. */

	ne_ssl_context *ne_ssl_context_create(void);	ne_ssl_context *ne_ssl_context_create(int mode);


	/* Trust the given certificate 'cert' in context 'ctx'. */	/* Client mode: trust the given certificate 'cert' in context 'ctx'. */
	void ne_ssl_ctx_trustcert(ne_ssl_context ctx, const ne_ssl_certificate ce	void ne_ssl_context_trustcert(ne_ssl_context *ctx, const ne_ssl_certificate
	rt);	*cert);

		/* Server mode: use given cert and key (filenames to PEM certificates). */
		int ne_ssl_context_keypair(ne_ssl_context *ctx,
		const char cert, const char key);

		/* Server mode: set client cert verification options: required is non-zero
		if
		* a client cert is required, if ca_names is non-NULL it is a filename cont
		aining
		* a set of PEM certs from which CA names are sent in the ccert request. */
		int ne_ssl_context_set_verify(ne_ssl_context *ctx, int required,
		const char ca_names, const char verify_cas)
		;

	/* Destroy an SSL context. */	/* Destroy an SSL context. */
	void ne_ssl_context_destroy(ne_ssl_context *ctx);	void ne_ssl_context_destroy(ne_ssl_context *ctx);

	END_NEON_DECLS	END_NEON_DECLS

	#endif	#endif

End of changes. 7 change blocks.
	9 lines changed or deleted	28 lines changed or added