Esempio n. 1
0
void
RL::ListImpl::on_xcap_answer (bool error,
			      std::string value)
{
  if (error) {

    // FIXME: how to properly tell the user?

  } else {

    doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (value.c_str (), value.length ()), xmlFreeDoc);
    if ( !doc)
      doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
    node = xmlDocGetRootElement (doc.get ());
    if (node == NULL
	|| node->name == NULL
	|| !xmlStrEqual (BAD_CAST "list", node->name)) {

      // FIXME : how to properly tell the user?
    } else {

      parse ();
    }
  }
}
Esempio n. 2
0
int 
messageCheckAck(char *messageReceived, int messageSize)
{
    char *path = "/acknowledge";

    xmlDocPtr doc = NULL;
    xmlXPathContextPtr xpathCtx; 
    xmlXPathObjectPtr xpathObj; 

    xmlInitParser();
    doc = xmlRecoverMemory(messageReceived, messageSize);
    if (doc == NULL) { return -1;}
    
    xpathCtx = xmlXPathNewContext(doc);
    if(xpathCtx == NULL) { 
        xmlFreeDoc(doc);
        return -1;
    }

    xpathObj = xmlXPathEvalExpression(BAD_CAST path, xpathCtx);
    if(xpathObj->nodesetval->nodeTab == NULL){
        xmlXPathFreeContext(xpathCtx); 
        xmlFreeDoc(doc); 
        return(0);
    }

    xmlXPathFreeObject(xpathObj);
    xmlXPathFreeContext(xpathCtx); 
    xmlFreeDoc(doc);
    xmlCleanupParser();

    return 1;
}
Esempio n. 3
0
void
RL::Heap::parse_doc (std::string raw)
{
  doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);
  if ( !doc)
    doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
  xmlNodePtr doc_root = xmlDocGetRootElement (doc.get ());

  if (doc_root == NULL
      || doc_root->name == NULL
      || !xmlStrEqual (BAD_CAST "resource-lists", doc_root->name)) {

    std::cout << "Invalid document in " << __PRETTY_FUNCTION__ << std::endl;
    // FIXME: warn the user somehow?
    doc.reset ();
  } else {


    for (xmlNodePtr child = doc_root->children;
	 child != NULL;
	 child = child->next)
      if (child->type == XML_ELEMENT_NODE
	  && child->name != NULL
	  && xmlStrEqual (BAD_CAST ("list"), child->name)) {

	parse_list (child);
	break; // read only one!
      }
  }
}
static xmlDocPtr
idol_pl_parser_parse_xml_file (GFile *file)
{
	xmlDocPtr doc;
	char *contents;
	gsize size;

	if (g_file_load_contents (file, NULL, &contents, &size, NULL, NULL) == FALSE)
		return NULL;

	/* Try to remove HTML style comments */
	{
		char *needle;

		while ((needle = strstr (contents, "<!--")) != NULL) {
			while (strncmp (needle, "-->", 3) != 0) {
				*needle = ' ';
				needle++;
				if (*needle == '\0')
					break;
			}
		}
	}

	doc = xmlParseMemory (contents, size);
	if (doc == NULL)
		doc = xmlRecoverMemory (contents, size);
	g_free (contents);

	return doc;
}
Esempio n. 5
0
void
RL::Entry::on_xcap_answer (bool error,
			   std::string value)
{
  if (error) {

    set_note (value);

  } else {

    doc = boost::shared_ptr<xmlDoc> (xmlRecoverMemory (value.c_str (), value.length ()), xmlFreeDoc);
    if ( !doc)
      doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);

    node = xmlDocGetRootElement (doc.get ());
    if (node == NULL
        || node->name == NULL
        || !xmlStrEqual (BAD_CAST "entry", node->name)) {

      set_note (_("Invalid server data"));
    } else {

      set_note ("");
      parse ();
      updated ();
    }
  }
}
Esempio n. 6
0
LM::Bank::Bank (boost::shared_ptr<Ekiga::PersonalDetails> details_,
		boost::shared_ptr<Dialect> dialect_,
		boost::shared_ptr<Cluster> cluster_):
  details(details_), cluster(cluster_), dialect(dialect_), doc (NULL)
{
  gchar* c_raw = gm_conf_get_string (JABBER_KEY);

  if (c_raw != NULL) { // we already have it in store

    const std::string raw = c_raw;
    doc = xmlRecoverMemory (raw.c_str (), raw.length ());
    xmlNodePtr root = xmlDocGetRootElement (doc);
    if (root == NULL) {

      root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);
      xmlDocSetRootElement (doc, root);
    }

    for (xmlNodePtr child = root->children; child != NULL; child = child->next) {

      if (child->type == XML_ELEMENT_NODE && child->name != NULL && xmlStrEqual (BAD_CAST ("entry"), child->name)) {

	boost::shared_ptr<Account> account (new Account (details, dialect, cluster, child));
	add (account);
      }
    }
    g_free (c_raw);

  } else { // create a new XML document

    doc = xmlNewDoc (BAD_CAST "1.0");
    xmlNodePtr root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);
    xmlDocSetRootElement (doc, root);
  }
}
Esempio n. 7
0
/*Experimental*/
int
messageGetSingleValue(char *messageReceived, int messageSize, char *path, char *value, int valueMaxSize, int decodeB64)
{
    char *tempB64, *temp;  
    int finalSize;
    xmlDocPtr doc = NULL;/* node pointers */
    xmlXPathContextPtr xpathCtx; 
    xmlXPathObjectPtr xpathObj; 

    LIBXML_TEST_VERSION;
    xmlInitParser();
    doc = xmlRecoverMemory(messageReceived, messageSize);
    if (doc == NULL) { return -1;}
    
    xpathCtx = xmlXPathNewContext(doc);
    if(xpathCtx == NULL) { 
        xmlFreeDoc(doc);
        return -1;
    };

    xpathObj = xmlXPathEvalExpression(BAD_CAST path, xpathCtx);
    if(xpathObj == NULL){
        xmlXPathFreeContext(xpathCtx); 
        xmlFreeDoc(doc); 
        return(-1);
    };


    tempB64 = (char *) xmlXPathCastToString (xpathObj);
    if(decodeB64)
    {
        temp = b64decode((unsigned char *) tempB64, strlen(tempB64) , &finalSize);
        free(tempB64);
    }
    else
    {
        temp = tempB64;
        finalSize = strlen(temp);
    }
        

    if( finalSize + 1 <= valueMaxSize)
    {
        memcpy (value, temp, finalSize);
        value[finalSize] = '\0';
    }       
    else
        finalSize = -1;

    free(temp);
    xmlXPathFreeObject(xpathObj);
    xmlXPathFreeContext(xpathCtx); 
    xmlFreeDoc(doc);
    xmlCleanupParser();

    return finalSize;

}
Esempio n. 8
0
/*
 * SCPD URL downloaded.
 */
