Beispiel #1
0
/*
 * call-seq:
 *  element_children
 *
 * Get the list of children for this node as a NodeSet.  All nodes will be
 * element nodes.
 *
 * Example:
 *
 *   @doc.root.element_children.all? { |x| x.element? } # => true
 */
static VALUE element_children(VALUE self)
{
  xmlNodePtr node;
  xmlNodePtr child;
  xmlNodeSetPtr set;
  VALUE document;
  VALUE node_set;

  Data_Get_Struct(self, xmlNode, node);

  child = xmlFirstElementChild(node);
  set = xmlXPathNodeSetCreate(child);

  document = DOC_RUBY_OBJECT(node->doc);

  if(!child) return Nokogiri_wrap_xml_node_set(set, document);

  child = xmlNextElementSibling(child);
  while(NULL != child) {
    xmlXPathNodeSetAddUnique(set, child);
    child = xmlNextElementSibling(child);
  }

  node_set = Nokogiri_wrap_xml_node_set(set, document);

  return node_set;
}
Beispiel #2
0
    static NodeType findNextSibling(NodeType node, const std::string& name)
    {
        const xmlChar* convertedName = reinterpret_cast<const xmlChar*>(name.c_str());
        NodeType sibling = xmlNextElementSibling(node);
        while (sibling)
        {
            if (xmlStrcmp(sibling->name, convertedName) == 0)
                break;
            else
                node = xmlNextElementSibling(sibling);
        }

        return sibling;
    }
Beispiel #3
0
static gint
parse_radio_list(GString *data, GList **list)
{
	gint result = 1;
	xmlDocPtr doc;

	if (data->str == NULL || data->len == 0)
		return 1;

	doc = xmlReadMemory(data->str, data->len, NULL, NULL,
				XML_PARSE_RECOVER | XML_PARSE_NOERROR);

	if (doc == NULL)
		return result;

	do
	{
		xmlNodePtr radioList;
		xmlNodePtr p;

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

		for(p=xmlFirstElementChild(radioList); p; p=xmlNextElementSibling(p))
			get_radio(p, list);

		result = 0;
	}
	while(0);

	xmlFreeDoc(doc);

	return result;
}
Beispiel #4
0
/*******************  FUNCTION  *********************/
CMRXmlNode CMRXmlNode::getNext ( void )
{
	if (node == NULL)
		return CMRXmlNode(NULL);
	else
		return CMRXmlNode(xmlNextElementSibling(node));
}
Beispiel #5
0
xmlNode* XMLParser::getNext(xmlNodePtr cur) const
{
	if(!cur)
	{
		fprintf(stderr,"Warning: Got Empty Node\n");
		return NULL;
	}
	return xmlNextElementSibling(cur);
}
Beispiel #6
0
std::list< ::fwRuntime::io::Substitute > XMLSubstitute::getSubstitutions( xmlNodePtr substitutionRules )
{
    // create the context for xpath
    xmlXPathContextPtr xpathCtx;
    xpathCtx = xmlXPathNewContext(substitutionRules->doc);
    SLM_ASSERT("xpathCtx not instanced", xpathCtx);

    std::list< ::fwRuntime::io::Substitute > result;

    xmlChar *xpathExpr= BAD_CAST "//Substitutions/substitute";
    xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
    // xmlXPathObjectPtr::nodesetval : get set of node
    // xmlNodeSetPtr::nodeNr  = nb element
    // xmlNodeSetPtr::nodeTab[i] : ith element : must be processed in reverse order
    SLM_ASSERT("xpathObj not instanced", xpathObj);

    int NbNodesFound = xpathObj->nodesetval->nodeNr;

    for (int i=0; i < NbNodesFound ; ++i )
    {
        Substitute s;
        xmlNodePtr subNode = xpathObj->nodesetval->nodeTab[i];
        xmlNodePtr element = xmlNextElementSibling(subNode->children);
        while (element )
        {
            if ( xmlStrcmp( element->name, BAD_CAST "nodePath")==0 )
            {
                s.xpath = (const char *)xmlNodeGetContent( element );
            }
            if ( xmlStrcmp( element->name, BAD_CAST "replace")==0 )
            {
                s.dictEntry = (const char *)xmlGetProp( element, BAD_CAST "dictEntry" );
                s.status    = (const char *)xmlGetProp( element, BAD_CAST "status" );
            }
            element = xmlNextElementSibling(element);
        }
        assert( s.xpath.size()  && s.dictEntry.size() && s.status.size() );
        result.push_back( s );
    }

    xmlXPathFreeObject(xpathObj );

    return result;
}
Beispiel #7
0
/*
 * call-seq:
 *  next_element
 *
 * Returns the next Nokogiri::XML::Element type sibling node.
 */
