Example #1
0
int main(int argc, char **argv)
{
    xmlDocPtr doc;
    char buf[1024];
    FILE *f;
    size_t l;

    printf("- From file\n");
    doc = xmlParseFile(argv[1]);
    printf("encoding: %s\ncharset: %d\n",
           doc->encoding, doc->charset);
    xmlFreeDoc(doc);

    f = fopen(argv[1], "r");
    l = fread(buf, 1, 1024, f);
    
    printf("- From memory\n");
    doc = xmlParseMemory(buf, l);
    printf("encoding: %s\ncharset: %d\n",
           doc->encoding, doc->charset);
    xmlFreeDoc(doc);

    return 0;
}
Example #2
0
Map* parseDoc(char* filename){

	xmlDocPtr doc;
	xmlNodePtr root_element;
	doc = xmlParseFile(filename);

	if (doc == NULL) {
		fprintf(stderr, "Failed to parse %s\n", filename);
		return NULL;
	}

	root_element = xmlDocGetRootElement(doc);

	if (root_element == NULL){
		fprintf(stderr, "empty document\n");
		xmlFreeDoc(doc);
		return NULL;
	}

	Map* map = malloc(sizeof(Map));
	map = parseElements(doc, root_element);
	xmlFreeDoc(doc);
	return map;
}
short ParseFlowListTag( char *fname, void **list )
{
	xmlDocPtr doc = NULL;
	xmlNodePtr current;
	FLOWCOMP rootComp;
	short result = -1;

	if ( list == NULL ) goto Err1;

	if ( (doc = xmlParseFile( fname )) == NULL ) goto Err1;
	current = xmlDocGetRootElement( doc );
	if ( (current == NULL) || xmlStrcmp( current->name, (const xmlChar *)"maintenance-resource" ) ){
		goto Err2;
	}

	memset( &rootComp, 0, sizeof(FLOWCOMP) );
	current = current->xmlChildrenNode;
	while ( current != NULL ){
		if ( (!xmlStrcmp( current->name, (const xmlChar *)"flowlist" )) ){
			if ( ParseFlowTag( current->xmlChildrenNode, &rootComp ) != 0 ) goto Err2;
			break;
		}
		current = current->next;
	}

	*list = rootComp.next;
	result = 0;
EXIT:
	xmlFreeDoc( doc );
	return result;

Err2:
	FreeFlowCompList( rootComp.next );
Err1:
	goto EXIT;
}
Example #4
0
int interpret_oglerc(char *filename)
{
  xmlDocPtr doc;
  xmlNodePtr cur;
  
  
  doc = xmlParseFile(filename);


  if(doc != NULL) {

    cur = xmlDocGetRootElement(doc); 


    while(cur != NULL) {
      
      if(!xmlIsBlankNode(cur)) {
	if(!strcmp("ogle_conf", cur->name)) {
	  interpret_ogle_conf(doc, cur);
	}
      }
      cur = cur->next;
    }
    
    xmlFreeDoc(doc);

    return 0;

  } else {

    WARNING("Couldn't load config file\n");

    return -1;

  }
}
bool CZBConfiguration::ReadModelsFile(const char *_file)
{
	std::cout << "parsing models file " << std::string(_file) << std::endl;
	doc = xmlParseFile(_file);
	if(doc==NULL)
	{
		//std::cerr << "XML file " << std::string(_file) << " empty" << std::endl;
		return false;
	}
	root_element = xmlDocGetRootElement(doc);

	for( xmlNode *level_1 = root_element->children ; level_1 != NULL ; level_1 = level_1->next)
	{
		// end_devices_models level
		if(!xmlStrcmp(level_1->name,(const char *)"end_devices_model"))
			for( xmlNode *level_2 = level_1->children ; level_2 != NULL; level_2 = level_2->next)
			{
				// model level
				if(!xmlStrcmp(level_2->name,(const char *)"model"))
					for( xmlNode *level_3 = level2->children; level_3 != NULL ; level_3 = level_3->next )
					{
						// channel level
					}

				if(!xmlStrcmp(level_2->name,(const char *)"models_version"))
				{
				
				}



			}
	}

	return true;	
}
Example #6
0
/***
	loadCfg: This function loads cfg file to RAM memory using libxml API functions
	xmlfile: Cfg's file name
*/
void loadCfg(char *xmlfile)
{
    xmlDoc *doc = NULL;
    xmlNode *root_element = NULL;

    LIBXML_TEST_VERSION

    doc = xmlParseFile(xmlfile);

    if (doc == NULL) {
        printf("error: could not parse file file.xml\n");
	exit(1);
    }

    root_element = xmlDocGetRootElement(doc);

	puts("carregando nodos\n");
    loadNodes(getElement(root_element, "nodes"));
	puts("construindo arestas\n");
    buildGraphFromEdges(getElement(root_element, "edges"));

    xmlFreeDoc(doc);
    xmlCleanupParser();
}
Example #7
0
static void
findTags (void)
{
	xmlNode *i;
	xmlDocPtr doc = xmlParseFile(getInputFileName());
	xmlNode *root;

	if (doc == NULL) {
		g_warning ("could not parse file");
	}
	root = xmlDocGetRootElement(doc);
	for (i = root->children; i; i = i->next)
	{
		xmlNode *j;
		if (!i->name)
			continue;
		if (strcmp ((const char*)i->name, "namespace") !=0)
			continue;
		for (j = i->children; j; j = j->next)
		{
			makeTags (j, NULL);
		}
	}
}
Example #8
0
	int File::loadXML(const char *filename, Context *ctx) {
		xmlDocPtr doc = NULL;
		xmlNodePtr root;
		int length;

		doc = xmlParseFile(filename);
		if (!doc) {
			fprintf(stderr, "could not parse XML\n");
			return false;
		}

		root = doc->xmlRootNode;
		length = setXML(root, ctx);

		xmlFreeDoc(doc);
		return length;

	fail:
		if (doc) {
			xmlFreeDoc(doc);
		}

		return 0;
	}
Example #9
0
bool
load_player_objects_from_file(struct creature *ch, const char *path)
{
    int axs = access(path, W_OK);

    if (axs != 0) {
        if (errno != ENOENT) {
            errlog("Unable to open xml equipment file '%s': %s",
                path, strerror(errno));
            return -1;
        } else {
            return 1;           // normal no eq file
        }
    }
    xmlDocPtr doc = xmlParseFile(path);
    if (!doc) {
        errlog("XML parse error while loading %s", path);
        return -1;
    }

    xmlNodePtr root = xmlDocGetRootElement(doc);
    if (!root) {
        xmlFreeDoc(doc);
        errlog("XML file %s is empty", path);
        return 1;
    }

    for (xmlNodePtr node = root->xmlChildrenNode; node; node = node->next) {
        if (xmlMatches(node->name, "object"))
            (void)load_object_from_xml(NULL, ch, NULL, node);
    }

    xmlFreeDoc(doc);

    return 0;
}
Example #10
0
Manifest *create_manifest(const gchar *manifest_file, const unsigned int flags, const gchar *container_filter, const gchar *component_filter)
{
    xmlDocPtr doc;
    xmlNodePtr node_root;
    Manifest *manifest;

    /* Parse the XML document */

    if((doc = xmlParseFile(manifest_file)) == NULL)
    {
        g_printerr("Error with parsing the manifest XML file!\n");
        xmlCleanupParser();
        return NULL;
    }

    /* Retrieve root element */
    node_root = xmlDocGetRootElement(doc);

    if(node_root == NULL)
    {
        g_printerr("The manifest XML file is empty!\n");
        xmlFreeDoc(doc);
        xmlCleanupParser();
        return NULL;
    }

    /* Parse manifest */
    manifest = parse_manifest(node_root, flags, container_filter, component_filter);

    /* Cleanup */
    xmlFreeDoc(doc);
    xmlCleanupParser();

    /* Return manifest */
    return manifest;
}
Example #11
0
/**
 * gpa_printer_new_from_file:
 * @file: 
 * 
 * Load a new printer from @filename, file should contain a XML description
 * 
 * Return Value: 
 **/