static void
got_scpd_url (G_GNUC_UNUSED SoupSession *session,
              SoupMessage               *msg,
              GetSCPDURLData            *data)
{
        GUPnPServiceIntrospection *introspection;
        GError *error;
        GUPnPServiceInfoPrivate *priv;

        introspection = NULL;
        error = NULL;

        if (msg->status_code == SOUP_STATUS_CANCELLED)
                return;

        if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
                xmlDoc *scpd;

                scpd = xmlRecoverMemory (msg->response_body->data,
                                         msg->response_body->length);
                if (scpd) {
                        introspection = gupnp_service_introspection_new (scpd);

                        xmlFreeDoc (scpd);
                }

                if (!introspection) {
                        error = g_error_new
                                        (GUPNP_SERVER_ERROR,
                                         GUPNP_SERVER_ERROR_INVALID_RESPONSE,
                                         "Could not parse SCPD");
                }
        } else
                error = _gupnp_error_new_server_error (msg);

        /* prevent the callback from canceling the cancellable
         * (and so freeing data just before we do) */
        if (data->cancellable)
                g_cancellable_disconnect (data->cancellable,
                                          data->cancelled_id);

        priv = gupnp_service_info_get_instance_private (data->info);
        priv->pending_gets = g_list_remove (priv->pending_gets, data);

        data->callback (data->info,
                        introspection,
                        error,
                        data->user_data);

        if (error)
                g_error_free (error);

        get_scpd_url_data_free (data);
}
Esempio n. 9
0
xmlDocPtr XaLibDom::DomFromString(string XmlString) {

    xmlDocPtr XmlDomDoc;

	const char *XmlChar = (char*)XmlString.c_str();

	int XmlStringSize=XmlString.size();
	XmlDomDoc = xmlRecoverMemory(XmlChar,XmlStringSize);

	return XmlDomDoc;
};
Esempio n. 10
0
int
messageRemoveElement(char *original, int originalSize, char *path, char *modified, int maxSize)
{
    int messageSize;
    int result;
    xmlChar *s;
    xmlDocPtr doc = NULL;/* node pointers */
    xmlXPathContextPtr xpathCtx; 
    xmlXPathObjectPtr xpathObj;


    xmlInitParser();
    //xmlKeepBlanksDefault(0);
    doc = xmlRecoverMemory(original, originalSize);
    if (doc == NULL) { return -1;}
    
    xpathCtx = xmlXPathNewContext(doc);
    if(xpathCtx == NULL) { 
        xmlFreeDoc(doc);
        return -1;
    };

    xpathObj = xmlXPathEvalExpression(BAD_CAST path, xpathCtx);
    if(xpathObj == NULL){
        xmlXPathFreeContext(xpathCtx); 
        xmlFreeDoc(doc); 
        return(-1);
    };

    xmlUnlinkNode(xpathObj->nodesetval->nodeTab[0]);
    xmlFreeNode(xpathObj->nodesetval->nodeTab[0]);

    xmlDocDumpMemory(doc, &s, &messageSize);
    if( messageSize + 1 <= maxSize)
    {
        strcpy((char *) modified, (char *) s);
        result = messageSize + 1;
    }       
    else
        result = -1;

    xmlXPathFreeObject(xpathObj);
    xmlXPathFreeContext(xpathCtx); 
    xmlFree(s);
    xmlFreeDoc(doc);
    xmlCleanupParser();

    return result;
}
Esempio n. 11
0
xmlDocPtr XaLibDom::DomFromFile(const vector<string> XmlFilesPath,const int& AddRootTag) {

	xmlDocPtr XmlDomDoc;
    string XmlStringTotal="";

	if (AddRootTag==1){

        XmlStringTotal.append("<root>");

    }

	//ADDING FILE
    int XmlFilesSize=XmlFilesPath.size();

    if(XmlFilesSize>0) {

		unique_ptr<XaLibChar> LibChar (new XaLibChar());
		   
		for(auto i=0; i<XmlFilesSize; i++) {

			string XmlFilePath=XmlFilesPath.at(i).c_str();
            char* XmlFilePathChar=(char*)XmlFilePath.c_str();

            ifstream MyFile;
            MyFile.open(XmlFilePathChar);

            if (MyFile.is_open()){
 
                string TmpString;

                while(getline(MyFile,TmpString) ) {
					
					XaLibChar::ClearReturn(TmpString);
                    //string TmpStringCleared=LibChar->ClearReturn(TmpString);
                    XmlStringTotal.append(TmpString);
                }

                MyFile.close();

            }
        } 
    }
	
	const char *XmlChar = (char*)XmlStringTotal.c_str();
	int XmlStringSize=XmlStringTotal.size();
	XmlDomDoc = xmlRecoverMemory(XmlChar,XmlStringSize);

	return XmlDomDoc;
};
Esempio n. 12
0
/*
 * Public API
 */