static VALUE next_element(VALUE self)
{
  xmlNodePtr node, sibling;
  Data_Get_Struct(self, xmlNode, node);

  sibling = xmlNextElementSibling(node);
  if(!sibling) return Qnil;

  return Nokogiri_wrap_xml_node(Qnil, sibling);
}
Beispiel #8
0
/* create junction boxes */
int _create_jb_object(xmlNodePtr node, struct _zparser* parser)
{
    xmlNodePtr _child = NULL;
    struct _zobject* _obj = NULL;
    struct _jb_dims
    {
	double x __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double y __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double width __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double height __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double depth __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double radius __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
	double angle __attribute__ ((aligned (ZELIA_XML_TSTRUCT_ALIGN)));
    } _jb_dim;

    /* create notes object collection */
    memset(&_jb_dim, 0, sizeof(struct _jb_dims));

    _obj = (struct _zobject*) malloc(sizeof(struct _zobject));
    _obj->type = zobject_item;

    _child = xmlFirstElementChild(node);
    _create_jb_object_helper(_child, (void*) &_jb_dim);

    /* create junction box object */
    _obj->data._i = zjb_new(NULL,
			    &parser->device,
			    _jb_dim.x,
			    _jb_dim.y,
			    _jb_dim.width,
			    _jb_dim.height,
			    _jb_dim.depth,
			    _jb_dim.angle);

    zjb_set_fillet_radius(Z_JB(_obj->data._i), _jb_dim.radius);

    while(_child)
	{
	    if(strcmp((const char*) _child->name, ZPARSER_TERMINALS) == 0)
		_create_jb_object_terminals_helper(_child, _obj->data._i);
	    else if(strcmp((const char*) _child->name, ZPARSER_GLAND) == 0)
		_create_jb_object_gland_helper(_child, _obj->data._i);

	    _child = xmlNextElementSibling(_child);
	}

    /* call draw method */
    zgeneric_draw(_obj->data._i);

    /* push to the collection */
    blist_add_from_end(&parser->object_array, (void*) _obj);

    return ZELIA_OK;
}
ValgrindResult* valgrindXML_evaluate(char *xml_path,int testing_framework) {
  char *docname;
  xmlDocPtr doc;
  xmlChar *xpath = (xmlChar*) "//errorcounts/pair/count";
  xmlNodeSetPtr nodeset;
  xmlXPathObjectPtr result;
  int i;
  docname = xml_path;
  doc = getdoc(docname);
  result = getnodeset (doc, xpath);
  
  ValgrindResult *valgrindResult=NULL;
  //Get all the errors first
  if (result) {
    nodeset = result->nodesetval;
    if(nodeset->nodeNr==0){
      //NO valgrind errors for this mutant
      return NULL;
    }
    valgrindResult= malloc(sizeof(ValgrindResult));
    //Initialization of valgrindResult
    valgrindResult->valgrind_error_count=0;
    valgrindResult->unique_valgrind_error_count=0;
    
    //Capturing results in valgrindResult
    valgrindResult->unique_valgrind_error_count=nodeset->nodeNr;
    valgrindResult->valgrindErrors = malloc(nodeset->nodeNr*sizeof(ValgrindError));
    
    for (i=0; i < nodeset->nodeNr; i++) {
      //Get <count></count>
      xmlNodePtr countNode = nodeset->nodeTab[i];
      //Get <unique></unique>
      xmlNodePtr uniqueNode = xmlNextElementSibling(countNode);
      
      //Values for both of the nodes
      xmlChar *count_value = xmlNodeListGetString(doc, countNode->xmlChildrenNode, 1);
      xmlChar *unique_value = xmlNodeListGetString(doc, uniqueNode->xmlChildrenNode, 1);
      
      int error_count = (int)strtoumax((char*)count_value, NULL, 10);
      valgrindResult->valgrind_error_count+=error_count;
      
      //For each unique value, get all its error nodes
      evaluate_error_nodes(&valgrindResult->valgrindErrors[i],doc,error_count,unique_value,testing_framework);
      
      xmlFree(count_value);
      xmlFree(unique_value);
    }
    xmlXPathFreeObject (result);
  }
  xmlFreeDoc(doc);
  xmlCleanupParser();
  
  return valgrindResult;
}
Beispiel #10
0
xmlNodePtr XMLParser::getChildrenXMLElement (xmlNodePtr pNode)
{
    std::set<int> ignoredNodeType;
    ignoredNodeType += XML_TEXT_NODE, XML_CDATA_SECTION_NODE, XML_COMMENT_NODE;
    xmlNodePtr childNode = pNode->children;
    if(!childNode || ignoredNodeType.find(childNode->type) != ignoredNodeType.end())
    {
        childNode = xmlNextElementSibling( pNode->children );
    }
    return childNode;
}
Beispiel #11
0
int _create_label_object(xmlNodePtr node, struct _zparser* parser)
{
    struct _zobject* _obj = NULL;

    xmlNodePtr _child = NULL;
    xmlChar* _content = NULL;
    xmlChar* _path = NULL;
    unsigned int _del_flg = 1;
    double _x = 0.0, _y = 0.0;
    
    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    _del_flg = 1;
	    _content = xmlNodeGetContent(_child);
	    if(strcmp((const char*) _child->name, ZPARSER_TEMPLATE_PATH) == 0)
		{
		    _del_flg = 0;
		    _path = _content;
		}
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_X) == 0)
		_x = atof((const char*) _content);
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_Y) == 0)
		_y = atof((const char*) _content);
	    
	    /* if delete flag is true delete and set the pointer to NULL */
	    if(_del_flg)
		{
		    xmlFree(_content);
		    _content = NULL;
		}
	    
	    _child = xmlNextElementSibling(_child);
	}

    if(_path == NULL)
	return ZELIA_NULL;

    /* create object */
    _obj = (struct _zobject*) malloc(sizeof(struct _zobject));
    _obj->type = zobject_item;

    _obj->data._i = zlabel_new(NULL, &parser->file, (const char*) _path, _x, _y);
    
    /* call draw method */
    zgeneric_draw(_obj->data._i);

    /* push to the collection */
    blist_add_from_end(&parser->object_array, (void*) _obj);
    
    return ZELIA_OK;
}
Beispiel #12
0
    static NodeType findFirstChild(NodeType node, const std::string& name)
    {
        const xmlChar* convertedName = reinterpret_cast<const xmlChar*>(name.c_str());
        NodeType child = xmlFirstElementChild(node);
        while (child)
        {
            if (xmlStrcmp(child->name, convertedName) == 0)
                break;
            else
                child = xmlNextElementSibling(child);
        }

        return child;
    }
Beispiel #13
0
/**
 * Examine next sibling of node for a matching name and the sibling to
 * the output list if it matches.
 *
 * Returns a 0 (XQ_OK) on success, an error code otherwise
 */