static GPANode *
gpa_printer_new_from_file (const gchar *file)
{
	GPANode *printer = NULL;
	xmlDocPtr doc;
	xmlNodePtr node;

	doc = xmlParseFile (file);
	if (!doc) {
		g_warning ("Could not parse %s\n", file);
		return NULL;
	}

	node = doc->xmlRootNode;
	printer = gpa_printer_new_from_tree (node);
	xmlFreeDoc (doc);

	if (!printer || !gpa_node_verify (printer)) {
		g_warning ("Could not load printer from %s", file);
		printer = NULL;
	}
	
	return printer;
}
Example #12
0
GameManager::GameManager () :
	_currentGameDescription(0), _enginePath(GlobalRegistry().get(RKEY_ENGINE_PATH)), _cleanedEnginePath(
			DirectoryCleaned(_enginePath)), _emptyString("")
{
	GlobalRegistry().addKeyObserver(this, RKEY_ENGINE_PATH);

	// greebo: Register this class in the preference system so that the constructPreferencePage() gets called.
	GlobalPreferenceSystem().addConstructor(this);

	// TODO Remove this and read the game.xml data from the xmlregistry, too
	std::string strGameFilename = Environment::Instance().getAppPath() + "game.xml";

	xmlDocPtr pDoc = xmlParseFile(strGameFilename.c_str());
	if (pDoc) {
		_currentGameDescription = new GameDescription(pDoc, strGameFilename);
		// Import this information into the registry
		//GlobalRegistry().importFromFile(strGameFilename, "");
		xmlFreeDoc(pDoc);
	} else {
		gtkutil::errorDialog(_("XML parser failed to parse game.xml"));
	}

	initialise();
}
Example #13
0
int config_parse_file(const char *filename, ice_config_t *configuration)
{
    xmlDocPtr doc;
    xmlNodePtr node;

    if (filename == NULL || strcmp(filename, "") == 0) return CONFIG_EINSANE;
    
    xmlInitParser();
    doc = xmlParseFile(filename);
    if (doc == NULL) {
        return CONFIG_EPARSE;
    }

    node = xmlDocGetRootElement(doc);
    if (node == NULL) {
        xmlFreeDoc(doc);
        xmlCleanupParser();
        return CONFIG_ENOROOT;
    }

    if (strcmp(node->name, "icecast") != 0) {
        xmlFreeDoc(doc);
        xmlCleanupParser();
        return CONFIG_EBADROOT;
    }

    config_init_configuration(configuration);

    configuration->config_filename = (char *)strdup(filename);

    _parse_root(doc, node->xmlChildrenNode, configuration);

    xmlFreeDoc(doc);

    return 0;
}
Example #14
0
void readinput_init(){
  if(myid == 0) {

  doc = xmlParseFile("input");
  if (doc == NULL ) {
    fprintf(stderr,"input file not parsed successfully. \n");
#if defined(HAVE_MPI)
    MPI_Finalize();
#endif
    exit(0);
  }
  cur = xmlDocGetRootElement(doc);

  if (cur == NULL) {
    fprintf(stderr,"input file is empty\n");
    xmlFreeDoc(doc);
#if defined(HAVE_MPI)
    MPI_Finalize();
#endif
    exit(0);
  }

}
}
Example #15
0
void create_file(char *to, char *from, char *msg){
	int rc;
	xmlTextWriterPtr writer;
	xmlDocPtr doc;
	xmlNodePtr node, root;
	xmlChar *tmp;

	if(doc = xmlParseFile(to)){
		root = xmlDocGetRootElement(doc);

		xmlNodePtr pNode = xmlNewNode(0, (xmlChar*)"mes");
		//xmlSetProp(pNode, (const xmlChar*) "id", (const xmlChar*) "val");
		xmlSetProp(pNode, (const xmlChar*) "from", (const xmlChar*) from);
		xmlNodeSetContent(pNode, (xmlChar*)msg);
		xmlAddChild(root, pNode);

		xmlSaveFileEnc(to, doc, MY_ENCODING);
		xmlFreeDoc(doc);
	}else{
		doc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
		node = xmlNewDocNode(doc, NULL, BAD_CAST "inbox", NULL);
		xmlDocSetRootElement(doc, node);
		writer = xmlNewTextWriterTree(doc, node, 0);
		rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
		rc = xmlTextWriterStartElement(writer, BAD_CAST "mes");
		//rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "id", BAD_CAST "1");
		rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "from", BAD_CAST from);
		rc = xmlTextWriterEndAttribute(writer);
		rc = xmlTextWriterWriteString(writer, (const xmlChar*) msg);
		rc = xmlTextWriterEndElement(writer);
		rc = xmlTextWriterEndDocument(writer);
		xmlFreeTextWriter(writer);
		xmlSaveFileEnc(to, doc, MY_ENCODING);
		xmlFreeDoc(doc);
	}
}
Example #16
0
/**
 *
 * @param fileName Full path to the XML file to be read
 * @return true if the file could be read and parsed. Else false.
 */
