/* Handle an XML response parse error, setting session error string * and closing the connection. */ static int parse_error(ne_session *sess, ne_xml_parser *parser) { ne_set_error(sess, _("Could not parse response: %s"), ne_xml_get_error(parser)); ne_close_connection(sess); return NE_ERROR; }
svn_error_t * svn_ra_neon__check_parse_error(const char *method, ne_xml_parser *xml_parser, const char *url) { const char *msg = ne_xml_get_error(xml_parser); if (msg != NULL && *msg != '\0') return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL, _("The %s request returned invalid XML " "in the response: %s (%s)"), method, msg, url); return SVN_NO_ERROR; }
int DavXMLParser::parseChuck(const char *partial_string, size_t length){ int ret = ne_xml_parse(_ne_parser,partial_string,length); if(ret != 0){ if(ret > 0){ ret =-1; const char* ne_parser_err = ne_xml_get_error(_ne_parser); DavixError::setupError(&err, davix_scope_xml_parser(), StatusCode::WebDavPropertiesParsingError, "XML Parsing Error: " + std::string((ne_parser_err)?ne_parser_err:"Unknow ne error")); } if(!err){ DavixError::setupError(&err, davix_scope_xml_parser(), StatusCode::WebDavPropertiesParsingError, "Unknow XML parsing error "); } } return ret; }
int ne_lock_refresh(ne_session *sess, struct ne_lock *lock) { ne_request *req = ne_request_create(sess, "LOCK", lock->uri.path); ne_xml_parser *parser = ne_xml_create(); int ret; struct lock_ctx ctx; memset(&ctx, 0, sizeof ctx); ctx.cdata = ne_buffer_create(); ctx.req = req; ctx.token = lock->token; /* Handle the response and update *lock appropriately. */ ne_xml_push_handler(parser, lk_startelm, lk_cdata, lk_endelm, &ctx); /* For a lock refresh, submitting only this lock token must be * sufficient. */ ne_print_request_header(req, "If", "(<%s>)", lock->token); add_timeout_header(req, lock->timeout); ret = ne_xml_dispatch_request(req, parser); if (ret == NE_OK) { if (ne_get_status(req)->klass != 2) { ret = NE_ERROR; /* and use default session error */ } else if (ne_xml_failed(parser)) { ret = NE_ERROR; ne_set_error(sess, "%s", ne_xml_get_error(parser)); } else if (!ctx.found) { ne_set_error(sess, _("No activelock for <%s> returned in " "LOCK refresh response"), lock->token); ret = NE_ERROR; } else /* success! */ { /* update timeout for passed-in lock structure. */ lock->timeout = ctx.active.timeout; } } ne_lock_free(&ctx.active); ne_buffer_destroy(ctx.cdata); ne_request_destroy(req); ne_xml_destroy(parser); return ret; }
static void s3_parse_xml_response(S3 *s3,ne_request *req, ne_xml_startelm_cb *startelm, ne_xml_cdata_cb *cdata, ne_xml_endelm_cb *endelm, void *userdata) { char buffer[4096]; size_t bytes_read; ne_xml_parser *xml; xml = ne_xml_create(); ne_xml_push_handler(xml,startelm,cdata,endelm,userdata); while((bytes_read = ne_read_response_block(req,buffer,4096)) > 0) { if(ne_xml_parse(xml,buffer,bytes_read) != 0) strncpy(s3->error,ne_xml_get_error(xml),511); } ne_xml_parse(xml,buffer,0); ne_xml_destroy(xml); }
svn_error_t * svn_ra_neon__exchange_capabilities(svn_ra_neon__session_t *ras, apr_pool_t *pool) { svn_ra_neon__request_t* req; svn_error_t *err = SVN_NO_ERROR; ne_xml_parser *parser = NULL; options_ctx_t oc = { 0 }; const char *msg; int status_code; oc.pool = pool; oc.cdata = svn_stringbuf_create("", pool); req = svn_ra_neon__request_create(ras, "OPTIONS", ras->url->data, pool); /* ### Use a symbolic name somewhere for this MIME type? */ ne_add_request_header(req->ne_req, "Content-Type", "text/xml"); /* Create a parser to read the normal response body */ parser = svn_ra_neon__xml_parser_create(req, ne_accept_2xx, start_element, svn_ra_neon__xml_collect_cdata, end_element, &oc); /* Run the request and get the resulting status code. */ if ((err = svn_ra_neon__request_dispatch(&status_code, req, NULL, "<?xml version=\"1.0\" " "encoding=\"utf-8\"?>" "<D:options xmlns:D=\"DAV:\">" "<D:activity-collection-set/>" "</D:options>", 200, 0, pool))) goto cleanup; /* Was there an XML parse error somewhere? */ msg = ne_xml_get_error(parser); if (msg && *msg) { err = svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL, _("The %s request returned invalid XML " "in the response: %s (%s)"), "OPTIONS", msg, ras->url->data); goto cleanup; } /* We asked for, and therefore expect, to have found an activity collection in the response. */ if (oc.activity_coll == NULL) { err = svn_error_create(SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED, NULL, _("The OPTIONS response did not include the " "requested activity-collection-set; this often " "means that the URL is not WebDAV-enabled")); goto cleanup; } ras->act_coll = apr_pstrdup(ras->pool, oc.activity_coll->data); parse_capabilities(req->ne_req, ras, pool); cleanup: svn_ra_neon__request_destroy(req); return err; }
int ne_lock(ne_session *sess, struct ne_lock *lock) { ne_request *req = ne_request_create(sess, "LOCK", lock->uri.path); ne_buffer *body = ne_buffer_create(); ne_xml_parser *parser = ne_xml_create(); int ret, parse_failed; struct lock_ctx ctx; memset(&ctx, 0, sizeof ctx); ctx.cdata = ne_buffer_create(); ctx.req = req; ne_xml_push_handler(parser, lk_startelm, lk_cdata, lk_endelm, &ctx); /* Create the body */ ne_buffer_concat(body, "<?xml version=\"1.0\" encoding=\"utf-8\"?>" EOL "<lockinfo xmlns='DAV:'>" EOL " <lockscope>", lock->scope==ne_lockscope_exclusive? "<exclusive/>":"<shared/>", "</lockscope>" EOL "<locktype><write/></locktype>", NULL); if (lock->owner) { ne_buffer_concat(body, "<owner>", lock->owner, "</owner>" EOL, NULL); } ne_buffer_zappend(body, "</lockinfo>" EOL); ne_set_request_body_buffer(req, body->data, ne_buffer_size(body)); /* ne_add_request_header(req, "Content-Type", NE_XML_MEDIA_TYPE); */ /* Just to test whether sever accepts both text/xml and application/xml */ ne_add_request_header(req, "Content-Type", "text/xml"); ne_add_depth_header(req, lock->depth); add_timeout_header(req, lock->timeout); /* TODO: * By 2518, we need this only if we are creating a lock-null resource. * Since we don't KNOW whether the lock we're given is a lock-null * or not, we cover our bases. */ ne_lock_using_parent(req, lock->uri.path); /* This one is clearer from 2518 sec 8.10.4. */ ne_lock_using_resource(req, lock->uri.path, lock->depth); ret = ne_xml_dispatch_request(req, parser); ne_buffer_destroy(body); ne_buffer_destroy(ctx.cdata); parse_failed = ne_xml_failed(parser); if (ret == NE_OK && ne_get_status(req)->klass == 2) { if (ctx.token == NULL) { ret = NE_ERROR; ne_set_error(sess, _("No Lock-Token header given")); } else if (parse_failed) { ret = NE_ERROR; ne_set_error(sess, "%s", ne_xml_get_error(parser)); } else if (ne_get_status(req)->code == 207) { ret = NE_ERROR; /* TODO: set the error string appropriately */ } else if (ctx.found) { /* it worked: copy over real lock details if given. */ if (lock->token) ne_free(lock->token); lock->token = ctx.token; ctx.token = NULL; if (ctx.active.timeout != NE_TIMEOUT_INVALID) lock->timeout = ctx.active.timeout; lock->scope = ctx.active.scope; lock->type = ctx.active.type; if (ctx.active.depth >= 0) lock->depth = ctx.active.depth; if (ctx.active.owner) { if (lock->owner) ne_free(lock->owner); lock->owner = ctx.active.owner; ctx.active.owner = NULL; } } else { ret = NE_ERROR; ne_set_error(sess, _("Response missing activelock for %s"), ctx.token); } } else if (ret == NE_OK /* && status != 2xx */) { ret = NE_ERROR; } ne_lock_free(&ctx.active); if (ctx.token) ne_free(ctx.token); ne_request_destroy(req); ne_xml_destroy(parser); return ret; }