xml.c

linux集群服务器软件代码包

			case '<':
				inTag = TRUE;
				if(ch == '>') inTag = FALSE;
				xmlBufferAdd(xml_buffer, &ch, 1);
				break;
			case '\n':
			case '\t':
			case ' ':
				ch = ' ';
				if(inTag) {
					xmlBufferAdd(xml_buffer, &ch, 1);
				} 
				break;
			default:
				xmlBufferAdd(xml_buffer, &ch, 1);
				break;
		}
	}

	
	xmlInitParser();
	the_xml = xmlBufferContent(xml_buffer);
	doc = xmlParseMemory(the_xml, strlen(the_xml));
	xmlCleanupParser();

	if (doc == NULL) {
		crm_err("Malformed XML [xml=%s]", the_xml);
		xmlBufferFree(xml_buffer);
		return NULL;
	}

	xmlBufferFree(xml_buffer);
	xml_object = xmlDocGetRootElement(doc);

	return xml_object;
#else
	crm_data_t *output = parse_xml(input, NULL);
	if(output != NULL) {
		crm_update_parents(output);
		crm_validate_data(output);
	}
	return output;
#endif	
}

crm_data_t*
file2xml(FILE *input)
{
	
#ifdef USE_LIBXML
	char ch = 0;
	gboolean more = TRUE;
	gboolean inTag = FALSE;
	crm_data_t *xml_object = NULL;
	xmlBufferPtr xml_buffer = xmlBufferCreate();
	const char *the_xml;
	xmlDocPtr doc;

	if(input == NULL) {
		crm_err("File pointer was NULL");
		return NULL;
	}
	
	while (more) {
		ch = fgetc(input);
/* 		crm_devel("Got [%c]", ch); */
		switch(ch) {
			case EOF: 
			case 0:
				ch = 0;
				more = FALSE; 
				xmlBufferAdd(xml_buffer, &ch, 1);
				break;
			case '>':
			case '<':
				inTag = TRUE;
				if(ch == '>') inTag = FALSE;
				xmlBufferAdd(xml_buffer, &ch, 1);
				break;
			case '\n':
			case '\t':
			case ' ':
				ch = ' ';
				if(inTag) {
					xmlBufferAdd(xml_buffer, &ch, 1);
				} 
				break;
			default:
				xmlBufferAdd(xml_buffer, &ch, 1);
				break;
		}
	}

	xmlInitParser();
	the_xml = xmlBufferContent(xml_buffer);
	doc = xmlParseMemory(the_xml, strlen(the_xml));
	xmlCleanupParser();
	
	if (doc == NULL) {
		crm_err("Malformed XML [xml=%s]", the_xml);
		xmlBufferFree(xml_buffer);
		return NULL;
	}
	xmlBufferFree(xml_buffer);
	xml_object = xmlDocGetRootElement(doc);

	crm_xml_devel(xml_object, "Created fragment");

	return xml_object;
#else
	char *buffer = NULL;
	crm_data_t *new_obj = NULL;
	int start = 0, length = 0, read_len = 0;
	
	/* see how big the file is */
	start  = ftell(input);
	fseek(input, 0L, SEEK_END);
	length = ftell(input);
	fseek(input, 0L, start);
	
	if(start != ftell(input)) {
		crm_err("fseek not behaving");
		return NULL;
	}

	crm_devel("Reading %d bytes from file", length);
	crm_malloc(buffer, sizeof(char) * (length+1));
	read_len = fread(buffer, sizeof(char), length, input);
	if(read_len != length) {
		crm_err("Calculated and read bytes differ: %d vs. %d",
			length, read_len);
	} else  if(length > 0) {
		new_obj = string2xml(buffer);
	} else {
		crm_warn("File contained no XML");
	}
	
	crm_free(buffer);
	return new_obj;
#endif	
}