Local::Heap::Heap (boost::shared_ptr<Ekiga::PresenceCore> _presence_core,
		   boost::shared_ptr<Local::Cluster> _local_cluster):
  presence_core(_presence_core), local_cluster(_local_cluster), doc ()
{
  xmlNodePtr root;
  gchar *c_raw = gm_conf_get_string (ROSTER_KEY);

  // Build the XML document representing the contacts list from the configuration
  if (c_raw != NULL) {

    const std::string raw = c_raw;
    doc = boost::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);
    if ( !doc)
      doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);

    root = xmlDocGetRootElement (doc.get ());
    if (root == NULL) {

      root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
      xmlDocSetRootElement (doc.get (), root);
    }

    for (xmlNodePtr child = root->children; child != NULL; child = child->next)
      if (child->type == XML_ELEMENT_NODE
	  && child->name != NULL
	  && xmlStrEqual (BAD_CAST ("entry"), child->name))
	add (child);

    g_free (c_raw);

    // Or create a new XML document
  }
  else {

    doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
    root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
    xmlDocSetRootElement (doc.get (), root);

    {
      // add 500, 501 and 520 at ekiga.net in this case!
      std::set<std::string> groups;

      groups.insert (_("Services"));
      add (_("Echo test"), "sip:[email protected]", groups);
      add (_("Conference room"), "sip:[email protected]", groups);
      add (_("Call back test"), "sip:[email protected]", groups);
    }
  }
}
Esempio n. 13
0
/*
 * SCPD URL downloaded.
 */
