static void
test_by_data (const char *dir,
const char *filename,
const char *mt_expected,
int xfail)
{
FILE *file;
const char *mt;
int max_extent;
char *data;
int bytes_read;
int result_prio;
char path[1024];
snprintf (path, 1024, "%s/%s", dir, filename);
file = fopen (path, "r");
if (file == NULL)
{
printf ("Could not open %s\n", path);
error++;
return;
}
max_extent = xdg_mime_get_max_buffer_extents ();
data = malloc (max_extent);
if (data == NULL)
{
printf ("Failed to allocate memory for file %s\n", filename);
error++;
return;
}
bytes_read = fread (data, 1, max_extent, file);
if (ferror (file))
{
printf ("Error reading file %s\n", path);
error++;
free (data);
fclose (file);
return;
}
mt = xdg_mime_get_mime_type_for_data (data, bytes_read, &result_prio);
free (data);
fclose (file);
check_mime_type (mt, mt_expected, xfail, "data", filename);
}
static PyObject *get_mime_type_for_data (PyObject *self, PyObject *args)
{
const char* data;
Py_ssize_t len;
if (!PyArg_ParseTuple(args, "s#", &data, &len))
return NULL;
return PyString_FromString(xdg_mime_get_mime_type_for_data((const void*) data, (size_t) len, NULL));
}
const char *GuessMimeType(const char *data, size_t dlen)
{
int MimeIndex = 0;
while (MyMimes[MimeIndex].PatternLen != 0)
{
if ((MyMimes[MimeIndex].PatternLen +
MyMimes[MimeIndex].PatternOffset < dlen) &&
strncmp(MyMimes[MimeIndex].Pattern,
&data[MyMimes[MimeIndex].PatternOffset],
MyMimes[MimeIndex].PatternLen) == 0)
{
return MyMimes[MimeIndex].MimeString;
}
MimeIndex ++;
}
/*
* ok, our simple minded algorythm didn't find anything,
* let the big chegger try it, he wil default to application/octet-stream
*/
return (xdg_mime_get_mime_type_for_data(data, dlen));
}
/**
* 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;
}