void
dump_array(int log_level, const char *message, const char **array, int depth)
{
	int j;
	
	if(message != NULL) {
		do_crm_log(log_level, __FUNCTION__, NULL, "%s", message);
	}

	do_crm_log(log_level, __FUNCTION__, NULL,  "Contents of the array:");
	if(array == NULL || array[0] == NULL || depth == 0) {
		do_crm_log(log_level, __FUNCTION__, NULL, "\t<empty>");
		return;
	}
	
	for (j=0; j < depth && array[j] != NULL; j++) {
		if (array[j] == NULL) { break; }
		do_crm_log(log_level, __FUNCTION__, NULL, "\t--> (%s).", array[j]);
	}
}

int
write_xml_file(crm_data_t *xml_node, const char *filename) 
{
	int res = 0;
	char now_str[30];
	time_t now;

	crm_devel("Writing XML out to %s", filename);
	crm_validate_data(xml_node);
	if (xml_node == NULL) {
		return -1;
	}

	crm_validate_data(xml_node);
	crm_xml_devel(xml_node, "Writing out");
	crm_validate_data(xml_node);
	
	now = time(NULL);
	ctime_r(&now, now_str);
	now_str[24] = EOS; /* replace the newline */
	set_xml_property_copy(xml_node, "last_written", now_str);
	crm_validate_data(xml_node);
	
#ifdef USE_LIBXML
	if (xml_node->doc == NULL) {
		xmlDocPtr foo = NULL;
		crm_insane("Creating doc pointer for %s", xml_node->name);
		foo = xmlNewDoc("1.0");
		xmlDocSetRootElement(foo, xml_node);
		xmlSetTreeDoc(xml_node, foo);
	}

	/* save it.
	 * set arg 3 to 0 to disable line breaks,1 to enable
	 * res == num bytes saved
	 */
	res = xmlSaveFormatFile(filename, xml_node->doc, 1);
	/* for some reason, reading back after saving with
	 * line-breaks doesnt go real well 
	 */
#else
	{
		FILE *file_output_strm = fopen(filename, "w");
		char *buffer = dump_xml_formatted(xml_node);
		CRM_DEV_ASSERT(buffer != NULL && strlen(buffer) > 0);
		if(buffer != NULL && strlen(buffer) > 0) {
			res = fprintf(file_output_strm, "%s", buffer);
			fflush(file_output_strm);
		}
		fclose(file_output_strm);
		crm_free(buffer);
	}
#endif
	crm_devel("Saved %d bytes to the Cib as XML", res);

	return res;
}

void
print_xml_formatted(int log_level, const char *function,
		    crm_data_t *msg, const char *text)
{
	if(msg == NULL) {
		do_crm_log(log_level, function, NULL, "%s: %s",
			   crm_str(text), "<null>");
		return;
	}

	crm_validate_data(msg);
	do_crm_log(log_level, function, NULL, "%s:",
		   crm_str(text));
	log_data_element(function, log_level, 0, msg, TRUE);
	return;
}

crm_data_t *
get_message_xml(const HA_Message *msg, const char *field) 
{
	crm_data_t *xml_node = NULL;
#ifdef USE_LIBXML
	const char *xml_text = cl_get_string(msg, field);
	xml_node = string2xml(xml_text);
#else
	crm_data_t *tmp_node = NULL;
	crm_validate_data(msg);
	tmp_node = cl_get_struct(msg, field);
	if(tmp_node != NULL) {
		xml_node = copy_xml_node_recursive(tmp_node);
	}
#endif
	return xml_node;
}

gboolean
add_message_xml(HA_Message *msg, const char *field, crm_data_t *xml) 
{
	crm_validate_data(xml);
#ifdef USE_LIBXML
	char *buffer = dump_xml_unformatted(xml);
	CRM_DEV_ASSERT(buffer != NULL);
	if(buffer != NULL) {
		CRM_DEV_ASSERT(cl_is_allocated(buffer));
		ha_msg_add(msg, field, buffer);
		crm_devel("Added XML to message");
		CRM_DEV_ASSERT(cl_is_allocated(buffer));
		crm_free(buffer);
	}
#else
	crm_validate_data(msg);
	ha_msg_addstruct(msg, field, xml);
	crm_update_parents(msg);
#endif
	return TRUE;
}