xQStatusCode _xQ_findNextSiblingByName(xQ* context, xmlChar** args, xmlNodePtr node, xQNodeList* outList) {
  const xmlChar* name = args[0];
  const xmlChar* ns = args[1];
  xQStatusCode result = XQ_OK;
  xmlNodePtr sibling;
  
  nsLookup(context, ns);
  
  if (node->type == XML_ELEMENT_NODE && (sibling = xmlNextElementSibling(node))) {
    if ( (xmlStrcmp(name, sibling->name) == 0) && nsMatch(sibling, ns) )
      result = xQNodeList_push(outList, sibling);
  }
  
  return result;
}
Beispiel #14
0
int _create_file_object(xmlNodePtr node, struct _zparser* parser)
{
    char* _save_path = NULL;
    char* _template_path = NULL;
    char* _sheet_size = NULL;
    zSheets _sheet_type = zSheetA4_Portrait;

    xmlNodePtr _child = NULL;
    int stat = 0;

    /* get first child node */
    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    if(strcmp((const char*) _child->name, ZPARSER_TEMPLATE_PATH) == 0)
		_template_path = (char*) xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_SAVE_PATH) == 0)
		_save_path = (char*) xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_SHEET_SIZE) == 0)
		_sheet_size = (char*) xmlNodeGetContent(_child);

	    _child = xmlNextElementSibling(_child);
	}

    /* if the paths were set we create the file object */
    stat = zfile_create_file_from_template(&parser->file, _template_path, _save_path);
    if(stat != ZELIA_OK)
	ZELIA_LOG_MESSAGE("errors occured while creating a new file");

    if(strcmp(_sheet_size, ZPARSER_SHEET_A4_PORT) == 0)
	_sheet_type = zSheetA4_Portrait;
    else if(strcmp(_sheet_size, ZPARSER_SHEET_A4_LAND) == 0)
	_sheet_type = zSheetA4_Landscape;
    else if(strcmp(_sheet_size, ZPARSER_SHEET_A3_PORT) == 0)
	_sheet_type = zSheetA3_Portrait;
    else
	_sheet_type = zSheetA3_Landscape;

    zdevice_new2(_sheet_type, 0, &parser->device);

    /* free memory */
    free(_template_path);
    free(_save_path);
    free(_sheet_size);
    return ZELIA_OK;
}
Beispiel #15
0
char *filter(char *str, Regexfilter *filterList) 
{
	
	xmlDocPtr doc;
	xmlNodePtr item_node, title_node;
	xmlChar *xmlbuff, *title_content;
	int buffersize;
	
	doc = xmlReadMemory(str, strlen(str), "noname.xml", NULL, 0);
	
	if (doc == NULL) {
		fprintf(stderr, "Failed to parse document\n");
		return;
	}
	
	item_node = feed_first_item(doc);
	
	/* loop through items */
	while (item_node != NULL) {
		
		title_node = xmlFirstElementChild(item_node); 
		title_content = xmlNodeGetContent(title_node);

		if (!pattern_check((char *)title_content, filterList)) {
			/* remove <item> node and leftover space*/
			feed_remove_node(&item_node);
			feed_remove_node(&item_node);
		}
		
		item_node = xmlNextElementSibling(item_node);
	}

	
	/* 
	 * Convert rss doc to string 
	 * and return.
	 */
	xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize,1);
	
	xmlFreeDoc(doc);
	
	return xmlbuff;
}
Beispiel #16
0
void removeDefaultNamespace(xmlNs *ns, xmlNode *node) {
    removeNamespace(&node->nsDef, ns);

    xmlAttr *attr;

    for (attr = node->properties; attr; attr = attr->next) {
        if (!attr->ns)
            continue;

        removeNamespace(&attr->ns, ns);
    }

    if (node->ns == ns)
        node->ns = NULL;

    xmlNode *child;

    for (child = xmlFirstElementChild(node); child; child = xmlNextElementSibling(child)) {
        removeDefaultNamespace(ns, child);
    }
}
Beispiel #17
0
static gint
parse_track_list_data(GString *data, GList **list)
{
	gint result = 1;
	xmlDocPtr doc = NULL;

	doc = xmlReadMemory(data->str, data->len, NULL, NULL,
				XML_PARSE_RECOVER | XML_PARSE_NOERROR);

	if (doc == NULL)
		return result;

	do
	{
		xmlNodePtr root;
		xmlNodePtr track_list;
		xmlNodePtr p;

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

		track_list = xml_first_child(root, BAD_CAST "trackList");
		if (track_list == NULL)
			break;

		for(p = xmlFirstElementChild(track_list); p ; p = xmlNextElementSibling(p))
			get_track(p, list);

		result = 0;
	}
	while(0);

	xmlFreeDoc(doc);

	return result;
}
Beispiel #18
0
template <typename Traits> inline shared_ptr<typename detector_impl<Traits>::branch_type>
detector_impl<Traits>::parse_branch(xmlNodePtr node) const {
	
	shared_ptr<branch_type> result(new branch_type());
	for (xmlNodePtr n = xmlFirstElementChild(node); 0 != n; n = xmlNextElementSibling(n)) {
		if (disabled(n)) {
			continue;
		}
		else if (xmlStrncasecmp(n->name, (xmlChar const*) "match", sizeof("match")) == 0) {
			xml_elems elems(n, "pattern");
			for (xml_elems::iterator i = elems.begin(), end = elems.end(); i != end; ++i) {
				if (disabled(*i)) {
					continue;
				}
				char const *type = xml_attr_text(*i, "type");
				if (strncasecmp(type, "string", sizeof("string")) == 0) {
					result->add_match(xml_node_text(*i));
				}
				else if (strncasecmp(type, "regex", sizeof("regex")) == 0) {
					result->add_regex_match(xml_node_text(*i));
				}
				else {
					resource<xmlChar*, xml_string_traits> path(xmlGetNodePath(*i));
					throw error("unknown pattern type %s in [%s]", type, (char const*) path.get());
				}
			}
		}
		else if (xmlStrncasecmp(n->name, (xmlChar const*) "branch", sizeof("branch")) == 0) {
			result->add_child(parse_branch(n));
		}
		else if (xmlStrncasecmp(n->name, (xmlChar const*) "define", sizeof("definition")) == 0) {
			result->add_definition(parse_definition(n));
		}
	}
	return result;
}
Beispiel #19
0
/* create leader object */
int _create_leader_object(xmlNodePtr node, struct _zparser* parser)
{
    xmlChar* _content = NULL;
    xmlNodePtr _child = NULL;
    double _dim_dbl = 0.0, _x = 0.0, _y = 0.0, _ang = 0.0, _seg1 = 0.0, _seg2 = 0.0;
    struct _zobject* _obj = NULL;
    unsigned int _del_flg = 1;

    _obj = (struct _zobject*) malloc(sizeof(struct _zobject));
    _obj->type = zobject_item;

    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    _content = xmlNodeGetContent(_child);
	    if(_content != NULL)
		_dim_dbl = atof((char*) _content);
	    
	    _del_flg = 1;
	    
	    if(strcmp((const char*) _child->name, ZPARSER_COORD_X) == 0)
		_x = _dim_dbl;
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_Y) == 0)
		_y = _dim_dbl;
	    else if(strcmp((const char*) _child->name, ZPARSER_ANGLE) == 0)
		_ang = _dim_dbl;
	    else if(strcmp((const char*) _child->name, ZPARSER_SEGMENT_1) == 0)
		_seg1 = _dim_dbl;
	    else if(strcmp((const char*) _child->name, ZPARSER_SEGMENT_2) == 0)
		_seg2 = _dim_dbl;
	    else if(strcmp((const char*) _child->name, ZPARSER_DESCRIPTION) == 0)
		_del_flg = 0;
	    
	    if(_del_flg)
		{
		    xmlFree(_content);
		    _content = NULL;
		}

	    _child = xmlNextElementSibling(_child);	    
	}

    /* create a new leader object */
    _obj->data._i = zleader_new(NULL,
				&parser->device,
				_x,
				_y,
				_seg1,
				_seg2,
				_ang,
				(char*) _content);
    /* call draw method */
    zgeneric_draw(_obj->data._i);

    /* push to the collection */
    blist_add_from_end(&parser->object_array, (void*) _obj);

    if(_content)
	xmlFree(_content);
    
    return ZELIA_OK;
}
Beispiel #20
0
/**
 * get next sibling of a node
 *
 * @param n NftPrefsNode from which sibling should be fetched
 * @result sibling node or NULL
 */
