bool XMLWrapper::nodeDump(xmlNodePtr node, std::string &content, bool trim)
{
content.clear();
if (!mDocument) {
return false;
}
if (!node) {
return false;
}
bool result = false;
xmlBufferPtr buffer = xmlBufferCreate();
if (buffer) {
xmlOutputBufferPtr outputBuffer = xmlOutputBufferCreateBuffer(buffer, NULL);
if (outputBuffer) {
xmlNodeDumpOutput(outputBuffer, mDocument, node, 0, 0, "UTF8");
xmlOutputBufferClose(outputBuffer);
outputBuffer = NULL;
result = convertToString(buffer->content, content);
if (result && trim) {
trimString(content);
}
}
xmlBufferFree(buffer);
buffer = NULL;
}
return result;
}
string Node::XMLString() const
{
std::ostringstream stream;
StreamOutputBuffer buf(stream);
xmlNodeDumpOutput(buf, _xml->doc, _xml, 0, 0, nullptr);
return xmlString(stream.str().c_str());
}
/**
* xmlnode_to_pv:
* @node: an xmlNode* object
* @do_free: do we need to free the node after the conversion
*
* Return value: a newly allocated SV/PV or under.
*/
static SV*
xmlnode_to_pv(xmlNode *node, gboolean do_free)
{
xmlOutputBufferPtr buf;
SV *pestring = NULL;
if (node == NULL) {
return &PL_sv_undef;
}
buf = xmlAllocOutputBuffer(NULL);
if (buf == NULL) {
pestring = &PL_sv_undef;
} else {
xmlNodeDumpOutput(buf, NULL, node, 0, 1, NULL);
xmlOutputBufferFlush(buf);
if (buf->conv == NULL) {
pestring = newSVpv((char*)buf->buffer->content, 0);
} else {
pestring = newSVpv((char*)buf->conv->content, 0);
}
xmlOutputBufferClose(buf);
}
if (do_free) {
lasso_release_xml_node(node);
}
return pestring;
}
void XMLNode::GetXML(std::string& out_xml_str, bool user_friendly) const {
out_xml_str.resize(0);
if (!node_) return;
if (node_->type != XML_ELEMENT_NODE) return;
xmlDocPtr doc = node_->doc;
if (doc == NULL) return;
// Printing non-root node omits namespaces defined at higher level.
// So we need to create temporary namespace definitions and place them
// at node being printed
std::map<xmlNsPtr,xmlNsPtr> extns;
CollectExternalNamespaces(node_, extns);
// It is easier to insert namespaces into final text. Hence
// allocating place for them.
std::string ns_str;
NamespacesToString(extns, ns_str);
out_xml_str.append(ns_str.length(),' ');
/*
xmlBufferPtr buf = xmlBufferCreate();
xmlNodeDump(buf, doc, node_, 0, user_friendly ? 1 : 0);
out_xml_str = (char*)(buf->content);
xmlBufferFree(buf);
*/
xmlOutputBufferPtr buf =
xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL);
if(buf == NULL) return;
xmlNodeDumpOutput(buf, doc, node_, 0, user_friendly ? 1 : 0, (const char*)(doc->encoding));
xmlOutputBufferClose(buf);
// Insert external namespaces into final string using allocated space
InsertExternalNamespaces(out_xml_str, ns_str);
}
extern "C" void DumpXMLString(xmlNodePtr node)
{
xmlOutputBufferPtr buf = xmlOutputBufferCreateFile(stdout, nullptr);
xmlNodeDumpOutput(buf, node->doc, node, 0, 0, nullptr);
xmlOutputBufferClose(buf);
fprintf(stdout, "\n\n");
}
string Node::XMLString() const
{
std::ostringstream stream;
StreamOutputBuffer buf(stream);
xmlNodeDumpOutput(buf.xmlBuffer(), _xml->doc, _xml, 0, 1, "UTF-8");
buf.flush();
return xmlString(stream.str().c_str());
}
static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self)
{
VALUE result = Qnil;
VALUE options = Qnil;
xmlNodePtr xnode;
xmlCharEncodingHandlerPtr encodingHandler;
xmlOutputBufferPtr output;
int level = 0;
int indent = 1;
const char *xencoding = "UTF-8";
rb_scan_args(argc, argv, "01", &options);
if (!NIL_P(options))
{
VALUE rencoding, rindent, rlevel;
Check_Type(options, T_HASH);
rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding")));
rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level")));
if (rindent == Qfalse)
indent = 0;
if (rlevel != Qnil)
level = NUM2INT(rlevel);
if (rencoding != Qnil)
{
xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding));
if (!xencoding)
rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding));
}
}
encodingHandler = xmlFindCharEncodingHandler(xencoding);
output = xmlAllocOutputBuffer(encodingHandler);
xnode = rxml_get_xnode(self);
xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, xencoding);
xmlOutputBufferFlush(output);
if (output->conv)
result = rxml_new_cstr((const char*) output->conv->content, xencoding);
else
result = rxml_new_cstr((const char*) output->buffer->content, xencoding);
xmlOutputBufferClose(output);
return result;
}
string BEXMLTextReader::raw_xml()
{
xmlBufferPtr node_content = xmlBufferCreate();
xmlOutputBufferPtr node = (xmlOutputBufferPtr) xmlMalloc ( sizeof(xmlOutputBuffer) );
memset ( node, 0, (size_t) sizeof(xmlOutputBuffer) );
node->buffer = node_content;
xmlNodeDumpOutput ( node, xml_document, xmlTextReaderCurrentNode ( reader ), 0, true, "UTF-8" );
const xmlChar * xml_data = xmlBufferContent ( (xmlBufferPtr)node_content );
size_t xml_length = xmlBufferLength ( node_content );
string xml_result ( (char *)xml_data, xml_length );
xmlFree ( (xmlChar *)xml_data );
return xml_result;
} // raw_xml
/* {{{ internalSubset string
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-internalSubset
Since: DOM Level 2
*/
int dom_documenttype_internal_subset_read(dom_object *obj, zval *retval)
{
xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
xmlDtdPtr intsubset;
if (dtdptr == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
if (dtdptr->doc != NULL && ((intsubset = xmlGetIntSubset(dtdptr->doc)) != NULL)) {
smart_str ret_buf = {0};
xmlNodePtr cur = intsubset->children;
while (cur != NULL) {
xmlOutputBuffer *buff = xmlAllocOutputBuffer(NULL);
if (buff != NULL) {
xmlNodeDumpOutput (buff, NULL, cur, 0, 0, NULL);
xmlOutputBufferFlush(buff);
#ifdef LIBXML2_NEW_BUFFER
smart_str_appendl(&ret_buf, (const char *) xmlOutputBufferGetContent(buff), xmlOutputBufferGetSize(buff));
#else
smart_str_appendl(&ret_buf, (char *) buff->buffer->content, buff->buffer->use);
#endif
(void)xmlOutputBufferClose(buff);
}
cur = cur->next;
}
if (ret_buf.s) {
smart_str_0(&ret_buf);
ZVAL_NEW_STR(retval, ret_buf.s);
return SUCCESS;
}
}
ZVAL_NULL(retval);
return SUCCESS;
}
static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self)
{
VALUE options = Qnil;
xmlNodePtr xnode;
xmlCharEncodingHandlerPtr encodingHandler;
xmlOutputBufferPtr output;
int level = 0;
int indent = 1;
const char *encoding = "UTF-8";
rb_scan_args(argc, argv, "01", &options);
if (!NIL_P(options))
{
VALUE rencoding, rindent, rlevel;
Check_Type(options, T_HASH);
rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding")));
rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level")));
if (rindent == Qfalse)
indent = 0;
if (rlevel != Qnil)
level = NUM2INT(rlevel);
if (rencoding != Qnil)
encoding = RSTRING_PTR(rxml_input_encoding_to_s(cXMLInput, rencoding));
}
encodingHandler = xmlFindCharEncodingHandler(encoding);
output = xmlAllocOutputBuffer(encodingHandler);
Data_Get_Struct(self, xmlNode, xnode);
xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, encoding);
xmlOutputBufferFlush(output);
if (output->conv)
return rb_str_new2((const char*) output->conv->content);
else
return rb_str_new2((const char*) output->buffer->content);
}
void XMLNode::GetXML(std::string& out_xml_str, const std::string& encoding, bool user_friendly) const {
out_xml_str.resize(0);
if (!node_) return;
if (node_->type != XML_ELEMENT_NODE) return;
xmlDocPtr doc = node_->doc;
if (doc == NULL) return;
xmlCharEncodingHandlerPtr handler = NULL;
handler = xmlFindCharEncodingHandler(encoding.c_str());
if (handler == NULL) return;
std::map<xmlNsPtr,xmlNsPtr> extns;
CollectExternalNamespaces(node_, extns);
std::string ns_str;
NamespacesToString(extns, ns_str);
out_xml_str.append(ns_str.length(),' ');
//xmlOutputBufferPtr buf = xmlAllocOutputBuffer(handler);
xmlOutputBufferPtr buf =
xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL);
if(buf == NULL) return;
xmlNodeDumpOutput(buf, doc, node_, 0, user_friendly ? 1 : 0, encoding.c_str());
xmlOutputBufferFlush(buf);
//out_xml_str = (char*)(buf->conv ? buf->conv->content : buf->buffer->content);
xmlOutputBufferClose(buf);
InsertExternalNamespaces(out_xml_str, ns_str);
}
/**
* xmlSecEncCtxXmlEncrypt:
* @encCtx: the pointer to <enc:EncryptedData/> processing context.
* @tmpl: the pointer to <enc:EncryptedData/> template node.
* @node: the pointer to node for encryption.
*
* Encrypts @node according to template @tmpl. If requested, @node is replaced
* with result <enc:EncryptedData/> node.
*
* Returns: 0 on success or a negative value if an error occurs.
*/
int
xmlSecEncCtxXmlEncrypt(xmlSecEncCtxPtr encCtx, xmlNodePtr tmpl, xmlNodePtr node) {
xmlOutputBufferPtr output;
int ret;
xmlSecAssert2(encCtx != NULL, -1);
xmlSecAssert2(encCtx->result == NULL, -1);
xmlSecAssert2(tmpl != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2(node->doc != NULL, -1);
/* initialize context and add ID atributes to the list of known ids */
encCtx->operation = xmlSecTransformOperationEncrypt;
xmlSecAddIDs(tmpl->doc, tmpl, xmlSecEncIds);
/* read the template and set encryption method, key, etc. */
ret = xmlSecEncCtxEncDataNodeRead(encCtx, tmpl);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecEncCtxEncDataNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecTransformCtxPrepare(&(encCtx->transformCtx), xmlSecTransformDataTypeBin);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPrepare",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"type=bin");
return(-1);
}
xmlSecAssert2(encCtx->transformCtx.first != NULL, -1);
output = xmlSecTransformCreateOutputBuffer(encCtx->transformCtx.first,
&(encCtx->transformCtx));
if(output == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(encCtx->transformCtx.first)),
"xmlSecTransformCreateOutputBuffer",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* push data thru */
if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncElement)) {
/* get the content of the node */
xmlNodeDumpOutput(output, node->doc, node, 0, 0, NULL);
} else if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncContent)) {
xmlNodePtr cur;
/* get the content of the nodes childs */
for(cur = node->children; cur != NULL; cur = cur->next) {
xmlNodeDumpOutput(output, node->doc, cur, 0, 0, NULL);
}
} else {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_INVALID_TYPE,
"type=%s",
xmlSecErrorsSafeString(encCtx->type));
xmlOutputBufferClose(output);
return(-1);
}
/* close the buffer and flush everything */
ret = xmlOutputBufferClose(output);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlOutputBufferClose",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
encCtx->result = encCtx->transformCtx.result;
xmlSecAssert2(encCtx->result != NULL, -1);
ret = xmlSecEncCtxEncDataNodeWrite(encCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecEncCtxEncDataNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* now we need to update our original document */
if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncElement)) {
/* check if we need to return the replaced node */
if((encCtx->flags & XMLSEC_ENC_RETURN_REPLACED_NODE) != 0) {
ret = xmlSecReplaceNodeAndReturn(node, tmpl, &(encCtx->replacedNodeList));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecReplaceNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(-1);
}
} else {
ret = xmlSecReplaceNode(node, tmpl);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecReplaceNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(-1);
}
}
encCtx->resultReplaced = 1;
} else if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncContent)) {
/* check if we need to return the replaced node */
if((encCtx->flags & XMLSEC_ENC_RETURN_REPLACED_NODE) != 0) {
ret = xmlSecReplaceContentAndReturn(node, tmpl, &(encCtx->replacedNodeList));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecReplaceContentAndReturn",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(-1);
}
} else {
ret = xmlSecReplaceContent(node, tmpl);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecReplaceContent",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(-1);
}
}
encCtx->resultReplaced = 1;
} else {
/* we should've catached this error before */
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_INVALID_TYPE,
"type=%s",
xmlSecErrorsSafeString(encCtx->type));
return(-1);
}
return(0);
}
extern "C" void DebugPrintNodeConst(std::shared_ptr<const ePub3::xml::Node> aNode)
{
auto output = xmlOutputBufferCreateFile(stderr, nullptr);
xmlNodeDumpOutput(output, aNode->Document()->xml(), aNode->xml(), 0, 1, "UTF-8");
xmlOutputBufferClose(output);
}
/**
* gdata_entry_new_from_xmlptr:
* @doc: A xml document pointer
* @ptr: A xml Node pointer
**/
GDataEntry *
gdata_entry_new_from_xmlptr (xmlDocPtr doc, xmlNodePtr cur)
{
GDataEntry *entry;
GDataEntryPrivate *priv;
xmlChar *value = NULL;
xmlOutputBufferPtr buf;
gchar *xmlString;
g_return_val_if_fail(doc != NULL, NULL);
g_return_val_if_fail(cur != NULL, NULL);
if (xmlStrcmp(cur->name, (xmlChar *)"entry")) {
return NULL;
}
entry = gdata_entry_new ();
priv = GDATA_ENTRY_GET_PRIVATE(entry);
buf = xmlAllocOutputBuffer (NULL);
if (buf == NULL) {
xmlString = NULL;
}
else {
xmlNodeDumpOutput (buf, NULL, cur, 0, 1, NULL);
xmlOutputBufferFlush (buf);
if (buf->conv == NULL)
xmlString = g_strdup ((gchar *)buf->buffer->content);
else
xmlString = g_strdup ((gchar *)buf->conv->content);
xmlOutputBufferClose (buf);
}
priv->entry_xml = g_strdup (xmlString);
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if (!xmlStrcmp(cur->name, (xmlChar *)"author")) {
priv->authors = g_slist_prepend(priv->authors, xmlnode_to_author(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"link")) {
priv->links = g_slist_prepend(priv->links, xmlnode_to_link(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"category")) {
priv->categories = g_slist_prepend(priv->categories, xmlnode_to_category(doc, cur));
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"where")) {
priv->location = (gchar *)xmlGetProp (cur, (xmlChar *)"valueString");
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"eventStatus")) {
priv->status = (gchar *)xmlGetProp (cur, (xmlChar *)"value");
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"visibility")) {
priv->visibility = (gchar *)xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"when")) {
priv->start_time = (gchar *)xmlGetProp (cur, (xmlChar *)"startTime");
priv->end_time = (gchar *)xmlGetProp (cur, (xmlChar *)"endTime");
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"recurrence")) {
priv->is_recurrent = TRUE;
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"who")) {
priv->attendees = g_slist_prepend (priv->attendees, xmlnode_to_attendee (doc, cur));
priv->has_attendees = TRUE;
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"sendEventNotifications")) {
priv->send_notification =(gchar *)xmlGetProp (cur, (xmlChar *)"value");
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"comments")) {
/*FIXME Call _comment_to_xml_node */
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"email")) {
priv->email_addresses = g_slist_prepend(priv->email_addresses, xmlnode_to_email_address(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"im")) {
priv->im_addresses = g_slist_prepend(priv->im_addresses, xmlnode_to_im_address(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"organization")) {
priv->organizations = g_slist_prepend(priv->organizations, xmlnode_to_organization(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"phoneNumber")) {
priv->phone_numbers = g_slist_prepend(priv->phone_numbers, xmlnode_to_phone_number(doc, cur));
}
else if (!xmlStrcmp(cur->name, (xmlChar *)"postalAddress")) {
priv->postal_addresses = g_slist_prepend(priv->postal_addresses, xmlnode_to_postal_address(doc, cur));
}
else if (!xmlStrcmp (cur->name, (xmlChar *)"deleted")) {
priv->is_deleted = TRUE;
}
else {
value = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
g_hash_table_insert(priv->field_table, g_strdup((gchar *)cur->name),
g_strdup((gchar *)value));
xmlFree(value);
}
cur = cur->next;
}
return entry;
}
void
goa_ews_autodiscover (GoaObject *goa_object,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GoaAccount *goa_account;
GoaExchange *goa_exchange;
GoaPasswordBased *goa_password;
GSimpleAsyncResult *simple;
AutodiscoverData *data;
AutodiscoverAuthData *auth;
gchar *url1;
gchar *url2;
xmlDoc *doc;
xmlOutputBuffer *buf;
gchar *email;
gchar *host;
gchar *password = NULL;
GError *error = NULL;
g_return_if_fail (GOA_IS_OBJECT (goa_object));
goa_account = goa_object_get_account (goa_object);
goa_exchange = goa_object_get_exchange (goa_object);
goa_password = goa_object_get_password_based (goa_object);
email = goa_account_dup_presentation_identity (goa_account);
host = goa_exchange_dup_host (goa_exchange);
doc = ews_create_autodiscover_xml (email);
buf = xmlAllocOutputBuffer (NULL);
xmlNodeDumpOutput (buf, doc, xmlDocGetRootElement (doc), 0, 1, NULL);
xmlOutputBufferFlush (buf);
url1 = g_strdup_printf (
"https://%s/autodiscover/autodiscover.xml", host);
url2 = g_strdup_printf (
"https://autodiscover.%s/autodiscover/autodiscover.xml", host);
g_free (host);
g_free (email);
/* http://msdn.microsoft.com/en-us/library/ee332364.aspx says we are
* supposed to try $domain and then autodiscover.$domain. But some
* people have broken firewalls on the former which drop packets
* instead of rejecting connections, and make the request take ages
* to time out. So run both queries in parallel and let the fastest
* (successful) one win. */
data = g_slice_new0 (AutodiscoverData);
data->buf = buf;
data->msgs[0] = ews_create_msg_for_url (url1, buf);
data->msgs[1] = ews_create_msg_for_url (url2, buf);
data->session = soup_session_async_new_with_options (
SOUP_SESSION_USE_NTLM, TRUE,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_TIMEOUT, 90,
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
if (G_IS_CANCELLABLE (cancellable)) {
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (
data->cancellable,
G_CALLBACK (ews_autodiscover_cancelled_cb),
data, NULL);
}
simple = g_simple_async_result_new (
G_OBJECT (goa_object), callback,
user_data, goa_ews_autodiscover);
g_simple_async_result_set_check_cancellable (simple, cancellable);
g_simple_async_result_set_op_res_gpointer (
simple, data, (GDestroyNotify) ews_autodiscover_data_free);
goa_password_based_call_get_password_sync (
goa_password, "", &password, cancellable, &error);
/* Sanity check */
g_return_if_fail (
((password != NULL) && (error == NULL)) ||
((password == NULL) && (error != NULL)));
if (error == NULL) {
gchar *username;
username = goa_account_dup_identity (goa_account);
auth = g_slice_new0 (AutodiscoverAuthData);
auth->username = username; /* takes ownership */
auth->password = password; /* takes ownership */
g_signal_connect_data (
data->session, "authenticate",
G_CALLBACK (ews_authenticate), auth,
ews_autodiscover_auth_data_free, 0);
soup_session_queue_message (
data->session, data->msgs[0],
ews_autodiscover_response_cb, simple);
soup_session_queue_message (
data->session, data->msgs[1],
ews_autodiscover_response_cb, simple);
} else {
g_dbus_error_strip_remote_error (error);
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
g_free (url2);
g_free (url1);
xmlFreeDoc (doc);
g_object_unref (goa_account);
g_object_unref (goa_exchange);
g_object_unref (goa_password);
}