char *
dump_xml_formatted(crm_data_t *an_xml_node)
{
	char *buffer     = NULL;
#if 0
	int       len        = 0;
	xmlChar  *xml_buffer = NULL;
	xmlDocPtr foo        = NULL;

	crm_data_t* xml_node  = NULL;

	xml_node  = copy_xml_node_recursive(an_xml_node);
	
	if (xml_node == NULL) {
		return NULL;
		
	} else {
		/* reset the doc pointer */
		crm_insane("Creating doc pointer for %s", xml_node->name);
		foo = xmlNewDoc("1.0");
		xmlDocSetRootElement(foo, xml_node);
		xmlSetTreeDoc(xml_node, foo);
		crm_insane("Doc pointer set for %s", xml_node->name);
	}

	crm_insane("Initializing Parser");
	xmlInitParser();
	crm_insane("Dumping data");
	xmlDocDumpFormatMemory(xml_node->doc, &xml_buffer, &len, 1);
	crm_insane("Cleaning up parser");
	xmlCleanupParser();

	crm_insane("Copying memory into crm_ space");
	if(xml_buffer != NULL && len > 0) {
		/* copy the text into crm_ memory */ 
		buffer = crm_strdup(xml_buffer);
		xmlFree(xml_buffer);
	}
	crm_insane("Buffer coppied");
	
	free_xml(xml_node);
#else
	char *mutable_ptr = NULL;
/* 	crm_malloc(buffer, 2*(an_xml_node->stringlen)); */
	crm_malloc(buffer, sizeof(char)*30000);
	mutable_ptr = buffer;
	
	crm_validate_data(an_xml_node);
	CRM_DEV_ASSERT(dump_data_element(
			       0, &mutable_ptr, an_xml_node, TRUE) >= 0);
	if(crm_assert_failed) {
		crm_crit("Could not dump the whole message");
	}
	crm_trace("Dumped: %s", buffer);
#endif
	return buffer;
}
	
char *
dump_xml_unformatted(crm_data_t *an_xml_node)
{
	char *buffer     = NULL;
#if 0
	int       lpc	     = 0;
	int       len        = 0;
	xmlChar  *xml_buffer = NULL;
	xmlDocPtr foo        = NULL;

	crm_data_t* xml_node  = NULL;

	xml_node  = copy_xml_node_recursive(an_xml_node);
	
	if (xml_node == NULL) {
		return NULL;
		
	} else {
	  /* reset the doc pointer */
		crm_insane("Creating doc pointer for %s", xml_node->name);
		foo = xmlNewDoc("1.0");
		xmlDocSetRootElement(foo, xml_node);
		xmlSetTreeDoc(xml_node, foo);
		crm_insane("Doc pointer set for %s", xml_node->name);
	}

	crm_insane("Initializing Parser");
	xmlInitParser();
	crm_insane("Dumping data");
	xmlDocDumpFormatMemory(xml_node->doc, &xml_buffer, &len, 0);
	crm_insane("Cleaning up parser");
	xmlCleanupParser();

	crm_insane("Copying memory into crm_ space");
	if(xml_buffer != NULL && len > 0) {
		/* copy the text into crm_ memory */ 
		buffer = crm_strdup(xml_buffer);
		xmlFree(xml_buffer);
	}
	crm_insane("Buffer coppied");
	
	free_xml(xml_node);

	/* remove <?xml version="1.0"?> and the newline	 */
/* 	for(lpc = 0; lpc < len; lpc++) { */
/* 		if(buffer[lpc] == '\n') { */
/* 			buffer[lpc] = ' '; */
/* 			break; */
/* 		} else { */
/* 			buffer[lpc] = ' '; */
/* 		} */
/* 	} */
/* 	for(lpc = len - 2; lpc > 0 && lpc < len; lpc++) { */
	for(lpc = 0; lpc < len; lpc++) {
		if(buffer[lpc] == '\n') {
			crm_devel("Reset newline at %d", lpc);
			buffer[lpc] = ' ';
		}
	}
	crm_devel("Processed %d chars for newlines", lpc);
#else
	char *mutable_ptr = NULL;
/* 	crm_malloc(buffer, 2*(an_xml_node->stringlen)); */
	crm_malloc(buffer, sizeof(char)*20000);
	mutable_ptr = buffer;
	
	crm_validate_data(an_xml_node);
	CRM_DEV_ASSERT(dump_data_element(
			       0, &mutable_ptr, an_xml_node, TRUE) >= 0);
	if(crm_assert_failed) {
		crm_crit("Could not dump the whole message");
	}

	crm_trace("Dumped: %s", buffer);
#endif
	return buffer;
}

