/**
* xslDbgCatToFile:
* @node : Is valid
* @file : Is valid
*
* Send the results of cat command in @node to @file
*/
void
xslDbgCatToFile(xmlNodePtr node, FILE * file)
{
if (!node || !file)
return;
/* assume that HTML usage is enabled */
if (node->doc->type == XML_HTML_DOCUMENT_NODE) {
if (node->type == XML_HTML_DOCUMENT_NODE)
htmlDocDump(file, (htmlDocPtr) node);
else
htmlNodeDumpFile(file, node->doc, node);
} else if (node->type == XML_DOCUMENT_NODE) {
/* turn off encoding for the moment and just dump UTF-8
* which will be converted by xsldbgGeneralErrorFunc */
xmlDocPtr doc = (xmlDocPtr) node;
const xmlChar *encoding = doc->encoding;
if (encoding) {
xsldbgGenericErrorFunc(i18n("Information: Temporarily setting document's encoding to UTF-8. Previously was %1.\n").arg(xsldbgText(encoding)));
}
doc->encoding = (xmlChar *) "UTF-8";
xmlDocDump(file, (xmlDocPtr) node);
doc->encoding = encoding;
} else {
xmlElemDump(file, node->doc, node);
}
}
/*
* Performs blind dump of XML fault registry to stdout.
*/
static void
dump_eucafaults_db (void)
{
printf ("\n");
xmlDocDump (stdout, ef_doc);
printf ("\n");
}
bool gpl::xml::dumpXPath(FILE* f /*= stdout*/)
{
if (xmlDocDump(f, m_xml->doc) < 0)
return false;
return true;
}
/*
* call-seq:
* document.dump([stream]) -> true
*
* Dump this document's XML to the specified IO stream.
* If no stream is specified, stdout is used.
*/
VALUE
ruby_xml_document_dump(int argc, VALUE *argv, VALUE self) {
OpenFile *fptr;
VALUE io;
FILE *out;
ruby_xml_document_t *rxd;
Data_Get_Struct(self, ruby_xml_document_t, rxd);
if (rxd->doc == NULL)
return(Qnil);
switch (argc) {
case 0:
io = rb_stdout;
break;
case 1:
io = argv[0];
if (!rb_obj_is_kind_of(io, rb_cIO))
rb_raise(rb_eTypeError, "need an IO object");
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)");
}
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
out = GetWriteFile(fptr);
xmlDocDump(out, rxd->doc);
return(Qtrue);
}
void gabor_mag_face_node_data_stack_output_file(GrmGui* gui){
xmlDocPtr doc;
char* fname;
doc= gabor_mag_stack_data_convert_to_xml(gui, &gui->face_node_data_stack);
xmlDocDump(stdout, doc);/* debug_write */
fname= (char*)gtk_entry_get_text((GtkEntry*)gui->file_io_gui.output_file_entry);
xmlSaveFile(fname, doc);
printf("save xml data to %s\n", fname);
}
/**
* example4:
* @filename: the input XML filename.
* @xpathExpr: the xpath expression for evaluation.
* @value: the new node content.
*
* Parses input XML file, evaluates XPath expression and update the nodes
* then print the result.
*
* Returns 0 on success and a negative value otherwise.
*/
static int
example4(const char* filename, const xmlChar* xpathExpr, const xmlChar* value) {
xmlDocPtr doc;
xmlXPathContextPtr xpathCtx;
xmlXPathObjectPtr xpathObj;
assert(filename);
assert(xpathExpr);
assert(value);
/* Load XML document */
doc = xmlParseFile(filename);
if (doc == NULL) {
fprintf(stderr, "Error: unable to parse file \"%s\"\n", filename);
return(-1);
}
/* Create xpath evaluation context */
xpathCtx = xmlXPathNewContext(doc);
if(xpathCtx == NULL) {
fprintf(stderr,"Error: unable to create new XPath context\n");
xmlFreeDoc(doc);
return(-1);
}
/* Evaluate xpath expression */
xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
if(xpathObj == NULL) {
fprintf(stderr,"Error: unable to evaluate xpath expression \"%s\"\n", xpathExpr);
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
return(-1);
}
/* update selected nodes */
update_xpath_nodes(xpathObj->nodesetval, value);
/* Cleanup of XPath data */
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
/* dump the resulting document */
xmlDocDump(stdout, doc);
/* free the document */
xmlFreeDoc(doc);
return(0);
}
/**
* example:
* @filename: the input XML filename.
*
* Parses input XML file, evaluates XPath expression and update the nodes
* then print the result.
*
* Returns 0 on success and a negative value otherwise.
*/
static int example(const char* filename) {
xmlDocPtr doc;
xmlXPathContextPtr xpathCtx;
assert(filename);
/* Load XML document */
doc = xmlParseFile(filename);
if (doc == NULL) {
fprintf(stderr, "Error: unable to parse file \"%s\"\n", filename);
return(-1);
}
/* Create xpath evaluation context */
xpathCtx = xmlXPathNewContext(doc);
if(xpathCtx == NULL) {
fprintf(stderr,"Error: unable to create new XPath context\n");
xmlFreeDoc(doc);
return(-1);
}
//change the PATH attribute of GRID
if(setNodeValue(xpathCtx, "//ert/eclipse/grid/@path", "sillypath")) {
xmlFreeDoc(doc);
return -1;
}
//node TEST does not exist but will not create an error. Prints "no nodes!"
if(setNodeValue(xpathCtx, "//ert/eclipse/test", "sillypath")) {
xmlFreeDoc(doc);
return -1;
}
/* Cleanup of XPath data */
xmlXPathFreeContext(xpathCtx);
/* dump the resulting document */
xmlDocDump(stdout, doc);
/* free the document */
xmlFreeDoc(doc);
return(0);
}
/* Save doc as XML as filename, 0 on success or 1 on failure */
int save_xml_file(xmlDocPtr doc, const gchar *filename)
{
#if LIBXML_VERSION > 20400
if (xmlSaveFormatFileEnc(filename, doc, NULL, 1) < 0)
return 1;
#else
FILE *out;
out = fopen(filename, "w");
if (!out)
return 1;
xmlDocDump(out, doc); /* Some versions return void */
if (fclose(out))
return 1;
#endif
return 0;
}
int main(int argc, char **argv) {
const char *filename = "test3.xml";
const char *pattern = "preserved";
xmlDocPtr doc;
if (argc == 3) {
filename = argv[1];
pattern = argv[2];
}
/*
* this initialize the library and check potential ABI mismatches
* between the version it was compiled for and the actual shared
* library used.
*/
LIBXML_TEST_VERSION
doc = extractFile(filename, (const xmlChar *) pattern);
if (doc != NULL) {
/*
* ouptut the result.
*/
xmlDocDump(stdout, doc);
/*
* don't forget to free up the doc
*/
xmlFreeDoc(doc);
}
/*
* Cleanup function for the XML library.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
return(0);
}
void xml_end(struct writer *w) {
struct xml_writer_private *p = w->priv;
if (xmlTextWriterEndElement(p->xw) < 0 )
log_warnx("lldpctl", "cannot end element");
if (--p->depth == 0) {
int failed = 0;
if (xmlTextWriterEndDocument(p->xw) < 0 ) {
log_warnx("lldpctl", "cannot finish document");
failed = 1;
}
xmlFreeTextWriter(p->xw);
if (!failed) {
xmlDocDump(p->fh, p->doc);
fflush(p->fh);
}
xmlFreeDoc(p->doc);
}
}
int xml_sign(opendcp_t *opendcp, char *filename) {
xmlSecDSigCtxPtr dsig_ctx = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr root_node;
xmlNodePtr sign_node;
FILE *fp;
int result = OPENDCP_ERROR;
xmlSecKeysMngrPtr key_manager = NULL;
dcp_log(LOG_DEBUG, "xml_sign: xmlsec_init");
xmlsec_init();
/* load doc file */
dcp_log(LOG_DEBUG, "xml_sign: parse file");
doc = xmlParseFile(filename);
if (doc == NULL) {
dcp_log(OPENDCP_ERROR, "Error: unable to parse file %s", filename);
goto done;
}
/* find root node */
root_node = xmlDocGetRootElement(doc);
if (root_node == NULL){
dcp_log(OPENDCP_ERROR, "Error: unable to find root node");
goto done;
}
/* find signature node */
sign_node = xmlSecFindNode(root_node, xmlSecNodeSignature, xmlSecDSigNs);
if(sign_node == NULL) {
fprintf(stderr, "Error: start node not found");
goto done;
}
/* create keys manager */
key_manager = load_certificates_sign(opendcp);
if (key_manager == NULL) {
fprintf(stderr,"Error: failed to create key manager\n");
goto done;
}
/* create signature opendcp */
dsig_ctx = xmlSecDSigCtxCreate(key_manager);
if(dsig_ctx == NULL) {
fprintf(stderr,"Error: failed to create signature opendcp\n");
goto done;
}
/* sign the template */
if(xmlSecDSigCtxSign(dsig_ctx, sign_node) < 0) {
fprintf(stderr,"Error: signature failed\n");
goto done;
}
/* open xml file */
fp = fopen(filename,"wb");
if (fp == NULL) {
fprintf(stderr,"Error: could not open output file\n");
goto done;
}
/* write the xml file */
if (xmlDocDump(fp, doc) < 0) {
fprintf(stderr,"Error: writing XML document failed\n");
goto done;
}
/* close the file */
fclose(fp);
/* 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);
}
/**
* decrypt_file:
* @mngr: the pointer to keys manager.
* @enc_file: the encrypted XML file name.
*
* Decrypts the XML file #enc_file using DES key from #key_file and
* prints results to stdout.
*
* Returns 0 on success or a negative value if an error occurs.
*/
int
decrypt_file(xmlSecKeysMngrPtr mngr, const char* enc_file) {
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
xmlSecEncCtxPtr encCtx = NULL;
int res = -1;
assert(mngr);
assert(enc_file);
/* load template */
doc = xmlParseFile(enc_file);
if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
fprintf(stderr, "Error: unable to parse file \"%s\"\n", enc_file);
goto done;
}
/* find start node */
node = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeEncryptedData, xmlSecEncNs);
if(node == NULL) {
fprintf(stderr, "Error: start node not found in \"%s\"\n", enc_file);
goto done;
}
/* create encryption context */
encCtx = xmlSecEncCtxCreate(mngr);
if(encCtx == NULL) {
fprintf(stderr,"Error: failed to create encryption context\n");
goto done;
}
/* decrypt the data */
if((xmlSecEncCtxDecrypt(encCtx, node) < 0) || (encCtx->result == NULL)) {
fprintf(stderr,"Error: decryption failed\n");
goto done;
}
/* print decrypted data to stdout */
if(encCtx->resultReplaced != 0) {
fprintf(stdout, "Decrypted XML data:\n");
xmlDocDump(stdout, doc);
} else {
fprintf(stdout, "Decrypted binary data (%d bytes):\n", xmlSecBufferGetSize(encCtx->result));
if(xmlSecBufferGetData(encCtx->result) != NULL) {
fwrite(xmlSecBufferGetData(encCtx->result),
1,
xmlSecBufferGetSize(encCtx->result),
stdout);
}
}
fprintf(stdout, "\n");
/* success */
res = 0;
done:
/* cleanup */
if(encCtx != NULL) {
xmlSecEncCtxDestroy(encCtx);
}
if(doc != NULL) {
xmlFreeDoc(doc);
}
return(res);
}
int ExporterVTK<MeshType,N>::writeTimePVD(std::string xmlFilename, double timestep, std::string dataFilename, int partNo) const
{
/*
<!-- Sample xml code for PVD format -->
<?xml version="1.0"?>
<VTKFile type="Collection" version="0.1">
<Collection>
<DataSet timestep="0" group="" part="0" file="ts_0.vtm"/>
<DataSet timestep="0.5" group="" part="0" file="ts_1.vtm"/>
</Collection>
</VTKFile>
*/
int retcode = 0;
xmlDocPtr doc = NULL;
xmlNodePtr root = NULL, node1 = NULL, node2 = NULL;
std::ostringstream oss;
/* only do this on the master rank */
if(this->worldComm().isMasterRank())
{
/* First Step: Find the Collection node */
/* Either in a newly created file or in an existing file */
/* check if the time file already exists */
/* if so we update its data by adding a new DataSet node */
if(boost::filesystem::exists(xmlFilename))
{
doc = xmlReadFile(xmlFilename.c_str(), NULL, 0);
if (doc == NULL) {
//std::cerr << "Failed to parse %s" << std::endl;
return 1;
}
root = xmlDocGetRootElement(doc);
/* check that we have VTKFile as a first entry */
if(xmlStrncmp(root->name, BAD_CAST "VTKFile", 7) == 0 && root->children != NULL)
{
/* get first child */
node1 = root->children;
if(xmlStrncmp(node1->name, BAD_CAST "Collection", 10) != 0)
{
node1 = NULL;
retcode = 1;
}
}
/* mark this as an error */
else
{
retcode = 1;
}
}
/* if the file does not already exists we create it */
else
{
/* create a new document */
doc = xmlNewDoc(BAD_CAST "1.0");
root = xmlNewNode(NULL, BAD_CAST "VTKFile");
xmlSetProp(root, BAD_CAST "type", BAD_CAST "Collection");
xmlSetProp(root, BAD_CAST "version", BAD_CAST "0.1");
xmlDocSetRootElement(doc, root);
node1 = xmlNewNode(NULL, BAD_CAST "Collection");
xmlAddChild(root, node1);
}
/* Second step */
/* Create a new dataset entry to add to the Collection node */
if(node1)
{
node2 = xmlNewNode(NULL, BAD_CAST "DataSet");
xmlAddChild(node1, node2);
oss.str("");
oss << timestep;
xmlSetProp(node2, BAD_CAST "timestep", BAD_CAST oss.str().c_str());
xmlSetProp(node2, BAD_CAST "group", BAD_CAST "");
oss.str("");
oss << partNo;
xmlSetProp(node2, BAD_CAST "part", BAD_CAST oss.str().c_str());
xmlSetProp(node2, BAD_CAST "file", BAD_CAST dataFilename.c_str());
/*
xmlChar * mem = NULL;
int size = 0;
xmlDocDumpFormatMemory(doc, &mem, &size, 1);
std::cout << mem << std::endl;
xmlFree(mem);
*/
//std::cout << "Writing file " << xmlFilename << std::endl;
FILE * f = fopen(xmlFilename.c_str(), "w");
xmlDocDump(f, doc);
fclose(f);
}
xmlFreeDoc(doc);
}
return retcode;
}
gJobPtr parseGjobFile(char *filename) {
xmlDocPtr doc;
gJobPtr ret;
jobPtr job;
xmlNsPtr ns;
xmlNodePtr cur;
/*
* build an XML tree from a the file;
*/
doc = xmlParseFile(filename);
if (doc == NULL) return(NULL);
/*
* Check the document is of the right kind
*/
// cur = doc->root;
// cur = doc->children;
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
return(NULL);
}
ns = xmlSearchNsByHref(doc, cur, "http://www.gnome.org/some-location");
if (ns == NULL) {
fprintf(stderr,
"document of the wrong type, GJob Namespace not found\n");
xmlFreeDoc(doc);
return(NULL);
}
if (strcmp(cur->name, "Helping")) {
fprintf(stderr,"document of the wrong type, root node != Helping");
xmlFreeDoc(doc);
return(NULL);
}
/*
* Allocate the structure to be returned.
*/
ret = (gJobPtr) malloc(sizeof(gJob));
if (ret == NULL) {
fprintf(stderr,"out of memory\n");
xmlFreeDoc(doc);
return(NULL);
}
memset(ret, 0, sizeof(gJob));
/*
* Now, walk the tree.
*/
/* First level we expect just Jobs */
// cur = cur->children;
cur = cur -> children;
while ( cur && xmlIsBlankNode ( cur ) )
{
cur = cur -> next;
}
if ( cur == 0 )
return ( NULL );
if ((strcmp(cur->name, "Jobs")) || (cur->ns != ns)) {
fprintf(stderr,"document of the wrong type, was '%s', Jobs expected",
cur->name);
fprintf(stderr,"xmlDocDump follows\n");
xmlDocDump ( stderr, doc );
fprintf(stderr,"xmlDocDump finished\n");
xmlFreeDoc(doc);
free(ret);
return(NULL);
}
/* Second level is a list of Job, but be laxist */
cur = cur->children;
while (cur != NULL) {
if ((!strcmp(cur->name, "Job")) && (cur->ns == ns)) {
job = parseJob(doc, ns, cur);
if (job != NULL)
ret->jobs[ret->nbJobs++] = job;
if (ret->nbJobs >= 500) break;
}
cur = cur->next;
}
return(ret);
}
int cXmlDoc::dump(FILE* f) {
if (!m_doc)
throw eXmlInvalid("Tried to write bad document");
return xmlDocDump(f, m_doc.get());
}
int main(int argc, char **argv) {
int arg_indx;
const char *params[16 + 1];
int params_indx = 0;
int stylesheet_indx = 0;
int file_indx = 0;
int i, j, k;
FILE *output_file = stdout;
xsltStylesheetPtr *stylesheets =
(xsltStylesheetPtr *) calloc(argc, sizeof(xsltStylesheetPtr));
xmlDocPtr *files = (xmlDocPtr *) calloc(argc, sizeof(xmlDocPtr));
xmlDocPtr doc, res;
int return_value = 0;
if (argc <= 1) {
usage(argv[0]);
return_value = 1;
goto finish;
}
/* Collect arguments */
for (arg_indx = 1; arg_indx < argc; arg_indx++) {
if (argv[arg_indx][0] != '-')
break;
if ((!strcmp(argv[arg_indx], "-param"))
|| (!strcmp(argv[arg_indx], "--param"))) {
arg_indx++;
params[params_indx++] = argv[arg_indx++];
params[params_indx++] = argv[arg_indx];
if (params_indx >= 16) {
fprintf(stderr, "too many params\n");
return_value = 1;
goto finish;
}
} else if ((!strcmp(argv[arg_indx], "-o"))
|| (!strcmp(argv[arg_indx], "--out"))) {
arg_indx++;
output_file = fopen(argv[arg_indx], "w");
} else {
fprintf(stderr, "Unknown option %s\n", argv[arg_indx]);
usage(argv[0]);
return_value = 1;
goto finish;
}
}
params[params_indx] = 0;
/* Collect and parse stylesheets and files to be transformed */
for (; arg_indx < argc; arg_indx++) {
char *argument =
(char *) malloc(sizeof(char) * (strlen(argv[arg_indx]) + 1));
strcpy(argument, argv[arg_indx]);
if (strtok(argument, ".")) {
char *suffix = strtok(0, ".");
if (suffix && !strcmp(suffix, "xsl")) {
stylesheets[stylesheet_indx++] =
xsltParseStylesheetFile((const xmlChar *)argv[arg_indx]);;
} else {
files[file_indx++] = xmlParseFile(argv[arg_indx]);
}
} else {
files[file_indx++] = xmlParseFile(argv[arg_indx]);
}
free(argument);
}
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
/* Process files */
for (i = 0; files[i]; i++) {
doc = files[i];
res = doc;
for (j = 0; stylesheets[j]; j++) {
res = xsltApplyStylesheet(stylesheets[j], doc, params);
xmlFreeDoc(doc);
doc = res;
}
if (stylesheets[0]) {
xsltSaveResultToFile(output_file, res, stylesheets[j-1]);
} else {
xmlDocDump(output_file, res);
}
xmlFreeDoc(res);
}
fclose(output_file);
for (k = 0; stylesheets[k]; k++) {
xsltFreeStylesheet(stylesheets[k]);
}
xsltCleanupGlobals();
xmlCleanupParser();
finish:
free(stylesheets);
free(files);
return(return_value);
}
int main ( int argc , char **argv )
{
fprintf(stdout,"\n===== SIMPLE UI TOOLKIT =====\n\n");
const char *wrong_arg = 0;
char *output_model_file = 0;
char *xforms_text = 0;
char *input_xml_file = 0;
sXformsNode *head;
struct sCbData *CallBackData;
xmlDoc *modelDocPtr;
GtkBuilder *builder;
GtkWidget *window;
GError *error = NULL;
if(argc)
{
#define OY_PARSE_STRING_ARG( opt ) \
if( pos + 1 < argc && argv[pos][i+1] == 0 ) \
{ opt = argv[pos+1]; \
if( opt == 0 && strcmp(argv[pos+1],"0") ) \
wrong_arg = "-" #opt; \
++pos; \
i = 1000; \
} else if(argv[pos][i+1] == '=') \
{ opt = &argv[pos][i+2]; \
if( opt == 0 && strcmp(&argv[pos][i+2],"0") ) \
wrong_arg = "-" #opt; \
i = 1000; \
} else wrong_arg = "-" #opt; \
if(argc != 1)
{
int pos = 1, i;
while(pos < argc)
{
switch(argv[pos][0])
{
case '-':
for(i = 1; i < (int)strlen(argv[pos]); ++i)
switch (argv[pos][i])
{
case 'o': OY_PARSE_STRING_ARG( output_model_file ); break;
case 'i': OY_PARSE_STRING_ARG( input_xml_file ); break;
case 'v': break;//oy_debug += 1; break;
case 'h': usage(argc, argv);
exit (0); break;
case 'l': /* only for compatibility with cmd line */ break;
#if 0
case '-':
if(strcmp(&argv[pos][2],"verbose") == 0)
{
//oy_debug += 1;
i=100;
break;
}
STRING_ADD( t, &argv[pos][2] );
text = oyStrrchr_(t, '=');
/* get the key only */
if(text)
text[0] = 0;
oyStringListAddStaticString_( &other_args,&other_args_n,
t,
oyAllocateFunc_,oyDeAllocateFunc_ );
if(text)
oyStringListAddStaticString_( &other_args,&other_args_n,
oyStrrchr_(&argv[pos][2], '=') + 1,
oyAllocateFunc_,oyDeAllocateFunc_ );
else {
if(argv[pos+1])
{
oyStringListAddStaticString_( &other_args,
&other_args_n,
argv[pos+1],
oyAllocateFunc_,oyDeAllocateFunc_ );
++pos;
} else wrong_arg = argv[pos];
}
if(t) oyDeAllocateFunc_( t );
t = 0;
i=100;
break;
#endif
case '?':
default:
fprintf(stderr, "%s -%c\n", ("Unknown argument"), argv[pos][i]);
usage(argc, argv);
exit (0);
break;
}
break;
default:
wrong_arg = argv[pos];
}
if( wrong_arg )
{
fprintf(stderr, "%s %s\n", ("wrong argument to option:"), wrong_arg);
exit(1);
}
++pos;
}
}
}
fprintf(stdout,"INPUT FILE = %s\n",input_xml_file);
if(!input_xml_file)
{
#if 0
size_t text_size = 0;
text = oyReadStdinToMem_(&text_size, oyAllocateFunc_);
if(text_size == 0)
{
usage(argc, argv);
exit (0);
}
#else
usage(argc, argv);
exit (0);
#endif
}
if(input_xml_file)
{
xforms_text = sReadFileToMem(input_xml_file);
}
head = ParseXformsToTree( xforms_text,&modelDocPtr);
//sPrintsXformsTree(head);
gtk_init( &argc, &argv );
builder = gtk_builder_new();
//cb_data = sGenerateGladeFile(head);
CallBackData = sGenerateGladeFile(head,modelDocPtr,&DummyIfFunction);
//print_user_data(CallBackData);
if( ! gtk_builder_add_from_file( builder, sGTK_UI_FILE, &error ) )
{
g_warning( "%s", error->message );
g_free( error );
return( 1 );
}
//Get main window pointer from UI
window = GTK_WIDGET( gtk_builder_get_object( builder, sGTK_GLADE_MAIN_WINDOW_NAME) );
// = MakeDummy();
gtk_builder_connect_signals( builder, CallBackData);
g_object_unref( G_OBJECT( builder ) );
gtk_widget_show( window );
gtk_main();
if(output_model_file)
{
FILE *fp = fopen(output_model_file,"w");
if( fp != NULL )
xmlDocDump(fp, modelDocPtr);
fclose(fp);
}
xmlDocDump(stdout, modelDocPtr);
fprintf(stdout,"\n");
return( 0 );
}
/**
* sign_file:
* @tmpl_file: the signature template file name.
* @key_file: the PEM private key file name.
*
* Signs the #tmpl_file using private key from #key_file.
*
* Returns 0 on success or a negative value if an error occurs.
*/
int
sign_file(const char* tmpl_file, const char* key_file) {
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
xmlSecDSigCtxPtr dsigCtx = NULL;
int res = -1;
assert(tmpl_file);
assert(key_file);
/* load template */
doc = xmlParseFile(tmpl_file);
if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
fprintf(stderr, "Error: unable to parse file \"%s\"\n", tmpl_file);
goto done;
}
/* find start node */
node = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeSignature, xmlSecDSigNs);
if(node == NULL) {
fprintf(stderr, "Error: start node not found in \"%s\"\n", tmpl_file);
goto done;
}
/* create signature context, we don't need keys manager in this example */
dsigCtx = xmlSecDSigCtxCreate(NULL);
if(dsigCtx == NULL) {
fprintf(stderr,"Error: failed to create signature context\n");
goto done;
}
/* load private key, assuming that there is not password */
dsigCtx->signKey = xmlSecCryptoAppKeyLoad(key_file, xmlSecKeyDataFormatPem, NULL, NULL, NULL);
if(dsigCtx->signKey == NULL) {
fprintf(stderr,"Error: failed to load private pem key from \"%s\"\n", key_file);
goto done;
}
/* set key name to the file name, this is just an example! */
if(xmlSecKeySetName(dsigCtx->signKey, key_file) < 0) {
fprintf(stderr,"Error: failed to set key name for key from \"%s\"\n", key_file);
goto done;
}
/* sign the template */
if(xmlSecDSigCtxSign(dsigCtx, node) < 0) {
fprintf(stderr,"Error: signature failed\n");
goto done;
}
/* print signed document to stdout */
xmlDocDump(stdout, doc);
/* success */
res = 0;
done:
/* cleanup */
if(dsigCtx != NULL) {
xmlSecDSigCtxDestroy(dsigCtx);
}
if(doc != NULL) {
xmlFreeDoc(doc);
}
return(res);
}
/**
* encrypt_file:
* @tmpl_file: the encryption template file name.
* @key_file: the Triple DES key file.
* @data: the binary data to encrypt.
* @dataSize: the binary data size.
*
* Encrypts binary #data using template from #tmpl_file and DES key from
* #key_file.
*
* Returns 0 on success or a negative value if an error occurs.
*/
int
encrypt_file(const char* tmpl_file, const char* key_file,
const unsigned char* data, size_t dataSize) {
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
xmlSecEncCtxPtr encCtx = NULL;
int res = -1;
assert(tmpl_file);
assert(key_file);
assert(data);
/* load template */
doc = xmlParseFile(tmpl_file);
if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
printf_a_ignorar3(stderr, "Error: unable to parse file \"%s\"\n", tmpl_file);
goto done;
}
/* find start node */
node = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeEncryptedData, xmlSecEncNs);
if(node == NULL) {
printf_a_ignorar3(stderr, "Error: start node not found in \"%s\"\n", tmpl_file);
goto done;
}
/* create encryption context, we don't need keys manager in this example */
encCtx = xmlSecEncCtxCreate(NULL);
if(encCtx == NULL) {
printf_a_ignorar3(stderr,"Error: failed to create encryption context\n");
goto done;
}
/* load DES key, assuming that there is not password */
encCtx->encKey = xmlSecKeyReadBinaryFile(xmlSecKeyDataDesId, key_file);
if(encCtx->encKey == NULL) {
printf_a_ignorar3(stderr,"Error: failed to load des key from binary file \"%s\"\n", key_file);
goto done;
}
/* set key name to the file name, this is just an example! */
if(xmlSecKeySetName(encCtx->encKey, key_file) < 0) {
printf_a_ignorar3(stderr,"Error: failed to set key name for key from \"%s\"\n", key_file);
goto done;
}
/* encrypt the data */
if(xmlSecEncCtxBinaryEncrypt(encCtx, node, data, dataSize) < 0) {
printf_a_ignorar3(stderr,"Error: encryption failed\n");
goto done;
}
/* print encrypted data with document to stdout */
xmlDocDump(stdout, doc);
/* success */
res = 0;
done:
/* cleanup */
if(encCtx != NULL) {
xmlSecEncCtxDestroy(encCtx);
}
if(doc != NULL) {
xmlFreeDoc(doc);
}
return(res);
}
/**
* encrypt_file:
* @xml_file: the encryption template file name.
* @key_file: the Triple DES key file.
*
* Encrypts #xml_file using a dynamicaly created template and DES key from
* #key_file.
*
* Returns 0 on success or a negative value if an error occurs.
*/
int
encrypt_file(const char* xml_file, const char* key_file) {
xmlDocPtr doc = NULL;
xmlNodePtr encDataNode = NULL;
xmlNodePtr keyInfoNode = NULL;
xmlSecEncCtxPtr encCtx = NULL;
int res = -1;
assert(xml_file);
assert(key_file);
/* load template */
doc = xmlParseFile(xml_file);
if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
fprintf(stderr, "Error: unable to parse file \"%s\"\n", xml_file);
goto done;
}
/* create encryption template to encrypt XML file and replace
* its content with encryption result */
encDataNode = xmlSecTmplEncDataCreate(doc, xmlSecTransformDes3CbcId,
NULL, xmlSecTypeEncElement, NULL, NULL);
if(encDataNode == NULL) {
fprintf(stderr, "Error: failed to create encryption template\n");
goto done;
}
/* we want to put encrypted data in the <enc:CipherValue/> node */
if(xmlSecTmplEncDataEnsureCipherValue(encDataNode) == NULL) {
fprintf(stderr, "Error: failed to add CipherValue node\n");
goto done;
}
/* add <dsig:KeyInfo/> and <dsig:KeyName/> nodes to put key name in the signed document */
keyInfoNode = xmlSecTmplEncDataEnsureKeyInfo(encDataNode, NULL);
if(keyInfoNode == NULL) {
fprintf(stderr, "Error: failed to add key info\n");
goto done;
}
if(xmlSecTmplKeyInfoAddKeyName(keyInfoNode, NULL) == NULL) {
fprintf(stderr, "Error: failed to add key name\n");
goto done;
}
/* create encryption context, we don't need keys manager in this example */
encCtx = xmlSecEncCtxCreate(NULL);
if(encCtx == NULL) {
fprintf(stderr,"Error: failed to create encryption context\n");
goto done;
}
/* load DES key, assuming that there is not password */
encCtx->encKey = xmlSecKeyReadBinaryFile(xmlSecKeyDataDesId, key_file);
if(encCtx->encKey == NULL) {
fprintf(stderr,"Error: failed to load des key from binary file \"%s\"\n", key_file);
goto done;
}
/* set key name to the file name, this is just an example! */
if(xmlSecKeySetName(encCtx->encKey, key_file) < 0) {
fprintf(stderr,"Error: failed to set key name for key from \"%s\"\n", key_file);
goto done;
}
/* encrypt the data */
if(xmlSecEncCtxXmlEncrypt(encCtx, encDataNode, xmlDocGetRootElement(doc)) < 0) {
fprintf(stderr,"Error: encryption failed\n");
goto done;
}
/* we template is inserted in the doc */
encDataNode = NULL;
/* print encrypted data with document to stdout */
xmlDocDump(stdout, doc);
/* success */
res = 0;
done:
/* cleanup */
if(encCtx != NULL) {
xmlSecEncCtxDestroy(encCtx);
}
if(encDataNode != NULL) {
xmlFreeNode(encDataNode);
}
if(doc != NULL) {
xmlFreeDoc(doc);
}
return(res);
}
/**
* sign_file:
* @xml_file: the XML file name.
* @key_file: the PEM private key file name.
*
* Signs the #xml_file using private key from #key_file and dynamicaly
* created enveloped signature template.
*
* Returns 0 on success or a negative value if an error occurs.
*/
int
sign_file(const char* xml_file, const char* key_file) {
xmlDocPtr doc = NULL;
xmlNodePtr signNode = NULL;
xmlNodePtr refNode = NULL;
xmlNodePtr keyInfoNode = NULL;
xmlSecDSigCtxPtr dsigCtx = NULL;
int res = -1;
assert(xml_file);
assert(key_file);
/* load doc file */
doc = xmlParseFile(xml_file);
if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
printf_a_ignorar3(stderr, "Error: unable to parse file \"%s\"\n", xml_file);
goto done;
}
/* create signature template for RSA-SHA1 enveloped signature */
signNode = xmlSecTmplSignatureCreate(doc, xmlSecTransformExclC14NId,
xmlSecTransformRsaSha1Id, NULL);
if(signNode == NULL) {
printf_a_ignorar3(stderr, "Error: failed to create signature template\n");
goto done;
}
/* add <dsig:Signature/> node to the doc */
xmlAddChild(xmlDocGetRootElement(doc), signNode);
/* add reference */
refNode = xmlSecTmplSignatureAddReference(signNode, xmlSecTransformSha1Id,
NULL, NULL, NULL);
if(refNode == NULL) {
printf_a_ignorar3(stderr, "Error: failed to add reference to signature template\n");
goto done;
}
/* add enveloped transform */
if(xmlSecTmplReferenceAddTransform(refNode, xmlSecTransformEnvelopedId) == NULL) {
printf_a_ignorar3(stderr, "Error: failed to add enveloped transform to reference\n");
goto done;
}
/* add <dsig:KeyInfo/> and <dsig:KeyName/> nodes to put key name in the signed document */
keyInfoNode = xmlSecTmplSignatureEnsureKeyInfo(signNode, NULL);
if(keyInfoNode == NULL) {
printf_a_ignorar3(stderr, "Error: failed to add key info\n");
goto done;
}
if(xmlSecTmplKeyInfoAddKeyName(keyInfoNode, NULL) == NULL) {
printf_a_ignorar3(stderr, "Error: failed to add key name\n");
goto done;
}
/* create signature context, we don't need keys manager in this example */
dsigCtx = xmlSecDSigCtxCreate(NULL);
if(dsigCtx == NULL) {
printf_a_ignorar3(stderr,"Error: failed to create signature context\n");
goto done;
}
/* load private key, assuming that there is not password */
dsigCtx->signKey = xmlSecCryptoAppKeyLoad(key_file, xmlSecKeyDataFormatPem, NULL, NULL, NULL);
if(dsigCtx->signKey == NULL) {
printf_a_ignorar3(stderr,"Error: failed to load private pem key from \"%s\"\n", key_file);
goto done;
}
/* set key name to the file name, this is just an example! */
if(xmlSecKeySetName(dsigCtx->signKey, key_file) < 0) {
printf_a_ignorar3(stderr,"Error: failed to set key name for key from \"%s\"\n", key_file);
goto done;
}
/* sign the template */
if(xmlSecDSigCtxSign(dsigCtx, signNode) < 0) {
printf_a_ignorar3(stderr,"Error: signature failed\n");
goto done;
}
/* print signed document to stdout */
xmlDocDump(stdout, doc);
/* success */
res = 0;
done:
/* cleanup */
if(dsigCtx != NULL) {
xmlSecDSigCtxDestroy(dsigCtx);
}
if(doc != NULL) {
xmlFreeDoc(doc);
}
return(res);
}
int
main (int argc, char *argv[])
{
xmlDocPtr doc;
xmlNodePtr parent;
GstCaps *caps;
gst_init (&argc, &argv);
doc = xmlNewDoc ((const xmlChar *) "1.0");
doc->xmlRootNode =
xmlNewDocNode (doc, NULL, (const xmlChar *) "Capabilities", NULL);
/*
for (i = 0; i<100000; i++) {
caps = gst_caps_intersect (gst_static_caps_get (rawcaps3), GST_CAPS_GET (rawcaps4));
gst_caps_unref (caps);
}
*/
caps = gst_caps_intersect (gst_static_caps_get (&sinkcaps),
gst_static_caps_get (&mp1parsecaps));
parent =
xmlNewChild (doc->xmlRootNode, NULL, (const xmlChar *) "Capabilities1",
NULL);
gst_caps_save_thyself (caps, parent);
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps),
gst_static_caps_get (&rawcaps2));
parent =
xmlNewChild (doc->xmlRootNode, NULL, (const xmlChar *) "Capabilities2",
NULL);
gst_caps_save_thyself (caps, parent);
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps3),
gst_static_caps_get (&rawcaps4));
parent =
xmlNewChild (doc->xmlRootNode, NULL, (const xmlChar *) "Capabilities3",
NULL);
gst_caps_save_thyself (caps, parent);
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps3),
gst_static_caps_get (&rawcaps5));
parent =
xmlNewChild (doc->xmlRootNode, NULL, (const xmlChar *) "Capabilities4",
NULL);
gst_caps_save_thyself (caps, parent);
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps6),
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
(gst_static_caps_get (&rawcaps6), 0)), NULL));
parent =
xmlNewChild (doc->xmlRootNode, NULL, (const xmlChar *) "Capabilities5",
NULL);
gst_caps_save_thyself (caps, parent);
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps7),
gst_static_caps_get (&rawcaps8));
g_print ("intersection: %s\n", gst_caps_to_string (caps));
xmlDocDump (stdout, doc);
return 0;
}
int main(int argc, char *argv[])
{
char *descr;
Board board;
xmlDocPtr doc;
xmlNodePtr gameNode, boardNode, analysisNode, node;
if (argc != 2)
{
printf("usage: analyze <game.xml>\n");
exit(1);
}
LIBXML_TEST_VERSION
/* Parse input file */
xmlInitParser();
doc = xmlReadFile(argv[1], NULL, 0);
if (doc == NULL)
{
fprintf(stderr, "Could not read/parse input file.\n");
exit(1);
}
xmlCleanupParser();
/* Process input data */
gameNode = xmlDocGetRootElement(doc);
if (strcmp((char*)gameNode->name, "game") != 0)
{
fprintf(stderr, "Root element should be <game>\n");
exit(1);
}
boardNode = NULL;
for (node = gameNode->children; node != NULL; node = node->next)
{
if (node->type == XML_ELEMENT_NODE)
{
if (strcmp((char*)node->name, "board") == 0)
{
if (boardNode != NULL)
{
fprintf(stderr, "Multiple Mboard> elements found.\n");
exit(1);
}
boardNode = node;
}
if (strcmp((char*)node->name, "analysis") == 0)
{
xmlUnlinkNode(node);
xmlFreeNode(node);
}
}
}
if (boardNode == NULL)
{
fprintf(stderr, "No <board> element found.\n");
exit(1);
}
if ( boardNode->children == NULL ||
boardNode->children != boardNode->last ||
boardNode->children->type != XML_TEXT_NODE )
{
fprintf(stderr, "<board> should contain only text.\n");
exit(1);
}
descr = (char*)xmlNodeGetContent(boardNode->children);
/* Decode board */
if (!board_decode_full(&board, descr))
{
fprintf(stderr, "Cannot decode full board description: %s\n", descr);
exit(1);
}
/* Add analysis to data */
analysisNode = analyze_board(&board);
xmlAddChild(gameNode, analysisNode);
/* Write output document */
xmlDocDump(stdout, doc);
xmlFreeDoc(doc);
return 0;
}
static gJobPtr
parseGjobFile(char *filename) {
xmlDocPtr doc;
gJobPtr ret;
jobPtr curjob;
xmlNsPtr ns;
xmlNodePtr cur;
#ifdef LIBXML_SAX1_ENABLED
/*
* build an XML tree from a the file;
*/
doc = xmlParseFile(filename);
if (doc == NULL) return(NULL);
#else
/*
* the library has been compiled without some of the old interfaces
*/
return(NULL);
#endif /* LIBXML_SAX1_ENABLED */
/*
* Check the document is of the right kind
*/
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
return(NULL);
}
ns = xmlSearchNsByHref(doc, cur,
(const xmlChar *) "http://www.gnome.org/some-location");
if (ns == NULL) {
fprintf(stderr,
"document of the wrong type, GJob Namespace not found\n");
xmlFreeDoc(doc);
return(NULL);
}
if (xmlStrcmp(cur->name, (const xmlChar *) "Helping")) {
fprintf(stderr,"document of the wrong type, root node != Helping");
xmlFreeDoc(doc);
return(NULL);
}
/*
* Allocate the structure to be returned.
*/
ret = (gJobPtr) malloc(sizeof(gJob));
if (ret == NULL) {
fprintf(stderr,"out of memory\n");
xmlFreeDoc(doc);
return(NULL);
}
memset(ret, 0, sizeof(gJob));
/*
* Now, walk the tree.
*/
/* First level we expect just Jobs */
cur = cur->xmlChildrenNode;
while ( cur && xmlIsBlankNode ( cur ) ) {
cur = cur -> next;
}
if ( cur == 0 ) {
xmlFreeDoc(doc);
free(ret);
return ( NULL );
}
if ((xmlStrcmp(cur->name, (const xmlChar *) "Jobs")) || (cur->ns != ns)) {
fprintf(stderr,"document of the wrong type, was '%s', Jobs expected",
cur->name);
fprintf(stderr,"xmlDocDump follows\n");
#ifdef LIBXML_OUTPUT_ENABLED
xmlDocDump ( stderr, doc );
fprintf(stderr,"xmlDocDump finished\n");
#endif /* LIBXML_OUTPUT_ENABLED */
xmlFreeDoc(doc);
free(ret);
return(NULL);
}
/* Second level is a list of Job, but be laxist */
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *) "Job")) &&
(cur->ns == ns)) {
curjob = parseJob(doc, ns, cur);
if (curjob != NULL)
ret->jobs[ret->nbJobs++] = curjob;
if (ret->nbJobs >= 500) break;
}
cur = cur->next;
}
return(ret);
}
int Repository::build_index(string server_url, string server_name, bool rebuild)
{
if (rebuild) server_name=server_url; // Temp warning workaround
pkgDupeNames.clear();
unlink("index.log");
unlink("dupes.log");
unlink("legacy.log");
pkgcounter=0;
__doc = xmlNewDoc((const xmlChar *)"1.0");
if (__doc == NULL) {
mDebug("_root == NULL");
} else {
mDebug("_root != NULL");
}
_rootNode = xmlNewNode(NULL, (const xmlChar *)"repository");
if (_rootNode == NULL) {
mDebug("_rootNode == NULL");
} else {
mDebug("_rootNode != NULL");
}
xmlDocSetRootElement(__doc, _rootNode);
if (_rootNode == NULL) {
mDebug("[2]_rootNode == NULL");
} else {
mDebug("[2]_rootNode != NULL");
}
#ifdef DEBUG
printf("OMFGDUMP\n");
mDebug("Saving repo xml dump");
FILE *__xmlDump = fopen("/tmp/xmldump-repo.xml", "w");
if (xmlDocDump(__xmlDump, __doc) != -1) {
fclose(__xmlDump);
mDebug("Xml dump saved");
} else {
fclose(__xmlDump);
mDebug("Xml dump failed");
}
#endif
// Next, run thru files and extract data.
// We consider that repository root is current directory. So, what we need to do:
// Enter each sub-dir, get each file which name ends with .tgz, extracts xml (and other) data from them,
// and build an XML tree for whole repository, then write it to ./packages.xml
// for the first, let's calculate the package count
pkgcount_ftw=0;
ftw(".", countPackage,600);
ftw(".", ProcessPackage, 600);
// Finally, write our XML tree to file
xmlSaveFileEnc("packages.xml", __doc, "UTF-8");
// Compress file
mDebug("Compressing files");
say("Compressing files\n");
if (/*system("gzip -f filelist.xml")==0 && */system("gzip -f packages.xml")==0)
say("\n-------------SUMMARY------------------\nTotal: %d packages\n\nRepository index created successfully\n",pkgcounter);
else mError("Error creating repository index!");
return 0;
}