static void
got_scpd_url (SoupSession    *session,
              SoupMessage    *msg,
              GetSCPDURLData *data)
{
        GUPnPServiceIntrospection *introspection;
        GError *error;

        introspection = NULL;
        error = NULL;

        if (msg->status_code == SOUP_STATUS_CANCELLED)
                return;

        if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
                xmlDoc *scpd;

                scpd = xmlRecoverMemory (msg->response_body->data,
                                         msg->response_body->length);
                if (scpd) {
                        introspection = gupnp_service_introspection_new (scpd);

                        xmlFreeDoc (scpd);
                }

                if (!introspection) {
                        error = g_error_new
                                        (GUPNP_SERVER_ERROR,
                                         GUPNP_SERVER_ERROR_INVALID_RESPONSE,
                                         "Could not parse SCPD");
                }
        } else
                error = _gupnp_error_new_server_error (msg);

        data->info->priv->pending_gets =
                g_list_remove (data->info->priv->pending_gets, data);

        data->callback (data->info,
                        introspection,
                        error,
                        data->user_data);

        if (error)
                g_error_free (error);

        get_scpd_url_data_free (data);
}
OPENLDAP::Source::Source (Ekiga::ServiceCore &_core):
    core(_core), doc(), should_add_ekiga_net_book(false)
{
    xmlNodePtr root;
    gchar *c_raw = gm_conf_get_string (KEY);

    if (c_raw != NULL && strcmp (c_raw, "")) {

        const std::string raw = c_raw;

        doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);
        if ( !doc)
            doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);

        root = xmlDocGetRootElement (doc.get ());

        if (root == NULL) {

            root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
            xmlDocSetRootElement (doc.get (), root);
        }

        migrate_from_3_0_0 ();

        for (xmlNodePtr child = root->children ;
                child != NULL ;
                child = child->next)
            if (child->type == XML_ELEMENT_NODE
                    && child->name != NULL
                    && xmlStrEqual (BAD_CAST "server", child->name))
                add (child);

        g_free (c_raw);
    } else {

        doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
        root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
        xmlDocSetRootElement (doc.get (), root);

        should_add_ekiga_net_book = true;
    }

    if (should_add_ekiga_net_book)
        new_ekiga_net_book ();
}
Esempio n. 15
0
RL::Cluster::Cluster (Ekiga::ServiceCore& core_): core(core_), doc()
{
  boost::shared_ptr<Ekiga::PresenceCore> presence_core = core.get<Ekiga::PresenceCore> ("presence-core");

  presence_core->presence_received.connect (boost::bind (&RL::Cluster::on_presence_received, this, _1, _2));
  presence_core->status_received.connect (boost::bind (&RL::Cluster::on_status_received, this, _1, _2));
  contacts_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (CONTACTS_SCHEMA));
  std::string raw = contacts_settings->get_string (RL_KEY);

  if (!raw.empty ()) {

    doc = boost::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);
    if ( !doc)
      doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);

    xmlNodePtr root = xmlDocGetRootElement (doc.get ());
    if (root == NULL) {

      root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
      xmlDocSetRootElement (doc.get (), root);
    } else {

      for (xmlNodePtr child = root->children;
	   child != NULL;
	   child = child->next)
	if (child->type == XML_ELEMENT_NODE
	    && child->name != NULL
	    && xmlStrEqual (BAD_CAST "entry", child->name))
	  add (child);
    }

  } else {

    doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
    xmlNodePtr root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL);
    xmlDocSetRootElement (doc.get (), root);
    add ("https://xcap.sipthor.net/xcap-root", "alice", "123", "*****@*****.**", "XCAP Test", false); // FIXME: remove
  }
}
Esempio n. 16
0
OPENLDAP::Source::Source (Ekiga::ServiceCore &_core): core(_core), doc(NULL)
{
  xmlNodePtr root;
  gchar *c_raw = gm_conf_get_string (KEY);

  if (c_raw != NULL && strcmp (c_raw, "")) {

    const std::string raw = c_raw;

    doc = xmlRecoverMemory (raw.c_str (), raw.length ());
    if (doc == NULL)
      doc = xmlNewDoc (BAD_CAST "1.0");

    root = xmlDocGetRootElement (doc);

    if (root == NULL) {

      root = xmlNewNode (NULL, BAD_CAST "list");
      xmlDocSetRootElement (doc, root);
    }

    for (xmlNodePtr child = root->children ;
	 child != NULL ;
	 child = child->next)
      if (child->type == XML_ELEMENT_NODE
	  && child->name != NULL
	  && xmlStrEqual (BAD_CAST "server", child->name))
	add (child);

    g_free (c_raw);
  } else {

    doc = xmlNewDoc (BAD_CAST "1.0");
    root = xmlNewNode (NULL, BAD_CAST "list");
    xmlDocSetRootElement (doc, root);

    new_ekiga_net_book ();
  }
}
Esempio n. 17
0
int 
messagecheckDiffieHellmanResponse(
    char *messageReceived, int messageSize ,char *sessionId, char *seqNumber, DH *dh)
{
    char path [128];

	xmlDocPtr doc = NULL;
    xmlXPathContextPtr xpathCtx; 
    xmlXPathObjectPtr xpathObj; 

    xmlInitParser();
    doc = xmlRecoverMemory(messageReceived, messageSize);
    if (doc == NULL) { return -1;}
    
    xpathCtx = xmlXPathNewContext(doc);
    if(xpathCtx == NULL) { 
        xmlFreeDoc(doc);
        return -1;
    }

    strcpy(path, "/diffie-hellman[@sessionId = '");
    strcat(path, sessionId);
    strcat(path, "' and @type= 'serverParam']");

    xpathObj = xmlXPathEvalExpression(BAD_CAST path, xpathCtx);
    if(xpathObj == NULL){
        xmlXPathFreeContext(xpathCtx); 
        xmlFreeDoc(doc); 
        return(-1);
    }

    xmlXPathFreeObject(xpathObj);
    xmlXPathFreeContext(xpathCtx); 
    xmlFreeDoc(doc);
    xmlCleanupParser();

    return 0;
}
Esempio n. 18
0
static void
proxy_call_browse_grlnet_async_cb (GObject *source_object,
                                   GAsyncResult *res,
                                   gpointer user_data)
{
  RaitvOperation    *op = (RaitvOperation *) user_data;
  xmlDocPtr           doc = NULL;
  xmlXPathContextPtr  xpath = NULL;
  xmlXPathObjectPtr   obj = NULL;
  gint i, nb_items = 0;
  gsize length;


  GRL_DEBUG ("Response id=%u", op->operation_id);

  GError *wc_error = NULL;
  GError *error = NULL;
  gchar *content = NULL;

  if (g_cancellable_is_cancelled (op->cancellable)) {
    goto finalize;
  }


  if (!grl_net_wc_request_finish (GRL_NET_WC (source_object),
                                  res,
                                  &content,
                                  &length,
                                  &wc_error)) {
    error = g_error_new (GRL_CORE_ERROR,
                         GRL_CORE_ERROR_SEARCH_FAILED,
                         _("Failed to browse: %s"),
                         wc_error->message);

    op->callback (op->source,
                  op->operation_id,
                  NULL,
                  0,
                  op->user_data,
                  error);

    g_error_free (wc_error);
    g_error_free (error);

    return;
  }

  doc = xmlRecoverMemory (content, (gint) length);

  if (!doc) {
    GRL_DEBUG ("Doc failed");
    goto finalize;
  }

  xpath = xmlXPathNewContext (doc);
  if (!xpath) {
    GRL_DEBUG ("Xpath failed");
    goto finalize;
  }

  gchar* xquery=NULL;
  switch (classify_media_id (op->container_id))
    {
    case RAITV_MEDIA_TYPE_POPULAR_THEME:
      xquery = "/CLASSIFICAVISTI/content";
      break;
    case RAITV_MEDIA_TYPE_RECENT_THEME:
      xquery = "/INFORMAZIONICONTENTS/content";
      break;
    default:
      goto finalize;
    }

  obj = xmlXPathEvalExpression ((xmlChar *) xquery, xpath);
  if (obj)
    {
      nb_items = xmlXPathNodeSetGetLength (obj->nodesetval);
      xmlXPathFreeObject (obj);
    }

  if (nb_items < op->count)
    op->count = nb_items;

  op->category_info->count = nb_items;

  for (i = 0; i < nb_items; i++)
    {

      //Skip
      if(op->skip>0) {
        op->skip--;
        continue;
      }

      GrlRaitvSource *source = GRL_RAITV_SOURCE (op->source);
      GList *mapping = source->priv->raitv_browse_mappings;
      GrlMedia *media = grl_media_video_new ();

      while (mapping)
        {
          gchar *str;
          gchar *strvalue;

          RaitvAssoc *assoc = (RaitvAssoc *) mapping->data;
          str = g_strdup_printf ("string(%s[%i]/%s)",
                                 xquery,i + 1, assoc->exp);


          obj = xmlXPathEvalExpression ((xmlChar *) str, xpath);
          if (obj)
            {
              if (obj->stringval && obj->stringval[0] != '\0')
                {
                  strvalue = 	g_strdup((gchar *) obj->stringval);
                  //Sometimes GRL_METADATA_KEY_THUMBNAIL doesn't report complete url
                  if(assoc->grl_key == GRL_METADATA_KEY_THUMBNAIL && !g_str_has_prefix(strvalue,"http://www.rai.tv/")) {
                    strvalue = g_strdup_printf("http://www.rai.tv%s",obj->stringval);
                  }

                  GType _type;
                  _type = grl_metadata_key_get_type (assoc->grl_key);
                  switch (_type)
                    {
                    case G_TYPE_STRING:
                      grl_data_set_string (GRL_DATA (media),
                                           assoc->grl_key,
                                           strvalue);
                      break;

                    case G_TYPE_INT:
                      grl_data_set_int (GRL_DATA (media),
                                        assoc->grl_key,
                                        (gint) atoi (strvalue));
                      break;

                    case G_TYPE_FLOAT:
                      grl_data_set_float (GRL_DATA (media),
                                          assoc->grl_key,
                                          (gfloat) atof (strvalue));
                      break;

                    default:
                      /* G_TYPE_DATE_TIME is not a constant, so this has to be
                       * in "default:" */
                      if (_type == G_TYPE_DATE_TIME) {
                        int year,month,day,hour,minute,seconds;
                        sscanf((const char*)obj->stringval, "%02d/%02d/%04d %02d:%02d:%02d",
                               &day, &month, &year, &hour,&minute, &seconds);
                        GDateTime *date = g_date_time_new_local (year, month, day, hour,minute, seconds);
                        grl_data_set_boxed (GRL_DATA (media),
                                            assoc->grl_key, date);
                        if(date) g_date_time_unref (date);
                      } else {
                        GRL_DEBUG ("\tUnexpected data type: %s",
                                   g_type_name (_type));
                      }
                      break;
                    }
                  g_free (strvalue);
                }
              xmlXPathFreeObject (obj);
            }

          g_free (str);

          mapping = mapping->next;
        }

      op->callback (op->source,
                    op->operation_id,
                    media,
                    --op->count,
                    op->user_data,
                    NULL);

      if (op->count == 0) {
        break;
      }
    }

 finalize:
  g_clear_pointer (&xpath, xmlXPathFreeContext);
  g_clear_pointer (&doc, xmlFreeDoc);

  /* Signal the last element if it was not already signaled */
  if (nb_items == 0) {
    op->callback (op->source,
                  op->operation_id,
                  NULL,
                  0,
                  op->user_data,
                  NULL);
  }
  else {
    //Continue the search
    if(op->count>0) {
      //Skip the ones already read
      op->skip +=  nb_items;
      op->offset +=  nb_items;
      switch (classify_media_id (op->container_id))
		  {
        case RAITV_MEDIA_TYPE_POPULAR_THEME:
          produce_from_popular_theme(op);
          break;
        case RAITV_MEDIA_TYPE_RECENT_THEME:
          produce_from_recent_theme(op);
          break;
        default:
          g_assert_not_reached ();
          break;
		  }

    }
  }

}
Esempio n. 19
0
/*
 * Description URL downloaded.
 */
