static PyObject *get_mime_types_from_file_name (PyObject *self, PyObject *args) { const char* file_name; if (!PyArg_ParseTuple(args, "s", &file_name)) return NULL; const char *mime_types[5]; int len = xdg_mime_get_mime_types_from_file_name(file_name, mime_types, 5); PyObject *result = PyList_New(len); Py_ssize_t i; for (i = 0; i < len; i++) { PyList_SetItem(result, i, PyString_FromString(mime_types[i])); } return result; }
/** * g_content_type_guess: * @filename: (allow-none): a string, or %NULL * @data: (allow-none) (array length=data_size): a stream of data, or %NULL * @data_size: the size of @data * @result_uncertain: (allow-none) (out): return location for the certainty * of the result, or %NULL * * Guesses the content type based on example data. If the function is * uncertain, @result_uncertain will be set to %TRUE. Either @filename * or @data may be %NULL, in which case the guess will be based solely * on the other argument. * * Returns: a string indicating a guessed content type for the * given data. Free with g_free() */ gchar * g_content_type_guess (const gchar *filename, const guchar *data, gsize data_size, gboolean *result_uncertain) { char *basename; const char *name_mimetypes[10], *sniffed_mimetype; char *mimetype; int i; int n_name_mimetypes; int sniffed_prio; sniffed_prio = 0; n_name_mimetypes = 0; sniffed_mimetype = XDG_MIME_TYPE_UNKNOWN; if (result_uncertain) *result_uncertain = FALSE; /* our test suite and potentially other code used -1 in the past, which is * not documented and not allowed; guard against that */ g_return_val_if_fail (data_size != (gsize) -1, g_strdup (XDG_MIME_TYPE_UNKNOWN)); G_LOCK (gio_xdgmime); if (filename) { i = strlen (filename); if (filename[i - 1] == '/') { name_mimetypes[0] = "inode/directory"; name_mimetypes[1] = NULL; n_name_mimetypes = 1; if (result_uncertain) *result_uncertain = TRUE; } else { basename = g_path_get_basename (filename); n_name_mimetypes = xdg_mime_get_mime_types_from_file_name (basename, name_mimetypes, 10); g_free (basename); } } /* Got an extension match, and no conflicts. This is it. */ if (n_name_mimetypes == 1) { gchar *s = g_strdup (name_mimetypes[0]); G_UNLOCK (gio_xdgmime); return s; } if (data) { sniffed_mimetype = xdg_mime_get_mime_type_for_data (data, data_size, &sniffed_prio); if (sniffed_mimetype == XDG_MIME_TYPE_UNKNOWN && data && looks_like_text (data, data_size)) sniffed_mimetype = "text/plain"; /* For security reasons we don't ever want to sniff desktop files * where we know the filename and it doesn't have a .desktop extension. * This is because desktop files allow executing any application and * we don't want to make it possible to hide them looking like something * else. */ if (filename != NULL && strcmp (sniffed_mimetype, "application/x-desktop") == 0) sniffed_mimetype = "text/plain"; } if (n_name_mimetypes == 0) { if (sniffed_mimetype == XDG_MIME_TYPE_UNKNOWN && result_uncertain) *result_uncertain = TRUE; mimetype = g_strdup (sniffed_mimetype); } else { mimetype = NULL; if (sniffed_mimetype != XDG_MIME_TYPE_UNKNOWN) { if (sniffed_prio >= 80) /* High priority sniffing match, use that */ mimetype = g_strdup (sniffed_mimetype); else { /* There are conflicts between the name matches and we * have a sniffed type, use that as a tie breaker. */ for (i = 0; i < n_name_mimetypes; i++) { if ( xdg_mime_mime_type_subclass (name_mimetypes[i], sniffed_mimetype)) { /* This nametype match is derived from (or the same as) * the sniffed type). This is probably it. */ mimetype = g_strdup (name_mimetypes[i]); break; } } } } if (mimetype == NULL) { /* Conflicts, and sniffed type was no help or not there. * Guess on the first one */ mimetype = g_strdup (name_mimetypes[0]); if (result_uncertain) *result_uncertain = TRUE; } } G_UNLOCK (gio_xdgmime); return mimetype; }