bool XMLConfParser::readFile(std::string fileName){
	if(fDoc != NULL) closeFile();
	fDoc = xmlParseFile(fileName.data());

	if (fDoc == NULL ) {
		std::stringstream ss;
		xmlErrorPtr errPtr = xmlGetLastError();

		ss << "Document not parsed successfully." << std::endl;
		ss << "File: " << errPtr->file << " at (l:";
		ss << errPtr->line << ", c:" << errPtr->int2;
		ss << "): " << errPtr->message << std::endl;
		throw XMLConfParserFatalException(ss);
		return false;
	}

	fRoot = xmlDocGetRootElement(fDoc);

	if (fRoot == NULL) {
		throw XMLConfParserFatalException("Document is empty.");
		return false;
	}
	return true;
}
Example #17
0
bool Vocations::loadFromXml()
{
	xmlDocPtr doc = xmlParseFile(getFilePath(FILE_TYPE_XML,"vocations.xml").c_str());
	if(!doc)
	{
		std::clog << "[Warning - Vocations::loadFromXml] Cannot load vocations file." << std::endl;
		std::clog << getLastXMLError() << std::endl;
		return false;
	}

	xmlNodePtr p, root = xmlDocGetRootElement(doc);
	if(xmlStrcmp(root->name,(const xmlChar*)"vocations"))
	{
		std::clog << "[Error - Vocations::loadFromXml] Malformed vocations file." << std::endl;
		xmlFreeDoc(doc);
		return false;
	}

	for(p = root->children; p; p = p->next)
		parseVocationNode(p);

	xmlFreeDoc(doc);
	return true;
}
Example #18
0
GRSTgaclAcl *GRSTxacmlAclLoadFile(char *filename)
{
  xmlDocPtr   doc;
  xmlNodePtr  cur;
  GRSTgaclAcl    *acl;

  doc = xmlParseFile(filename);
  if (doc == NULL) return NULL;

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

  if (!xmlStrcmp(cur->name, (const xmlChar *) "Policy")) { acl=GRSTxacmlAclParse(doc, cur, acl);}
  else if (!xmlStrcmp(cur->name, (const xmlChar *) "gacl")) {acl=GRSTgaclAclParse(doc, cur, acl);}
  else /* ACL format not recognised */
    {
      xmlFreeDoc(doc);
      free(cur);
      return NULL;
    }

  xmlFreeDoc(doc);
  return acl;
}
Example #19
0
bool Vocations::loadFromXml()
{
	std::string filename = "data/XML/vocations.xml";

	xmlDocPtr doc = xmlParseFile(filename.c_str());

	if (doc) {
		xmlNodePtr root, p;
		root = xmlDocGetRootElement(doc);

		if (xmlStrcmp(root->name, (const xmlChar*)"vocations") != 0) {
			xmlFreeDoc(doc);
			return false;
		}

		p = root->children;

		while (p) {
			std::string str;
			int32_t intVal;

			if (xmlStrcmp(p->name, (const xmlChar*)"vocation") == 0) {
				Vocation* voc = new Vocation();
				uint32_t voc_id;
				xmlNodePtr configNode;

				if (readXMLInteger(p, "id", intVal)) {
					float floatVal;

					voc_id = intVal;

					if (readXMLString(p, "name", str)) {
						voc->name = str;
					}

					if (readXMLInteger(p, "clientid", intVal)) {
						voc->clientId = intVal;
					}

					if (readXMLString(p, "description", str)) {
						voc->description = str;
					}

					if (readXMLInteger(p, "gaincap", intVal)) {
						voc->gainCap = intVal;
					}

					if (readXMLInteger(p, "gainhp", intVal)) {
						voc->gainHP = intVal;
					}

					if (readXMLInteger(p, "gainmana", intVal)) {
						voc->gainMana = intVal;
					}

					if (readXMLInteger(p, "gainhpticks", intVal)) {
						voc->gainHealthTicks = intVal;
					}

					if (readXMLInteger(p, "gainhpamount", intVal)) {
						voc->gainHealthAmount = intVal;
					}

					if (readXMLInteger(p, "gainmanaticks", intVal)) {
						voc->gainManaTicks = intVal;
					}

					if (readXMLInteger(p, "gainmanaamount", intVal)) {
						voc->gainManaAmount = intVal;
					}

					if (readXMLFloat(p, "manamultiplier", floatVal)) {
						voc->manaMultiplier = floatVal;
					}

					if (readXMLInteger(p, "attackspeed", intVal)) {
						voc->attackSpeed = intVal;
					}

					if (readXMLInteger(p, "basespeed", intVal)) {
						voc->baseSpeed = intVal;
					}

					if (readXMLInteger(p, "soulmax", intVal)) {
						voc->soulMax = intVal;
					}

					if (readXMLInteger(p, "gainsoulticks", intVal)) {
						voc->gainSoulTicks = intVal;
					}

					if (readXMLInteger(p, "fromvoc", intVal)) {
						voc->fromVocation = intVal;
					}

					configNode = p->children;

					while (configNode) {
						if (xmlStrcmp(configNode->name, (const xmlChar*)"skill") == 0) {
							uint32_t skill_id;

							if (readXMLInteger(configNode, "id", intVal)) {
								skill_id = intVal;

								if (skill_id > SKILL_LAST) {
									std::cout << "No valid skill id. " << skill_id << std::endl;
								} else {
									if (readXMLFloat(configNode, "multiplier", floatVal)) {
										voc->skillMultipliers[skill_id] = floatVal;
									}
								}
							} else {
								std::cout << "Missing skill id." << std::endl;
							}
						} else if (xmlStrcmp(configNode->name, (const xmlChar*)"formula") == 0) {
							if (readXMLFloat(configNode, "meleeDamage", floatVal)) {
								voc->meleeDamageMultipler = floatVal;
							}

							if (readXMLFloat(configNode, "distDamage", floatVal)) {
								voc->distDamageMultipler = floatVal;
							}

							if (readXMLFloat(configNode, "defense", floatVal)) {
								voc->defenseMultipler = floatVal;
							}

							if (readXMLFloat(configNode, "armor", floatVal)) {
								voc->armorMultipler = floatVal;
							}
						}

						configNode = configNode->next;
					}

					vocationsMap[voc_id] = voc;
				} else {
					std::cout << "Missing vocation id." << std::endl;
				}
			}

			p = p->next;
		}

		xmlFreeDoc(doc);
	}

	return true;
}
Example #20
0
// Processes input XML file (e.g., instance metadata) into output XML file or string (e.g., for libvirt)
// using XSL-T specification file (e.g., libvirt.xsl)
static int apply_xslt_stylesheet (const char * xsltStylesheetPath, const char * inputXmlPath, const char * outputXmlPath, char * outputXmlBuffer, int outputXmlBufferSize)
{
        int err = OK;

        INIT();
        xsltStylesheetPtr cur = xsltParseStylesheetFile ((const xmlChar *)xsltStylesheetPath);
        if (cur) {
                xmlDocPtr doc = xmlParseFile (inputXmlPath);
                if (doc) {
                        xsltTransformContextPtr ctxt = xsltNewTransformContext (cur, doc); // need context to get result
                        xsltSetCtxtParseOptions (ctxt, 0); // TODO: do we want any XSL-T parsing options?
                        xmlDocPtr res = xsltApplyStylesheetUser (cur, doc, NULL, NULL, NULL, ctxt); // applies XSLT to XML
                        int applied_ok = ctxt->state==XSLT_STATE_OK; // errors are communicated via ctxt->state
                        xsltFreeTransformContext (ctxt);
                        
                        if (res && applied_ok) {

                            // save to a file, if path was provied
                            if (outputXmlPath!=NULL) {
                                FILE * fp = fopen (outputXmlPath, "w");
                                if (fp) {
                                    int bytes = xsltSaveResultToFile (fp, res, cur);
                                    if (bytes==-1) {
                                        logprintfl (EUCAERROR, "ERROR: failed to save XML document to %s\n", outputXmlPath);
                                        err = ERROR;
                                    }
                                    fclose (fp);
                                } else {
                                    logprintfl (EUCAERROR, "ERROR: failed to create file %s\n", outputXmlPath);
                                    err = ERROR;
                                }                                
                            }

                            // convert to an ASCII buffer, if such was provided
                            if (err==OK && outputXmlBuffer!=NULL && outputXmlBufferSize > 0) {
                                xmlChar * buf;
                                int buf_size;
                                if (xsltSaveResultToString (&buf, &buf_size, res, cur)==0) { // success
                                    if (buf_size < outputXmlBufferSize) {
                                        bzero (outputXmlBuffer, outputXmlBufferSize);
                                        for (int i=0, j=0; i<buf_size; i++) {
                                            char c = (char) buf [i];
                                            if (c != '\n') // remove newlines
                                                outputXmlBuffer [j++] = c;
                                        }
                                    } else {
                                        logprintfl (EUCAERROR, "ERROR: XML string buffer is too small (%d > %d)\n", buf_size, outputXmlBufferSize);
                                        err = ERROR;
                                    }
                                    xmlFree (buf);
                                } else {
                                    logprintfl (EUCAERROR, "ERROR: failed to save XML document to a string\n");
                                    err = ERROR;
                                }
                            }
                        } else {
                            logprintfl (EUCAERROR, "ERROR: failed to apply stylesheet %s to %s\n", xsltStylesheetPath, inputXmlPath);
                            err = ERROR;
                        }
                        if (res!=NULL) xmlFreeDoc(res);
                        xmlFreeDoc(doc);
                } else {
                        logprintfl (EUCAERROR, "ERROR: failed to parse XML document %s\n", inputXmlPath);
                        err = ERROR;
                }
                xsltFreeStylesheet(cur);
        } else {
                logprintfl (EUCAERROR, "ERROR: failed to open and parse XSL-T stylesheet file %s\n", xsltStylesheetPath);
                err = ERROR;
        }

        return err;
}
static void get_tone_set(const char *tone_file, const char *set_id)
{
    xmlDocPtr doc;
    xmlNsPtr ns;
    xmlNodePtr cur;
#if 0
    xmlValidCtxt valid;
#endif
    xmlChar *x;

    ns = NULL;    
    xmlKeepBlanksDefault(0);
    xmlCleanupParser();
    doc = xmlParseFile(tone_file);
    if (doc == NULL)
    {
        fprintf(stderr, "No document\n");
        exit(2);
    }
    /*endif*/
    xmlXIncludeProcess(doc);
#if 0
    if (!xmlValidateDocument(&valid, doc))
    {
        fprintf(stderr, "Invalid document\n");
        exit(2);
    }
    /*endif*/
#endif
    /* Check the document is of the right kind */
    if ((cur = xmlDocGetRootElement(doc)) == NULL)
    {
        fprintf(stderr, "Empty document\n");
        xmlFreeDoc(doc);
        exit(2);
    }
    /*endif*/
    if (xmlStrcmp(cur->name, (const xmlChar *) "global-tones"))
    {
        fprintf(stderr, "Document of the wrong type, root node != global-tones");
        xmlFreeDoc(doc);
        exit(2);
    }
    /*endif*/
    cur = cur->xmlChildrenNode;
    while (cur  &&  xmlIsBlankNode(cur))
        cur = cur->next;
    /*endwhile*/
    if (cur == NULL)
        exit(2);
    /*endif*/
    while (cur)
    {
        if (xmlStrcmp(cur->name, (const xmlChar *) "tone-set") == 0)
        {
            if ((x = xmlGetProp(cur, (const xmlChar *) "uncode")))
            {
                if (strcmp((char *) x, set_id) == 0)
                    parse_tone_set(doc, ns, cur);
                /*endif*/
                xmlFree(x);
            }
            /*endif*/
        }
        /*endif*/
        cur = cur->next;
    }
    /*endwhile*/
    xmlFreeDoc(doc);
}
Example #22
0
bool Traces::parse(const char *filename, int verbose) {
  xmlDocPtr doc = xmlParseFile(filename);
  
  if (doc == NULL) {
    cout << "Error parsing the "<< filename << " !" << endl;
    goto err;
  }
  
  xmlNodePtr node;
  
  node = doc->children; 
  
  XMLASSERT(node->type == XML_ELEMENT_NODE && 
            !strcmp((const char*)node->name, "gltrace"));
  
  { // parse tracelist
    xmlNodePtr xmllist = get_child_element(node, "tracelist"); 
    
    XMLASSERT(xmllist);
    
    for(xmlNodePtr tracenode = xmllist->children; tracenode; tracenode = tracenode->next) {
      if(tracenode->type == XML_TEXT_NODE) continue; 
      XMLASSERT(tracenode->type == XML_ELEMENT_NODE && 
                !strcmp((const char*)tracenode->name, "trace"));
      
      const char *object = get_element_attribute(tracenode, "object"); 
      const char *name = get_element_attribute(tracenode, "name"); 
      XMLASSERT(object && name);
      xmlNodePtr shot = get_child_element(tracenode, "shot"); 
      XMLASSERT(shot);
      const char *id_str = get_element_attribute(shot, "id"); 
      XMLASSERT(id_str); 
      int id; 
      XMLASSERT(sscanf(id_str, "%d", &id) == 1); 
      while((int)tracelist.size() <= id) {
        tracelist.push_back(TracedEvent());           
      }
      tracelist[id].name = name;
      tracelist[id].obj = object;        
    }        
    if(verbose) printf("loaded %ld traces\n", tracelist.size());
  }      
  
  { // load links      
    xmlNodePtr linklist = get_child_element(node, "linklist");
    XMLASSERT(linklist);
    for(xmlNodePtr linknode = linklist->children; linknode; linknode = linknode->next) {
      if(linknode->type == XML_TEXT_NODE) continue; 

      Link link;
      
      XMLASSERT(linknode->type == XML_ELEMENT_NODE && 
                !strcmp((const char*)linknode->name, "link"));
      
      xmlNodePtr source = get_child_element(linknode, "source");
      xmlNodePtr destination = get_child_element(linknode, "destination");
      XMLASSERT(source && destination); 
      
      string sourcecol = get_element_attribute(source, "name"); 
      string destcol = get_element_attribute(destination, "name");       
      XMLASSERT(sourcecol.size() && destcol.size()); 
      

      link.source = sourcecol.substr(0, sourcecol.find(':'));
      link.sourceport = sourcecol.substr(sourcecol.find(':') + 1);
      link.dest = destcol.substr(0, destcol.find(':'));
      link.destport = destcol.substr(destcol.find(':') + 1);

      // printf("size %d %p\n", links.size(), &links[0]);
      links.push_back(link);
      // printf("osize %d %s\n", links.size(), links[0].source.c_str());
    }
    if(verbose)  printf("%ld links\n", links.size());
  }
  
  { // fill in nextEvents
    for(int i = 0; i < tracelist.size(); i++) {
      TracedEvent &ev = tracelist[i];
      Link *waitBeginLink = NULL; 
      bool recorded = false; 
      for(int l = 0; l < links.size(); l++) {
        Link & link = links[l];

        if(link.source == ev.obj && link.sourceport == ev.name) {
          int dest_ev = find_event(link.dest, link.destport); 
          ev.links.push_back(&link);
          if(dest_ev >= 0) {
            ev.nextEvents.push_back(dest_ev); 
            recorded = true;
          }
        }
        if(link.source == ev.obj && link.sourceport == "waitBegin")
          waitBeginLink = &link;

        if(link.dest == ev.obj && link.destport == ev.name &&
           link.destport != "waitEnd") {
          ev.links.push_back(&link);
          recorded = true;
        }
      }
      
      if(!recorded) { //  probably a user event
        if(waitBeginLink) {
          ev.links.push_back(waitBeginLink);
        } else {
          printf("could not find waitBegin/waitEnd where trace %d %s:%s fits\n", 
                 i, ev.obj.c_str(), ev.name.c_str());
        }
      }

      if(verbose) {
        printf("tev %d %s:%s, nextEvents = [", i, ev.obj.c_str(), ev.name.c_str()); 
        for(int j = 0; j < ev.nextEvents.size(); j++) 
          printf("%d ", ev.nextEvents[j]);
        printf("] links = [");
        for(int j = 0; j < ev.links.size(); j++) {
          Link & link = *ev.links[j];
          printf("%s:%s->%s:%s ", 
                 link.source.c_str(), link.sourceport.c_str(), 
                 link.dest.c_str(), link.destport.c_str());
        }
        printf("]\n");
      }
    }
  }
  
  { // load actual trace data
    xmlNodePtr xmlfiles = get_child_element(node, "filelist");
    XMLASSERT(xmlfiles);
    vector<Chunk> chunks;  

    for(xmlNodePtr filenode = xmlfiles->children; filenode; filenode = filenode->next) {
      
      if(filenode->type == XML_TEXT_NODE || 
         (filenode->type == XML_ELEMENT_NODE && 
          !strcmp((const char*)filenode->name, "pingresults"))) continue;
      
      XMLASSERT(filenode->type == XML_ELEMENT_NODE && 
                !strcmp((const char*)filenode->name, "tracefile"));
      
      const char *chunkfilename = get_element_attribute(filenode, "file"); 
      XMLASSERT(chunkfilename);
      
      {
        FILE *chunkfile = fopen(chunkfilename, "r"); 
        XMLASSERT(chunkfile);
        size_t file_size; 
        {
          struct stat sbuf;
          fstat(fileno(chunkfile), &sbuf);
          file_size = sbuf.st_size;
        }
        XMLASSERT(file_size % sizeof(Chunk) == 0);
        size_t nelt = file_size / sizeof(Chunk);
        size_t n0 = chunks.size();
        chunks.resize(n0 + nelt); 
        fread(&chunks[n0], nelt, sizeof(Chunk), chunkfile);
        fclose(chunkfile);
      }

    }
    if(verbose) printf("loaded %ld chunks\n", chunks.size());
    
    chunks_to_evlists(chunks, tracelist, t0, t1);

    {// also record all timestamps
      double t_prev = -10; 
      for(int i = 0; i < chunks.size(); i++) {
        double t = chunks[i].tv_sec + chunks[i].tv_usec * 1e-6;
        if(t > t_prev) 
          timestamps.push_back(t); 
        t_prev = t;        
      }
    }


  }
  xmlFreeDoc(doc);  

  return true;
 err:
  xmlFreeDoc(doc);
  return false; 
}
static gboolean
convert_metadata_file (const gchar *filename)
{
	ConvertData *data;
	xmlDocPtr doc;
	xmlNodePtr cur;

	if (!g_file_test (filename, G_FILE_TEST_EXISTS))
		return FALSE;

	doc = xmlParseFile (filename);
	if (!doc) {
		g_printerr ("Error loading metadata file %s\n", filename);
		return FALSE;
	}

	cur = xmlDocGetRootElement (doc);
	if (!cur) {
		g_printerr ("Metadata file %s is empty\n", filename);
		xmlFreeDoc (doc);
		return TRUE;
	}

	if (xmlStrcmp (cur->name, (const xmlChar *) "metadata")) {
		g_printerr ("File %s is not a valid atril metadata file\n", filename);
		xmlFreeDoc (doc);
		return FALSE;
	}

	data = g_new0 (ConvertData, 1);
	data->doc = doc;

	for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) {
		xmlChar *uri;
		DocItem *item;

		if (xmlStrcmp (cur->name, (const xmlChar *)"document") != 0)
			continue;

		uri = xmlGetProp (cur, (const xmlChar *)"uri");
		if (!uri)
			continue;

		item = g_new (DocItem, 1);
		item->uri = uri;
		item->cur = cur;
		data->items = g_list_prepend (data->items, item);
	}

	if (!data->items) {
		xmlFreeDoc (data->doc);
		g_free (data);

		return TRUE;
	}

	show_progress_dialog (data);

	data->current = data->items;
	g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
			 (GSourceFunc)convert_file,
			 data,
			 (GDestroyNotify)convert_finish);

	return TRUE;
}
Example #24
0
int settings_read(const char* path)
{
    xmlDocPtr   doc;
    xmlNodePtr  noderoot;
    xmlNodePtr  node1;
    xmlNodePtr  node2;
    xmlChar*    prop;

    msg_log(MSG_MESSAGE, "Reading global settings from: %s\n",path);

    doc = xmlParseFile (path);

    if (doc == NULL)
    {
        msg_log(MSG_ERROR, "Failed to parse %s\n", path);
        return -1;
    }

    noderoot = xmlDocGetRootElement(doc);

    if (noderoot == NULL)
    {
        msg_log(MSG_WARNING, "%s is empty\n", path);
        xmlFreeDoc(doc);
        return -1;
    }

    if (xmlStrcmp(noderoot->name, BAD_CAST "Petri-Foo-Settings") != 0)
    {
        msg_log(MSG_ERROR,
                "%s is not a valid 'Petri-Foo-Settings' file\n", path);
        xmlFreeDoc(doc);
        return -1;
    }

    for (node1 = noderoot->children;
         node1 != NULL;
         node1 = node1->next)
    {
        if (node1->type != XML_ELEMENT_NODE)
            continue;

        for ( node2 = node1->children;
            node2 != NULL;
            node2 = node2->next)
        {
            int n;

            if (xmlStrcmp(node2->name, BAD_CAST "property") == 0)
            {
                prop = BAD_CAST xmlGetProp(node2, BAD_CAST "name");

                if (xmlStrcmp(prop, BAD_CAST "last-sample-directory") == 0)
                {
                    free(gbl_settings->last_sample_dir);
                    gbl_settings->last_sample_dir =
                        (char*) xmlGetProp(node2, BAD_CAST "value");
                }

                if (xmlStrcmp(prop, BAD_CAST "last-bank-directory") == 0)
                {
                    free(gbl_settings->last_bank_dir);
                    gbl_settings->last_bank_dir =
                        (char*) xmlGetProp(node2, BAD_CAST "value");
                }

                if (xmlStrcmp(prop, BAD_CAST "sliders-use-fans") == 0)
                {
                    phin_fan_slider_set_fans_active(
                        xmlstr_to_gboolean(xmlGetProp(node2,
                                                    BAD_CAST "value")));
                }

                if (xmlStrcmp(prop, BAD_CAST "log-lines") == 0)
                {
                    xmlChar* vprop = xmlGetProp(node2, BAD_CAST "value");

                    if (sscanf((const char*)vprop, "%d", &n) == 1)
                        gbl_settings->log_lines = n;
                }
            }
        }
    }

    return 0;
}
Example #25
0
/*---------------------------------------------------------------------------*
 * NAME: xml_parsing
 * DESC: Main xml parsing function
 *---------------------------------------------------------------------------*/
