src/io-xml/naxml-reader.c

   1 /*
   2  * Nautilus-Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <glib/gi18n.h>
  36 #include <libxml/tree.h>
  37 #include <string.h>
  38
  39 #include <api/na-core-utils.h>
  40 #include <api/na-gconf-utils.h>
  41 #include <api/na-data-types.h>
  42 #include <api/na-ifactory-provider.h>
  43 #include <api/na-object-api.h>
  44
  45 #include <io-gconf/nagp-keys.h>
  46
  47 #include "naxml-keys.h"
  48 #include "naxml-reader.h"
  49
  50 /* private class data
  51  */
  52 struct NAXMLReaderClassPrivate {
  53         void *empty;                                            /* so that gcc -pedantic is happy */
  54 };
  55
  56 /* the association between a document root node key and the functions
  57  */
  58 typedef struct {
  59         gchar     *root_key;
  60         gchar     *list_key;
  61         gchar     *element_key;
  62         gchar     *key_entry;
  63         guint      key_length;
  64         guint   ( *fn_root_parms )     ( NAXMLReader *, xmlNode * );
  65         guint   ( *fn_list_parms )     ( NAXMLReader *, xmlNode * );
  66         guint   ( *fn_element_parms )  ( NAXMLReader *, xmlNode * );
  67         guint   ( *fn_element_content )( NAXMLReader *, xmlNode * );
  68         gchar * ( *fn_get_value )      ( NAXMLReader *, xmlNode *, const NADataDef *def );
  69 }
  70         RootNodeStr;
  71
  72 /* private instance data
  73  * main naxml_reader_import_from_uri() function is called once for each file
  74  * to import. We thus have one NAXMLReader object per import operation.
  75  */
  76 struct NAXMLReaderPrivate {
  77         gboolean                       dispose_has_run;
  78
  79         /* data provided by the caller
  80          */
  81         NAIImporter                   *importer;
  82         NAIImporterImportFromUriParms *parms;
  83
  84         /* data dynamically set during the import operation
  85          */
  86         gboolean                       type_found;
  87         GList                         *nodes;
  88         GList                         *dealt;
  89         RootNodeStr                   *root_node_str;
  90         gchar                         *item_id;
  91
  92         /* following values are reset and reused while iterating on each
  93          * element nodes of the imported item (cf. reset_node_data())
  94          */
  95         gboolean                       node_ok;
  96 };
  97
  98 extern NAXMLKeyStr naxml_schema_key_schema_str[];
  99 extern NAXMLKeyStr naxml_dump_key_entry_str[];
 100
 101 static GObjectClass *st_parent_class = NULL;
 102
 103 static GType         register_type( void );
 104 static void          class_init( NAXMLReaderClass *klass );
 105 static void          instance_init( GTypeInstance *instance, gpointer klass );
 106 static void          instance_dispose( GObject *object );
 107 static void          instance_finalize( GObject *object );
 108
 109 static NAXMLReader  *reader_new( void );
 110
 111 static guint         schema_parse_schema_content( NAXMLReader *reader, xmlNode *node );
 112 static void          schema_check_for_id( NAXMLReader *reader, xmlNode *iter );
 113 static void          schema_check_for_type( NAXMLReader *reader, xmlNode *iter );
 114 static gchar        *schema_read_value( NAXMLReader *reader, xmlNode *node, const NADataDef *def );
 115
 116 static guint         dump_parse_list_parms( NAXMLReader *reader, xmlNode *node );
 117 static guint         dump_parse_entry_content( NAXMLReader *reader, xmlNode *node );
 118 static void          dump_check_for_type( NAXMLReader *reader, xmlNode *key_node );
 119 static gchar        *dump_read_value( NAXMLReader *reader, xmlNode *node, const NADataDef *def );
 120
 121 static RootNodeStr st_root_node_str[] = {
 122
 123         { NAXML_KEY_SCHEMA_ROOT,
 124                         NAXML_KEY_SCHEMA_LIST,
 125                         NAXML_KEY_SCHEMA_NODE,
 126                         NAXML_KEY_SCHEMA_NODE_APPLYTO,
 127                         6,
 128                         NULL,
 129                         NULL,
 130                         NULL,
 131                         schema_parse_schema_content,
 132                         schema_read_value },
 133
 134         { NAXML_KEY_DUMP_ROOT,
 135                         NAXML_KEY_DUMP_LIST,
 136                         NAXML_KEY_DUMP_NODE,
 137                         NAXML_KEY_DUMP_NODE_KEY,
 138                         1,
 139                         NULL,
 140                         dump_parse_list_parms,
 141                         NULL,
 142                         dump_parse_entry_content,
 143                         dump_read_value },
 144
 145         { NULL }
 146 };
 147
 148 #define ERR_ITEM_ID_NOT_FOUND           _( "Item ID not found." )
 149 #define ERR_MENU_UNWAITED                       _( "Unwaited key path %s while importing a menu." )
 150 #define ERR_NODE_ALREADY_FOUND          _( "Element %s at line %d already found, ignored." )
 151 #define ERR_NODE_INVALID_ID                     _( "Invalid item ID: waited for %s, found %s at line %d." )
 152 #define ERR_NODE_UNKNOWN                        _( "Unknown element %s found at line %d while waiting for %s." )
 153 /* i18n: do not translate keywords 'Action' nor 'Menu' */
 154 #define ERR_NODE_UNKNOWN_TYPE           _( "Unknown type %s found at line %d, while waiting for Action or Menu." )
 155 #define ERR_ROOT_UNKNOWN                        _( "Invalid XML root element %s found at line %d while waiting for %s." )
 156 #define ERR_XMLDOC_UNABLE_TOPARSE       _( "Unable to parse XML file: %s." )
 157 #define WARN_UNDEALT_NODE                       _( "Node %s at line %d has not been dealt with." )
 158
 159 static void          read_start_profile_attach_profile( NAXMLReader *reader, NAObjectProfile *profile );
 160 static gboolean      read_data_is_path_adhoc_for_object( NAXMLReader *reader, const NAIFactoryObject *object, xmlChar *text );
 161 static NADataBoxed  *read_data_boxed_from_node( NAXMLReader *reader, xmlChar *text, xmlNode *parent, const NADataDef *def );
 162 static void          read_done_item_set_localized_icon( NAXMLReader *reader, NAObjectItem *item );
 163 static void          read_done_action_read_profiles( NAXMLReader *reader, NAObjectAction *action );
 164 static gchar        *read_done_action_get_next_profile_id( NAXMLReader *reader );
 165 static void          read_done_action_load_profile( NAXMLReader *reader, const gchar *profile_id );
 166 static void          read_done_profile_set_localized_label( NAXMLReader *reader, NAObjectProfile *profile );
 167
 168 static guint         reader_parse_xmldoc( NAXMLReader *reader );
 169 static guint         iter_on_root_children( NAXMLReader *reader, xmlNode *root );
 170 static guint         iter_on_list_children( NAXMLReader *reader, xmlNode *first );
 171
 172 static gchar        *build_key_node_list( NAXMLKeyStr *strlist );
 173 static gchar        *build_root_node_list( void );
 174 static gchar        *get_value_from_child_node( xmlNode *node, const gchar *child );
 175 static gchar        *get_value_from_child_child_node( xmlNode *node, const gchar *first, const gchar *second );
 176 static gboolean      is_profile_path( NAXMLReader *reader, xmlChar *text );
 177 static guint         manage_import_mode( NAXMLReader *reader );
 178 static void          publish_undealt_nodes( NAXMLReader *reader );
 179 static void          reset_node_data( NAXMLReader *reader );
 180 static xmlNode      *search_for_child_node( xmlNode *node, const gchar *key );
 181 static int           strxcmp( const xmlChar *a, const char *b );
 182
 183 GType
 184 naxml_reader_get_type( void )
 185 {
 186         static GType object_type = 0;
 187
 188         if( !object_type ){
 189                 object_type = register_type();
 190         }
 191
 192         return( object_type );
 193 }
 194
 195 static GType
 196 register_type( void )
 197 {
 198         static const gchar *thisfn = "naxml_reader_register_type";
 199         GType type;
 200
 201         static GTypeInfo info = {
 202                 sizeof( NAXMLReaderClass ),
 203                 NULL,
 204                 NULL,
 205                 ( GClassInitFunc ) class_init,
 206                 NULL,
 207                 NULL,
 208                 sizeof( NAXMLReader ),
 209                 0,
 210                 ( GInstanceInitFunc ) instance_init
 211         };
 212
 213         g_debug( "%s", thisfn );
 214
 215         type = g_type_register_static( G_TYPE_OBJECT, "NAXMLReader", &info, 0 );
 216
 217         return( type );
 218 }
 219
 220 static void
 221 class_init( NAXMLReaderClass *klass )
 222 {
 223         static const gchar *thisfn = "naxml_reader_class_init";
 224         GObjectClass *object_class;
 225
 226         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 227
 228         st_parent_class = g_type_class_peek_parent( klass );
 229
 230         object_class = G_OBJECT_CLASS( klass );
 231         object_class->dispose = instance_dispose;
 232         object_class->finalize = instance_finalize;
 233
 234         klass->private = g_new0( NAXMLReaderClassPrivate, 1 );
 235 }
 236
 237 static void
 238 instance_init( GTypeInstance *instance, gpointer klass )
 239 {
 240         static const gchar *thisfn = "naxml_reader_instance_init";
 241         NAXMLReader *self;
 242
 243         g_debug( "%s: instance=%p, klass=%p", thisfn, ( void * ) instance, ( void * ) klass );
 244         g_return_if_fail( NAXML_IS_READER( instance ));
 245         self = NAXML_READER( instance );
 246
 247         self->private = g_new0( NAXMLReaderPrivate, 1 );
 248
 249         self->private->dispose_has_run = FALSE;
 250         self->private->importer = NULL;
 251         self->private->parms = NULL;
 252         self->private->type_found = FALSE;
 253         self->private->nodes = NULL;
 254         self->private->dealt = NULL;
 255         self->private->root_node_str = NULL;
 256 }
 257
 258 static void
 259 instance_dispose( GObject *object )
 260 {
 261         static const gchar *thisfn = "naxml_reader_instance_dispose";
 262         NAXMLReader *self;
 263
 264         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 265         g_return_if_fail( NAXML_IS_READER( object ));
 266         self = NAXML_READER( object );
 267
 268         if( !self->private->dispose_has_run ){
 269
 270                 self->private->dispose_has_run = TRUE;
 271
 272                 g_list_free( self->private->nodes );
 273                 g_list_free( self->private->dealt );
 274
 275                 /* chain up to the parent class */
 276                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 277                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 278                 }
 279         }
 280 }
 281
 282 static void
 283 instance_finalize( GObject *object )
 284 {
 285         static const gchar *thisfn = "naxml_reader_instance_finalize";
 286         NAXMLReader *self;
 287
 288         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 289         g_return_if_fail( NAXML_IS_READER( object ));
 290         self = NAXML_READER( object );
 291
 292         g_free( self->private->item_id );
 293
 294         reset_node_data( self );
 295
 296         g_free( self->private );
 297
 298         /* chain call to parent class */
 299         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 300                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 301         }
 302 }
 303
 304 static NAXMLReader *
 305 reader_new( void )
 306 {
 307         return( g_object_new( NAXML_READER_TYPE, NULL ));
 308 }
 309
 310 /**
 311  * naxml_reader_import_uri:
 312  * @instance: the #NAIImporter provider.
 313  * @parms: a #NAIImporterUriParms structure.
 314  *
 315  * Imports an item.
 316  *
 317  * Returns: the import operation code.
 318  */
 319 guint
 320 naxml_reader_import_from_uri( const NAIImporter *instance, NAIImporterImportFromUriParms *parms )
 321 {
 322         static const gchar *thisfn = "naxml_reader_import_from_uri";
 323         NAXMLReader *reader;
 324         guint code;
 325
 326         g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, ( void * ) parms );
 327
 328         g_return_val_if_fail( NA_IS_IIMPORTER( instance ), IMPORTER_CODE_PROGRAM_ERROR );
 329
 330         reader = reader_new();
 331         reader->private->importer = ( NAIImporter * ) instance;
 332         reader->private->parms = parms;
 333
 334         parms->exist = FALSE;
 335         parms->import_mode = IMPORTER_MODE_NO_IMPORT;
 336         parms->imported = NULL;
 337
 338         code = reader_parse_xmldoc( reader );
 339
 340         if( code == IMPORTER_CODE_OK ){
 341                 g_assert( NA_IS_OBJECT_ITEM( reader->private->parms->imported ));
 342                 code = manage_import_mode( reader );
 343         }
 344
 345         if( code != IMPORTER_CODE_OK ){
 346                 if( reader->private->parms->imported ){
 347                         g_object_unref( reader->private->parms->imported );
 348                         reader->private->parms->imported = NULL;
 349                 }
 350         }
 351
 352         if( code == IMPORTER_CODE_OK ){
 353                 publish_undealt_nodes( reader );
 354         }
 355
 356         g_object_unref( reader );
 357
 358         return( code );
 359 }
 360
 361 /*
 362  * check that the file is a valid XML document
 363  * and that the root node can be identified as a schema or a dump
 364  */
 365 static guint
 366 reader_parse_xmldoc( NAXMLReader *reader )
 367 {
 368         RootNodeStr *istr;
 369         gboolean found;
 370         guint code;
 371
 372         xmlDoc *doc = xmlParseFile( reader->private->parms->uri );
 373
 374         if( !doc ){
 375                 xmlErrorPtr error = xmlGetLastError();
 376                 na_core_utils_slist_add_message( &reader->private->parms->messages,
 377                                 ERR_XMLDOC_UNABLE_TOPARSE, error->message );
 378                 xmlResetError( error );
 379                 code = IMPORTER_CODE_NOT_WILLING_TO;
 380
 381         } else {
 382                 xmlNode *root_node = xmlDocGetRootElement( doc );
 383
 384                 istr = st_root_node_str;
 385                 found = FALSE;
 386
 387                 while( istr->root_key && !found ){
 388                         if( !strxcmp( root_node->name, istr->root_key )){
 389                                 found = TRUE;
 390                                 reader->private->root_node_str = istr;
 391                                 code = iter_on_root_children( reader, root_node );
 392                         }
 393                         istr++;
 394                 }
 395
 396                 if( !found ){
 397                         gchar *node_list = build_root_node_list();
 398                         na_core_utils_slist_add_message( &reader->private->parms->messages,
 399                                                 ERR_ROOT_UNKNOWN,
 400                                                 ( const char * ) root_node->name, root_node->line, node_list );
 401                         g_free( node_list );
 402                         code = IMPORTER_CODE_NOT_WILLING_TO;
 403                 }
 404
 405                 xmlFreeDoc (doc);
 406         }
 407
 408         xmlCleanupParser();
 409         return( code );
 410 }
 411
 412 /*
 413  * parse a XML tree
 414  * - must have one child on the named 'first_child' key (others are warned)
 415  * - then iter on child nodes of this previous first named which must ne 'next_child'
 416  */
 417 static guint
 418 iter_on_root_children( NAXMLReader *reader, xmlNode *root )
 419 {
 420         static const gchar *thisfn = "naxml_reader_iter_on_root_children";
 421         xmlNodePtr iter;
 422         gboolean found;
 423         guint code;
 424
 425         g_debug( "%s: reader=%p, root=%p", thisfn, ( void * ) reader, ( void * ) root );
 426
 427         code = IMPORTER_CODE_OK;
 428
 429         /* deal with properties attached to the root node
 430          */
 431         if( reader->private->root_node_str->fn_root_parms ){
 432                 code = ( *reader->private->root_node_str->fn_root_parms )( reader, root );
 433         }
 434
 435         /* iter through the first level of children (list)
 436          * we must have only one occurrence of this first 'list' child
 437          */
 438         found = FALSE;
 439         for( iter = root->children ; iter && code == IMPORTER_CODE_OK ; iter = iter->next ){
 440
 441                 if( iter->type != XML_ELEMENT_NODE ){
 442                         continue;
 443                 }
 444
 445                 if( strxcmp( iter->name, reader->private->root_node_str->list_key )){
 446                         na_core_utils_slist_add_message( &reader->private->parms->messages,
 447                                         ERR_NODE_UNKNOWN,
 448                                         ( const char * ) iter->name, iter->line, reader->private->root_node_str->list_key );
 449                         continue;
 450                 }
 451
 452                 if( found ){
 453                         na_core_utils_slist_add_message( &reader->private->parms->messages, ERR_NODE_ALREADY_FOUND, ( const char * ) iter->name, iter->line );
 454                         continue;
 455                 }
 456
 457                 found = TRUE;
 458                 code = iter_on_list_children( reader, iter );
 459         }
 460
 461         return( code );
 462 }
 463
 464 /*
 465  * iter on 'schema/entry' element nodes
 466  * each node should correspond to an elementary data of the imported item
 467  * other nodes are warned (and ignored)
 468  *
 469  * we have to iterate a first time through all nodes to be sure to find
 470  * a potential 'type' indication - this is needed in order to allocate an
 471  * action or a menu - if not found at the end of this first pass, we default
 472  * to allocate an action
 473  *
 474  * this first pass is also used to check nodes
 475  *
 476  * - for each node, check that
 477  *   > 'schema/entry' childs are in the list of known schema/entry child nodes
 478  *   > 'schema/entry' childs appear only once per node
 479  *     -> this requires a per-node 'found' flag which is reset for each node
 480  *   > schema has an 'applyto' child node
 481  *     -> only checkable at the end of the schema
 482  *
 483  * - check that each data, identified by the 'applyto' value, appears only once
 484  *   applyto node -> elementary data + id item + (optionally) id profile
 485  *   elementary data -> group (action,  menu, profile)
 486  *   -> this requires a 'found' flag for each group+data reset at item level
 487  *      as the item may not be allocated yet, we cannot check that data
 488  *      is actually relevant with the to-be-imported item
 489  *
 490  * each schema 'applyto' node let us identify a data and its value
 491  */
 492 static guint
 493 iter_on_list_children( NAXMLReader *reader, xmlNode *list )
 494 {
 495         static const gchar *thisfn = "naxml_reader_iter_on_list_children";
 496         guint code;
 497         xmlNode *iter;
 498
 499         g_debug( "%s: reader=%p, list=%p", thisfn, ( void * ) reader, ( void * ) list );
 500
 501         code = IMPORTER_CODE_OK;
 502
 503         /* deal with properties attached to the list node
 504          */
 505         if( reader->private->root_node_str->fn_list_parms ){
 506                 code = ( *reader->private->root_node_str->fn_list_parms )( reader, list );
 507         }
 508
 509         /* each occurrence should correspond to an elementary data
 510          * we run first to determine the type, and allocate the object
 511          * we then rely on NAIFactoryProvider to actually read the data
 512          */
 513         for( iter = list->children ; iter && code == IMPORTER_CODE_OK ; iter = iter->next ){
 514
 515                 if( iter->type != XML_ELEMENT_NODE ){
 516                         continue;
 517                 }
 518
 519                 if( strxcmp( iter->name, reader->private->root_node_str->element_key )){
 520                         na_core_utils_slist_add_message( &reader->private->parms->messages,
 521                                         ERR_NODE_UNKNOWN,
 522                                         ( const char * ) iter->name, iter->line, reader->private->root_node_str->element_key );
 523                         continue;
 524                 }
 525
 526                 reset_node_data( reader );
 527
 528                 if( reader->private->root_node_str->fn_element_parms ){
 529                         code = ( *reader->private->root_node_str->fn_element_parms )( reader, iter );
 530                         if( code != IMPORTER_CODE_OK ){
 531                                 continue;
 532                         }
 533                 }
 534
 535                 if( reader->private->root_node_str->fn_element_content ){
 536                         code = ( *reader->private->root_node_str->fn_element_content )( reader, iter );
 537                         if( code != IMPORTER_CODE_OK ){
 538                                 continue;
 539                         }
 540                 }
 541
 542                 if( reader->private->node_ok ){
 543                         reader->private->nodes = g_list_prepend( reader->private->nodes, iter );
 544                 }
 545         }
 546
 547         /* check that we have a not empty id
 548          */
 549         if( code == IMPORTER_CODE_OK ){
 550                 if( !reader->private->item_id || !strlen( reader->private->item_id )){
 551                         na_core_utils_slist_add_message( &reader->private->parms->messages, ERR_ITEM_ID_NOT_FOUND );
 552                         code =  IMPORTER_CODE_NO_ITEM_ID;
 553                 }
 554         }
 555
 556         /* if type not found, then suppose that we have an action
 557          */
 558         if( code == IMPORTER_CODE_OK ){
 559
 560                 if( !reader->private->type_found ){
 561                         reader->private->parms->imported = NA_OBJECT_ITEM( na_object_action_new());
 562                 }
 563         }
 564
 565         /* now load the data
 566          */
 567         if( code == IMPORTER_CODE_OK ){
 568
 569                 na_object_set_id( reader->private->parms->imported, reader->private->item_id );
 570
 571                 na_ifactory_provider_read_item(
 572                                 NA_IFACTORY_PROVIDER( reader->private->importer ),
 573                                 reader,
 574                                 NA_IFACTORY_OBJECT( reader->private->parms->imported ),
 575                                 &reader->private->parms->messages );
 576         }
 577
 578         return( code );
 579 }
 580
 581 void
 582 naxml_reader_read_start( const NAIFactoryProvider *provider, void *reader_data, const NAIFactoryObject *object, GSList **messages  )
 583 {
 584         static const gchar *thisfn = "naxml_reader_read_start";
 585
 586         g_return_if_fail( NA_IS_IFACTORY_PROVIDER( provider ));
 587         g_return_if_fail( NA_IS_IFACTORY_OBJECT( object ));
 588
 589         g_debug( "%s: provider=%p, reader_data=%p, object=%p (%s), messages=%p",
 590                         thisfn,
 591                         ( void * ) provider,
 592                         ( void * ) reader_data,
 593                         ( void * ) object, G_OBJECT_TYPE_NAME( object ),
 594                         ( void * ) messages );
 595
 596         if( NA_IS_OBJECT_PROFILE( object )){
 597                 read_start_profile_attach_profile( NAXML_READER( reader_data ), NA_OBJECT_PROFILE( object ));
 598         }
 599 }
 600
 601 static void
 602 read_start_profile_attach_profile( NAXMLReader *reader, NAObjectProfile *profile )
 603 {
 604         na_object_attach_profile( reader->private->parms->imported, profile );
 605 }
 606
 607 /*
 608  * this callback function is called by NAIFactoryObject once for each
 609  * serializable data for the object
 610  *
 611  * Note that some nodes may be readen twice because of multiple definition
 612  * of the same data (e.g. icon which exists in localized and unlocalized
 613  * versions). So do not remove dealt-with nodes here
 614  */
 615 NADataBoxed *
 616 naxml_reader_read_data( const NAIFactoryProvider *provider, void *reader_data, const NAIFactoryObject *object, const NADataDef *def, GSList **messages )
 617 {
 618         static const gchar *thisfn = "naxml_reader_read_data";
 619         xmlNode *parent_node;
 620         GList *ielt;
 621
 622         g_return_val_if_fail( NA_IS_IFACTORY_PROVIDER( provider ), NULL );
 623         g_return_val_if_fail( NA_IS_IFACTORY_OBJECT( object ), NULL );
 624
 625         g_debug( "%s: reader_data=%p, object=%p (%s), data=%s",
 626                         thisfn, ( void * ) reader_data, ( void * ) object, G_OBJECT_TYPE_NAME( object ), def->name );
 627
 628         if( !def->gconf_entry || !strlen( def->gconf_entry )){
 629                 g_warning( "%s: GConf entry is not set for NADataDef %s", thisfn, def->name );
 630                 return( NULL );
 631         }
 632
 633         NADataBoxed *boxed = NULL;
 634         NAXMLReader *reader = NAXML_READER( reader_data );
 635
 636         /*g_debug( "naxml_reader_read_data: nodes=%p (count=%d)",
 637                                  ( void * ) reader->private->nodes, g_list_length( reader->private->nodes ));*/
 638         for( ielt = reader->private->nodes ; ielt && !boxed ; ielt = ielt->next ){
 639
 640                 parent_node = ( xmlNode * ) ielt->data;
 641                 xmlNode *entry_node = search_for_child_node( parent_node, reader->private->root_node_str->key_entry );
 642
 643                 if( !entry_node ){
 644                         g_warning( "%s: no '%s' child in node at line %u", thisfn, reader->private->root_node_str->key_entry, parent_node->line );
 645
 646                 } else {
 647                         xmlChar *path = xmlNodeGetContent( entry_node );
 648                         /*g_debug( "%s: found %s=%s", thisfn, def->gconf_entry, ( const gchar * ) path );*/
 649
 650                         if( read_data_is_path_adhoc_for_object( reader, object, path )){
 651                                 boxed = read_data_boxed_from_node( reader, path, parent_node, def );
 652                         }
 653
 654                         xmlFree( path );
 655                 }
 656         }
 657
 658         if( boxed ){
 659                 reader->private->dealt = g_list_prepend( reader->private->dealt, parent_node );
 660         }
 661
 662         return( boxed );
 663 }
 664
 665 static gboolean
 666 read_data_is_path_adhoc_for_object( NAXMLReader *reader, const NAIFactoryObject *object, xmlChar *text )
 667 {
 668         gboolean adhoc;
 669         GSList *path_slist;
 670         guint path_length;
 671         gchar *node_profile_id;
 672         gchar *factory_profile_id;
 673
 674         adhoc = TRUE;
 675         path_slist = na_core_utils_slist_from_split(( const gchar * ) text, "/" );
 676         path_length = g_slist_length( path_slist );
 677
 678         if( NA_IS_OBJECT_ITEM( object )){
 679                 if( path_length != reader->private->root_node_str->key_length ){
 680                         adhoc = FALSE;
 681                 }
 682
 683         } else if( !is_profile_path( reader, text )){
 684                 adhoc = FALSE;
 685                 /*g_debug( "%s not adhoc as not profile path", ( const gchar * ) text );*/
 686
 687         } else {
 688                 gchar *key_dirname = g_path_get_dirname(( const gchar * ) text );
 689                 node_profile_id = g_path_get_basename( key_dirname );
 690                 g_free( key_dirname );
 691
 692                 factory_profile_id = na_object_get_id( object );
 693
 694                 if( strcmp( node_profile_id, factory_profile_id ) != 0 ){
 695                         adhoc = FALSE;
 696                         /*g_debug( "%s not adhoc (%s) as not searched profile %s",
 697                                         ( const gchar * ) text, node_profile_id, factory_profile_id );*/
 698                 }
 699
 700                 g_free( factory_profile_id );
 701                 g_free( node_profile_id );
 702         }
 703
 704         na_core_utils_slist_free( path_slist );
 705
 706         return( adhoc );
 707 }
 708
 709 static NADataBoxed *
 710 read_data_boxed_from_node( NAXMLReader *reader, xmlChar *path, xmlNode *parent, const NADataDef *def )
 711 {
 712         NADataBoxed *boxed;
 713         gchar *entry;
 714         gchar *value;
 715
 716         boxed = NULL;
 717         entry = g_path_get_basename(( const gchar * ) path );
 718
 719         /*g_debug( "read_data_boxed_from_node: node_entry=%s def_gconf=%s",
 720                         entry, def->gconf_entry );*/
 721
 722         /* read the value
 723          */
 724         if( !strcmp( entry, def->gconf_entry )){
 725
 726                 if( reader->private->root_node_str->fn_get_value ){
 727                         value = ( *reader->private->root_node_str->fn_get_value )( reader, parent, def );
 728                         boxed = na_data_boxed_new( def );
 729                         na_data_boxed_set_from_string( boxed, value );
 730                         g_free( value );
 731                 }
 732         }
 733
 734         g_free( entry );
 735
 736         return( boxed );
 737 }
 738
 739 /*
 740  * all serializable data of the object has been readen
 741  */
 742 void
 743 naxml_reader_read_done( const NAIFactoryProvider *provider, void *reader_data, const NAIFactoryObject *object, GSList **messages  )
 744 {
 745         static const gchar *thisfn = "naxml_reader_read_done";
 746
 747         g_return_if_fail( NA_IS_IFACTORY_PROVIDER( provider ));
 748         g_return_if_fail( NA_IS_IFACTORY_OBJECT( object ));
 749
 750         g_debug( "%s: provider=%p, reader_data=%p, object=%p (%s), messages=%p",
 751                         thisfn,
 752                         ( void * ) provider,
 753                         ( void * ) reader_data,
 754                         ( void * ) object, G_OBJECT_TYPE_NAME( object ),
 755                         ( void * ) messages );
 756
 757         if( NA_IS_OBJECT_ITEM( object )){
 758                 read_done_item_set_localized_icon( NAXML_READER( reader_data ), NA_OBJECT_ITEM( object ));
 759         }
 760
 761         if( NA_IS_OBJECT_ACTION( object )){
 762                 read_done_action_read_profiles( NAXML_READER( reader_data ), NA_OBJECT_ACTION( object ));
 763         }
 764
 765         if( NA_IS_OBJECT_PROFILE( object )){
 766                 read_done_profile_set_localized_label( NAXML_READER( reader_data ), NA_OBJECT_PROFILE( object ));
 767         }
 768
 769         g_debug( "%s: quitting for %s at %p", thisfn, G_OBJECT_TYPE_NAME( object ), ( void * ) object );
 770 }
 771
 772 /*
 773  * just having readen this NAObjectItem
 774  * so deals with unlocalized/localized icon name/path
 775  */
 776 static void
 777 read_done_item_set_localized_icon( NAXMLReader *reader, NAObjectItem *item )
 778 {
 779         gchar *icon, *unloc_icon;
 780
 781         /* deals with localized/unlocalized icon name
 782          * it used to be unlocalized up to 2.29.4 included
 783          */
 784         icon = na_object_get_icon( item );
 785
 786         if( !icon || !strlen( icon )){
 787                 unloc_icon = na_object_get_icon_noloc( item );
 788
 789                 if( unloc_icon && strlen( unloc_icon )){
 790                         na_object_set_icon( item, unloc_icon );
 791                 }
 792
 793                 g_free( unloc_icon );
 794         }
 795
 796         g_free( icon );
 797 }
 798
 799 /*
 800  * if we have detected a pre-v2 action, then the action_read_done() function
 801  * has already allocated and define the corresponding profile
 802  * -> deals here with v2 and post, i.e. with profiles
 803  *
 804  * Also note that profiles order has been introduced in 2.29 serie
 805  */
 806 static void
 807 read_done_action_read_profiles( NAXMLReader *reader, NAObjectAction *action )
 808 {
 809         GSList *order, *ip;
 810         gchar *profile_id;
 811
 812         if( !na_object_get_items_count( reader->private->parms->imported )){
 813
 814                 /* first attach potential ordered profiles
 815                  */
 816                 order = na_object_get_items_slist( reader->private->parms->imported );
 817                 for( ip = order ; ip ; ip = ip->next ){
 818                         read_done_action_load_profile( reader, ( const gchar * ) ip->data );
 819                 }
 820
 821                 /* then attach unordered ones
 822                  */
 823                 while( 1 ){
 824                         profile_id = read_done_action_get_next_profile_id( reader );
 825
 826                         if( profile_id ){
 827                                 read_done_action_load_profile( reader, profile_id );
 828                                 g_free( profile_id );
 829
 830                         } else {
 831                                 break;
 832                         }
 833                 }
 834         }
 835 }
 836
 837 /*
 838  * return the first profile id found in the nodes
 839  */
 840 static gchar *
 841 read_done_action_get_next_profile_id( NAXMLReader *reader )
 842 {
 843         gchar *profile_id;
 844         GList *ip;
 845
 846         profile_id = NULL;
 847
 848         /*g_debug( "read_done_action_get_next_profile_id: nodes=%p (count=%d)",
 849                         ( void * ) reader->private->nodes, g_list_length( reader->private->nodes ));*/
 850
 851         for( ip = reader->private->nodes ; ip && !profile_id ; ip = ip->next ){
 852                 xmlNode *parent_node = ( xmlNode * ) ip->data;
 853                 xmlNode *entry_node = search_for_child_node( parent_node, reader->private->root_node_str->key_entry );
 854                 xmlChar *text = xmlNodeGetContent( entry_node );
 855
 856                 /*g_debug( "text=%s, is_profile=%s",
 857                                         ( const gchar * ) text, is_profile_path( reader, text ) ? "True":"False" );*/
 858
 859                 if( is_profile_path( reader, text )){
 860                         gchar *name = g_path_get_dirname(( const gchar * ) text );
 861                         profile_id = g_path_get_basename( name );
 862                         g_free( name );
 863
 864                         if( na_object_get_item( reader->private->parms->imported, profile_id )){
 865                                 g_free( profile_id );
 866                                 profile_id = NULL;
 867                         }
 868                 }
 869
 870                 xmlFree( text );
 871         }
 872
 873         return( profile_id );
 874 }
 875
 876 static void
 877 read_done_action_load_profile( NAXMLReader *reader, const gchar *profile_id )
 878 {
 879         /*g_debug( "naxml_reader_read_done_action_load_profile: profile_id=%s", profile_id );*/
 880
 881         NAObjectProfile *profile = na_object_profile_new();
 882
 883         na_object_set_id( profile, profile_id );
 884
 885         na_ifactory_provider_read_item(
 886                         NA_IFACTORY_PROVIDER( reader->private->importer ),
 887                         reader,
 888                         NA_IFACTORY_OBJECT( profile ),
 889                         &reader->private->parms->messages );
 890 }
 891
 892 /*
 893  * just having readen this NAObjectProfile
 894  * so deals with unlocalized/localized desc-name
 895  */
 896 static void
 897 read_done_profile_set_localized_label( NAXMLReader *reader, NAObjectProfile *profile )
 898 {
 899         gchar *descname, *unloc_descname;
 900
 901         /* deals with localized/unlocalized descname name
 902          * it used to be unlocalized up to 2.29.4 included
 903          */
 904         descname = na_object_get_label( profile );
 905
 906         if( !descname || !strlen( descname )){
 907                 unloc_descname = na_object_get_label_noloc( profile );
 908
 909                 if( unloc_descname && strlen( unloc_descname )){
 910                         na_object_set_label( profile, unloc_descname );
 911                 }
 912
 913                 g_free( unloc_descname );
 914         }
 915
 916         g_free( descname );
 917 }
 918
 919 /*
 920  * 'key' and 'applyto' keys: check the id
 921  * 'applyto' key: check for type
 922  * returns set node_ok if:
 923  * - each key appears is known and appears only once
 924  * - there is an applyto key
 925  */
 926 static guint
 927 schema_parse_schema_content( NAXMLReader *reader, xmlNode *schema )
 928 {
 929         xmlNode *iter;
 930         NAXMLKeyStr *str;
 931         int i;
 932         guint code;
 933
 934         code = IMPORTER_CODE_OK;
 935
 936         for( iter = schema->children ; iter && code == IMPORTER_CODE_OK ; iter = iter->next ){
 937
 938                 if( iter->type != XML_ELEMENT_NODE ){
 939                         continue;
 940                 }
 941
 942                 str = NULL;
 943                 for( i = 0 ; naxml_schema_key_schema_str[i].key && !str ; ++i ){
 944                         if( !strxcmp( iter->name, naxml_schema_key_schema_str[i].key )){
 945                                 str = naxml_schema_key_schema_str+i;
 946                         }
 947                 }
 948
 949                 if( !str ){
 950                         gchar *node_list = build_key_node_list( naxml_schema_key_schema_str );
 951                         na_core_utils_slist_add_message( &reader->private->parms->messages,
 952                                         ERR_NODE_UNKNOWN,
 953                                         ( const char * ) iter->name, iter->line, node_list );
 954                         g_free( node_list );
 955                         reader->private->node_ok = FALSE;
 956                         continue;
 957                 }
 958
 959                 if( str->reader_found ){
 960                         na_core_utils_slist_add_message( &reader->private->parms->messages,
 961                                         ERR_NODE_ALREADY_FOUND,
 962                                         ( const char * ) iter->name, iter->line );
 963                         reader->private->node_ok = FALSE;
 964                         continue;
 965                 }
 966
 967                 str->reader_found = TRUE;
 968
 969                 /* set the item id the first time, check after
 970                  */
 971                 if( !strxcmp( iter->name, NAXML_KEY_SCHEMA_NODE_KEY ) ||
 972                         !strxcmp( iter->name, NAXML_KEY_SCHEMA_NODE_APPLYTO )){
 973
 974                         schema_check_for_id( reader, iter );
 975
 976                         if( !reader->private->node_ok ){
 977                                 continue;
 978                         }
 979                 }
 980
 981                 /* search for the type of the item
 982                  */
 983                 if( !strxcmp( iter->name, NAXML_KEY_SCHEMA_NODE_APPLYTO )){
 984
 985                         schema_check_for_type( reader, iter );
 986
 987                         if( !reader->private->node_ok ){
 988                                 continue;
 989                         }
 990                 }
 991         }
 992
 993         return( code );
 994 }
 995
 996 /*
 997  * check the id on 'key' and 'applyto' keys
 998  */
 999 static void
