gio/xdgmime/xdgmimeglob.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* xdgmimeglob.c: Private file.  Datastructure for storing the globs.
   3  *
   4  * More info can be found at http://www.freedesktop.org/standards/
   5  *
   6  * Copyright (C) 2003  Red Hat, Inc.
   7  * Copyright (C) 2003  Jonathan Blandford <jrb@alum.mit.edu>
   8  *
   9  * Licensed under the Academic Free License version 2.0
  10  * Or under the following terms:
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the
  24  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25  * Boston, MA 02111-1307, USA.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include "xdgmimeglob.h"
  33 #include "xdgmimeint.h"
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <assert.h>
  37 #include <string.h>
  38 #include <fnmatch.h>
  39
  40 #ifndef FALSE
  41 #define FALSE   (0)
  42 #endif
  43
  44 #ifndef TRUE
  45 #define TRUE    (!FALSE)
  46 #endif
  47
  48 typedef struct XdgGlobHashNode XdgGlobHashNode;
  49 typedef struct XdgGlobList XdgGlobList;
  50
  51 struct XdgGlobHashNode
  52 {
  53   xdg_unichar_t character;
  54   const char *mime_type;
  55   int weight;
  56   int case_sensitive;
  57   XdgGlobHashNode *next;
  58   XdgGlobHashNode *child;
  59 };
  60 struct XdgGlobList
  61 {
  62   const char *data;
  63   const char *mime_type;
  64   int weight;
  65   int case_sensitive;
  66   XdgGlobList *next;
  67 };
  68
  69 struct XdgGlobHash
  70 {
  71   XdgGlobList *literal_list;
  72   XdgGlobHashNode *simple_node;
  73   XdgGlobList *full_list;
  74 };
  75
  76
  77 /* XdgGlobList
  78  */
  79 static XdgGlobList *
  80 _xdg_glob_list_new (void)
  81 {
  82   XdgGlobList *new_element;
  83
  84   new_element = calloc (1, sizeof (XdgGlobList));
  85
  86   return new_element;
  87 }
  88
  89 /* Frees glob_list and all of it's children */
  90 static void
  91 _xdg_glob_list_free (XdgGlobList *glob_list)
  92 {
  93   XdgGlobList *ptr, *next;
  94
  95   ptr = glob_list;
  96
  97   while (ptr != NULL)
  98     {
  99       next = ptr->next;
 100
 101       if (ptr->data)
 102         free ((void *) ptr->data);
 103       if (ptr->mime_type)
 104         free ((void *) ptr->mime_type);
 105       free (ptr);
 106
 107       ptr = next;
 108     }
 109 }
 110
 111 static XdgGlobList *
 112 _xdg_glob_list_append (XdgGlobList *glob_list,
 113                        void        *data,
 114                        const char  *mime_type,
 115                        int          weight,
 116                        int          case_sensitive)
 117 {
 118   XdgGlobList *new_element;
 119   XdgGlobList *tmp_element;
 120
 121   tmp_element = glob_list;
 122   while (tmp_element != NULL)
 123     {
 124       if (strcmp (tmp_element->data, data) == 0 &&
 125           strcmp (tmp_element->mime_type, mime_type) == 0)
 126         return glob_list;
 127
 128       tmp_element = tmp_element->next;
 129     }
 130
 131   new_element = _xdg_glob_list_new ();
 132   new_element->data = data;
 133   new_element->mime_type = mime_type;
 134   new_element->weight = weight;
 135   new_element->case_sensitive = case_sensitive;
 136   if (glob_list == NULL)
 137     return new_element;
 138
 139   tmp_element = glob_list;
 140   while (tmp_element->next != NULL)
 141     tmp_element = tmp_element->next;
 142
 143   tmp_element->next = new_element;
 144
 145   return glob_list;
 146 }
 147
 148 /* XdgGlobHashNode
 149  */
 150
 151 static XdgGlobHashNode *
 152 _xdg_glob_hash_node_new (void)
 153 {
 154   XdgGlobHashNode *glob_hash_node;
 155
 156   glob_hash_node = calloc (1, sizeof (XdgGlobHashNode));
 157
 158   return glob_hash_node;
 159 }
 160
 161 static void
 162 _xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node,
 163                           int depth)
 164 {
 165   int i;
 166   for (i = 0; i < depth; i++)
 167     printf (" ");
 168
 169   printf ("%c", (char)glob_hash_node->character);
 170   if (glob_hash_node->mime_type)
 171     printf (" - %s %d\n", glob_hash_node->mime_type, glob_hash_node->weight);
 172   else
 173     printf ("\n");
 174   if (glob_hash_node->child)
 175     _xdg_glob_hash_node_dump (glob_hash_node->child, depth + 1);
 176   if (glob_hash_node->next)
 177     _xdg_glob_hash_node_dump (glob_hash_node->next, depth);
 178 }
 179
 180 static XdgGlobHashNode *
 181 _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
 182                             xdg_unichar_t   *text,
 183                             const char      *mime_type,
 184                             int              weight,
 185                             int              case_sensitive)
 186 {
 187   XdgGlobHashNode *node;
 188   xdg_unichar_t character;
 189
 190   character = text[0];
 191
 192   if ((glob_hash_node == NULL) ||
 193       (character < glob_hash_node->character))
 194     {
 195       node = _xdg_glob_hash_node_new ();
 196       node->character = character;
 197       node->next = glob_hash_node;
 198       glob_hash_node = node;
 199     }
 200   else if (character == glob_hash_node->character)
 201     {
 202       node = glob_hash_node;
 203     }
 204   else
 205     {
 206       XdgGlobHashNode *prev_node;
 207       int found_node = FALSE;
 208
 209       /* Look for the first character of text in glob_hash_node, and insert it if we
 210        * have to.*/
 211       prev_node = glob_hash_node;
 212       node = prev_node->next;
 213
 214       while (node != NULL)
 215         {
 216           if (character < node->character)
 217             {
 218               node = _xdg_glob_hash_node_new ();
 219               node->character = character;
 220               node->next = prev_node->next;
 221               prev_node->next = node;
 222
 223               found_node = TRUE;
 224               break;
 225             }
 226           else if (character == node->character)
 227             {
 228               found_node = TRUE;
 229               break;
 230             }
 231           prev_node = node;
 232           node = node->next;
 233         }
 234
 235       if (! found_node)
 236         {
 237           node = _xdg_glob_hash_node_new ();
 238           node->character = character;
 239           node->next = prev_node->next;
 240           prev_node->next = node;
 241         }
 242     }
 243
 244   text++;
 245   if (*text == 0)
 246     {
 247       if (node->mime_type)
 248         {
 249           if (strcmp (node->mime_type, mime_type) != 0)
 250             {
 251               XdgGlobHashNode *child;
 252               int found_node = FALSE;
 253
 254               child = node->child;
 255               while (child && child->character == 0)
 256                 {
 257                   if (strcmp (child->mime_type, mime_type) == 0)
 258                     {
 259                       found_node = TRUE;
 260                       break;
 261                     }
 262                   child = child->next;
 263                 }
 264
 265               if (!found_node)
 266                 {
 267                   child = _xdg_glob_hash_node_new ();
 268                   child->character = 0;
 269                   child->mime_type = strdup (mime_type);
 270                   child->weight = weight;
 271                   child->case_sensitive = case_sensitive;
 272                   child->child = NULL;
 273                   child->next = node->child;
 274                   node->child = child;
 275                 }
 276             }
 277         }
 278       else
 279         {
 280           node->mime_type = strdup (mime_type);
 281           node->weight = weight;
 282           node->case_sensitive = case_sensitive;
 283         }
 284     }
 285   else
 286     {
 287       node->child = _xdg_glob_hash_insert_ucs4 (node->child, text, mime_type, weight, case_sensitive);
 288     }
 289   return glob_hash_node;
 290 }
 291
 292 /* glob must be valid UTF-8 */
 293 static XdgGlobHashNode *
 294 _xdg_glob_hash_insert_text (XdgGlobHashNode *glob_hash_node,
 295                             const char      *text,
 296                             const char      *mime_type,
 297                             int              weight,
 298                             int              case_sensitive)
 299 {
 300   XdgGlobHashNode *node;
 301   xdg_unichar_t *unitext;
 302   int len;
 303
 304   unitext = _xdg_convert_to_ucs4 (text, &len);
 305   _xdg_reverse_ucs4 (unitext, len);
 306   node = _xdg_glob_hash_insert_ucs4 (glob_hash_node, unitext, mime_type, weight, case_sensitive);
 307   free (unitext);
 308   return node;
 309 }
 310
 311 typedef struct {
 312   const char *mime;
 313   int weight;
 314 } MimeWeight;
 315
 316 static int
 317 _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
 318                                       const char      *file_name,
 319                                       int              len,
 320                                       int              case_sensitive_check,
 321                                       MimeWeight       mime_types[],
 322                                       int              n_mime_types)
 323 {
 324   int n;
 325   XdgGlobHashNode *node;
 326   xdg_unichar_t character;
 327
 328   if (glob_hash_node == NULL)
 329     return 0;
 330
 331   character = file_name[len - 1];
 332
 333   for (node = glob_hash_node; node && character >= node->character; node = node->next)
 334     {
 335       if (character == node->character)
 336         {
 337           len--;
 338           n = 0;
 339           if (len > 0)
 340             {
 341               n = _xdg_glob_hash_node_lookup_file_name (node->child,
 342                                                         file_name,
 343                                                         len,
 344                                                         case_sensitive_check,
 345                                                         mime_types,
 346                                                         n_mime_types);
 347             }
 348           if (n == 0)
 349             {
 350               if (node->mime_type &&
 351                   (case_sensitive_check ||
 352                    !node->case_sensitive))
 353                 {
 354                   mime_types[n].mime = node->mime_type;
 355                   mime_types[n].weight = node->weight;
 356                   n++;
 357                 }
 358               node = node->child;
 359               while (n < n_mime_types && node && node->character == 0)
 360                 {
 361                   if (node->mime_type &&
 362                       (case_sensitive_check ||
 363                        !node->case_sensitive))
 364                     {
 365                       mime_types[n].mime = node->mime_type;
 366                       mime_types[n].weight = node->weight;
 367                       n++;
 368                     }
 369                   node = node->next;
 370                 }
 371             }
 372           return n;
 373         }
 374     }
 375
 376   return 0;
 377 }
 378
 379 static int compare_mime_weight (const void *a, const void *b)
 380 {
 381   const MimeWeight *aa = (const MimeWeight *)a;
 382   const MimeWeight *bb = (const MimeWeight *)b;
 383
 384   return aa->weight - bb->weight;
 385 }
 386
 387 #define ISUPPER(c)              ((c) >= 'A' && (c) <= 'Z')
 388 static char *
 389 ascii_tolower (const char *str)
 390 {
 391   char *p, *lower;
 392
 393   lower = strdup (str);
 394   p = lower;
 395   while (*p != 0)
 396     {
 397       char c = *p;
 398       *p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
 399     }
 400   return lower;
 401 }
 402
 403 int
 404 _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
 405                                  const char  *file_name,
 406                                  const char  *mime_types[],
 407                                  int          n_mime_types)
 408 {
 409   XdgGlobList *list;
 410   int i, n;
 411   MimeWeight mimes[10];
 412   int n_mimes = 10;
 413   int len;
 414   char *lower_case;
 415   int try_lower_case;
 416
 417   /* First, check the literals */
 418
 419   assert (file_name != NULL && n_mime_types > 0);
 420
 421   n = 0;
 422
 423   lower_case = ascii_tolower (file_name);
 424
 425   for (list = glob_hash->literal_list; list; list = list->next)
 426     {
 427       if (strcmp ((const char *)list->data, file_name) == 0)
 428         {
 429           mime_types[0] = list->mime_type;
 430           free (lower_case);
 431           return 1;
 432         }
 433     }
 434
 435   for (list = glob_hash->literal_list; list; list = list->next)
 436     {
 437       if (!list->case_sensitive &&
 438           strcmp ((const char *)list->data, lower_case) == 0)
 439         {
 440           mime_types[0] = list->mime_type;
 441           free (lower_case);
 442           return 1;
 443         }
 444     }
 445
 446
 447   len = strlen (file_name);
 448   n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE,
 449                                             mimes, n_mimes);
 450   if (n == 0)
 451     n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE,
 452                                               mimes, n_mimes);
 453
 454   if (n == 0)
 455     {
 456       for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
 457         {
 458           if (fnmatch ((const char *)list->data, file_name, 0) == 0)
 459             {
 460               mimes[n].mime = list->mime_type;
 461               mimes[n].weight = list->weight;
 462               n++;
 463             }
 464         }
 465     }
 466   free (lower_case);
 467
 468   qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
 469
 470   if (n_mime_types < n)
 471     n = n_mime_types;
 472
 473   for (i = 0; i < n; i++)
 474     mime_types[i] = mimes[i].mime;
 475
 476   return n;
 477 }
 478
 479
 480
 481 /* XdgGlobHash
 482  */
 483
 484 XdgGlobHash *
 485 _xdg_glob_hash_new (void)
 486 {
 487   XdgGlobHash *glob_hash;
 488
 489   glob_hash = calloc (1, sizeof (XdgGlobHash));
 490
 491   return glob_hash;
 492 }
 493
 494
 495 static void
 496 _xdg_glob_hash_free_nodes (XdgGlobHashNode *node)
 497 {
 498   if (node)
 499     {
 500       if (node->child)
 501        _xdg_glob_hash_free_nodes (node->child);
 502       if (node->next)
 503        _xdg_glob_hash_free_nodes (node->next);
 504       if (node->mime_type)
 505         free ((void *) node->mime_type);
 506       free (node);
 507     }
 508 }
 509
 510 void
 511 _xdg_glob_hash_free (XdgGlobHash *glob_hash)
 512 {
 513   _xdg_glob_list_free (glob_hash->literal_list);
 514   _xdg_glob_list_free (glob_hash->full_list);
 515   _xdg_glob_hash_free_nodes (glob_hash->simple_node);
 516   free (glob_hash);
 517 }
 518
 519 XdgGlobType
 520 _xdg_glob_determine_type (const char *glob)
 521 {
 522   const char *ptr;
 523   int maybe_in_simple_glob = FALSE;
 524   int first_char = TRUE;
 525
 526   ptr = glob;
 527
 528   while (*ptr != '\0')
 529     {
 530       if (*ptr == '*' && first_char)
 531         maybe_in_simple_glob = TRUE;
 532       else if (*ptr == '\\' || *ptr == '[' || *ptr == '?' || *ptr == '*')
 533           return XDG_GLOB_FULL;
 534
 535       first_char = FALSE;
 536       ptr = _xdg_utf8_next_char (ptr);
 537     }
 538   if (maybe_in_simple_glob)
 539     return XDG_GLOB_SIMPLE;
 540   else
 541     return XDG_GLOB_LITERAL;
 542 }
 543
 544 /* glob must be valid UTF-8 */
 545 void
 546 _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
 547                             const char  *glob,
 548                             const char  *mime_type,
 549                             int          weight,
 550                             int          case_sensitive)
 551 {
 552   XdgGlobType type;
 553
 554   assert (glob_hash != NULL);
 555   assert (glob != NULL);
 556
 557   type = _xdg_glob_determine_type (glob);
 558
 559   switch (type)
 560     {
 561     case XDG_GLOB_LITERAL:
 562       glob_hash->literal_list = _xdg_glob_list_append (glob_hash->literal_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
 563       break;
 564     case XDG_GLOB_SIMPLE:
 565       glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, mime_type, weight, case_sensitive);
 566       break;
 567     case XDG_GLOB_FULL:
 568       glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
 569       break;
 570     }
 571 }
 572
 573 void
 574 _xdg_glob_hash_dump (XdgGlobHash *glob_hash)
 575 {
 576   XdgGlobList *list;
 577   printf ("LITERAL STRINGS\n");
 578   if (!glob_hash || glob_hash->literal_list == NULL)
 579     {
 580       printf ("    None\n");
 581     }
 582   else
 583     {
 584       for (list = glob_hash->literal_list; list; list = list->next)
 585         printf ("    %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
 586     }
 587   printf ("\nSIMPLE GLOBS\n");
 588   if (!glob_hash || glob_hash->simple_node == NULL)
 589     {
 590       printf ("    None\n");
 591     }
 592   else
 593     {
 594       _xdg_glob_hash_node_dump (glob_hash->simple_node, 4);
 595     }
 596
 597   printf ("\nFULL GLOBS\n");
 598   if (!glob_hash || glob_hash->full_list == NULL)
 599     {
 600       printf ("    None\n");
 601     }
 602   else
 603     {
 604       for (list = glob_hash->full_list; list; list = list->next)
 605         printf ("    %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
 606     }
 607 }
 608
 609
 610 void
 611 _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
 612                                const char  *file_name,
 613                                int          version_two)
 614 {
 615   FILE *glob_file;
 616   char line[255];
 617   char *p;
 618
 619   glob_file = fopen (file_name, "r");
 620
 621   if (glob_file == NULL)
 622     return;
 623
 624   /* FIXME: Not UTF-8 safe.  Doesn't work if lines are greater than 255 chars.
 625    * Blah */
 626   while (fgets (line, 255, glob_file) != NULL)
 627     {
 628       char *colon;
 629       char *mimetype, *glob, *end;
 630       int weight;
 631       int case_sensitive;
 632
 633       if (line[0] == '#' || line[0] == 0)
 634         continue;
 635
 636       end = line + strlen(line) - 1;
 637       if (*end == '\n')
 638         *end = 0;
 639
 640       p = line;
 641       if (version_two)
 642         {
 643           colon = strchr (p, ':');
 644           if (colon == NULL)
 645             continue;
 646           *colon = 0;
 647           weight = atoi (p);
 648           p = colon + 1;
 649         }
 650       else
 651         weight = 50;
 652
 653       colon = strchr (p, ':');
 654       if (colon == NULL)
 655         continue;
 656       *colon = 0;
 657
 658       mimetype = p;
 659       p = colon + 1;
 660       glob = p;
 661       case_sensitive = FALSE;
 662
 663       colon = strchr (p, ':');
 664       if (version_two && colon != NULL)
 665         {
 666           char *flag;
 667
 668           /* We got flags */
 669           *colon = 0;
 670           p = colon + 1;
 671
 672           /* Flags end at next colon */
 673           colon = strchr (p, ':');
 674           if (colon != NULL)
 675             *colon = 0;
 676
 677           flag = strstr (p, "cs");
 678           if (flag != NULL &&
 679               /* Start or after comma */
 680               (flag == p ||
 681                flag[-1] == ',') &&
 682               /* ends with comma or end of string */
 683               (flag[2] == 0 ||
 684                flag[2] == ','))
 685             case_sensitive = TRUE;
 686         }
 687
 688       _xdg_glob_hash_append_glob (glob_hash, glob, mimetype, weight, case_sensitive);
 689     }
 690
 691   fclose (glob_file);
 692 }