static ne_xml_parser *
error_parser_create(svn_ra_neon__request_t *req)
{
error_parser_baton_t *b = apr_palloc(req->pool, sizeof(*b));
ne_xml_parser *error_parser;
b->dst_err = &(req->err);
b->marshalled_error = &(req->marshalled_error);
b->tmp_err = NULL;
b->want_cdata = NULL;
b->cdata = svn_stringbuf_create("", req->pool);
/* attach a standard <D:error> body parser to the request */
error_parser = xml_parser_create(req);
ne_xml_push_handler(error_parser,
start_err_element,
collect_error_cdata,
end_err_element, b);
apr_pool_cleanup_register(req->pool, b,
error_parser_baton_cleanup,
apr_pool_cleanup_null);
/* Register the "error" accepter and body-reader with the request --
the one to use when HTTP status is *not* 2XX */
attach_ne_body_reader(req, ra_neon_error_accepter,
ne_xml_parse_v, error_parser);
return error_parser;
}
static int netxml_get_page(const char *page)
{
int ret = NE_ERROR;
ne_request *request;
ne_xml_parser *parser;
upsdebugx(2, "%s: %s", __func__, (page != NULL)?page:"(null)");
if (page != NULL) {
request = ne_request_create(session, "GET", page);
parser = ne_xml_create();
ne_xml_push_handler(parser, subdriver->startelm_cb, subdriver->cdata_cb, subdriver->endelm_cb, NULL);
ret = netxml_dispatch_request(request, parser);
if (ret) {
upsdebugx(2, "%s: %s", __func__, ne_get_error(session));
}
ne_xml_destroy(parser);
ne_request_destroy(request);
}
return ret;
}
ne_xml_parser *
svn_ra_neon__xml_parser_create(svn_ra_neon__request_t *req,
ne_accept_response accpt,
svn_ra_neon__startelm_cb_t startelm_cb,
svn_ra_neon__cdata_cb_t cdata_cb,
svn_ra_neon__endelm_cb_t endelm_cb,
void *baton)
{
ne_xml_parser *p = xml_parser_create(req);
parser_wrapper_baton_t *pwb = apr_palloc(req->pool, sizeof(*pwb));
pwb->req = req;
pwb->parser = p;
pwb->baton = baton;
pwb->startelm_cb = startelm_cb;
pwb->cdata_cb = cdata_cb;
pwb->endelm_cb = endelm_cb;
ne_xml_push_handler(p,
wrapper_startelm_cb,
wrapper_cdata_cb,
wrapper_endelm_cb, pwb);
if (accpt)
attach_ne_body_reader(req, accpt, wrapper_reader_cb, pwb);
return p;
}
/* Discover all locks on URI */
int ne_lock_discover(ne_session *sess, const char *uri,
ne_lock_result callback, void *userdata)
{
ne_propfind_handler *handler;
struct discover_ctx ctx = {0};
int ret;
ctx.results = callback;
ctx.userdata = userdata;
ctx.session = sess;
ctx.cdata = ne_buffer_create();
handler = ne_propfind_create(sess, uri, NE_DEPTH_ZERO,"PROPFIND");
ne_propfind_set_private(handler, ld_create, &ctx);
ne_xml_push_handler(ne_propfind_get_parser(handler),
ld_startelm, ld_cdata, end_element_ldisc, handler);
ret = ne_propfind_named(handler, lock_props, discover_results, &ctx);
ne_buffer_destroy(ctx.cdata);
ne_propfind_destroy(handler);
return ret;
}
DavXMLParser::DavXMLParser() : err(NULL), _ne_parser(ne_xml_create())
{
ne_xml_push_handler(_ne_parser,
&InternalDavParser::dav_xml_parser_ne_xml_startelm_cb,
&InternalDavParser::dav_xml_ne_xml_cdata_cb,
&InternalDavParser::ne_xml_endelm_cb,
this);
}
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);
}
static object_query_t *set_object_deserialise_raw(ne_buffer *buff) {
int ne_status;
assert(NULL != buff);
/* Create SET_OBJECT query response */
object_query_t *handle = object_query_create(SET_OBJECT_RESPONSE, RAW_POST);
if (NULL == handle)
return NULL;
/* Create XML parser */
ne_xml_parser *parser = ne_xml_create();
/* neon API ref. states that the function always succeeds */
assert(NULL != parser);
/* Set element & data handlers */
ne_xml_push_handler(
parser,
set_object_raw_resp_start_element,
set_object_raw_resp_cdata,
set_object_raw_resp_end_element,
handle);
/* Parse the response */
ne_status = ne_xml_parse(parser, buff->data, buff->used);
if (NE_OK != ne_status)
handle->status = OBJECT_PARSE_ERROR;
/* Destroy parser */
ne_xml_destroy(parser);
return handle;
}
void upsdrv_updateinfo(void)
{
int ret, errors = 0;
/* We really should be dealing with alarms through a separate callback, so that we can keep the
* processing of alarms and polling for data separated. Currently, this isn't supported by the
* driver main body, so we'll have to revert to polling each time we're called, unless the
* socket indicates we're no longer connected.
*/
if (testvar("subscribe")) {
char buf[LARGEBUF];
ret = ne_sock_read(sock, buf, sizeof(buf));
if (ret > 0) {
/* alarm message received */
ne_xml_parser *parser = ne_xml_create();
upsdebugx(2, "%s: ne_sock_read(%d bytes) => %s", __func__, ret, buf);
ne_xml_push_handler(parser, subdriver->startelm_cb, subdriver->cdata_cb, subdriver->endelm_cb, NULL);
ne_xml_parse(parser, buf, strlen(buf));
ne_xml_destroy(parser);
time(&lastheard);
} else if ((ret == NE_SOCK_TIMEOUT) && (difftime(time(NULL), lastheard) < 180)) {
/* timed out */
upsdebugx(2, "%s: ne_sock_read(timeout)", __func__);
} else {
/* connection closed or unknown error */
upslogx(LOG_ERR, "NSM connection with '%s' lost", uri.host);
upsdebugx(2, "%s: ne_sock_read(%d) => %s", __func__, ret, ne_sock_error(sock));
ne_sock_close(sock);
if (netxml_alarm_subscribe(subdriver->subscribe) == NE_OK) {
extrafd = ne_sock_fd(sock);
time(&lastheard);
return;
}
dstate_datastale();
extrafd = -1;
return;
}
}
/* get additional data */
ret = netxml_get_page(subdriver->getobject);
if (ret != NE_OK) {
errors++;
}
ret = netxml_get_page(subdriver->summary);
if (ret != NE_OK) {
errors++;
}
if (errors > 1) {
dstate_datastale();
return;
}
status_init();
alarm_init();
netxml_alarm_set();
alarm_commit();
netxml_status_set();
status_commit();
dstate_dataok();
}
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;
}
