/* vim: set sw=4 ts=4 sts=4 et: */ #include #include #include #include "efreet_private.h" #include static Ecore_List *globs = NULL; /* contains Efreet_Mime_Glob structs */ static Ecore_List *magics = NULL; /* contains Efreet_Mime_Magic structs */ static Ecore_List *monitors = NULL; /* contains Efreet_Mime_Monitor structs */ /** * @internal * @brief Holds whether we are big/little endian * @note This is set during efreet_mime_init based on * a runtime check. */ static enum { EFREET_ENDIAN_BIG = 0, EFREET_ENDIAN_LITTLE = 1 } efreet_mime_endianess = EFREET_ENDIAN_BIG; /* * Buffer sized used for magic checks. The default is good enough for the * current set of magic rules. This setting is only here for the future. */ #define EFREET_MIME_MAGIC_BUFFER_SIZE 512 typedef struct Efreet_Mime_Monitor Efreet_Mime_Monitor; struct Efreet_Mime_Monitor { const char *file; Ecore_File_Monitor *monitor; }; /** * Efreet_Mime_Glob * @brief A parsed representation of a globs file */ typedef struct Efreet_Mime_Glob Efreet_Mime_Glob; struct Efreet_Mime_Glob { const char *glob; const char *mime; }; /** * Efreet_Mime_Magic * @brief A parsed representation of a magic file section */ typedef struct Efreet_Mime_Magic Efreet_Mime_Magic; struct Efreet_Mime_Magic { unsigned int priority; const char *mime; Ecore_List *entries; }; /** * Efreet_Mime_Magic_Entry * @brief A parsed representation of a magic file entry */ typedef struct Efreet_Mime_Magic_Entry Efreet_Mime_Magic_Entry; struct Efreet_Mime_Magic_Entry { unsigned int indent; unsigned int offset; unsigned int word_size; unsigned int range_len; unsigned short value_len; char *mask; char *value; }; static int efreet_mime_glob_remove(const char *glob); static void efreet_mime_mime_types_load(const char *file); static void efreet_mime_shared_mimeinfo_globs_load(const char *file); static void efreet_mime_shared_mimeinfo_magic_load(const char *file); static const char * efreet_mime_magic_check_priority(const char *file, unsigned int start, unsigned int end); static void efreet_mime_update_file_cb(void *data, Ecore_File_Monitor *monitor, Ecore_File_Event event, const char *path); static int efreet_mime_init_files(void); static const char * efreet_mime_special_check(const char *file); static void efreet_mime_glob_free(void *data); static void efreet_mime_magic_free(void *data); static int efreet_mime_glob_match(const char *str, const char *glob); static int efreet_mime_glob_case_match(char *str, const char *glob); static int efreet_mime_endian_check(void); static void efreet_mime_monitor_del(const char *file); static void efreet_mime_monitor_free(void *data); /** * @return Returns 1 on success or 0 on failure * @brief Initializes the efreet mime settings */ int efreet_mime_init(void) { if (!ecore_init()) return 0; if (!ecore_file_init()) return 0; if (!efreet_init()) return 0; efreet_mime_endianess = efreet_mime_endian_check(); monitors = ecore_list_new(); ecore_list_set_free_cb(monitors, efreet_mime_monitor_free); if (!efreet_mime_init_files()) return 0; return 1; } /** * @return Returns no value * @brief Cleans up the efreet mime settings system */ void efreet_mime_shutdown(void) { IF_FREE_LIST(magics); IF_FREE_LIST(globs); IF_FREE_LIST(monitors); efreet_shutdown(); ecore_file_shutdown(); ecore_shutdown(); } /** * @param file: The file to check the mime type * @param methods: The methods to use, see Efreet_Mime_Method structure * @return Returns mime type as a string * @brief Retreive the mime type of a file */ const char * efreet_mime_get(const char *file, int methods) { const char *type = NULL; if (!methods) methods = EFREET_MIME_FLAG_GLOB | EFREET_MIME_FLAG_TYPES; if ((type = efreet_mime_special_check(file))) return type; if (methods & EFREET_MIME_FLAG_MAGIC) { if ((type = efreet_mime_magic_check_priority(file, 0, 80))) return type; } if ((methods & EFREET_MIME_FLAG_GLOB) || (methods & EFREET_MIME_FLAG_TYPES)) { Efreet_Mime_Glob *g; char *s; ecore_list_goto_first(globs); while ((g = ecore_list_next(globs))) { if (efreet_mime_glob_match(file, g->glob)) return g->mime; } s = strdup(file); ecore_list_goto_first(globs); while ((g = ecore_list_next(globs))) { if (efreet_mime_glob_case_match(s, g->glob)) return g->mime; } FREE(s); } if (methods & EFREET_MIME_FLAG_MAGIC) { if ((type = efreet_mime_magic_check_priority(file, 80, 0))) return type; } return NULL; } /** * @internal * @return Returns the endianess * @brief Retreive the endianess of the machine */ static int efreet_mime_endian_check(void) { int test = 1; return (*((char*)(&test))); } /** * @internal * @param file: File to monitor * @return Returns the monitor, see Efreet_Mime_Monitor * @brief Create/Add a new file monitor */ static Efreet_Mime_Monitor * efreet_mime_monitor_add(const char *file) { Efreet_Mime_Monitor *mm = NULL; Ecore_File_Monitor *fm = NULL; efreet_mime_monitor_del(file); mm = NEW(Efreet_Mime_Monitor, 1); if ((fm = ecore_file_monitor_add(file, efreet_mime_update_file_cb, mm))) { mm->file = strdup(file); mm->monitor = fm; ecore_list_append(monitors, mm); } else FREE(mm); return mm; } /** * @internal * @param file: File to discontinue monitoring * @return Returns no value * @brief Delete a file monitor */ static void efreet_mime_monitor_del(const char *file) { Efreet_Mime_Monitor *mm = NULL; ecore_list_goto_first(monitors); while ((mm = ecore_list_current(monitors))) { if (!strcmp(mm->file, file)) { ecore_list_remove_destroy(monitors); break; } ecore_list_next(monitors); } } /** * @internal * @param data: Pointer to the monitor to free * @return Returns no value * @brief Free a file monitor structure. * Destroy callback for monitors. */ static void efreet_mime_monitor_free(void *data) { Efreet_Mime_Monitor *mm = NULL; mm = data; if (mm->monitor) ecore_file_monitor_del(mm->monitor); FREE(mm); } /** * @internal * @param datadirs: List of XDG data dirs * @param datahome: Path to XDG data home directory * @return Returns no value * @brief Read all glob files in XDG data/home dirs. * Also reads the /etc/mime.types file. */ static void efreet_mime_load_globs(Ecore_List *datadirs, const char *datahome) { char buf[4096]; const char *datadir = NULL; IF_FREE_LIST(globs); globs = ecore_list_new(); ecore_list_set_free_cb(globs, efreet_mime_glob_free); datadir = datahome ecore_list_goto_first(datadirs); while (datadir) { snprintf(buf, sizeof(buf), "%s/mime/globs", datadir); efreet_mime_shared_mimeinfo_globs_load(buf); datadir = ecore_list_next(datadirs); } /* * This is here for legacy reasons. It is mentioned briefly * in the spec and seems to still be quite valid. */ efreet_mime_mime_types_load("/etc/mime.types"); } /** * @internal * @param datadirs: List of XDG data dirs * @param datahome: Path to XDG data home directory * @return Returns no value * @brief Read all magic files in XDG data/home dirs. */ static void efreet_mime_load_magics(Ecore_List *datadirs, const char *datahome) { char buf[4096]; const char *datadir = NULL; IF_FREE_LIST(magics); magics = ecore_list_new(); ecore_list_set_free_cb(magics, efreet_mime_magic_free); datadir = datahome; ecore_list_goto_first(datadirs); while (datadir) { snprintf(buf, sizeof(buf), "%s/mime/magic", datadir); efreet_mime_shared_mimeinfo_magic_load(buf); datadir = ecore_list_next(datadirs); } } /** * @internal * @param data: Data pointer passed to monitor_add * @param monitor: Ecore_File_Monitor associated with this event * @param event: The type of event * @param path: Path to the file that was updated * @return Returns no value * @brief Callback for all file monitors. Just reloads the appropriate * list depending on which file changed. If it was a magic file * only the magic list is updated. If it was a glob file or /etc/mime.types, * the globs are updated. */ static void efreet_mime_update_file_cb(void *data __UNUSED__, Ecore_File_Monitor *monitor __UNUSED__, Ecore_File_Event event __UNUSED__, const char *path) { Ecore_List *datadirs = NULL; const char *datahome = NULL; if (!(datahome = efreet_data_home_get())) return; if (!(datadirs = efreet_data_dirs_get())) return; if (strstr(path, "magic")) efreet_mime_load_magics(datadirs, datahome); else efreet_mime_load_globs(datadirs, datahome); } /** * @internal * @param datadirs: List of XDG data dirs * @param datahome: Path to XDG data home directory * @return Returns 1 on success, 0 on failure * @brief Initializes globs, magics, and monitors lists. */ static int efreet_mime_init_files(void) { Ecore_List *datadirs = NULL; char buf[PATH_MAX]; const char *datahome, *datadir = NULL; if (!(datahome = efreet_data_home_get())) return 0; if (!(datadirs = efreet_data_dirs_get())) return 0; /* Add our file monitors */ /* We watch the directories so we can watch for new files? */ datadir = datahome; ecore_list_goto_first(datadirs); while (datadir) { snprintf(buf, PATH_MAX, "%s/mime", datadir); efreet_mime_monitor_add(buf); datadir = ecore_list_next(datadirs); } efreet_mime_monitor_add("/etc/mime.types"); /* Load our mime information */ efreet_mime_load_globs(datadirs, datahome); efreet_mime_load_magics(datadirs, datahome); return 1; } /** * @internal * @param datadirs: List of XDG data dirs * @param datahome: Path to XDG data home directory * @return Returns mime type if special file, else NULL * @brief Returns a mime type based on the stat of a file. * This is used first to catch directories and other special * files. A NULL return doesn't necessarily mean failure, but * can also mean the file is regular. * @note Mapping of file types to mime types: * Stat Macro File Type Mime Type * S_IFREG regular NULL * S_IFIFO named pipe (fifo) inode/fifo * S_IFCHR character special inode/chardevice * S_IFDIR directory inode/directory * S_IFBLK block special inode/blockdevice * S_IFLNK symbolic link inode/symlink * S_IFSOCK socket inode/socket * * This function can also return inode/mount-point. * This is calculated by comparing the st_dev of the directory * against that of it's parent directory. If they differ it * is considered a mount point. */ static const char * efreet_mime_special_check(const char *file) { struct stat s; int path_len = 0; if (!lstat(file, &s)) { if (S_ISREG(s.st_mode)) return NULL; if (S_ISLNK(s.st_mode)) return "inode/symlink"; if (S_ISFIFO(s.st_mode)) return "inode/fifo"; if (S_ISCHR(s.st_mode)) return "inode/chardevice"; if (S_ISBLK(s.st_mode)) return "inode/blockdevice"; if (S_ISSOCK(s.st_mode)) return "inode/socket"; if (S_ISDIR(s.st_mode)) { struct stat s2; char parent[PATH_MAX]; char path[PATH_MAX]; strncpy(path, file, PATH_MAX); path_len = strlen(file); strncpy(parent, path, PATH_MAX); /* Kill any trailing slash */ parent[--path_len] = '\0'; /* Truncate to last slash */ while (parent[--path_len] != '/') parent[path_len] = '\0'; if (!lstat(parent, &s2)) { if (s.st_dev != s2.st_dev) return "inode/mount-point"; } return "inode/directory"; } return NULL; } return NULL; } /** * @internal * @param glob: Glob to search for * @return Returns 1 on success, 0 on failure * @brief Removes a glob from the list */ static int efreet_mime_glob_remove(const char *glob) { Efreet_Mime_Glob *mime = NULL; mime = ecore_list_goto_first(globs); while ((mime = ecore_list_current(globs))) { if (!strcmp(glob, mime->glob)) { ecore_list_remove(globs); IF_RELEASE(mime->glob); IF_RELEASE(mime->mime); FREE(mime); return 1; } ecore_list_next(globs); } return 0; } /** * @internal * @param file: mime.types file to load * @return Returns no value * @brief Loads values from a mime.types style file * into the globs list. * @note Format: * application/msaccess mdb * application/msword doc dot */ static void efreet_mime_mime_types_load(const char *file) { FILE *f = NULL; char buf[4096], buf2[4096], mimetype[4096]; char ext[4096], *p = NULL, *pp = NULL; Efreet_Mime_Glob *mime = NULL; f = fopen(file, "rb"); if (!f) return; while (fgets(buf, sizeof(buf), f)) { p = buf; while (isspace(*p) && (*p != 0) && (*p != '\n')) p++; if (*p == '#') continue; if ((*p == '\n') || (*p == 0)) continue; pp = p; while (!isspace(*p) && (*p != 0) && (*p != '\n')) p++; if ((*p == '\n') || (*p == 0)) continue; strncpy(mimetype, pp, (p - pp)); mimetype[p - pp] = 0; do { while (isspace(*p) && (*p != 0) && (*p != '\n')) p++; if ((*p == '\n') || (*p == 0)) break; pp = p; while (!isspace(*p) && (*p != 0) && (*p != '\n')) p++; strncpy(ext, pp, (p - pp)); ext[p - pp] = 0; mime = NEW(Efreet_Mime_Glob,1); if (mime) { mime->mime = ecore_string_instance(mimetype); snprintf(buf2, sizeof(buf2), "*.%s", ext); mime->glob = ecore_string_instance(buf2); if ((!mime->mime) || (!mime->glob)) { IF_RELEASE(mime->mime); IF_RELEASE(mime->glob); FREE(mime); } else { efreet_mime_glob_remove(buf2); ecore_list_append(globs, mime); } } } while ((*p != '\n') && (*p != 0)); } fclose(f); } /** * @internal * @param file: globs file to load * @return Returns no value * @brief Loads values from a mime.types style file * into the globs list. * @note Format: * text/vnd.wap.wml:*.wml * application/x-7z-compressed:*.7z * application/vnd.corel-draw:*.cdr * text/spreadsheet:*.sylk */ static void efreet_mime_shared_mimeinfo_globs_load(const char *file) { FILE *f = NULL; char buf[4096], mimetype[4096], ext[4096], *p, *pp; Efreet_Mime_Glob *mime = NULL; f = fopen(file, "rb"); if (!f) return; while (fgets(buf, sizeof(buf), f)) { p = buf; while (isspace(*p) && (*p != 0) && (*p != '\n')) p++; if (*p == '#') continue; if ((*p == '\n') || (*p == 0)) continue; pp = p; while ((*p != ':') && (*p != 0) && (*p != '\n')) p++; if ((*p == '\n') || (*p == 0)) continue; strncpy(mimetype, pp, (p - pp)); mimetype[p - pp] = 0; p++; pp = ext; while ((*p != 0) && (*p != '\n')) { *pp = *p; pp++; p++; } *pp = 0; mime = NEW(Efreet_Mime_Glob, 1); if (mime) { mime->mime = ecore_string_instance(mimetype); mime->glob = ecore_string_instance(ext); if ((!mime->mime) || (!mime->glob)) { IF_RELEASE(mime->mime); IF_RELEASE(mime->glob); FREE(mime); } else { efreet_mime_glob_remove(ext); ecore_list_append(globs, mime); } } } fclose(f); } /** * @internal * @param in: Number to count the digits * @return Returns number of digits * @brief Calculates and returns the number of digits * in a number. */ static int efreet_mime_count_digits(int in) { int i = 1, j = in; if (j < 10) return 1; while ((j /= 10) > 0) ++i; return i; } /** * @internal * @param file: File to parse * @return Returns number of digits * @brief Parses a magic file and adds information to magics list * @note Format: * * ---------------------------------------------------------------------- * | HEX | ASCII | * ---------------------------------------------------------------------- * |4D 49 4D 45 2D 4D 61 67 69 63 00 0A 5B 39 30 3A | MIME-Magic..[90: | * |61 70 70 6C 69 63 61 74 69 6F 6E 2F 64 6F 63 62 | application/docb | * |6F 6F 6B 2B 78 6D 6C 5D 0A 3E 30 3D 00 05 3C 3F | ook+xml].>0=..0=..-//OAS | * |49 53 2F 2F 44 54 44 20 44 6F 63 42 6F 6F 6B 20 | IS//DTD DocBook | * |58 4D 4C 2B 31 30 31 0A 31 3E 30 3D 00 17 2D 2F | XML+101.1>0=..-/ | * ---------------------------------------------------------------------- * * indent * The nesting depth of the rule, corresponding to the number of '>' * characters in the traditional file format. * ">" start-offset * The offset into the file to look for a match. * "=" value * Two bytes giving the (big-endian) length of the value, followed by the * value itself. * "&" mask * The mask, which (if present) is exactly the same length as the value. * "~" word-size * On little-endian machines, the size of each group to byte-swap. * "+" range-length * The length of the region in the file to check. * * The indent, range-length, word-size and mask components are optional. * If missing, indent defaults to 0, range-length to 1, the word-size to 1, * and the mask to all 'one' bits. In our case, mask is null as it is * quicker, uses less memory and will acheive the same exact effect. */ static void efreet_mime_shared_mimeinfo_magic_load(const char *file) { FILE *f = NULL; int priority = 0, i = 0; enum {INDENT=0, OFFSET, VALUE, MASK, WORD_SIZE, RANGE_LEN} magic_state = 0; char buf[4096], mimetype[4096]; Efreet_Mime_Magic *mime = NULL; Efreet_Mime_Magic_Entry *entry = NULL; int bytes_read = 0, last_section = 0; f = fopen(file, "rb"); if (!f) return; /* Check for magic string. Will also move us to first section */ if (fread(buf, 1, 12, f)) { if (memcmp(buf, "MIME-Magic\0\n", 12)) return; } /* Begin reading in sections and mime data */ while ((bytes_read = fread(buf, 1, sizeof(buf), f))) { for (i = 0; i < bytes_read;) { if (buf[i] == '[') { IF_FREE(entry); last_section = i; i++; priority = atoi(strtok(&(buf[i]), ":")); strncpy(mimetype, strtok(NULL, "]"), sizeof(mimetype)); mime = NEW(Efreet_Mime_Magic, 1); mime->mime = ecore_string_instance(mimetype); mime->priority = priority; mime->entries = ecore_list_new(); while (i < bytes_read && buf[i] != '\n') ++i; } else { if (!mime) continue; switch(buf[i]) { case '>': magic_state = OFFSET; break; case '=': magic_state = VALUE; break; case '&': magic_state = MASK; break; case '~': magic_state = WORD_SIZE; break; case '+': magic_state = RANGE_LEN; break; default: if (isdigit(buf[i])) magic_state = INDENT; break; } if (magic_state != INDENT) ++i; switch(magic_state) { case INDENT: entry->indent = atoi(&buf[i]); i += efreet_mime_count_digits(entry->indent); break; case OFFSET: entry->offset = atoi(&buf[i]); i += efreet_mime_count_digits(entry->offset); break; case VALUE: if (efreet_mime_endianess == EFREET_ENDIAN_LITTLE) entry->value_len = ntohs(buf[i + 1] << 8 | (short)(buf[i])); else entry->value_len = ntohs((short)(buf[i + 1]) | buf[i] << 8); i += 2; entry->value = NEW(1, entry->value_len); memcpy(entry->value, &(buf[i]), entry->value_len); i += entry->value_len; break; case MASK: entry->mask = NEW(1, entry->value_len); memcpy(entry->mask, &(buf[i]), entry->value_len); i += entry->value_len; break; case WORD_SIZE: entry->word_size = atoi(&(buf[i])); if (((entry->word_size != 0) && (entry->word_size != 1) && (entry->word_size != 2) && (entry->word_size != 4)) || (entry->value_len % entry->word_size)) { /* Invalid, Destroy */ FREE(entry->value); FREE(entry->mask); FREE(entry); while ((i < bytes_read) && (buf[i] != '\n')) ++i; break; } if (efreet_mime_endianess == EFREET_ENDIAN_LITTLE) { int j; for (j = 0; j < entry->value_len; j += entry->word_size) { if (entry->word_size == 2) { ((short*)entry->value)[j] = ntohs(((short*)entry->value)[j]); if (entry->mask) ((short*)entry->mask)[j] = ntohs(((short*)entry->mask)[j]); } else if (entry->word_size == 4) { ((long*)entry->value)[j] = ntohl(((long*)entry->value)[j]); if (entry->mask) ((long*)entry->mask)[j] = ntohl(((long*)entry->mask)[j]); } } } i += efreet_mime_count_digits(entry->word_size); break; case RANGE_LEN: entry->range_len = atoi(&(buf[i])); i += efreet_mime_count_digits(entry->range_len); break; default: break; } } /* * Reached the end of the file. Need to go back to the last * section. This can probably be elmiminated if the file is * read another way which allows random access without having * to read the file in chunks. This works fine for now though. */ if (i >= 4096) { /* If we have a mime, clean it up */ if (mime) { Efreet_Mime_Magic *m; m = ecore_list_goto_last(magics); if (m && !(strcmp(m->mime,mimetype))) { efreet_mime_magic_free(m); ecore_list_remove(magics); } FREE(mime); } /* * If we finished in the middle of an entry, make sure to * clean it up as well. */ IF_FREE(entry); fseek(f, last_section-4096, SEEK_CUR); break; } /* Create our new structure */ if (buf[i] == '\n') { if (entry) ecore_list_append(mime->entries, entry); if (!(entry = NEW(Efreet_Mime_Magic_Entry, 1))) { IF_FREE_LIST(magics); return; } entry->indent = 0; entry->offset = 0; entry->value_len = 0; entry->word_size = 1; entry->range_len = 1; entry->mask = NULL; entry->value = NULL; ++i; } /* Append Mime to list of magics */ if (mime && ((buf[i] == '[') || (i >= bytes_read))) ecore_list_append(magics, mime); } } } /** * @internal * @param file: File to check * @param start: Start priority, if 0 start at beginning * @param end: End priority, should be less then start * unless start * @return Returns mime type for file if found, NULL if not * @brief Applies magic rules to a file given a start and end priority */ static const char * efreet_mime_magic_check_priority(const char *file, unsigned int start, unsigned int end) { Efreet_Mime_Magic *m = NULL; Efreet_Mime_Magic_Entry *e = NULL; FILE *f = NULL; unsigned int i = 0, offset = 0,level = 0, match = 0, bytes_read = 0; const char *last_mime = NULL; char c, v, buf[EFREET_MIME_MAGIC_BUFFER_SIZE]; f = fopen(file, "rb"); if (!f) return NULL; if (!(m = ecore_list_goto_first(magics))) { fclose(f); return NULL; } bytes_read = fread(buf, 1, sizeof(buf), f); while ((m = ecore_list_next(magics))) { if ((start != 0) && (m->priority > start)) continue; if (m->priority < end) break; ecore_list_goto_first(m->entries); while ((e = ecore_list_next(m->entries))) { if ((level < e->indent) && !match) continue; if ((level >= e->indent) && !match) level = e->indent; else if ((level > e->indent) && match) { fclose(f); if (last_mime) return last_mime; } for (offset = e->offset; offset < e->offset+e->range_len; ++offset) { if (((offset+e->value_len) > bytes_read) && (fseek(f, offset, SEEK_SET) == -1)) break; match = 1; for (i = 0; i < e->value_len; ++i) { if (offset+e->value_len > bytes_read) c = fgetc(f); else c = buf[offset + i]; v = e->value[i]; if (e->mask) v &= e->mask[i]; if (!(c == v)) { match = 0; break; } } if (match) { level += 1; last_mime = m->mime; break; } } } } fclose(f); return NULL; } /** * @internal * @param data: Data pointer that is being destroyed * @return Returns no value * @brief Callback for globs destroy */ static void efreet_mime_glob_free(void *data) { Efreet_Mime_Glob *m = data; IF_RELEASE(m->mime); IF_RELEASE(m->glob); } /** * @internal * @param data: Data pointer that is being destroyed * @return Returns no value * @brief Callback for magics destroy */ static void efreet_mime_magic_free(void *data) { Efreet_Mime_Magic *m = data; Efreet_Mime_Magic_Entry *e; IF_RELEASE(m->mime); if (m->entries) { ecore_list_goto_first(m->entries); while ((e = ecore_list_next(m->entries))) { IF_FREE(e->mask); IF_FREE(e->value); } IF_FREE_LIST(m->entries); } } /** * @internal * @param str: String (filename) to match * @param glob: Glob to match str to * @return Returns 1 on success, 0 on failure * @brief Compares str to glob, case sensitive */ static int efreet_mime_glob_match(const char *str, const char *glob) { if (!str || !glob) return 0; if (glob[0] == '\0') { if (str[0] == '\0') return 1; return 0; } if (!fnmatch(glob, str, 0)) return 1; return 0; } /** * @internal * @param str: String (filename) to match * @param glob: Glob to match str to * @return Returns 1 on success, 0 on failure * @brief Compares str to glob, case insensitive */ static int efreet_mime_glob_case_match(char *str, const char *glob) { const char *p; char *tglob, *tp; if (glob[0] == '\0') { if (str[0] == '\0') return 1; return 0; } for (tp = str; *tp != '\0'; tp++) *tp = tolower(*tp); tglob = NEW(1, strlen(glob) + 1); for (tp = tglob, p = glob; *p != 0; p++, tp++) *tp = tolower(*p); *tp = 0; if (!fnmatch(str, p, 0)) return 1; IF_FREE(tglob); return 0; }