NftPrefsNode *nft_prefs_node_get_next(NftPrefsNode * n)
{
        return xmlNextElementSibling(n);
}
Beispiel #21
0
/* create table object */
int _create_table_object(xmlNodePtr node, struct _zparser* parser)
{
    xmlChar* _content = NULL, *_rows = NULL, *_cols = NULL;
    double _dim_dbl = 0.0;
    int _num_cols = 0, _num_rows = 0;
    struct _zobject* _obj = NULL;

    xmlNodePtr _child = NULL;


    /* create notes object collection */
    _obj = (struct _zobject*) malloc(sizeof(struct _zobject));
    _obj->type = zobject_item;

    /* create the table object */
    _obj->data._i = ztable_new(NULL);

    if(_obj->data._i == NULL)
	{
	    free(_obj);
	    return ZELIA_NULL;
	}
    zgeneric_set_device(_obj->data._i, &parser->device);
    zgeneric_set_default_dev_context(_obj->data._i);

    /* set the reference flag this is so that retrieved values of xml to be freed */
    if(!zgenerics_get_ref_flg(_obj->data._c))
	{
	    zgenerics_toggle_ref_flg(_obj->data._c);
	}


    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    _content = xmlNodeGetContent(_child);
	    if(_content != NULL)
		_dim_dbl = atof((char*) _content);

	    if(strcmp((const char*) _child->name, ZPARSER_COORD_X) == 0)
		zbase_set_base_coords_x(Z_BASE(_obj->data._i), _dim_dbl);
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_Y) == 0)
		zbase_set_base_coords_y(Z_BASE(_obj->data._i), _dim_dbl);
	    else if(strcmp((const char*) _child->name, ZPARSER_ROW_HEIGHT_ATTRIB) == 0)
		zbase_set_height(Z_BASE(_obj->data._i), _dim_dbl);
	    else if(strcmp((const char*) _child->name, ZPARSER_COLUMN_WIDTH_ATTRIB) == 0)
		zbase_set_width(Z_BASE(_obj->data._i), _dim_dbl);
	    else if(strcmp((const char*) _child->name, ZPARSER_TABLE_ROWS) == 0 && _rows == NULL)
		_rows = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_TABLE_COLUMNS) == 0 && _cols == NULL)
		_cols = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_TABLE_COLUMN) == 0)
		_create_table_object_dim(_child, _obj->data._i);
	    else if(strcmp((const char*) _child->name, ZPARSER_CONTENT) == 0)
		_create_table_object_content(_child, _content, _obj->data._i);

	    /* set numbeer of rows and columns */
	    if(_cols && _rows)
		{
		    _num_rows = atoi((char*) _rows);
		    _num_cols = atoi((char*) _cols);

		    ztable_set_rows_and_cols(Z_TABLE(_obj->data._i), _num_rows, _num_cols);

		    xmlFree(_rows);
		    xmlFree(_cols);

		    _cols = NULL;
		    _rows = NULL;
		}

	    /* free copy */
	    if(_content)
		xmlFree(_content);

	    _content = NULL;
	    _child = xmlNextElementSibling(_child);
	}

    /* call draw method */
    zgeneric_draw(_obj->data._i);

    /* push to the collection */
    blist_add_from_end(&parser->object_array, (void*) _obj);

    return ZELIA_OK;
}
Beispiel #22
0
/*
 * Construct an iCalendar component from a XML element.
 */
static icalcomponent *xml_element_to_icalcomponent(xmlNodePtr xcomp)
{
    icalcomponent_kind kind;
    icalcomponent *comp = NULL;
    xmlNodePtr node, xprop, xsub;

    if (!xcomp) return NULL;

    /* Get component type */
    kind =
        icalenum_string_to_component_kind(
            ucase(icalmemory_tmp_copy((const char *) xcomp->name)));
    if (kind == ICAL_NO_COMPONENT) {
        syslog(LOG_WARNING, "Unknown xCal component type: %s", xcomp->name);
        return NULL;
    }

    /* Create new component */
    comp = icalcomponent_new(kind);
    if (!comp) {
        syslog(LOG_ERR, "Creation of new %s component failed", xcomp->name);
        return NULL;
    }

    /* Add properties */
    node = xmlFirstElementChild(xcomp);
    if (!node || xmlStrcmp(node->name, BAD_CAST "properties")) {
        syslog(LOG_WARNING,
               "Expected <properties> XML element, received %s", node->name);
        goto error;
    }
    for (xprop = xmlFirstElementChild(node); xprop;
            xprop = xmlNextElementSibling(xprop)) {
        icalproperty *prop = xml_element_to_icalproperty(xprop);

        if (!prop) goto error;

        icalcomponent_add_property(comp, prop);
    }

    /* Add sub-components */
    if (!(node = xmlNextElementSibling(node))) return comp;

    if (xmlStrcmp(node->name, BAD_CAST "components")) {
        syslog(LOG_WARNING,
               "Expected <components> XML element, received %s", node->name);
        goto error;
    }

    for (xsub = xmlFirstElementChild(node); xsub;
            xsub = xmlNextElementSibling(xsub)) {
        icalcomponent *sub = xml_element_to_icalcomponent(xsub);

        if (!sub) goto error;

        icalcomponent_add_component(comp, sub);
    }

    /* Sanity check */
    if ((node = xmlNextElementSibling(node))) {
        syslog(LOG_WARNING,
               "Unexpected XML element in component: %s", node->name);
        goto error;
    }

    return comp;

error:
    icalcomponent_free(comp);
    return NULL;
}
Beispiel #23
0
int xml_verify(char *filename) {
    xmlSecDSigCtxPtr dsig_ctx = NULL;
    xmlDocPtr        doc = NULL;
    xmlNodePtr       root_node;
    xmlNodePtr       sign_node;
    xmlNodePtr       cert_node;
    xmlNodePtr       x509d_node; 
    xmlNodePtr       cur_node; 
    int              result = DCP_FATAL;
    xmlSecKeysMngrPtr key_manager;
    char cert[5000];
    int  cert_l; 
    xmlsec_verify_init();

    /* load doc file */
    doc = xmlParseFile(filename);

    if (doc == NULL) {
        dcp_log(LOG_ERROR, "unable to parse file %s", filename);
        goto done;
    }

    /* find root node */
    root_node = xmlDocGetRootElement(doc);

    if (root_node == NULL){
        dcp_log(LOG_ERROR, "unable to find root node");
        goto done;
    }

    /* find signature node */
    sign_node = xmlSecFindNode(root_node, xmlSecNodeSignature, xmlSecDSigNs);
    if(sign_node == NULL) {
        dcp_log(LOG_ERROR, "signature node not found");
        goto done;      
    }

    /* create keys manager */
    key_manager = load_certificates();
    if (key_manager == NULL) {
        dcp_log(LOG_ERROR,"create key manager failed");
        goto done;
    }

    /* find certificates */
    cur_node = sign_node;
    while (x509d_node = xmlSecFindNode(cur_node, xmlSecNodeX509Data, xmlSecDSigNs)) {
        cert_node = xmlSecFindNode(x509d_node, xmlSecNodeX509Certificate, xmlSecDSigNs);
        if(cert_node == NULL) {
            dcp_log(LOG_ERROR, "X509certficate node not found");
            goto done;      
        }
        sprintf(cert,"-----BEGIN CERTIFICATE-----\n%s\n-----END CERTIFICATE-----\n",xmlNodeGetContent(cert_node));
        cert_l = strlen(cert);
        if (xmlSecCryptoAppKeysMngrCertLoadMemory(key_manager, cert, cert_l, xmlSecKeyDataFormatPem, xmlSecKeyDataTypeTrusted) < 0) {
            dcp_log(LOG_ERROR, "could read X509certificate node value");
            goto done;      
        }
        cur_node = xmlNextElementSibling(x509d_node);
    }

    /* create signature context */
    dsig_ctx = xmlSecDSigCtxCreate(key_manager);

    if (dsig_ctx == NULL) {
        dcp_log(LOG_ERROR,"create signature opendcp failed");
        goto done;
    }

    /* sign the template */
    if (xmlSecDSigCtxVerify(dsig_ctx, sign_node) < 0) {
        dcp_log(LOG_ERROR,"signature verify failed");
        goto done;
    }

    if (dsig_ctx->status != xmlSecDSigStatusSucceeded) {
        dcp_log(LOG_ERROR,"signature validation failed");
        goto done;
    }

    /* success */
    result = 0;

done:    
    /* destroy keys manager */
    xmlSecKeysMngrDestroy(key_manager);

    /* destroy signature context */
    if(dsig_ctx != NULL) {
        xmlSecDSigCtxDestroy(dsig_ctx);
    }
    
    /* destroy xml doc */
    if(doc != NULL) {
        xmlFreeDoc(doc); 
    }

    xmlsec_close();
    return(result);
}
Beispiel #24
0
/*
 * Construct an iCalendar property value from XML content.
 */