void xml_parsing(config *conf) {

  /* open the file using the libxml2 library */
  debug(3, "xml parsing of the file: %s\n", conf->xml_filename);
  conf->doc = xmlParseFile(conf->xml_filename);
  if (conf->doc == NULL) {
    error_("Document not parsed successfully!\n");
    return;
  }
  verbose_("[*] parsing the file: %s\n", conf->xml_filename);

  /* point on the root element of the tree */
  conf->cur = xmlDocGetRootElement(conf->doc);
  if (conf->cur == NULL) {
    error_("Empty Document!\n");
    xmlFreeDoc(conf->doc);
    return;
  }

  /* check if the format seems to be PDML: ie root = pdml */
  debug(3,"name of the root: %s\n", conf->cur->name);
  if (xmlStrcmp(conf->cur->name, (const xmlChar *) "pdml")) {
    error_("Document NOT a PDML file!\n");
    xmlFreeDoc(conf->doc);
    return;
  }

  /* start the autodafe's script language */
  output_("/*--------------------------------------------------------------------------*\n");
  output_(" * xml autodafe's parser v.%d.%d (c) Martin Vuagnoux - 2004-2006            *\n", MAJOR_VERSION, MINOR_VERSION);
  output_(" * auto-generated script using PDML (Packet Details Markup Language) source *\n");
  output_(" *--------------------------------------------------------------------------*/\n\n");

  /* the file is good, check for the packet entry (child) */
  conf->cur = conf->cur->xmlChildrenNode;
  while (conf->cur != NULL) {
    if (!xmlStrcmp(conf->cur->name, (const xmlChar *) "packet")) {
      debug(3, "packet field found\n");
      /* open the block */
      output_(AD_F_BLOCK_BEGIN"(\"packet_%d\");\n", conf->packet_counter);

      /* parse the internal data of the packet block */
      xml_parse_packet(conf);

      /* close the block */
      output_(AD_F_BLOCK_END"(\"packet_%d\");\n", conf->packet_counter);

      /* client send/recv */
      if ((conf->ip_pkt == conf->ip_client) && (conf->port_pkt == conf->port_client)) {
	debug(3, "check client\n");
	if (conf->transport_type == 1) {
	  if (conf->invert == 0)
	    output_(AD_F_SEND"(\"packet_%d\");  /* tcp */\n\n", conf->packet_counter);
	  else
	    output_(AD_F_RECV"(\"packet_%d\");  /* tcp */\n\n", conf->packet_counter);
	}
	else if (conf->transport_type == 2) {
	  if (conf->invert == 0)
	    output_(AD_F_SEND"(\"packet_%d\");  /* udp */\n\n", conf->packet_counter);
	  else
	    output_(AD_F_RECV"(\"packet_%d\");  /* udp */\n\n", conf->packet_counter);
	}
      }

      /* server send/recv */
      else if ((conf->ip_pkt == conf->ip_server) && (conf->port_pkt == conf->port_server)) {
	debug(3, "check server\n");
	if (conf->transport_type == 1) {
	  if (conf->invert == 1)
	    output_(AD_F_SEND"(\"packet_%d\");  /* tcp */\n\n", conf->packet_counter);
	  else
	    output_(AD_F_RECV"(\"packet_%d\");  /* tcp */\n\n", conf->packet_counter);
	}
	else if (conf->transport_type == 2) {
	  if (conf->invert == 1)
	    output_(AD_F_SEND"(\"packet_%d\");  /* udp */\n\n", conf->packet_counter);
	  else
	    output_(AD_F_RECV"(\"packet_%d\");  /* udp */\n\n", conf->packet_counter);
	}
      }

      else {
	error_("too much different packets?! Check your Ethereal logs!\n");
	error_("client: ip->%d, port->%d\n", conf->ip_client, conf->port_client);
	error_("server: ip->%d, port->%d\n", conf->ip_server, conf->port_server);
	error_("packet: ip->%d, port->%d\n", conf->ip_pkt, conf->port_pkt);
	exit(-1);
      }

      conf->packet_counter++;
    }
    conf->cur = conf->cur->next;
  }

  /* free */
  xmlFreeDoc(conf->doc);
}
Example #26
0
int ReadGPX(const char* File, struct GPSTrack* Track)
{
	/* Init the libxml library. Also checks version. */
	LIBXML_TEST_VERSION

	xmlDocPtr GPXData;
	
	/* Read the GPX data from file. */
	GPXData = xmlParseFile(File);
	if (GPXData == NULL)
	{
		fprintf(stderr, _("Failed to parse GPX data from %s.\n"), File);
		return 0;
	}

	/* Now grab the "root" node. */
	xmlNodePtr GPXRoot;
	GPXRoot = xmlDocGetRootElement(GPXData);

	if (GPXRoot == NULL)
	{
		fprintf(stderr, _("GPX file has no root. Not healthy.\n"));
		xmlFreeDoc(GPXData);
		xmlCleanupParser();
		return 0;
	}

	/* Check that this is indeed a GPX - the root node
	 * should be "gpx". */
	if (strcmp((const char *)GPXRoot->name, "gpx") == 0)
	{
		/* Ok, it is a GPX file. */
	} else {
		/* Not valid. */
		fprintf(stderr, _("Invalid GPX file.\n"));
		xmlFreeDoc(GPXData);
		xmlCleanupParser();
		return 0;
	}

	/* Now comes the messy part... walking the tree to find
	 * what we want.
	 * I've chosen to do it with two functions, one of which
	 * is recursive, rather than a clever inside-this-function
	 * walk the tree thing.
	 * 
	 * We start by calling the recursive function to look for
	 * <trkseg> tags, and then that function calls another
	 * when it has found one... this sub function then
	 * hauls out the <trkpt> tags with the actual data.
	 * Messy, convoluted, but it seems to work... */
	/* As to where to store the data? Again, its messy.
	 * We maintain two global vars, FirstPoint and LastPoint.
	 * FirstPoint points to the first GPSPoint done, and
	 * LastPoint is the last point done, used for the next
	 * point... we use this to build a singly-linked list. */
	/* (I think I'll just be grateful for the work that libxml
	 * puts in for me... imagine having to write an XML parser!
	 * Nasty.) */
	/* Before we go into this function, we also setlocale to "C".
	 * The GPX def indicates that the decimal separator should be
	 * ".", but certain locales specify otherwise. Which has caused issues.
	 * So we set the locale for this function, and then revert it.
	 */
	
	FirstPoint = NULL;
	LastPoint = NULL;
	
	char* OldLocale = setlocale(LC_NUMERIC, "C");
	
	FindTrackSeg(GPXRoot);

	setlocale(LC_NUMERIC, OldLocale);

	/* Clean up stuff for the XML library. */
	xmlFreeDoc(GPXData);
	xmlCleanupParser();

	Track->Points = FirstPoint;

	/* Find the time range for this track */
	GetTrackRange(Track);

	return 1;
}
Example #27
0
/** 
 * xmlSecSimpleKeysStoreLoad:
 * @store:		the pointer to simple keys store.
 * @uri:		the filename.
 * @keysMngr:		the pointer to associated keys manager. 
 * 
 * Reads keys from an XML file.
 *
 * Returns 0 on success or a negative value if an error occurs.
 */