1000 schema_check_for_id( NAXMLReader *reader, xmlNode *iter )
1001 {
1002         guint idx = 0;
1003
1004         if( !strxcmp( iter->name, NAXML_KEY_SCHEMA_NODE_KEY )){
1005                 idx = 1;
1006         }
1007
1008         xmlChar *text = xmlNodeGetContent( iter );
1009         gchar **path_elts = g_strsplit(( const gchar * ) text, "/", -1 );
1010         gchar *id = g_strdup( path_elts[ reader->private->root_node_str->key_length+idx-2 ] );
1011         g_strfreev( path_elts );
1012         xmlFree( text );
1013
1014         if( reader->private->item_id ){
1015                 if( strcmp( reader->private->item_id, id ) != 0 ){
1016                         na_core_utils_slist_add_message( &reader->private->parms->messages,
1017                                         ERR_NODE_INVALID_ID,
1018                                         reader->private->item_id, id, iter->line );
1019                         reader->private->node_ok = FALSE;
1020                 }
1021         } else {
1022                 reader->private->item_id = g_strdup( id );
1023         }
1024
1025         g_free( id );
1026 }
1027
1028 /*
1029  * check 'applyto' key for 'Type'
1030  */
1031 static void
1032 schema_check_for_type( NAXMLReader *reader, xmlNode *iter )
1033 {
1034         xmlChar *text = xmlNodeGetContent( iter );
1035
1036         gchar *entry = g_path_get_basename(( const gchar * ) text );
1037
1038         if( !strcmp( entry, NAGP_ENTRY_TYPE )){
1039                 reader->private->type_found = TRUE;
1040                 gchar *type = get_value_from_child_node( iter->parent, NAXML_KEY_SCHEMA_NODE_DEFAULT );
1041
1042                 if( !strcmp( type, NAGP_VALUE_TYPE_ACTION )){
1043                         reader->private->parms->imported = NA_OBJECT_ITEM( na_object_action_new());
1044
1045                 } else if( !strcmp( type, NAGP_VALUE_TYPE_MENU )){
1046                         reader->private->parms->imported = NA_OBJECT_ITEM( na_object_menu_new());
1047
1048                 } else {
1049                         na_core_utils_slist_add_message( &reader->private->parms->messages, ERR_NODE_UNKNOWN_TYPE, type, iter->line );
1050                         reader->private->node_ok = FALSE;
1051                 }
1052
1053                 g_free( type );
1054         }
1055
1056         g_free( entry );
1057         xmlFree( text );
1058 }
1059
1060 static gchar *
1061 schema_read_value( NAXMLReader *reader, xmlNode *node, const NADataDef *def )
1062 {
1063         gchar *value;
1064
1065         if( def->localizable ){
1066                 value = get_value_from_child_child_node( node, NAXML_KEY_SCHEMA_NODE_LOCALE, NAXML_KEY_SCHEMA_NODE_LOCALE_DEFAULT );
1067         } else {
1068                 value = get_value_from_child_node( node, NAXML_KEY_SCHEMA_NODE_DEFAULT );
1069         }
1070
1071         /*g_debug( "name=%s, localizable=%s, value=%s", def->name, def->localizable ? "True":"False", value );*/
1072         return( value );
1073 }
1074
1075 /*
1076  * first run: do nothing
1077  * second run: get the id
1078  */
1079 static guint
1080 dump_parse_list_parms( NAXMLReader *reader, xmlNode *node )
1081 {
1082         guint code;
1083
1084         code = IMPORTER_CODE_OK;
1085
1086         xmlChar *path = xmlGetProp( node, ( const xmlChar * ) NAXML_KEY_DUMP_LIST_PARM_BASE );
1087         reader->private->item_id = g_path_get_basename(( const gchar * ) path );
1088         xmlFree( path );
1089
1090         return( code );
1091 }
1092
1093 /*
1094  * first_run: only search for a 'Type' key, and allocate the item
1095  * second run: load data
1096  */
1097 static guint
1098 dump_parse_entry_content( NAXMLReader *reader, xmlNode *entry )
1099 {
1100         xmlNode *iter;
1101         NAXMLKeyStr *str;
1102         int i;
1103         guint code;
1104
1105         code = IMPORTER_CODE_OK;
1106
1107         for( iter = entry->children ; iter && code == IMPORTER_CODE_OK ; iter = iter->next ){
1108
1109                 if( iter->type != XML_ELEMENT_NODE ){
1110                         continue;
1111                 }
1112
1113                 str = NULL;
1114                 for( i = 0 ; naxml_dump_key_entry_str[i].key && !str ; ++i ){
1115                         if( !strxcmp( iter->name, naxml_dump_key_entry_str[i].key )){
1116                                 str = naxml_dump_key_entry_str+i;
1117                         }
1118                 }
1119
1120                 if( !str ){
1121                         gchar *node_list = build_key_node_list( naxml_dump_key_entry_str );
1122                         na_core_utils_slist_add_message( &reader->private->parms->messages,
1123                                         ERR_NODE_UNKNOWN,
1124                                         ( const char * ) iter->name, iter->line, node_list );
1125                         g_free( node_list );
1126                         reader->private->node_ok = FALSE;
1127                         continue;
1128                 }
1129
1130                 if( str->reader_found ){
1131                         na_core_utils_slist_add_message( &reader->private->parms->messages,
1132                                         ERR_NODE_ALREADY_FOUND,
1133                                         ( const char * ) iter->name, iter->line );
1134                         reader->private->node_ok = FALSE;
1135                         continue;
1136                 }
1137
1138                 str->reader_found = TRUE;
1139
1140                 /* search for the type of the item
1141                  */
1142                 if( !strxcmp( iter->name, NAXML_KEY_DUMP_NODE_KEY )){
1143
1144                         dump_check_for_type( reader, iter );
1145
1146                         if( !reader->private->node_ok ){
1147                                 continue;
1148                         }
1149                 }
1150         }
1151
1152         return( code );
1153 }
1154
1155 /*
1156  * check for 'Type'
1157  */
1158 static void
1159 dump_check_for_type( NAXMLReader *reader, xmlNode *key_node )
1160 {
1161         xmlChar *key_content = xmlNodeGetContent( key_node );
1162
1163         if( !strxcmp( key_content, NAGP_ENTRY_TYPE )){
1164                 reader->private->type_found = TRUE;
1165                 gchar *type = get_value_from_child_child_node( key_node->parent, NAXML_KEY_DUMP_NODE_VALUE, NAXML_KEY_DUMP_NODE_VALUE_TYPE_STRING );
1166
1167                 if( !strcmp( type, NAGP_VALUE_TYPE_ACTION )){
1168                         reader->private->parms->imported = NA_OBJECT_ITEM( na_object_action_new());
1169
1170                 } else if( !strcmp( type, NAGP_VALUE_TYPE_MENU )){
1171                         reader->private->parms->imported = NA_OBJECT_ITEM( na_object_menu_new());
1172
1173                 } else {
1174                         na_core_utils_slist_add_message( &reader->private->parms->messages, ERR_NODE_UNKNOWN_TYPE, type, key_node->line );
1175                         reader->private->node_ok = FALSE;
1176                 }
1177
1178                 g_free( type );
1179         }
1180
1181         xmlFree( key_content );
1182 }
1183
1184 /*
1185  * string list is converted to GSList, then to a GConf string
1186  */
1187 static gchar *
1188 dump_read_value( NAXMLReader *reader, xmlNode *node, const NADataDef *def )
1189 {
1190         gchar *string;
1191         GSList *slist;
1192         xmlNode *value_node;
1193         xmlNode *list_node;
1194         xmlNode *vv_node;
1195         xmlChar *text;
1196         xmlNode *it;
1197
1198         string = NULL;
1199
1200         switch( def->type ){
1201                 case NAFD_TYPE_STRING:
1202                 case NAFD_TYPE_LOCALE_STRING:
1203                 case NAFD_TYPE_UINT:
1204                 case NAFD_TYPE_BOOLEAN:
1205                         string = get_value_from_child_child_node( node, NAXML_KEY_DUMP_NODE_VALUE, NAXML_KEY_DUMP_NODE_VALUE_TYPE_STRING );
1206                         break;
1207
1208                 case NAFD_TYPE_STRING_LIST:
1209                         slist = NULL;
1210                         value_node = search_for_child_node( node, NAXML_KEY_DUMP_NODE_VALUE );
1211
1212                         if( value_node ){
1213                                 list_node = search_for_child_node( value_node, NAXML_KEY_DUMP_NODE_VALUE_LIST );
1214
1215                                 if( list_node ){
1216                                         vv_node = search_for_child_node( list_node, NAXML_KEY_DUMP_NODE_VALUE );
1217
1218                                         for( it = vv_node->children ; it ; it = it->next ){
1219
1220                                                 if( it->type == XML_ELEMENT_NODE &&
1221                                                                 !strxcmp( it->name, NAXML_KEY_DUMP_NODE_VALUE_TYPE_STRING )){
1222
1223                                                         text = xmlNodeGetContent( it );
1224                                                         slist = g_slist_append( slist, ( gchar * ) text );
1225                                                 }
1226
1227                                         }
1228                                 }
1229                         }
1230                         string = na_gconf_utils_slist_to_string( slist );
1231                         na_core_utils_slist_free( slist );
1232                         break;
1233
1234                 case NAFD_TYPE_POINTER:
1235                 default:
1236                         break;
1237         }
1238
1239         return( string );
1240 }
1241
1242 static gchar *
1243 build_key_node_list( NAXMLKeyStr *strlist )
1244 {
1245         NAXMLKeyStr *next;
1246
1247         NAXMLKeyStr *istr = strlist;
1248         GString *string = g_string_new( "" );
1249
1250         while( istr->key ){
1251                 next = istr+1;
1252                 if( string->len ){
1253                         if( next->key ){
1254                                 string = g_string_append( string, ", " );
1255                         } else {
1256                                 string = g_string_append( string, " or " );
1257                         }
1258                 }
1259                 string = g_string_append( string, istr->key );
1260                 istr++;
1261         }
1262
1263         return( g_string_free( string, FALSE ));
1264 }
1265
1266 static gchar *
1267 build_root_node_list( void )
1268 {
1269         RootNodeStr *next;
1270
1271         RootNodeStr *istr = st_root_node_str;
1272         GString *string = g_string_new( "" );
1273
1274         while( istr->root_key ){
1275                 next = istr+1;
1276                 if( string->len ){
1277                         if( next->root_key ){
1278                                 string = g_string_append( string, ", " );
1279                         } else {
1280                                 string = g_string_append( string, " or " );
1281                         }
1282                 }
1283                 string = g_string_append( string, istr->root_key );
1284                 istr++;
1285         }
1286
1287         return( g_string_free( string, FALSE ));
1288 }
1289
1290 static gchar *
1291 get_value_from_child_node( xmlNode *node, const gchar *child )
1292 {
1293         gchar *value = NULL;
1294
1295         xmlNode *value_node = search_for_child_node( node, child );
1296         if( value_node ){
1297                 xmlChar *value_value = xmlNodeGetContent( value_node );
1298                 if( value_value ){
1299                         value = g_strdup(( const char * ) value_value );
1300                         xmlFree( value_value );
1301                 }
1302         }
1303
1304         return( value );
1305 }
1306
1307 static gchar *
1308 get_value_from_child_child_node( xmlNode *node, const gchar *first, const gchar *second )
1309 {
1310         gchar *value = NULL;
1311
1312         xmlNode *first_node = search_for_child_node( node, first );
1313         if( first_node ){
1314                 xmlNode *second_node = search_for_child_node( first_node, second );
1315                 if( second_node ){
1316                         xmlChar *value_value = xmlNodeGetContent( second_node );
1317                         if( value_value ){
1318                                 value = g_strdup(( const char * ) value_value );
1319                                 xmlFree( value_value );
1320                         }
1321                 }
1322         }
1323
1324         return( value );
1325 }
1326
1327 static gboolean
1328 is_profile_path( NAXMLReader *reader, xmlChar *text )
1329 {
1330         gboolean is_profile;
1331         GSList *path_slist;
1332         guint path_length;
1333
1334         path_slist = na_core_utils_slist_from_split(( const gchar * ) text, "/" );
1335         path_length = g_slist_length( path_slist );
1336
1337         is_profile = ( path_length == 1+reader->private->root_node_str->key_length );
1338
1339         na_core_utils_slist_free( path_slist );
1340
1341         return( is_profile );
1342 }
1343
1344 static guint
1345 manage_import_mode( NAXMLReader *reader )
1346 {
1347         NAIImporterManageImportModeParms parms;
1348         guint code;
1349
1350         parms.version = 1;
1351         parms.imported = reader->private->parms->imported;
1352         parms.check_fn = reader->private->parms->check_fn;
1353         parms.check_fn_data = reader->private->parms->check_fn_data;
1354         parms.ask_fn = reader->private->parms->ask_fn;
1355         parms.ask_fn_data = reader->private->parms->ask_fn_data;
1356         parms.asked_mode = reader->private->parms->asked_mode;
1357         parms.messages = reader->private->parms->messages;
1358
1359         code = na_iimporter_manage_import_mode( &parms );
1360
1361         reader->private->parms->exist = parms.exist;
1362         reader->private->parms->import_mode = parms.import_mode;
1363
1364         return( code );
1365 }
1366
1367 static void
1368 publish_undealt_nodes( NAXMLReader *reader )
1369 {
1370         GList *iter;
1371         xmlChar *text;
1372
1373         g_debug( "naxml_reader_publish_undealt_nodes: count=%d", g_list_length( reader->private->nodes ));
1374
1375         for( iter = reader->private->nodes ; iter ; iter = iter->next ){
1376                 xmlNode *node = ( xmlNode * ) iter->data;
1377
1378                 if( !g_list_find( reader->private->dealt, node )){
1379                         text = xmlNodeGetContent( node );
1380                         na_core_utils_slist_add_message( &reader->private->parms->messages, WARN_UNDEALT_NODE, ( const gchar * ) text, node->line );
1381                         xmlFree( text );
1382                 }
1383         }
1384 }
1385
1386 /*
1387  * data are reset before first run on nodes for an item
1388  */
1389 static void
1390 reset_node_data( NAXMLReader *reader )
1391 {
1392         int i;
1393
1394         for( i=0 ; naxml_schema_key_schema_str[i].key ; ++i ){
1395                 naxml_schema_key_schema_str[i].reader_found = FALSE;
1396         }
1397
1398         for( i=0 ; naxml_dump_key_entry_str[i].key ; ++i ){
1399                 naxml_dump_key_entry_str[i].reader_found = FALSE;
1400         }
1401
1402         reader->private->node_ok = TRUE;
1403 }
1404
1405 static xmlNode *
1406 search_for_child_node( xmlNode *node, const gchar *key )
1407 {
1408         xmlNode *iter;
1409
1410         for( iter = node->children ; iter ; iter = iter->next ){
1411                 if( iter->type == XML_ELEMENT_NODE ){
1412                         if( !strxcmp( iter->name, key )){
1413                                 return( iter );
1414                         }
1415                 }
1416         }
1417
1418         return( NULL );
1419 }
1420
1421 /*
1422  * note that up to v 1.10 included, key check was made via a call to
1423  * g_ascii_strncasecmp, which was doubly wrong:
1424  * - because XML is case sensitive by definition
1425  * - because this did not detect a key longer that the reference.
1426  */
1427 static int
1428 strxcmp( const xmlChar *a, const char *b )
1429 {
1430         xmlChar *xb = xmlCharStrdup( b );
1431         int ret = xmlStrcmp( a, xb );
1432         xmlFree( xb );
1433         return( ret );
1434 }