static icalvalue *xml_element_to_icalvalue(xmlNodePtr xtype,
        icalvalue_kind kind)
{
    icalvalue *value = NULL;
    xmlNodePtr node;
    xmlChar *content = NULL;

    switch (kind) {

    case ICAL_GEO_VALUE: {
        struct icalgeotype geo;

        node = xmlFirstElementChild(xtype);
        if (!node) {
            syslog(LOG_WARNING, "Missing <latitude> XML element");
            break;
        }
        else if (xmlStrcmp(node->name, BAD_CAST "latitude")) {
            syslog(LOG_WARNING,
                   "Expected <latitude> XML element, received %s", node->name);
            break;
        }

        content = xmlNodeGetContent(node);
        geo.lat = atof((const char *) content);

        node = xmlNextElementSibling(node);
        if (!node) {
            syslog(LOG_WARNING, "Missing <longitude> XML element");
            break;
        }
        else if (xmlStrcmp(node->name, BAD_CAST "longitude")) {
            syslog(LOG_WARNING,
                   "Expected <longitude> XML element, received %s", node->name);
            break;
        }

        xmlFree(content);
        content = xmlNodeGetContent(node);
        geo.lon = atof((const char *) content);

        value = icalvalue_new_geo(geo);

        break;
    }

    case ICAL_PERIOD_VALUE: {
        struct icalperiodtype p;

        p.start = p.end = icaltime_null_time();
        p.duration = icaldurationtype_from_int(0);

        node = xmlFirstElementChild(xtype);
        if (!node) {
            syslog(LOG_WARNING, "Missing <start> XML element");
            break;
        }
        else if (xmlStrcmp(node->name, BAD_CAST "start")) {
            syslog(LOG_WARNING,
                   "Expected <start> XML element, received %s", node->name);
            break;
        }

        content = xmlNodeGetContent(node);
        p.start = icaltime_from_string((const char *) content);
        if (icaltime_is_null_time(p.start)) break;

        node = xmlNextElementSibling(node);
        if (!node) {
            syslog(LOG_WARNING, "Missing <end> / <duration> XML element");
            break;
        }
        else if (!xmlStrcmp(node->name, BAD_CAST "end")) {
            xmlFree(content);
            content = xmlNodeGetContent(node);
            p.end = icaltime_from_string((const char *) content);
            if (icaltime_is_null_time(p.end)) break;
        }
        else if (!xmlStrcmp(node->name, BAD_CAST "duration")) {
            xmlFree(content);
            content = xmlNodeGetContent(node);
            p.duration = icaldurationtype_from_string((const char *) content);
            if (icaldurationtype_as_int(p.duration) == 0) break;
        }
        else {
            syslog(LOG_WARNING,
                   "Expected <end> / <duration> XML element, received %s",
                   node->name);
            break;
        }

        value = icalvalue_new_period(p);

        break;
    }

    case ICAL_RECUR_VALUE: {
        struct buf rrule = BUF_INITIALIZER;
        struct hash_table byrules;
        struct icalrecurrencetype rt;
        char *sep = "";

        construct_hash_table(&byrules, 10, 1);

        /* create an iCal RRULE string from xCal <recur> sub-elements */
        for (node = xmlFirstElementChild(xtype); node;
                node = xmlNextElementSibling(node)) {

            content = xmlNodeGetContent(node);
            if (!xmlStrncmp(node->name, BAD_CAST "by", 2)) {
                /* BY* rules can have a list of values -
                   assemble them using a hash table */
                struct buf *vals =
                    hash_lookup((const char *) node->name, &byrules);

                if (vals) {
                    /* append this value to existing list */
                    buf_printf(vals, ",%s", (char *) content);
                }
                else {
                    /* create new list with this valiue */
                    vals = xzmalloc(sizeof(struct buf));
                    buf_setcstr(vals, (char *) content);
                    hash_insert((char *) node->name, vals, &byrules);
                }
            }
            else {
                /* single value rpart */
                buf_printf(&rrule, "%s%s=%s", sep,
                           ucase((char *) node->name), (char *) content);
                sep = ";";
            }

            xmlFree(content);
            content = NULL;
        }

        /* append the BY* rules to RRULE buffer */
        hash_enumerate(&byrules,
                       (void (*)(const char*, void*, void*)) &append_byrule,
                       &rrule);
        free_hash_table(&byrules, NULL);

        /* parse our iCal RRULE string */
        rt = icalrecurrencetype_from_string(buf_cstring(&rrule));
        buf_free(&rrule);

        if (rt.freq != ICAL_NO_RECURRENCE) value = icalvalue_new_recur(rt);

        break;
    }

    case ICAL_REQUESTSTATUS_VALUE: {
        struct icalreqstattype rst = { ICAL_UNKNOWN_STATUS, NULL, NULL };
        short maj, min;

        node = xmlFirstElementChild(xtype);
        if (!node) {
            syslog(LOG_WARNING, "Missing <code> XML element");
            break;
        }
        else if (xmlStrcmp(node->name, BAD_CAST "code")) {
            syslog(LOG_WARNING,
                   "Expected <code> XML element, received %s", node->name);
            break;
        }

        content = xmlNodeGetContent(node);
        if (sscanf((const char *) content, "%hd.%hd", &maj, &min) == 2) {
            rst.code = icalenum_num_to_reqstat(maj, min);
        }
        if (rst.code == ICAL_UNKNOWN_STATUS) {
            syslog(LOG_WARNING, "Unknown request-status code");
            break;
        }

        node = xmlNextElementSibling(node);
        if (!node) {
            syslog(LOG_WARNING, "Missing <description> XML element");
            break;
        }
        else if (xmlStrcmp(node->name, BAD_CAST "description")) {
            syslog(LOG_WARNING,
                   "Expected <description> XML element, received %s",
                   node->name);
            break;
        }

        xmlFree(content);
        content = xmlNodeGetContent(node);
        rst.desc = (const char *) content;

        node = xmlNextElementSibling(node);
        if (node) {
            if (xmlStrcmp(node->name, BAD_CAST "data")) {
                syslog(LOG_WARNING,
                       "Expected <data> XML element, received %s", node->name);
                break;
            }

            xmlFree(content);
            content = xmlNodeGetContent(node);
            rst.debug = (const char *) content;
        }

        value = icalvalue_new_requeststatus(rst);
        break;
    }

    case ICAL_UTCOFFSET_VALUE: {
        int n, utcoffset, hours, minutes, seconds = 0;
        char sign;

        content = xmlNodeGetContent(xtype);
        n = sscanf((const char *) content, "%c%02d:%02d:%02d",
                   &sign, &hours, &minutes, &seconds);

        if (n < 3) {
            syslog(LOG_WARNING, "Unexpected utc-offset format");
            break;
        }

        utcoffset = hours*3600 + minutes*60 + seconds;

        if (sign == '-') utcoffset = -utcoffset;

        value = icalvalue_new_utcoffset(utcoffset);
        break;
    }

    default:
        content = xmlNodeGetContent(xtype);
        value = icalvalue_new_from_string(kind, (const char *) content);
        break;
    }

    if (content) xmlFree(content);

    return value;
}
Beispiel #25
0
/*
 * Construct an iCalendar property from a XML element.
 */