int
xmlSecSimpleKeysStoreLoad(xmlSecKeyStorePtr store, const char *uri, 
			    xmlSecKeysMngrPtr keysMngr) {
    xmlDocPtr doc;
    xmlNodePtr root;
    xmlNodePtr cur;
    xmlSecKeyPtr key;
    xmlSecKeyInfoCtx keyInfoCtx;
    int ret;

    xmlSecAssert2(xmlSecKeyStoreCheckId(store, xmlSecSimpleKeysStoreId), -1);
    xmlSecAssert2(uri != NULL, -1);    

    doc = xmlParseFile(uri);
    if(doc == NULL) {
	xmlSecErr_a_ignorar6(XMLSEC_ERRORS_HERE,
		    xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
		    "xmlParseFile",
		    XMLSEC_ERRORS_R_XML_FAILED,
		    "uri=%s", 
		    xmlSecErrorsSafeString(uri));
	return(-1);
    }
    
    root = xmlDocGetRootElement(doc);
    if(!xmlSecCheckNodeName(root, BAD_CAST "Keys", xmlSecNs)) {
	xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,
		    xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
		    xmlSecErrorsSafeString(xmlSecNodeGetName(root)),
		    XMLSEC_ERRORS_R_INVALID_NODE,
		    "expected-node=<xmlsec:Keys>");
	xmlFreeDoc(doc);
	return(-1);
    }
        
    cur = xmlSecGetNextElementNode(root->children);
    while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeKeyInfo, xmlSecDSigNs)) {  
	key = xmlSecKeyCreate();
	if(key == NULL) {
	    xmlSecErr_a_ignorar6(XMLSEC_ERRORS_HERE,
			xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
			xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
			XMLSEC_ERRORS_R_INVALID_NODE,
			"expected-node=%s",
			xmlSecErrorsSafeString(xmlSecNodeKeyInfo));
	    xmlFreeDoc(doc);
	    return(-1);
	}

	ret = xmlSecKeyInfoCtxInitialize(&keyInfoCtx, NULL);
	if(ret < 0) {
	    xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,
		        xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
			"xmlSecKeyInfoCtxInitialize",
			XMLSEC_ERRORS_R_XMLSEC_FAILED,
			XMLSEC_ERRORS_NO_MESSAGE);
	    xmlSecKeyDestroy(key);
	    xmlFreeDoc(doc);
	    return(-1);
	}
	
	keyInfoCtx.mode 	  = xmlSecKeyInfoModeRead;
	keyInfoCtx.keysMngr	  = keysMngr;
	keyInfoCtx.flags 	  = XMLSEC_KEYINFO_FLAGS_DONT_STOP_ON_KEY_FOUND |
				    XMLSEC_KEYINFO_FLAGS_X509DATA_DONT_VERIFY_CERTS;
        keyInfoCtx.keyReq.keyId	  = xmlSecKeyDataIdUnknown;
	keyInfoCtx.keyReq.keyType = xmlSecKeyDataTypeAny;
	keyInfoCtx.keyReq.keyUsage= xmlSecKeyDataUsageAny;

	ret = xmlSecKeyInfoNodeRead(cur, key, &keyInfoCtx);
	if(ret < 0) {
	    xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,
			xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
			"xmlSecKeyInfoNodeRead",
			XMLSEC_ERRORS_R_XMLSEC_FAILED,
			XMLSEC_ERRORS_NO_MESSAGE);
	    xmlSecKeyInfoCtxFinalize(&keyInfoCtx);
	    xmlSecKeyDestroy(key);
	    xmlFreeDoc(doc);
	    return(-1);
	}
	xmlSecKeyInfoCtxFinalize(&keyInfoCtx);
	
	if(xmlSecKeyIsValid(key)) {
    	    ret = xmlSecSimpleKeysStoreAdoptKey(store, key);
	    if(ret < 0) {
		xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,
			    xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
			    "xmlSecSimpleKeysStoreAdoptKey",
			    XMLSEC_ERRORS_R_XMLSEC_FAILED,
			    XMLSEC_ERRORS_NO_MESSAGE);
		xmlSecKeyDestroy(key);
		xmlFreeDoc(doc);
		return(-1);
	    }
	} else {
	    /* we have an unknown key in our file, just ignore it */
	    xmlSecKeyDestroy(key);
	}
        cur = xmlSecGetNextElementNode(cur->next);
    }
    
    if(cur != NULL) {
	xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,
		    xmlSecErrorsSafeString(xmlSecKeyStoreGetName(store)),
		    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
		    XMLSEC_ERRORS_R_UNEXPECTED_NODE,
		    XMLSEC_ERRORS_NO_MESSAGE);
	xmlFreeDoc(doc);
	return(-1);	    
    }
    
    xmlFreeDoc(doc);
    return(0);

}
Example #28
0
static void save_obconf_settings (void)
{
	const char *session_name;
	char *user_config_file, *c, *font, *fname;
	int count;
	const gchar *size = NULL, *bold = NULL, *italic = NULL;

	// construct the file path
	session_name = g_getenv ("DESKTOP_SESSION");
	if (!session_name) session_name = DEFAULT_SES;
	fname = g_strconcat (g_ascii_strdown (session_name, -1), "-rc.xml", NULL);
	user_config_file = g_build_filename (g_get_user_config_dir (), "openbox/", fname, NULL);
	g_free (fname);

	// set the font description variables for XML from the font name
	font = g_strdup (desktop_font);
	while ((c = strrchr (font, ' ')))
	{
		if (!bold && !italic && !size && atoi (c + 1))
			size = c + 1;
		else if (!bold && !italic && !g_ascii_strcasecmp (c + 1, "italic"))
			italic = c + 1;
		else if (!bold && !g_ascii_strcasecmp (c + 1, "bold"))
			bold = c + 1;
		else break;
		*c = '\0';
	}
	if (!bold) bold = "Normal";
	if (!italic) italic = "Normal";

	// read in data from XML file
	xmlInitParser ();
	LIBXML_TEST_VERSION
	xmlDocPtr xDoc = xmlParseFile (user_config_file);
	if (xDoc == NULL)
	{
		g_free (font);
		g_free (user_config_file);
		return;
	}

	xmlXPathContextPtr xpathCtx = xmlXPathNewContext (xDoc);
	xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression ((xmlChar *) "/*[local-name()='openbox_config']/*[local-name()='theme']/*[local-name()='font']", xpathCtx);

	// update relevant nodes with new values
	for (count = 0; count < xpathObj->nodesetval->nodeNr; count++)
	{
		xmlNode *node = xpathObj->nodesetval->nodeTab[count];
		xmlAttr *attr = node->properties;
		xmlNode *cur_node = NULL;
		for (cur_node = node->children; cur_node; cur_node = cur_node->next)
		{
			if (cur_node->type == XML_ELEMENT_NODE)
			{
				if (!strcmp (cur_node->name, "name")) xmlNodeSetContent (cur_node, font);
				if (!strcmp (cur_node->name, "size")) xmlNodeSetContent (cur_node, size);
				if (!strcmp (cur_node->name, "weight")) xmlNodeSetContent (cur_node, bold);
				if (!strcmp (cur_node->name, "slant"))	xmlNodeSetContent (cur_node, italic);
			}
		}
	}

	// cleanup XML
	xmlXPathFreeObject (xpathObj);
	xmlXPathFreeContext (xpathCtx);
	xmlSaveFile (user_config_file, xDoc);
	xmlFreeDoc (xDoc);
	xmlCleanupParser ();

	g_free (font);
	g_free (user_config_file);
}
Example #29
0
static void check_themes (void)
{
	const char *session_name, *ret;
	char *user_config_file, *cptr, *nptr, *fname;
	GKeyFile *kf;
	GError *err;
	int count;

	orig_lxsession_theme = "";
	orig_openbox_theme = "";

	// construct the file path for lxsession settings
	session_name = g_getenv ("DESKTOP_SESSION");
	if (!session_name) session_name = DEFAULT_SES;
	user_config_file = g_build_filename (g_get_user_config_dir (), "lxsession/", session_name, "/desktop.conf", NULL);

	// read in data from file to a key file structure
	kf = g_key_file_new ();
	if (g_key_file_load_from_file (kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL))
	{
		// get data from the key file
		err = NULL;
		ret = g_key_file_get_string (kf, "GTK", "sNet/ThemeName", &err);
		if (err == NULL) orig_lxsession_theme = ret;
	}

	// construct the file path for openbox settings
	fname = g_strconcat (g_ascii_strdown (session_name, -1), "-rc.xml", NULL);
	user_config_file = g_build_filename (g_get_user_config_dir (), "openbox/", fname, NULL);
	g_free (fname);

	// read in data from XML file
	xmlInitParser ();
	LIBXML_TEST_VERSION
	xmlDocPtr xDoc = xmlParseFile (user_config_file);
	if (xDoc)
	{
		xmlXPathContextPtr xpathCtx = xmlXPathNewContext (xDoc);
		xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression ((xmlChar *) "/*[local-name()='openbox_config']/*[local-name()='theme']", xpathCtx);

		// find relevant node and read value
		for (count = 0; count < xpathObj->nodesetval->nodeNr; count++)
		{
			xmlNode *node = xpathObj->nodesetval->nodeTab[count];
			xmlAttr *attr = node->properties;
			xmlNode *cur_node = NULL;
			for (cur_node = node->children; cur_node; cur_node = cur_node->next)
			{
				if (cur_node->type == XML_ELEMENT_NODE)
				{
					if (!strcmp (cur_node->name, "name"))
						orig_openbox_theme = xmlNodeGetContent (cur_node);
				}
			}
		}

		// cleanup XML
		xmlXPathFreeObject (xpathObj);
		xmlXPathFreeContext (xpathCtx);
		xmlSaveFile (user_config_file, xDoc);
		xmlFreeDoc (xDoc);
		xmlCleanupParser ();
	}

	g_free (user_config_file);

	// set the new themes if needed
	if (strcmp ("PiX", orig_lxsession_theme))
	{
		set_lxsession_theme ("PiX");
		if (needs_refresh) system (RELOAD_LXSESSION);
	}
	if (strcmp ("PiX", orig_openbox_theme))
	{
		set_openbox_theme ("PiX");
		system (RELOAD_OPENBOX);
	}
}
Example #30
0
static void *construct_xslt(const xmlNode *ptr,
                            const char *path, WRBUF wr_error)
{
    struct _xmlAttr *attr;
    const char *stylesheet = 0;
    struct xslt_info *info = 0;
    NMEM nmem = 0;
    int max_parms = 10;
    int no_parms = 0;

    if (strcmp((const char *) ptr->name, "xslt"))
        return 0;

    for (attr = ptr->properties; attr; attr = attr->next)
    {
        if (!xmlStrcmp(attr->name, BAD_CAST "stylesheet") &&
            attr->children && attr->children->type == XML_TEXT_NODE)
            stylesheet = (const char *) attr->children->content;
        else
        {
            wrbuf_printf(wr_error, "Bad attribute '%s'"
                         "Expected stylesheet.", attr->name);
            return 0;
        }
    }
    nmem = nmem_create();
    info = nmem_malloc(nmem, sizeof(*info));
    info->nmem = nmem;
    info->xsl_parms = nmem_malloc(
        nmem, (2 * max_parms + 1) * sizeof(*info->xsl_parms));

    for (ptr = ptr->children; ptr; ptr = ptr->next)
    {
        const char *name = 0;
        const char *value = 0;
        char *qvalue = 0;
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
        if (strcmp((const char *) ptr->name, "param"))
        {
            wrbuf_printf(wr_error, "Bad element '%s'"
                         "Expected param.", ptr->name);
            nmem_destroy(nmem);
            return 0;
        }
        for (attr = ptr->properties; attr; attr = attr->next)
        {
            if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
                attr->children && attr->children->type == XML_TEXT_NODE)
                name = (const char *) attr->children->content;
            else if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
                attr->children && attr->children->type == XML_TEXT_NODE)
                value = (const char *) attr->children->content;
            else
            {
                wrbuf_printf(wr_error, "Bad attribute '%s'"
                             "Expected name or value.", attr->name);
                nmem_destroy(nmem);
                return 0;
            }
        }
        if (!name || !value)
        {
            wrbuf_printf(wr_error, "Missing attributes name or value");
            nmem_destroy(nmem);
            return 0;
        }
        if (no_parms >= max_parms)
        {
            wrbuf_printf(wr_error, "Too many parameters given");
            nmem_destroy(nmem);
            return 0;
        }

        qvalue = nmem_malloc(nmem, strlen(value) + 3);
        strcpy(qvalue, "\'");
        strcat(qvalue, value);
        strcat(qvalue, "\'");

        info->xsl_parms[2 * no_parms] = nmem_strdup(nmem, name);
        info->xsl_parms[2 * no_parms + 1] = qvalue;
        no_parms++;
    }
    info->xsl_parms[2 * no_parms] = 0;

    if (!stylesheet)
    {
        wrbuf_printf(wr_error, "Element <xslt>: "
                     "attribute 'stylesheet' expected");
        nmem_destroy(nmem);
    }
    else
    {
        char fullpath[1024];
        xsltStylesheetPtr xsp;
        if (!yaz_filepath_resolve(stylesheet, path, 0, fullpath))
        {
            wrbuf_printf(wr_error, "Element <xslt stylesheet=\"%s\"/>:"
                         " could not locate stylesheet '%s'",
                         stylesheet, stylesheet);
            if (path)
                wrbuf_printf(wr_error, " with path '%s'", path);

            nmem_destroy(nmem);
            return 0;
        }
        info->xsp_doc = xmlParseFile(fullpath);
        if (!info->xsp_doc)
        {
            wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
                         " xml parse failed: %s", stylesheet, fullpath);
            if (path)
                wrbuf_printf(wr_error, " with path '%s'", path);
            nmem_destroy(nmem);
            return 0;
        }
        /* need to copy this before passing it to the processor. It will
           be encapsulated in the xsp and destroyed by xsltFreeStylesheet */
        xsp = xsltParseStylesheetDoc(xmlCopyDoc(info->xsp_doc, 1));
        if (!xsp)
        {
            wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
                         " xslt parse failed: %s", stylesheet, fullpath);
            if (path)
                wrbuf_printf(wr_error, " with path '%s'", path);
            wrbuf_printf(wr_error, " ("
#if YAZ_HAVE_EXSLT

                         "EXSLT enabled"
#else
                         "EXSLT not supported"
#endif
                         ")");
            xmlFreeDoc(info->xsp_doc);
            nmem_destroy(info->nmem);
        }
        else
        {
            xsltFreeStylesheet(xsp);
            return info;
        }
    }
    return 0;
}