utils/xmlgrep/xmlgrep.c

   1 #include <stdio.h>
   2
   3 #define _GNU_SOURCE
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #ifndef _MSC_VER
   7 # include <strings.h>
   8 #else
   9 # define strncasecmp strnicmp
  10 # include <stdlib.h>
  11 #endif
  12 #include <assert.h>
  13 #include <unistd.h>     /* read */
  14 #include <sys/stat.h>   /* fstat */
  15 #include <fcntl.h>      /* open */
  16
  17 #include "xml.h"
  18
  19 static const char *_static_root = "/";
  20 static const char *_static_element = "*";
  21 static unsigned int _fcount = 0;
  22 static char **_filenames = 0;
  23 static char *_element = 0;
  24 static char *_value = 0;
  25 static char *_root = 0;
  26 static char *_print = 0;
  27 static char *_attribute = 0;
  28 static int print_filenames = 0;
  29
  30 static void free_and_exit(int i);
  31
  32 #define USE_BUFFER              0
  33 #define NODE_NAME_LEN           256
  34 #define STRING_LEN              2048
  35
  36 #define SHOW_NOVAL(opt) \
  37 { \
  38     printf("option '%s' requires a value\n\n", (opt)); \
  39     free_and_exit(-1); \
  40 }
  41
  42 void
  43 show_help ()
  44 {
  45     printf("usage: xmlgrep [options] [file ...]\n\n");
  46     printf("Options:\n");
  47     printf("\t-h\t\tshow this help message\n");
  48     printf("\t-a <string>\tprint this attribute as the output\n");
  49     printf("\t-e <id>\t\tshow sections that contain this element\n");
  50     printf("\t-p <id>\t\tprint this element as the output\n");
  51     printf("\t-r <path>\tspecify the XML search root\n");
  52     printf("\t-v <string>\tfilter sections that contain this vale\n\n");
  53     printf(" To print the contents of the 'type' element of the XML section ");
  54     printf("that begins\n at '/printer/output' use the following command:\n\n");
  55     printf("\txmlgrep -r /printer/output -p type sample.xml\n\n");
  56     printf(" To filter 'output' elements under '/printer' that have attribute");
  57     printf(" 'n' set to '1'\n use the following command:\n\n");
  58     printf("\txmlgrep -r /printer -p output -a n -v 1 sample.xml\n\n");
  59     printf(" To filter out sections that contain the 'driver' element with ");
  60     printf("'generic' as\n it's value use the following command:");
  61     printf("\n\n\txmlgrep -r /printer/output -e driver -v generic sample.xml");
  62     printf("\n\n");
  63     free_and_exit(0);
  64 }
  65
  66 void
  67 free_and_exit(int ret)
  68 {
  69     if (_root && _root != _static_root) free(_root);
  70     if (_element && _element != _static_element) free(_element);
  71     if (_value) free(_value);
  72     if (_print) free(_print);
  73     if (_attribute) free(_attribute);
  74     if (_filenames)
  75     {
  76         unsigned int i;
  77         for (i=0; i < _fcount; i++)
  78         {
  79             if (_filenames[i])
  80             {
  81                 if (print_filenames) printf("%s\n", _filenames[i]);
  82                 free(_filenames[i]);
  83             }
  84         }
  85         free(_filenames);
  86     }
  87
  88     exit(ret);
  89 }
  90
  91 int
  92 parse_option(char **args, int n, int max)
  93 {
  94     char *opt, *arg = 0;
  95     unsigned int alen = 0;
  96     unsigned int olen;
  97
  98     opt = args[n];
  99     if (strncmp(opt, "--", 2) == 0)
 100         opt++;
 101
 102     if ((arg = strchr(opt, '=')) != NULL)
 103     {
 104         *arg++ = 0;
 105     }
 106     else if (++n < max)
 107     {
 108         arg = args[n];
 109 #if 0
 110         if (arg && arg[0] == '-')
 111             arg = 0;
 112 #endif
 113     }
 114
 115     olen = strlen(opt);
 116     if (strncmp(opt, "-help", olen) == 0)
 117     {
 118         show_help();
 119     }
 120     else if (strncmp(opt, "-root", olen) == 0)
 121     {
 122         if (arg == 0) SHOW_NOVAL(opt);
 123         alen = strlen(arg)+1;
 124         if (_root) free(_root);
 125         _root = malloc(alen);
 126         memcpy(_root, arg, alen);
 127         return 2;
 128     }
 129     else if (strncmp(opt, "-element", olen) == 0)
 130     {
 131         if (arg == 0) SHOW_NOVAL(opt);
 132         alen = strlen(arg)+1;
 133         if (_element) free(_element);
 134         _element = malloc(alen);
 135         memcpy(_element, arg, alen);
 136         return 2;
 137     }
 138     else if (strncmp(opt, "-value", olen) == 0)
 139     {
 140         if (arg == 0) SHOW_NOVAL(opt);
 141         alen = strlen(arg)+1;
 142         if (_value) free(_value);
 143         _value = malloc(alen);
 144         memcpy(_value, arg, alen);
 145         return 2;
 146     }
 147     else if (strncmp(opt, "-print", olen) == 0)
 148     {
 149         if (arg == 0) SHOW_NOVAL(opt);
 150         alen = strlen(arg)+1;
 151         if (_print) free(_print);
 152         _print = malloc(alen);
 153         memcpy(_print, arg, alen);
 154         return 2;
 155     }
 156     else if (strncmp(opt, "-attribute", olen) == 0)
 157     {
 158         if (arg == 0) SHOW_NOVAL(opt);
 159         alen = strlen(arg)+1;
 160         if (_attribute) free(_attribute);
 161         _attribute = malloc(alen);
 162         memcpy(_attribute, arg, alen);
 163         return 2;
 164     }
 165     else if (strncmp(opt, "-list-filenames", olen) == 0)
 166     { /* undocumented test argument */
 167         print_filenames = 1;
 168         return 1;
 169     }
 170     else if (opt[0] == '-')
 171     {
 172         printf("Unknown option %s\n", opt);
 173         free_and_exit(-1);
 174     }
 175     else
 176     {
 177         int pos = _fcount++;
 178         if (_filenames == 0)
 179         {
 180             _filenames = (char **)malloc(sizeof(char*));
 181         }
 182         else
 183         {
 184             char **ptr = (char **)realloc(_filenames, _fcount*sizeof(char*));
 185             if (ptr == 0)
 186             {
 187                 printf("Out of memory.\n\n");
 188                 free_and_exit(-1);
 189             }
 190            _filenames = ptr;
 191         }
 192
 193         alen = strlen(opt)+1;
 194         _filenames[pos] = malloc(alen);
 195         memcpy(_filenames[pos], opt, alen);
 196     }
 197
 198     return 1;
 199 }
 200
 201 void walk_the_tree(size_t num, void *xid, char *tree)
 202 {
 203     unsigned int i, no_elements;
 204
 205     if (!tree)                                  /* last node from the tree */
 206     {
 207         void *xmid = xmlMarkId(xid);
 208         if (xmid && _print)
 209         {
 210             no_elements = xmlNodeGetNum(xid, _print);
 211             for (i=0; i<no_elements; i++)
 212             {
 213                 if (xmlNodeGetPos(xid, xmid, _print, i) != 0)
 214                 {
 215                     char *value;
 216
 217                     value = xmlGetString(xmid);
 218                     if (_value && _attribute && value)
 219                     {
 220                        if (!xmlAttributeCompareString(xmid, _attribute, _value))
 221                        {
 222                           printf("%s: <%s %s=\"%s\">%s</%s>\n",
 223                                  _filenames[num], _print, _attribute, _value,
 224                                                   value, _print);
 225                        }
 226                        if (value) free(value);
 227                     }
 228                     else
 229                     {
 230                        printf("%s: <%s>%s</%s>\n",
 231                               _filenames[num], _print, value, _print);
 232                     }
 233                 }
 234             }
 235             free(xmid);
 236         }
 237         else if (xmid && _value)
 238         {
 239             no_elements = xmlNodeGetNum(xmid, _element);
 240             for (i=0; i<no_elements; i++)
 241             {
 242                 if (xmlNodeGetPos(xid, xmid, _element, i) != 0)
 243                 {
 244                     char nodename[NODE_NAME_LEN];
 245
 246                     xmlNodeCopyName(xmid, (char *)&nodename, NODE_NAME_LEN);
 247                     if (xmlCompareString(xmid, _value) == 0)
 248                     {
 249                         printf("%s: <%s>%s</%s>\n",
 250                                _filenames[num], nodename, _value, nodename);
 251                     }
 252                 }
 253             }
 254             free(xmid);
 255         }
 256         else if (xmid && _element)
 257         {
 258             char parentname[NODE_NAME_LEN];
 259
 260             xmlNodeCopyName(xid, (char *)&parentname, NODE_NAME_LEN);
 261
 262             no_elements = xmlNodeGetNum(xmid, _element);
 263             for (i=0; i<no_elements; i++)
 264             {
 265                 if (xmlNodeGetPos(xid, xmid, _element, i) != 0)
 266                 {
 267                     char nodename[NODE_NAME_LEN];
 268
 269                     xmlNodeCopyName(xmid, (char *)&nodename, NODE_NAME_LEN);
 270                     if (!strncasecmp((char*)&nodename, _element, NODE_NAME_LEN))
 271                     {
 272                         char value[NODE_NAME_LEN];
 273                         xmlCopyString(xmid, (char *)&value, NODE_NAME_LEN);
 274                         printf("%s: <%s> <%s>%s</%s> </%s>\n",
 275                                 _filenames[num], parentname, nodename, value,
 276                                                  nodename, parentname);
 277                     }
 278                 }
 279             }
 280         }
 281         else printf("Error executing xmlMarkId\n");
 282     }
 283     else if (xid)                        /* walk the rest of the tree */
 284     {
 285         char *elem, *next;
 286         void *xmid;
 287
 288         elem = tree;
 289         if (*elem == '/') elem++;
 290
 291         next = strchr(elem, '/');
 292
 293         xmid = xmlMarkId(xid);
 294         if (xmid)
 295         {
 296             if (next)
 297             {
 298                *next++ = 0;
 299             }
 300
 301             no_elements = xmlNodeGetNum(xid, elem);
 302             for (i=0; i<no_elements; i++)
 303             {
 304                 if (xmlNodeGetPos(xid, xmid, elem, i) != 0)
 305                     walk_the_tree(num, xmid, next);
 306             }
 307
 308             if (next)
 309             {
 310                *--next = '/';
 311             }
 312
 313             free(xmid);
 314         }
 315         else printf("Error executing xmlMarkId\n");
 316     }
 317 }
 318
 319 void grep_file(unsigned num)
 320 {
 321     void *xid;
 322
 323     xid = xmlOpen(_filenames[num]);
 324     if (xid)
 325     {
 326        void *xrid = xmlMarkId(xid);
 327        int r = 0;
 328
 329        walk_the_tree(num, xrid, _root);
 330
 331        r = xmlErrorGetNo(xrid, 0);
 332        if (r)
 333        {
 334             size_t n = xmlErrorGetLineNo(xrid, 0);
 335             size_t c = xmlErrorGetColumnNo(xrid, 0);
 336             const char *s = xmlErrorGetString(xrid, 1); /* clear the error */
 337             printf("%s: at line %u, column %u: '%s'\n",_filenames[num], n,c, s);
 338        }
 339
 340        free(xrid);
 341     }
 342     else
 343     {
 344         fprintf(stderr, "Error reading file '%s'\n", _filenames[num]);
 345     }
 346
 347     xmlClose(xid);
 348 }
 349
 350
 351 void grep_file_buffer(unsigned num)
 352 {
 353     struct stat st;
 354     void *xid, *buf;
 355     int fd, res;
 356
 357     fd = open(_filenames[num], O_RDONLY);
 358     if (fd == -1)
 359     {
 360         printf("read error opening file '%s'\n", _filenames[num]);
 361         return;
 362     }
 363
 364     fstat(fd, &st);
 365     buf = malloc(st.st_size);
 366     if (!buf)
 367     {
 368         printf("unable to allocate enough memory for reading.\n");
 369         return;
 370     }
 371
 372     res = read(fd, buf, st.st_size);
 373     if (res == -1)
 374     {
 375         printf("unable to read from file '%s'.\n", _filenames[num]);
 376         return;
 377     }
 378     close(fd);
 379
 380     xid = xmlInitBuffer(buf, st.st_size);
 381     if (xid)
 382     {
 383        void *xrid = xmlMarkId(xid);
 384        int r = 0;
 385
 386        walk_the_tree(num, xrid, _root);
 387
 388        r = xmlErrorGetNo(xrid, 0);
 389        if (r)
 390        {
 391             size_t n = xmlErrorGetLineNo(xrid, 0);
 392             size_t c = xmlErrorGetColumnNo(xrid, 0);
 393             const char *s = xmlErrorGetString(xrid, 1); /* clear the error */
 394             printf("%s: at line %u, column %u: '%s'\n",_filenames[num], n,c, s);
 395        }
 396
 397        free(xrid);
 398     }
 399     else
 400     {
 401         fprintf(stderr, "Error reading file '%s'\n", _filenames[num]);
 402     }
 403
 404     xmlClose(xid);
 405     free(buf);
 406 }
 407
 408 int
 409 main (int argc, char **argv)
 410 {
 411     unsigned int u;
 412     int i;
 413
 414     if (argc == 1)
 415         show_help();
 416
 417     for (i=1; i<argc;)
 418     {
 419         int ret = parse_option(argv, i, argc);
 420         i += ret;
 421     }
 422
 423     if (_root == 0) _root = (char *)_static_root;
 424     if (_element == 0) _element = (char *)_static_element;
 425
 426     for (u=0; u<_fcount; u++)
 427 #if USE_BUFFER
 428         grep_file_buffer(u);
 429 #else
 430         grep_file(u);
 431 #endif
 432
 433     free_and_exit(0);
 434
 435     return 0;
 436 }