#define update_buffer_head(buffer, len) if(len < 0) {	\
		(*buffer) = EOS; return -1;		\
	} else {					\
		buffer += len;				\
	}


int
print_spaces(char *buffer, int depth) 
{
	int lpc = 0;
	int spaces = 2*depth;
	/* <= so that we always print 1 space - prevents problems with syslog */
	for(lpc = 0; lpc <= spaces; lpc++) {
		if(sprintf(buffer, "%c", ' ') < 1) {
			return -1;
		}
		buffer += 1;
	}
	return lpc;
}

int
log_data_element(
	const char *function, int log_level, int depth,
	crm_data_t *data, gboolean formatted) 
{
	int printed = 0;
	int child_result = 0;
	int has_children = 0;
	char print_buffer[1000];
	char *buffer = print_buffer;
	const char *name = crm_element_name(data);

	crm_insane("Dumping %s...", name);
	crm_validate_data(data);
	if(data == NULL) {
		crm_warn("No data to dump as XML");
		return 0;

	} else if(name == NULL && depth == 0) {
		xml_child_iter(
			data, a_child, NULL,
			child_result = log_data_element(
				function, log_level, depth, a_child, formatted);
			if(child_result < 0) {
				return child_result;
			}
			);
		return 0;

	} else if(name == NULL) {
		crm_err("Cannot dump NULL element at depth %d", depth);
		return -1;
	}
	
	if(formatted) {
		printed = print_spaces(buffer, depth);
		update_buffer_head(buffer, printed);
	}
	
	printed = sprintf(buffer, "<%s", name);
	update_buffer_head(buffer, printed);

	xml_prop_iter(
		data, prop_name, prop_value,

		if(safe_str_eq(XML_ATTR_TAGNAME, prop_name)) {
			continue;
		} else if(safe_str_eq(XML_ATTR_PARENT, prop_name)) {
			continue;
		}
		
		crm_insane("Dumping <%s %s=\"%s\"...",
			  name, prop_name, prop_value);
		printed = sprintf(buffer, " %s=\"%s\"", prop_name, prop_value);
		update_buffer_head(buffer, printed);
		);

	xml_child_iter(
		data, child, NULL,
		if(child != NULL) {
			has_children++;
			break;
		}
		);

	printed = sprintf(buffer, "%s>", has_children==0?"/":"");
	update_buffer_head(buffer, printed);
	do_crm_log(log_level,  function, NULL, "%s", print_buffer);
	buffer = print_buffer;
	
	if(has_children == 0) {
		return 0;
	}
	
	xml_child_iter(
		data, a_child, NULL,
		child_result = log_data_element(
			function, log_level, depth+1, a_child, formatted);

		if(child_result < 0) { return -1; }
		);

	if(formatted) {
		printed = print_spaces(buffer, depth);
		update_buffer_head(buffer, printed);
	}
	do_crm_log(log_level, function, NULL, "%s</%s>",
		   print_buffer, name);
	crm_insane("Dumped %s...", name);

	return has_children;
}