static void
got_description_url (G_GNUC_UNUSED SoupSession *session,
                     SoupMessage               *msg,
                     GetDescriptionURLData     *data)
{
        GUPnPXMLDoc *doc;

        if (msg->status_code == SOUP_STATUS_CANCELLED)
                return;

        /* Now, make sure again this document is not already cached. If it is,
         * we re-use the cached one. */
        doc = g_hash_table_lookup (data->control_point->priv->doc_cache,
                                   data->description_url);
        if (doc) {
                /* Doc was cached */
                description_loaded (data->control_point,
                                    doc,
                                    data->udn,
                                    data->service_type,
                                    data->description_url);

                get_description_url_data_free (data);

                return;
        }

        /* Not cached */
        if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
                xmlDoc *xml_doc;

                /* Parse response */
                xml_doc = xmlRecoverMemory (msg->response_body->data,
                                            msg->response_body->length);
                if (xml_doc) {
                        doc = gupnp_xml_doc_new (xml_doc);

                        description_loaded (data->control_point,
                                            doc,
                                            data->udn,
                                            data->service_type,
                                            data->description_url);

                        /* Insert into document cache */
                        g_hash_table_insert
                                          (data->control_point->priv->doc_cache,
                                           g_strdup (data->description_url),
                                           doc);

                        /* Make sure the document is removed from the cache
                         * once finalized. */
                        g_object_weak_ref (G_OBJECT (doc),
                                           doc_finalized,
                                           data->control_point);

                        /* If no proxy was created, make sure doc is freed. */
                        g_object_unref (doc);
                } else
                        g_warning ("Failed to parse %s", data->description_url);
        } else
                g_warning ("Failed to GET %s: %s",
                           data->description_url,
                           msg->reason_phrase);

        get_description_url_data_free (data);
}
Esempio n. 20
0
/* simple function to retrieve an OPML document and 
   parse and output all depth 1 outline tags as
   HTML into a buffer */