static icalproperty *xml_element_to_icalproperty(xmlNodePtr xprop)
{
    const char *propname, *typestr;
    icalproperty_kind kind;
    icalproperty *prop = NULL;
    icalvalue_kind valkind;
    icalvalue *value;
    xmlNodePtr node;

    /* Get the property type */
    propname = ucase(icalmemory_tmp_copy((const char *) xprop->name));
    kind = icalenum_string_to_property_kind(propname);
    if (kind == ICAL_NO_PROPERTY) {
        syslog(LOG_WARNING, "Unknown xCal property type: %s", propname);
        return NULL;
    }

    /* Create new property */
    prop = icalproperty_new(kind);
    if (!prop) {
        syslog(LOG_ERR, "Creation of new %s property failed", propname);
        return NULL;
    }
    if (kind == ICAL_X_PROPERTY) icalproperty_set_x_name(prop, propname);


    /* Add parameters */
    node = xmlFirstElementChild(xprop);
    if (node && !xmlStrcmp(node->name, BAD_CAST "parameters")) {
        xmlNodePtr xparam;

        for (xparam = xmlFirstElementChild(node); xparam;
                xparam = xmlNextElementSibling(xparam)) {
            char *paramname =
                ucase(icalmemory_tmp_copy((const char *) xparam->name));
            xmlChar *paramval = xmlNodeGetContent(xmlFirstElementChild(xparam));

            /* XXX  Need to handle multi-valued parameters */
            icalproperty_set_parameter_from_string(prop, paramname,
                                                   (const char *) paramval);

            xmlFree(paramval);
        }

        node = xmlNextElementSibling(node);
    }

    /* Get the value type */
    if (!node) {
        syslog(LOG_WARNING, "Missing xCal value for %s property",
               propname);
        return NULL;
    }
    typestr = ucase(icalmemory_tmp_copy((const char *) node->name));
    valkind = !strcmp(typestr, "UNKNOWN") ? ICAL_X_VALUE :
              icalenum_string_to_value_kind(typestr);
    if (valkind == ICAL_NO_VALUE) {
        syslog(LOG_WARNING, "Unknown xCal value type for %s property: %s",
               propname, typestr);
        return NULL;
    }
    else if (valkind == ICAL_TEXT_VALUE) {
        /* "text" also includes enumerated types - grab type from property */
        valkind = icalproperty_kind_to_value_kind(kind);
    }


    /* Add value */
    switch (kind) {
    case ICAL_CATEGORIES_PROPERTY:
    case ICAL_RESOURCES_PROPERTY:
    case ICAL_POLLPROPERTIES_PROPERTY:
        if (valkind == ICAL_TEXT_VALUE) {
            /* Handle multi-valued properties */
            struct buf buf = BUF_INITIALIZER;
            xmlChar *content = NULL;

            content = xmlNodeGetContent(node);
            buf_setcstr(&buf, (const char *) content);
            free(content);

            while ((node = xmlNextElementSibling(node))) {
                buf_putc(&buf, ',');
                content = xmlNodeGetContent(node);
                buf_appendcstr(&buf, (const char *) content);
                free(content);
            }

            value = icalvalue_new_from_string(valkind, buf_cstring(&buf));
            buf_free(&buf);
            break;
        }

    default:
        value = xml_element_to_icalvalue(node, valkind);
        if (!value) {
            syslog(LOG_ERR, "Parsing %s property value failed", propname);
            goto error;
        }
    }

    icalproperty_set_value(prop, value);


    /* Sanity check */
    if ((node = xmlNextElementSibling(node))) {
        syslog(LOG_WARNING,
               "Unexpected XML element in property: %s", node->name);
        goto error;
    }

    return prop;

error:
    icalproperty_free(prop);
    return NULL;
}
Beispiel #26
0
int main(int argc, char **argv)
{
    int opt, r = 0;
    char *alt_config = NULL, *pub = NULL, *ver = NULL, *winfile = NULL;
    char prefix[2048];
    enum { REBUILD, WINZONES, NONE } op = NONE;

    if ((geteuid()) == 0 && (become_cyrus(/*ismaster*/0) != 0)) {
	fatal("must run as the Cyrus user", EC_USAGE);
    }

    while ((opt = getopt(argc, argv, "C:r:vw:")) != EOF) {
	switch (opt) {
	case 'C': /* alt config file */
	    alt_config = optarg;
	    break;

	case 'r':
	    if (op == NONE) {
		op = REBUILD;
		pub = optarg;
		ver = strchr(optarg, ':');
		if (ver) *ver++ = '\0';
		else usage();
	    }
	    else usage();
	    break;

	case 'v':
	    verbose = 1;
	    break;

	case 'w':
	    if (op == NONE) {
		op = WINZONES;
		winfile = optarg;
	    }
	    else usage();
	    break;

	default:
	    usage();
	}
    }

    cyrus_init(alt_config, "ctl_zoneinfo", 0, 0);

    signals_set_shutdown(&shut_down);
    signals_add_handlers(0);

    snprintf(prefix, sizeof(prefix), "%s%s", config_dir, FNAME_ZONEINFODIR);

    switch (op) {
    case REBUILD: {
	struct hash_table tzentries;
	struct zoneinfo *info;
	struct txn *tid = NULL;
	char buf[1024];
	FILE *fp;

	construct_hash_table(&tzentries, 500, 1);

	/* Add INFO record (overall lastmod and TZ DB source version) */
	info = xzmalloc(sizeof(struct zoneinfo));
	info->type = ZI_INFO;
	appendstrlist(&info->data, pub);
	appendstrlist(&info->data, ver);
	hash_insert(INFO_TZID, info, &tzentries);

	/* Add LEAP record (last updated and hash) */
	snprintf(buf, sizeof(buf), "%s%s", prefix, FNAME_LEAPSECFILE);
	if (verbose) printf("Processing leap seconds file %s\n", buf);
	if (!(fp = fopen(buf, "r"))) {
	    fprintf(stderr, "Could not open leap seconds file %s\n", buf);
	}
	else {
	    struct zoneinfo *leap = xzmalloc(sizeof(struct zoneinfo));
	    leap->type = ZI_INFO;

	    while(fgets(buf, sizeof(buf), fp)) {
		if (buf[0] == '#') {
		    /* comment line */

		    if (buf[1] == '$') {
			/* last updated */
			unsigned long last;

			sscanf(buf+2, "\t%lu", &last);
			leap->dtstamp = last - NIST_EPOCH_OFFSET;
		    }
		    else if (buf[1] == 'h') {
			/* hash */
			char *p, *hash = buf+3 /* skip "#h\t" */;

			/* trim trailing whitespace */
			for (p = hash + strlen(hash); isspace(*--p); *p = '\0');
			appendstrlist(&leap->data, hash);
		    }
		}
	    }
	    fclose(fp);

	    hash_insert(LEAP_TZID, leap, &tzentries);
	    info->dtstamp = leap->dtstamp;
	}

	/* Add ZONE/LINK records */
	do_zonedir(prefix, &tzentries, info);

	zoneinfo_open(NULL);

	/* Store records */
	hash_enumerate(&tzentries, &store_zoneinfo, &tid);

	zoneinfo_close(tid);

	free_hash_table(&tzentries, &free_zoneinfo);
	break;
    }

    case WINZONES: {
	xmlParserCtxtPtr ctxt;
	xmlDocPtr doc;
	xmlNodePtr node;
	struct buf tzidbuf = BUF_INITIALIZER;
	struct buf aliasbuf = BUF_INITIALIZER;

	if (verbose) printf("Processing Windows Zone file %s\n", winfile);

	/* Parse the XML file */
	ctxt = xmlNewParserCtxt();
	if (!ctxt) {
	    fprintf(stderr, "Failed to create XML parser context\n");
	    break;
	}

	doc = xmlCtxtReadFile(ctxt, winfile, NULL, 0);
	xmlFreeParserCtxt(ctxt);
	if (!doc) {
	    fprintf(stderr, "Failed to parse XML document\n");
	    break;
	}

	node = xmlDocGetRootElement(doc);
	if (!node || xmlStrcmp(node->name, BAD_CAST "supplementalData")) {
	    fprintf(stderr, "Incorrect root node\n");
	    goto done;
	}

	for (node = xmlFirstElementChild(node);
	     node && xmlStrcmp(node->name, BAD_CAST "windowsZones");
	     node = xmlNextElementSibling(node));
	if (!node) {
	    fprintf(stderr, "Missing windowsZones node\n");
	    goto done;
	}

	node = xmlFirstElementChild(node);
	if (!node || xmlStrcmp(node->name, BAD_CAST "mapTimezones")) {
	    fprintf(stderr, "Missing mapTimezones node\n");
	    goto done;
	}

	if (chdir(prefix)) {
	    fprintf(stderr, "chdir(%s) failed\n", prefix);
	    goto done;
	}

	for (node = xmlFirstElementChild(node);
	     node;
	     node = xmlNextElementSibling(node)) {
	    if (!xmlStrcmp(node->name, BAD_CAST "mapZone") &&
		!xmlStrcmp(xmlGetProp(node, BAD_CAST "territory"),
			   BAD_CAST "001")) {
		const char *tzid, *alias;

		buf_setcstr(&tzidbuf,
			    (const char *) xmlGetProp(node, BAD_CAST "type"));
		buf_appendcstr(&tzidbuf, ".ics");
		tzid = buf_cstring(&tzidbuf);
		buf_setcstr(&aliasbuf,
			    (const char *) xmlGetProp(node, BAD_CAST "other"));
		buf_appendcstr(&aliasbuf, ".ics");
		alias = buf_cstring(&aliasbuf);

		if (verbose) printf("\tLINK: %s -> %s\n", alias, tzid);

		if (symlink(tzid, alias)) {
		    if (errno == EEXIST) {
			struct stat sbuf;

			if (stat(alias, &sbuf)) {
			    fprintf(stderr, "stat(%s) failed: %s\n",
				    alias, strerror(errno));
			    errno = EEXIST;
			}
			else if (sbuf.st_mode & S_IFLNK) {
			    char link[MAX_MAILBOX_PATH+1];
			    int n = readlink(alias, link, MAX_MAILBOX_PATH);

			    if (n == -1) {
				fprintf(stderr, "readlink(%s) failed: %s\n",
					alias, strerror(errno));
				errno = EEXIST;
			    }
			    else if (n == (int) strlen(tzid) &&
				     !strncmp(tzid, link, n)) {
				errno = 0;
			    }
			}
		    }

		    if (errno) {
			fprintf(stderr, "symlink(%s, %s) failed: %s\n",
				tzid, alias, strerror(errno));
		    }
		}
	    }
	}

  done:
	buf_free(&aliasbuf);
	buf_free(&tzidbuf);
	xmlFreeDoc(doc);
	break;
    }

    case NONE:
	r = 2;
	usage();
	break;
    }

    cyrus_done();

    return r;
}
Beispiel #27
0
void SSDPParser::parseServiceList(
    xmlDocPtr doc,
    const xmlChar* ns,
    const xmlChar* udn,
    xmlNodeSetPtr serviceNodeSet, 
    xmlBufferPtr configBuf)
{
    int i;

    for (i = 0; i < serviceNodeSet->nodeNr; i++) {
        xmlNodePtr serviceNode = serviceNodeSet->nodeTab[i];
        xmlNodePtr childNode = serviceNode->xmlChildrenNode; 
        xmlNodePtr next = childNode;
        char* serviceType = 0;
        char* serviceId = 0;
        char* controlURL = 0;
        char* eventSubURL = 0;

        /* check namespace */
        if (strcmp((const char*)serviceNode->ns->href, (const char*)ns))
            continue;

        while (next) {
            char* value = (char*)xmlNodeListGetString(doc, next->xmlChildrenNode, 1);
            bool found = false;

            if (!strcmp((const char*)next->name, "serviceType")) {
                serviceType = value;
                found = true;
            } else if (!strcmp((const char*)next->name, "serviceId")) {
                serviceId = value;
                found = true;
            } else if (!strcmp((const char*)next->name, "controlURL")) {
                controlURL = value;
                found = true;
            } else if (!strcmp((const char*)next->name, "eventSubURL")) {
                eventSubURL = value;
                found = true;
            }

            if (!found)
                xmlFree(value);

            next = xmlNextElementSibling(next);
        }
        
        if (udn && serviceId && serviceType && controlURL)
            addService((const char*)udn, serviceId, serviceType, controlURL, 
                (const char*)configBuf->content, eventSubURL);
        else
            LOG_ERROR("resolve failed for service id %s", serviceId);
        
        if (serviceType)
            xmlFree(serviceType);
        if (serviceId)
            xmlFree(serviceId);
        if (controlURL)
            xmlFree(controlURL);
        if (eventSubURL)
            xmlFree(eventSubURL);
    }
}
Beispiel #28
0
inline __attribute__ ((always_inline)) static int _create_jb_object_helper(xmlNodePtr node, void* object)
{
    xmlChar *_xs = NULL;
    xmlChar *_ys = NULL;
    xmlChar *_widths = NULL;
    xmlChar *_heights = NULL;
    xmlChar *_depths = NULL;
    xmlChar *_angles = NULL;
    xmlChar *_radiuss = NULL;
    double _x = 0.0, _y = 0.0, _width = 0.0, _height = 0.0, _depth = 0.0, _angle = 0.0, _radius = 0.0;
    double* _ptr = (double*) object;

    xmlNodePtr _child = NULL;

    _child = node;
    while(_child)
	{

	    if(strcmp((const char*) _child->name, ZPARSER_COORD_X) == 0)
		_xs = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_Y) == 0)
		_ys = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_COLUMN_WIDTH_ATTRIB) == 0)
		_widths = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_ROW_HEIGHT_ATTRIB) == 0)
		_heights = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_DEPTH) == 0)
		_depths = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_RADIUS) == 0)
		_radiuss = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_ANGLE) == 0)
		_angles = xmlNodeGetContent(_child);

	    /* if all variables are set we exit loop here, otherwise continue looking */
	    if(_xs && _ys && _widths && _heights && _depths && _radiuss && _angles)
		break;

    	    _child = xmlNextElementSibling(_child);
	}


    /* convert the variables and free the buffers */
    if(_xs)
	{
	    _x = atof((const char*) _xs);
	    xmlFree(_xs);
	}
    if(_ys)
	{
	    _y = atof((const char*) _ys);
	    xmlFree(_ys);
	}

    if(_widths)
	{
	    _width = atof((const char*) _widths);
	    xmlFree(_widths);
	}

    if(_heights)
	{
	    _height = atof((const char*) _heights);
	    xmlFree(_heights);
	}

    if(_depths)
	{
	    _depth = atof((const char*) _depths);
	    xmlFree(_depths);
	}

    if(_radiuss)
	{
	    _radius = atof((const char*) _radiuss);
	    xmlFree(_radiuss);
	}

    if(_angles)
	{
	    _angle = atof((const char*) _angles);
	    xmlFree(_angles);
	}

    *_ptr = _x;
    _ptr++;

    *_ptr = _y;
    _ptr++;

    *_ptr = _width;
    _ptr++;

    *_ptr = _height;
    _ptr++;

    *_ptr = _depth;
    _ptr++;

    *_ptr = _radius;
    _ptr++;

    *_ptr = _angle;

    return ZELIA_OK;
}
Beispiel #29
0
inline __attribute__ ((always_inline)) static int _create_jb_object_gland_helper(xmlNodePtr node, zgeneric* object)
{
    xmlChar *_xs = NULL;
    xmlChar *_ys = NULL;
    xmlChar *_szs = NULL;
    xmlChar *_hexs = NULL;

    double _x = 0.0, _y = 0.0;
    zGlandSize _sz = zM16;
    int _hex = 0;
    xmlNodePtr _child = NULL;

    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    if(strcmp((const char*) _child->name, ZPARSER_COORD_X) == 0)
		_xs = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_COORD_Y) == 0)
		_ys = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_SIZE) == 0)
		_szs = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_HEX_FLG) == 0)
		_hexs = xmlNodeGetContent(_child);

	    /* break if all interested variables are set */
	    if(_xs && _ys && _szs && _hexs)
		break;

    	    _child = xmlNextElementSibling(_child);
	}


    if(_xs)
	{
	    _x = atof((const char*) _xs);
	    xmlFree(_xs);
	}

    if(_ys)
	{
	    _y = atof((const char*) _ys);
	    xmlFree(_ys);
	}

    if(_szs)
	{
	    if(strcmp((const char*) _szs, ZPARSER_GLAND_SZ_M16) == 0)
		_sz = zM16;
	    else if(strcmp((const char*) _szs, ZPARSER_GLAND_SZ_M20) == 0)
		_sz = zM20;
	    else
		_sz = zM25;

	    xmlFree(_szs);
	}

    if(_hexs)
	{
	    _hex = atoi((const char*) _hexs);
	    xmlFree(_hexs);
	}

    /* add glands */
    zjb_add_glands(Z_JB(object), _x, _y, _sz, _hex);

    return ZELIA_OK;
}
Beispiel #30
0
inline __attribute__ ((always_inline)) static int _create_jb_object_terminals_helper(xmlNodePtr node, zgeneric* object)
{
    xmlChar* _nums = NULL, *_widths = NULL, *_heights = NULL, *_links = NULL, *_enums = NULL;
    xmlChar* _annot = NULL;
    int _num = 0, _enum = 0;
    double _width = 0.0, _height = 0.0;

    xmlNodePtr _child = NULL;

    _child = xmlFirstElementChild(node);
    while(_child)
	{
	    if(strcmp((const char*) _child->name, ZPARSER_TERMINALS_NUM) == 0)
		_nums = xmlNodeGetContent(_child);
	    if(strcmp((const char*) _child->name, ZPARSER_ETERMINALS_NUM) == 0)
		_enums = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_COLUMN_WIDTH_ATTRIB) == 0)
		_widths = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_ROW_HEIGHT_ATTRIB) == 0)
		_heights = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_TERMINALS_LINKS) == 0)
		_links = xmlNodeGetContent(_child);
	    else if(strcmp((const char*) _child->name, ZPARSER_TERMINAL_ANNOT) == 0)
		_annot = xmlNodeGetContent(_child);
	    
	    /* break from loop if we have obtained every thing */
	    if(_nums && _widths && _heights && _links)
		break;
    	    _child = xmlNextElementSibling(_child);
	}

    if(_nums)
	{
	    _num = atoi((const char*) _nums);
	    xmlFree(_nums);
	}

    if(_enums)
	{
	    _enum = atoi((const char*) _enums);
	    xmlFree(_enums);
	}

    if(_widths)
	{
	    _width = atof((const char*) _widths);
	    xmlFree(_widths);
	}

    if(_heights)
	{
	    _height = atof((const char*) _heights);
	    xmlFree(_heights);
	}

    /* check links pointer and add terminals */
    zjb_add_with_earth_terminals(Z_JB(object),
				 _num,
				 _enum,
				 _width,
				 _height,
				 _annot? (const char*) _annot : NULL,
				 _links? (const char*) _links : NULL);
    if(_links)
	xmlFree(_links);

    if(_annot)
	xmlFree(_annot);

    return ZELIA_OK;
}