static void
out_result(int ret)
{
switch (ret) {
case NE_OK:
printf("succeeded.\n");
break;
case NE_AUTH:
case NE_PROXYAUTH:
printf("authentication failed.\n");
break;
case NE_CONNECT:
printf("could not connect to server.\n");
break;
case NE_TIMEOUT:
printf("connection timed out.\n");
break;
default:
if (ret == NE_REDIRECT) {
const ne_uri *dest = ne_redirect_location(session.sess);
if (dest) {
char *uri = ne_uri_unparse(dest);
printf("redirect to %s\n", uri);
ne_free(uri);
break;
}
}
printf("failed: %s\n", ne_get_error(session.sess));
break;
}
}
/* Run a request to 'path' and retrieve the redirect destination to
* *redir. */
static int process_redir(ne_session *sess, const char *path,
const ne_uri **redir)
{
ONN("did not get NE_REDIRECT", any_request(sess, path) != NE_REDIRECT);
*redir = ne_redirect_location(sess);
return OK;
}
/* ensure that ne_redirect_location returns NULL when no redirect has
* been encountered, or redirect hooks aren't registered. */
static int no_redirect(void)
{
ne_session *sess = ne_session_create("http", "localhost", 7777);
const ne_uri *loc;
ONN("redirect non-NULL before register", ne_redirect_location(sess));
ne_redirect_register(sess);
ONN("initial redirect non-NULL", ne_redirect_location(sess));
CALL(spawn_server(7777, single_serve_string,
"HTTP/1.0 200 OK\r\n\r\n\r\n"));
ONREQ(any_request(sess, "/noredir"));
CALL(await_server());
ONN("redirect non-NULL after non-redir req", ne_redirect_location(sess));
CALL(spawn_server(7777, single_serve_string, "HTTP/1.0 302 Get Ye Away\r\n"
"Location: /blah\r\n" "\r\n"));
CALL(process_redir(sess, "/foo", &loc));
CALL(await_server());
ne_session_destroy(sess);
return OK;
}
static int open_request (struct neon_handle * handle, uint64_t startbyte)
{
int ret;
const ne_status * status;
ne_uri * rediruri;
if (handle->purl->query && * (handle->purl->query))
{
SCONCAT3 (tmp, handle->purl->path, "?", handle->purl->query);
handle->request = ne_request_create (handle->session, "GET", tmp);
}
else
handle->request = ne_request_create (handle->session, "GET", handle->purl->path);
if (startbyte > 0)
ne_print_request_header (handle->request, "Range", "bytes=%"PRIu64"-", startbyte);
ne_print_request_header (handle->request, "Icy-MetaData", "1");
/* Try to connect to the server. */
_DEBUG ("<%p> Connecting...", handle);
ret = ne_begin_request (handle->request);
status = ne_get_status (handle->request);
_DEBUG ("<%p> Return: %d, Status: %d", handle, ret, status->code);
if (ret == NE_OK)
{
switch (status->code)
{
case 401:
/* Authorization required. Reconnect to authenticate */
_DEBUG ("Reconnecting due to 401");
ne_end_request (handle->request);
ret = ne_begin_request (handle->request);
break;
case 301:
case 302:
case 303:
case 307:
/* Redirect encountered. Reconnect. */
ne_end_request (handle->request);
ret = NE_REDIRECT;
break;
case 407:
/* Proxy auth required. Reconnect to authenticate */
_DEBUG ("Reconnecting due to 407");
ne_end_request (handle->request);
ret = ne_begin_request (handle->request);
break;
}
}
switch (ret)
{
case NE_OK:
if (status->code > 199 && status->code < 300)
{
/* URL opened OK */
_DEBUG ("<%p> URL opened OK", handle);
handle->content_start = startbyte;
handle->pos = startbyte;
handle_headers (handle);
return 0;
}
break;
case NE_REDIRECT:
/* We hit a redirect. Handle it. */
_DEBUG ("<%p> Redirect encountered", handle);
handle->redircount += 1;
rediruri = (ne_uri *) ne_redirect_location (handle->session);
ne_request_destroy (handle->request);
handle->request = NULL;
if (! rediruri)
{
_ERROR ("<%p> Could not parse redirect response", (void *) handle);
return -1;
}
ne_uri_free (handle->purl);
ne_uri_copy (handle->purl, rediruri);
return 1;
}
/* Something went wrong. */
_ERROR ("<%p> Could not open URL: %d (%d)", (void *) handle, ret, status->code);
if (ret)
_ERROR ("<%p> neon error string: %s", (void *) handle, ne_get_error (handle->session));
ne_request_destroy (handle->request);
handle->request = NULL;
return -1;
}
static int fetch_resource_list( const char *uri,
int depth,
struct listdir_context *fetchCtx )
{
int ret = 0;
ne_propfind_handler *hdl = NULL;
ne_request *request = NULL;
const char *content_type = NULL;
char *curi = NULL;
const ne_status *req_status = NULL;
curi = _cleanPath( uri );
if (!fetchCtx) {
errno = ENOMEM;
SAFE_FREE(curi);
return -1;
}
fetchCtx->list = NULL;
fetchCtx->target = curi;
fetchCtx->currResource = NULL;
/* do a propfind request and parse the results in the results function, set as callback */
hdl = ne_propfind_create(dav_session.ctx, curi, depth);
if(hdl) {
ret = ne_propfind_named(hdl, ls_props, results, fetchCtx);
request = ne_propfind_get_request( hdl );
req_status = ne_get_status( request );
}
if( ret == NE_OK ) {
fetchCtx->currResource = fetchCtx->list;
/* Check the request status. */
if( req_status && req_status->klass != 2 ) {
set_errno_from_http_errcode(req_status->code);
DEBUG_WEBDAV("ERROR: Request failed: status %d (%s)", req_status->code,
req_status->reason_phrase);
ret = NE_CONNECT;
set_error_message(req_status->reason_phrase);
}
DEBUG_WEBDAV("Simple propfind result code %d.", req_status ? req_status->code : -1);
} else {
if( ret == NE_ERROR && req_status->code == 404) {
errno = ENOENT;
} else {
set_errno_from_neon_errcode(ret);
}
}
if( ret == NE_OK ) {
/* Check the content type. If the server has a problem, ie. database is gone or such,
* the content type is not xml but a html error message. Stop on processing if it's
* not XML.
* FIXME: Generate user error message from the reply content.
*/
content_type = ne_get_response_header( request, "Content-Type" );
if( !(content_type && c_streq(content_type, "application/xml; charset=utf-8") ) ) {
DEBUG_WEBDAV("ERROR: Content type of propfind request not XML: %s.",
content_type ? content_type: "<empty>");
errno = ERRNO_WRONG_CONTENT;
set_error_message("Server error: PROPFIND reply is not XML formatted!");
ret = NE_CONNECT;
}
}
#ifndef NDEBUG
if( ret != NE_OK ) {
const char *err = ne_get_error(dav_session.ctx);
DEBUG_WEBDAV("WRN: propfind named failed with %d, request error: %s", ret, err ? err : "<nil>");
}
#endif /* NDEBUG */
if (hdl != NULL) {
ne_propfind_destroy(hdl);
}
#ifndef NDEBUG
if (ret == NE_REDIRECT) {
const ne_uri *redir_ne_uri = ne_redirect_location(dav_session.ctx);
if (redir_ne_uri) {
char *redir_uri = ne_uri_unparse(redir_ne_uri);
DEBUG_WEBDAV("Permanently moved to %s", redir_uri);
}
}
#endif /* NDEBUG */
if( ret != NE_OK ) {
free_fetchCtx(fetchCtx);
return -1;
}
return 0;
}