static void
ns_blogChannel_download_request_cb (const struct updateResult * const result, gpointer user_data, guint32 flags)
{
	struct requestData	*requestData = user_data;
	xmlDocPtr 		doc = NULL;
	xmlNodePtr 		cur;
	GString			*buffer = NULL;

	g_assert (NULL != requestData);

	if (result->data) {
		buffer = g_string_new (NULL);
		
		while (1) {
			doc = xmlRecoverMemory (result->data, result->size);

			if (NULL == doc)
				break;

			if (NULL == (cur = xmlDocGetRootElement (doc)))
				break;

			if (!xmlStrcmp (cur->name, BAD_CAST"opml") ||
			    !xmlStrcmp (cur->name, BAD_CAST"oml") ||
			    !xmlStrcmp (cur->name, BAD_CAST"outlineDocument")) {
		   		/* nothing */
			} else
				break;

			cur = cur->xmlChildrenNode;
			while (cur) {
				if (!xmlStrcmp (cur->name, BAD_CAST"body")) {
					/* process all <outline> tags */
					cur = cur->xmlChildrenNode;
					while (cur) {
						if (!xmlStrcmp (cur->name, BAD_CAST"outline")) {
							GString *tmp = getOutlineContents (cur);
							g_string_append_printf (buffer, "%s<br />", tmp->str);
							g_string_free (tmp, TRUE);
						}
						cur = cur->next;
					}
					break;
				}
				cur = cur->next;
			}
			break;		
		}

		if (doc)
			xmlFreeDoc (doc);
	}

	if (buffer) {
		switch (requestData->tag) {
			case TAG_BLOGROLL:
				g_string_prepend (buffer, BLOGROLL_START);
				g_string_append (buffer, BLOGROLL_END);
				g_hash_table_insert (requestData->ctxt->tmpdata, g_strdup ("bC:blogRoll"), buffer->str);
				break;
			case TAG_MYSUBSCRIPTIONS:
				g_string_prepend (buffer, MYSUBSCR_START);
				g_string_append (buffer, MYSUBSCR_END);
				g_hash_table_insert (requestData->ctxt->tmpdata, g_strdup ("bC:mySubscriptions"), buffer->str);
				break;
			default:
				g_error ("wrong requestData->tag value");
				break;
		}

		g_string_free (buffer, FALSE);

		buffer = g_string_new (NULL);
		g_string_append (buffer, g_hash_table_lookup (requestData->ctxt->tmpdata, "bC:blink"));
		g_string_append (buffer, g_hash_table_lookup (requestData->ctxt->tmpdata, "bC:blogRoll"));
		g_string_append (buffer, g_hash_table_lookup (requestData->ctxt->tmpdata, "bC:mySubscriptions"));
		metadata_list_set (&(requestData->ctxt->subscription->metadata), "blogChannel", buffer->str);
		g_string_free (buffer, TRUE);
	}
	g_list_free (requestData->ctxt->items);
	feed_free_parser_ctxt (requestData->ctxt);
	g_free (requestData);
}
Esempio n. 21
0
static void
proxy_call_resolve_grlnet_async_cb (GObject *source_object,
                                    GAsyncResult *res,
                                    gpointer user_data)
{
  RaitvOperation     *op = (RaitvOperation *) user_data;
  xmlDocPtr           doc = NULL;
  xmlXPathContextPtr  xpath = NULL;
  GError             *wc_error = NULL;
  GError             *error = NULL;
  gchar              *content = NULL;
  gsize               length;
  gchar              *value;
  gchar              *thumbnail;
  gchar             **tokens;
  GDateTime          *date;

  GRL_DEBUG ("Response id=%u", op->operation_id);

  if (g_cancellable_is_cancelled (op->cancellable)) {
    goto finalize;
  }


  if (!grl_net_wc_request_finish (GRL_NET_WC (source_object),
                                  res,
                                  &content,
                                  &length,
                                  &wc_error)) {
    error = g_error_new (GRL_CORE_ERROR,
                         GRL_CORE_ERROR_SEARCH_FAILED,
                         _("Failed to resolve: %s"),
                         wc_error->message);

    op->resolveCb (op->source,
                   op->operation_id,
                   op->media,
                   op->user_data,
                   error);

    g_error_free (wc_error);
    g_error_free (error);

    return;
  }

  doc = xmlRecoverMemory (content, (gint) length);

  if (!doc) {
    GRL_DEBUG ("Doc failed");
    goto finalize;
  }

  xpath = xmlXPathNewContext (doc);
  if (!xpath) {
    GRL_DEBUG ("Xpath failed");
    goto finalize;
  }

  if (!grl_data_has_key (GRL_DATA (op->media), GRL_METADATA_KEY_URL)) {
    value = eval_xquery ("/html/head/meta[@name='videourl']", xpath);
    if (value) {
      grl_media_set_url (op->media, value);
      g_free (value);
    }
  }

  if (!grl_data_has_key (GRL_DATA (op->media), GRL_METADATA_KEY_TITLE)) {
    value = eval_xquery ("/html/head/meta[@name='title']", xpath);
    if (value) {
      grl_media_set_title (op->media, value);
      g_free (value);
    }
  }

  if (!grl_data_has_key (GRL_DATA (op->media), GRL_METADATA_KEY_PUBLICATION_DATE)) {
    value = eval_xquery ("/html/head/meta[@name='itemDate']", xpath);
    if (value) {
      tokens = g_strsplit (value, "/", -1);
      if (g_strv_length (tokens) >= 3) {
        date = g_date_time_new_local (atoi (tokens[2]), atoi (tokens[1]), atoi (tokens[0]), 0, 0, 0);
        grl_media_set_publication_date (op->media, date);
        g_date_time_unref (date);
      }
      g_strfreev (tokens);
      g_free (value);
    }
  }

  if (!grl_data_has_key (GRL_DATA (op->media), GRL_METADATA_KEY_THUMBNAIL)) {
    value = eval_xquery ("/html/head/meta[@name='vod-image']", xpath);
    if (value) {
      /* Sometimes thumbnail doesn't report a complete url */
      if (value[0] == '/') {
        thumbnail = g_strconcat ("http://www.rai.tv", value, NULL);
        g_free (value);
      } else {
        thumbnail = value;
      }

      grl_media_set_thumbnail (op->media, thumbnail);
      g_free (thumbnail);
    }
  }

 finalize:
  op->resolveCb (op->source,
                 op->operation_id,
                 op->media,
                 op->user_data,
                 NULL);

  g_clear_pointer (&xpath, xmlXPathFreeContext);
  g_clear_pointer (&doc, xmlFreeDoc);
}
Esempio n. 22
0
/**
 * gupnp_service_info_get_introspection
 * @info: A #GUPnPServiceInfo
 * @error: return location for a #GError, or %NULL
 *
 * Note that introspection object is created from the information in service
 * description document (SCPD) provided by the service so it can not be created
 * if the service does not provide an SCPD.
 *
 * Warning: You  should use gupnp_service_info_get_introspection_async()
 * instead, this function re-enter the GMainloop before returning.
 *
 * Return value: (transfer full):  A new #GUPnPServiceIntrospection for this
 * service or %NULL. Unref after use.
 **/
GUPnPServiceIntrospection *
gupnp_service_info_get_introspection (GUPnPServiceInfo *info,
                                      GError          **error)
{
        GUPnPServiceIntrospection *introspection;
        SoupSession *session;
        SoupMessage *msg;
        int status;
        char *scpd_url;
        xmlDoc *scpd;

        g_return_val_if_fail (GUPNP_IS_SERVICE_INFO (info), NULL);

        introspection = NULL;

        scpd_url = gupnp_service_info_get_scpd_url (info);

        msg = NULL;
        if (scpd_url != NULL) {
                msg = soup_message_new (SOUP_METHOD_GET, scpd_url);

                g_free (scpd_url);
        }

        if (msg == NULL) {
                g_set_error (error,
                             GUPNP_SERVER_ERROR,
                             GUPNP_SERVER_ERROR_INVALID_URL,
                             "No valid SCPD URL defined");

                return NULL;
        }

        /* Send off the message */
        session = gupnp_context_get_session (info->priv->context);

        status = soup_session_send_message (session, msg);
        if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
                _gupnp_error_set_server_error (error, msg);

                g_object_unref (msg);

                return NULL;
        }

        scpd = xmlRecoverMemory (msg->response_body->data,
                                 msg->response_body->length);

        g_object_unref (msg);

        if (scpd) {
                introspection = gupnp_service_introspection_new (scpd);

                xmlFreeDoc (scpd);
        }

        if (!introspection) {
                g_set_error (error,
                             GUPNP_SERVER_ERROR,
                             GUPNP_SERVER_ERROR_INVALID_RESPONSE,
                             "Could not parse SCPD");
        }

        return introspection;
}
Esempio n. 23
0
xmlDocPtr XaLibDom::DomFromStringAndFile(const VectorXmlFilePath& XmlFiles,const VectorXmlString& XmlStrings,const int& AddRootTag) {

	xmlDocPtr XmlDomDoc;
    string XmlStringTotal="";
    
    if (AddRootTag==1){

        XmlStringTotal.append("<root>");

    } else if(AddRootTag==2){

        XmlStringTotal.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
        XmlStringTotal.append("<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">");
        XmlStringTotal.append("<xsl:output method=\"html\" encoding=\"UTF-8\"/>");
    }

    //ADDING FILE
    int XmlFilesSize=XmlFiles.size();

    if(XmlFilesSize>0) {

		unique_ptr<XaLibChar> LibChar (new XaLibChar());
		   
		for(int i=0; i<XmlFilesSize; i++) {

			string XmlFilePath=XmlFiles.at(i).c_str();
            char* XmlFilePathChar=(char*)XmlFilePath.c_str();

            ifstream MyFile;
            MyFile.open(XmlFilePathChar);

            if (MyFile.is_open()){
 
                string TmpString;

                while(getline(MyFile,TmpString) ) {

					XaLibChar::ClearReturn(TmpString);
                    //string TmpStringCleared=LibChar->ClearReturn(TmpString);
                    XmlStringTotal.append(TmpString);
                }

                MyFile.close();

            }
        } 
    }

    //ADDING STRINGS
    int XmlStringsSize=XmlStrings.size();

    if(XmlStringsSize>0) {

		for(int j=0; j<XmlStringsSize; j++) {

			string XmlString=XmlStrings.at(j).c_str();

            XmlStringTotal.append(XmlString);

            }
        }

    if (AddRootTag==1){

        XmlStringTotal.append("</root>");

    } else if(AddRootTag==2){

        XmlStringTotal.append("</xsl:stylesheet>");

    }

	const char *XmlChar = (char*)XmlStringTotal.c_str();
	int XmlStringSize=XmlStringTotal.size();
	XmlDomDoc = xmlRecoverMemory(XmlChar,XmlStringSize);

	return XmlDomDoc;
};
/**
 * gupnp_didl_lite_parser_parse_didl_recursive:
 * @parser: A #GUPnPDIDLLiteParser
 * @didl: The DIDL-Lite XML string to be parsed
 * @error: The location where to store any error, or %NULL
 *
 * Parses DIDL-Lite XML string @didl, emitting the ::object-available,
 * ::item-available and ::container-available signals appropriately during the
 * process.
 *
 * Return value: TRUE on success.
 **/
gboolean
gupnp_didl_lite_parser_parse_didl_recursive (GUPnPDIDLLiteParser *parser,
                                             const char          *didl,
                                             gboolean             recursive,
                                             GError             **error)
{
        xmlDoc        *doc;
        xmlNode       *element;
        xmlNs         *upnp_ns = NULL;
        xmlNs         *dc_ns   = NULL;
        xmlNs         *dlna_ns = NULL;
        xmlNs         *pv_ns   = NULL;
        GUPnPAVXMLDoc *xml_doc = NULL;
        gboolean       result;

        doc = xmlRecoverMemory (didl, strlen (didl));
        if (doc == NULL) {
                g_set_error (error,
                             G_MARKUP_ERROR,
                             G_MARKUP_ERROR_PARSE,
                             "Could not parse DIDL-Lite XML:\n%s", didl);

                return FALSE;
        }

        /* Get a pointer to root element */
        element = xml_util_get_element ((xmlNode *) doc,
                                        "DIDL-Lite",
                                        NULL);
        if (element == NULL) {
                g_set_error (error,
                             G_MARKUP_ERROR,
                             G_MARKUP_ERROR_PARSE,
                             "No 'DIDL-Lite' node in the DIDL-Lite XML:\n%s",
                             didl);
                xmlFreeDoc (doc);

                return FALSE;
        }

        if (element->children == NULL) {
                g_set_error (error,
                             G_MARKUP_ERROR,
                             G_MARKUP_ERROR_EMPTY,
                             "Empty 'DIDL-Lite' node in the DIDL-Lite XML:\n%s",
                             didl);
                xmlFreeDoc (doc);

                return FALSE;
        }

        /* Create namespaces if they don't exist */
        upnp_ns = xml_util_lookup_namespace (doc, GUPNP_XML_NAMESPACE_UPNP);
        if (! upnp_ns)
                upnp_ns = xml_util_create_namespace (xmlDocGetRootElement (doc),
                                                     GUPNP_XML_NAMESPACE_UPNP);

        dc_ns = xml_util_lookup_namespace (doc, GUPNP_XML_NAMESPACE_DC);
        if (! dc_ns)
                dc_ns = xml_util_create_namespace (xmlDocGetRootElement (doc),
                                                   GUPNP_XML_NAMESPACE_DC);
        dlna_ns = xml_util_lookup_namespace (doc, GUPNP_XML_NAMESPACE_DLNA);
        if (! dlna_ns)
                dlna_ns = xml_util_create_namespace (xmlDocGetRootElement (doc),
                                                   GUPNP_XML_NAMESPACE_DLNA);

        pv_ns = xml_util_lookup_namespace (doc, GUPNP_XML_NAMESPACE_PV);
        if (! pv_ns)
                pv_ns = xml_util_create_namespace (xmlDocGetRootElement (doc),
                                                   GUPNP_XML_NAMESPACE_PV);

        xml_doc = xml_doc_new (doc);

        result = parse_elements (parser,
                                 element,
                                 xml_doc,
                                 upnp_ns,
                                 dc_ns,
                                 dlna_ns,
                                 pv_ns,
                                 recursive,
                                 error);
        xml_doc_unref (xml_doc);

        return result;
}
Esempio n. 25
0
/**
 * gupnp_feature_list_parser_parse_text:
 * @parser: A #GUPnPFeatureListParser
 * @text: The feature list string to be parsed
 * @error: The location where to store the error information if any, or NULL
 *
 * Parses @text and returns the list of available features.
 * If an error occured @error will be set.
 *
 * Return value: (transfer full) (element-type GUPnPFeature): The list of
 * features or %NULL if an error occured.
 **/
GList *
gupnp_feature_list_parser_parse_text
                                 (G_GNUC_UNUSED GUPnPFeatureListParser *parser,
                                  const char             *text,
                                  GError                **error)
{
        xmlDoc       *doc;
        xmlNode      *element;
        GList        *feature_list = NULL;

        doc = xmlRecoverMemory (text, strlen (text));
        if (doc == NULL) {
                g_set_error (error,
                             G_MARKUP_ERROR,
                             G_MARKUP_ERROR_PARSE,
                             "Could not parse FeatureList XML:\n%s", text);

                return NULL;
        }

        /* Get a pointer to root element */
        element = av_xml_util_get_element ((xmlNode *) doc, "Features", NULL);
        if (element == NULL) {
                g_set_error (error,
                             G_MARKUP_ERROR,
                             G_MARKUP_ERROR_PARSE,
                             "No 'Features' node in the XML:\n%s",
                             text);
                xmlFreeDoc (doc);

                return NULL;
        }

        for (element = element->children; element; element = element->next) {
                GUPnPFeature *feature;
                const char   *name;
                const char   *version;
                char         *object_ids;

                if (g_ascii_strcasecmp ((char *) element->name,
                                        "Feature") == 0) {
                        name = av_xml_util_get_attribute_content (element,
                                                                  "name");
                        version = av_xml_util_get_attribute_content (element,
                                                                     "version");
                        if (!name || !version) {
                                g_set_error (error,
                                             G_MARKUP_ERROR,
                                             G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
                                             "Invalid attributes in 'Feature' "
                                             "node in the XML:\n%s",
                                             text);

                                xmlFreeDoc (doc);
                                if (feature_list)
                                        g_list_free_full (feature_list,
                                                          g_object_unref);

                                return NULL;
                        }

                        object_ids = get_feature_object_ids (element);

                        feature = g_object_new (GUPNP_TYPE_FEATURE,
                                                "name", name,
                                                "version", version,
                                                "object-ids", object_ids,
                                                NULL);

                        feature_list = g_list_append (feature_list, feature);

                        g_free (object_ids);
                }
        }

        xmlFreeDoc (doc);

        return feature_list;
}