Import sugar-base into sugar-toolkit
Probably needs cleaning up a bit. And we use pygtk-codegen, ugh... This is the commit id when we imported sugar-base: b9406e5c9c9df5404c5b0d995178b5edb4d93628 Signed-off-by: Daniel Drake <dsd@laptop.org> [squashed two patches into one] Signed-off-by: Sascha Silbe <silbe@activitycentral.com>master
Daniel Drake
13 years ago
committed by
Simon Schampijer
parent
b9a19e952f
commit
e2c07af748
@ -0,0 +1,30 @@
|
||||
# Copyright (C) 2006-2007, Red Hat, Inc.
|
||||
# Copyright (C) 2007-2008, One Laptop Per Child
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this library; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
|
||||
import os
|
||||
import gettext
|
||||
|
||||
|
||||
if 'SUGAR_PREFIX' in os.environ:
|
||||
prefix = os.environ['SUGAR_PREFIX']
|
||||
else:
|
||||
prefix = '/usr'
|
||||
|
||||
locale_path = os.path.join(prefix, 'share', 'locale')
|
||||
|
||||
gettext.bindtextdomain('sugar-base', locale_path)
|
||||
@ -0,0 +1,33 @@
|
||||
; functions
|
||||
|
||||
(define-function get_mime_type_from_file_name
|
||||
(c-name "sugar_mime_get_mime_type_from_file_name")
|
||||
(return-type "const-char*")
|
||||
(parameters
|
||||
'("const-char*" "filename")
|
||||
)
|
||||
)
|
||||
|
||||
(define-function get_mime_type_for_file
|
||||
(c-name "sugar_mime_get_mime_type_for_file")
|
||||
(return-type "const-char*")
|
||||
(parameters
|
||||
'("const-char*" "filename")
|
||||
)
|
||||
)
|
||||
|
||||
(define-function list_mime_parents
|
||||
(c-name "sugar_mime_list_mime_parents")
|
||||
(return-type "char**")
|
||||
(parameters
|
||||
'("const-char*" "mime")
|
||||
)
|
||||
)
|
||||
|
||||
(define-function uri_list_extract_uris
|
||||
(c-name "g_uri_list_extract_uris")
|
||||
(return-type "gchar**")
|
||||
(parameters
|
||||
'("const-char*" "uri_list")
|
||||
)
|
||||
)
|
||||
@ -0,0 +1,88 @@
|
||||
/* -*- Mode: C; c-basic-offset: 4 -*- */
|
||||
%%
|
||||
headers
|
||||
#include <Python.h>
|
||||
#include <glib.h>
|
||||
#include "xdgmime.h"
|
||||
%%
|
||||
modulename _sugarext
|
||||
%%
|
||||
ignore-glob
|
||||
*_get_type
|
||||
_*
|
||||
%%
|
||||
override sugar_mime_get_mime_type_for_file kwargs
|
||||
static PyObject *
|
||||
_wrap_sugar_mime_get_mime_type_for_file(PyObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "filename", NULL };
|
||||
char *filename;
|
||||
const char *ret;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:get_mime_type_for_file", kwlist, &filename))
|
||||
return NULL;
|
||||
|
||||
ret = sugar_mime_get_mime_type_for_file(filename, NULL);
|
||||
|
||||
if (ret)
|
||||
return PyString_FromString(ret);
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
%%
|
||||
override sugar_mime_list_mime_parents kwargs
|
||||
static PyObject *
|
||||
_wrap_sugar_mime_list_mime_parents(PyObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "mime_type", NULL };
|
||||
char *mime_type;
|
||||
char **parents, **tmp;
|
||||
int i = 0, j;
|
||||
PyObject *ret;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:list_mime_parents", kwlist, &mime_type))
|
||||
return NULL;
|
||||
|
||||
parents = (char **)sugar_mime_list_mime_parents(mime_type);
|
||||
if (!parents)
|
||||
return PyTuple_New(0);
|
||||
|
||||
tmp = parents;
|
||||
while (*tmp)
|
||||
tmp++, i++;
|
||||
|
||||
ret = PyTuple_New(i);
|
||||
for (j = 0; j < i; j++)
|
||||
PyTuple_SetItem(ret, j, PyString_FromString(parents[j]));
|
||||
|
||||
return ret;
|
||||
}
|
||||
%%
|
||||
override g_uri_list_extract_uris kwargs
|
||||
static PyObject *
|
||||
_wrap_g_uri_list_extract_uris(PyObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "uri_list", NULL };
|
||||
char *uri_list;
|
||||
char **uris, **tmp;
|
||||
int i = 0, j;
|
||||
PyObject *ret;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:uri_list_extract_uris", kwlist, &uri_list))
|
||||
return NULL;
|
||||
|
||||
uris = (char **)g_uri_list_extract_uris(uri_list);
|
||||
if (!uris)
|
||||
return PyTuple_New(0);
|
||||
|
||||
tmp = uris;
|
||||
while (*tmp)
|
||||
tmp++, i++;
|
||||
|
||||
ret = PyTuple_New(i);
|
||||
for (j = 0; j < i; j++)
|
||||
PyTuple_SetItem(ret, j, PyString_FromString(uris[j]));
|
||||
|
||||
return ret;
|
||||
}
|
||||
%%
|
||||
@ -0,0 +1,42 @@
|
||||
/*
|
||||
* Copyright (C) 2006-2007, Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
/* include this first, before NO_IMPORT_PYGOBJECT is defined */
|
||||
#include <pygobject.h>
|
||||
|
||||
extern PyMethodDef py_sugarbaseext_functions[];
|
||||
|
||||
DL_EXPORT(void)
|
||||
init_sugarbaseext(void)
|
||||
{
|
||||
PyObject *m, *d;
|
||||
|
||||
init_pygobject ();
|
||||
|
||||
m = Py_InitModule ("_sugarbaseext", py_sugarbaseext_functions);
|
||||
d = PyModule_GetDict (m);
|
||||
|
||||
if (PyErr_Occurred ()) {
|
||||
Py_FatalError ("can't initialise module _sugarext");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
sugardir = $(pythondir)/sugar3/dispatch
|
||||
sugar_PYTHON = \
|
||||
__init__.py \
|
||||
dispatcher.py \
|
||||
saferef.py
|
||||
|
||||
EXTRA_DIST = \
|
||||
license.txt
|
||||
|
||||
@ -0,0 +1,9 @@
|
||||
"""Multi-consumer multi-producer dispatching mechanism
|
||||
|
||||
Originally based on pydispatch (BSD) http://pypi.python.org/pypi/PyDispatcher/2.0.1
|
||||
See license.txt for original license.
|
||||
|
||||
Heavily modified for Django's purposes.
|
||||
"""
|
||||
|
||||
from sugar.dispatch.dispatcher import Signal
|
||||
@ -0,0 +1,191 @@
|
||||
import weakref
|
||||
try:
|
||||
set
|
||||
except NameError:
|
||||
from sets import Set as set # Python 2.3 fallback
|
||||
|
||||
from sugar.dispatch import saferef
|
||||
|
||||
WEAKREF_TYPES = (weakref.ReferenceType, saferef.BoundMethodWeakref)
|
||||
|
||||
def _make_id(target):
|
||||
if hasattr(target, 'im_func'):
|
||||
return (id(target.im_self), id(target.im_func))
|
||||
return id(target)
|
||||
|
||||
class Signal(object):
|
||||
"""Base class for all signals
|
||||
|
||||
Internal attributes:
|
||||
receivers -- { receriverkey (id) : weakref(receiver) }
|
||||
"""
|
||||
|
||||
def __init__(self, providing_args=None):
|
||||
"""providing_args -- A list of the arguments this signal can pass along in
|
||||
a send() call.
|
||||
"""
|
||||
self.receivers = []
|
||||
if providing_args is None:
|
||||
providing_args = []
|
||||
self.providing_args = set(providing_args)
|
||||
|
||||
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
|
||||
"""Connect receiver to sender for signal
|
||||
|
||||
receiver -- a function or an instance method which is to
|
||||
receive signals. Receivers must be
|
||||
hashable objects.
|
||||
|
||||
if weak is True, then receiver must be weak-referencable
|
||||
(more precisely saferef.safeRef() must be able to create
|
||||
a reference to the receiver).
|
||||
|
||||
Receivers must be able to accept keyword arguments.
|
||||
|
||||
If receivers have a dispatch_uid attribute, the receiver will
|
||||
not be added if another receiver already exists with that
|
||||
dispatch_uid.
|
||||
|
||||
sender -- the sender to which the receiver should respond
|
||||
Must either be of type Signal, or None to receive events
|
||||
from any sender.
|
||||
|
||||
weak -- whether to use weak references to the receiver
|
||||
By default, the module will attempt to use weak
|
||||
references to the receiver objects. If this parameter
|
||||
is false, then strong references will be used.
|
||||
|
||||
dispatch_uid -- an identifier used to uniquely identify a particular
|
||||
instance of a receiver. This will usually be a string, though it
|
||||
may be anything hashable.
|
||||
|
||||
returns None
|
||||
"""
|
||||
if dispatch_uid:
|
||||
lookup_key = (dispatch_uid, _make_id(sender))
|
||||
else:
|
||||
lookup_key = (_make_id(receiver), _make_id(sender))
|
||||
|
||||
if weak:
|
||||
receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)
|
||||
|
||||
for r_key, _ in self.receivers:
|
||||
if r_key == lookup_key:
|
||||
break
|
||||
else:
|
||||
self.receivers.append((lookup_key, receiver))
|
||||
|
||||
def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
|
||||
"""Disconnect receiver from sender for signal
|
||||
|
||||
receiver -- the registered receiver to disconnect. May be none if
|
||||
dispatch_uid is specified.
|
||||
sender -- the registered sender to disconnect
|
||||
weak -- the weakref state to disconnect
|
||||
dispatch_uid -- the unique identifier of the receiver to disconnect
|
||||
|
||||
disconnect reverses the process of connect.
|
||||
|
||||
If weak references are used, disconnect need not be called.
|
||||
The receiver will be remove from dispatch automatically.
|
||||
|
||||
returns None
|
||||
"""
|
||||
|
||||
if dispatch_uid:
|
||||
lookup_key = (dispatch_uid, _make_id(sender))
|
||||
else:
|
||||
lookup_key = (_make_id(receiver), _make_id(sender))
|
||||
|
||||
for idx, (r_key, _) in enumerate(self.receivers):
|
||||
if r_key == lookup_key:
|
||||
del self.receivers[idx]
|
||||
|
||||
def send(self, sender, **named):
|
||||
"""Send signal from sender to all connected receivers.
|
||||
|
||||
sender -- the sender of the signal
|
||||
Either a specific object or None.
|
||||
|
||||
named -- named arguments which will be passed to receivers.
|
||||
|
||||
Returns a list of tuple pairs [(receiver, response), ... ].
|
||||
|
||||
If any receiver raises an error, the error propagates back
|
||||
through send, terminating the dispatch loop, so it is quite
|
||||
possible to not have all receivers called if a raises an
|
||||
error.
|
||||
"""
|
||||
|
||||
responses = []
|
||||
if not self.receivers:
|
||||
return responses
|
||||
|
||||
for receiver in self._live_receivers(_make_id(sender)):
|
||||
response = receiver(signal=self, sender=sender, **named)
|
||||
responses.append((receiver, response))
|
||||
return responses
|
||||
|
||||
def send_robust(self, sender, **named):
|
||||
"""Send signal from sender to all connected receivers catching errors
|
||||
|
||||
sender -- the sender of the signal
|
||||
Can be any python object (normally one registered with
|
||||
a connect if you actually want something to occur).
|
||||
|
||||
named -- named arguments which will be passed to receivers.
|
||||
These arguments must be a subset of the argument names
|
||||
defined in providing_args.
|
||||
|
||||
Return a list of tuple pairs [(receiver, response), ... ],
|
||||
may raise DispatcherKeyError
|
||||
|
||||
if any receiver raises an error (specifically any subclass of Exception),
|
||||
the error instance is returned as the result for that receiver.
|
||||
"""
|
||||
|
||||
responses = []
|
||||
if not self.receivers:
|
||||
return responses
|
||||
|
||||
# Call each receiver with whatever arguments it can accept.
|
||||
# Return a list of tuple pairs [(receiver, response), ... ].
|
||||
for receiver in self._live_receivers(_make_id(sender)):
|
||||
try:
|
||||
response = receiver(signal=self, sender=sender, **named)
|
||||
except Exception, err:
|
||||
responses.append((receiver, err))
|
||||
else:
|
||||
responses.append((receiver, response))
|
||||
return responses
|
||||
|
||||
def _live_receivers(self, senderkey):
|
||||
"""Filter sequence of receivers to get resolved, live receivers
|
||||
|
||||
This checks for weak references
|
||||
and resolves them, then returning only live
|
||||
receivers.
|
||||
"""
|
||||
none_senderkey = _make_id(None)
|
||||
|
||||
for (receiverkey, r_senderkey), receiver in self.receivers:
|
||||
if r_senderkey == none_senderkey or r_senderkey == senderkey:
|
||||
if isinstance(receiver, WEAKREF_TYPES):
|
||||
# Dereference the weak reference.
|
||||
receiver = receiver()
|
||||
if receiver is not None:
|
||||
yield receiver
|
||||
else:
|
||||
yield receiver
|
||||
|
||||
def _remove_receiver(self, receiver):
|
||||
"""Remove dead receivers from connections."""
|
||||
|
||||
to_remove = []
|
||||
for key, connected_receiver in self.receivers:
|
||||
if connected_receiver == receiver:
|
||||
to_remove.append(key)
|
||||
for key in to_remove:
|
||||
for idx, (r_key, _) in enumerate(self.receivers):
|
||||
if r_key == key:
|
||||
del self.receivers[idx]
|
||||
@ -0,0 +1,66 @@
|
||||
sugar.dispatch was originally forked from django.dispatch
|
||||
|
||||
Copyright (c) Django Software Foundation and individual contributors.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of Django nor the names of its contributors may be used
|
||||
to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
django.dispatch was originally forked from PyDispatcher.
|
||||
|
||||
PyDispatcher License:
|
||||
|
||||
Copyright (c) 2001-2003, Patrick K. O'Brien and Contributors
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials
|
||||
provided with the distribution.
|
||||
|
||||
The name of Patrick K. O'Brien, or the name of any Contributor,
|
||||
may not be used to endorse or promote products derived from this
|
||||
software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
||||
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
@ -0,0 +1,250 @@
|
||||
"""
|
||||
"Safe weakrefs", originally from pyDispatcher.
|
||||
|
||||
Provides a way to safely weakref any function, including bound methods (which
|
||||
aren't handled by the core weakref module).
|
||||
"""
|
||||
|
||||
import weakref, traceback
|
||||
|
||||
def safeRef(target, onDelete = None):
|
||||
"""Return a *safe* weak reference to a callable target
|
||||
|
||||
target -- the object to be weakly referenced, if it's a
|
||||
bound method reference, will create a BoundMethodWeakref,
|
||||
otherwise creates a simple weakref.
|
||||
onDelete -- if provided, will have a hard reference stored
|
||||
to the callable to be called after the safe reference
|
||||
goes out of scope with the reference object, (either a
|
||||
weakref or a BoundMethodWeakref) as argument.
|
||||
"""
|
||||
if hasattr(target, 'im_self'):
|
||||
if target.im_self is not None:
|
||||
# Turn a bound method into a BoundMethodWeakref instance.
|
||||
# Keep track of these instances for lookup by disconnect().
|
||||
assert hasattr(target, 'im_func'), """safeRef target %r has im_self, but no im_func, don't know how to create reference"""%( target,)
|
||||
reference = get_bound_method_weakref(
|
||||
target=target,
|
||||
onDelete=onDelete
|
||||
)
|
||||
return reference
|
||||
if callable(onDelete):
|
||||
return weakref.ref(target, onDelete)
|
||||
else:
|
||||
return weakref.ref( target )
|
||||
|
||||
class BoundMethodWeakref(object):
|
||||
"""'Safe' and reusable weak references to instance methods
|
||||
|
||||
BoundMethodWeakref objects provide a mechanism for
|
||||
referencing a bound method without requiring that the
|
||||
method object itself (which is normally a transient
|
||||
object) is kept alive. Instead, the BoundMethodWeakref
|
||||
object keeps weak references to both the object and the
|
||||
function which together define the instance method.
|
||||
|
||||
Attributes:
|
||||
key -- the identity key for the reference, calculated
|
||||
by the class's calculateKey method applied to the
|
||||
target instance method
|
||||
deletionMethods -- sequence of callable objects taking
|
||||
single argument, a reference to this object which
|
||||
will be called when *either* the target object or
|
||||
target function is garbage collected (i.e. when
|
||||
this object becomes invalid). These are specified
|
||||
as the onDelete parameters of safeRef calls.
|
||||
weakSelf -- weak reference to the target object
|
||||
weakFunc -- weak reference to the target function
|
||||
|
||||
Class Attributes:
|
||||
_allInstances -- class attribute pointing to all live
|
||||
BoundMethodWeakref objects indexed by the class's
|
||||
calculateKey(target) method applied to the target
|
||||
objects. This weak value dictionary is used to
|
||||
short-circuit creation so that multiple references
|
||||
to the same (object, function) pair produce the
|
||||
same BoundMethodWeakref instance.
|
||||
|
||||
"""
|
||||
|
||||
_allInstances = weakref.WeakValueDictionary()
|
||||
|
||||
def __new__( cls, target, onDelete=None, *arguments,**named ):
|
||||
"""Create new instance or return current instance
|
||||
|
||||
Basically this method of construction allows us to
|
||||
short-circuit creation of references to already-
|
||||
referenced instance methods. The key corresponding
|
||||
to the target is calculated, and if there is already
|
||||
an existing reference, that is returned, with its
|
||||
deletionMethods attribute updated. Otherwise the
|
||||
new instance is created and registered in the table
|
||||
of already-referenced methods.
|
||||
"""
|
||||
key = cls.calculateKey(target)
|
||||
current =cls._allInstances.get(key)
|
||||
if current is not None:
|
||||
current.deletionMethods.append( onDelete)
|
||||
return current
|
||||
else:
|
||||
base = super( BoundMethodWeakref, cls).__new__( cls )
|
||||
cls._allInstances[key] = base
|
||||
base.__init__( target, onDelete, *arguments,**named)
|
||||
return base
|
||||
|
||||
def __init__(self, target, onDelete=None):
|
||||
"""Return a weak-reference-like instance for a bound method
|
||||
|
||||
target -- the instance-method target for the weak
|
||||
reference, must have im_self and im_func attributes
|
||||
and be reconstructable via:
|
||||
target.im_func.__get__( target.im_self )
|
||||
which is true of built-in instance methods.
|
||||
onDelete -- optional callback which will be called
|
||||
when this weak reference ceases to be valid
|
||||
(i.e. either the object or the function is garbage
|
||||
collected). Should take a single argument,
|
||||
which will be passed a pointer to this object.
|
||||
"""
|
||||
def remove(weak, self=self):
|
||||
"""Set self.isDead to true when method or instance is destroyed"""
|
||||
methods = self.deletionMethods[:]
|
||||
del self.deletionMethods[:]
|
||||
try:
|
||||
del self.__class__._allInstances[ self.key ]
|
||||
except KeyError:
|
||||
pass
|
||||
for function in methods:
|
||||
try:
|
||||
if callable( function ):
|
||||
function( self )
|
||||
except Exception, e:
|
||||
try:
|
||||
traceback.print_exc()
|
||||
except AttributeError, err:
|
||||
print '''Exception during saferef %s cleanup function %s: %s'''%(
|
||||
self, function, e
|
||||
)
|
||||
self.deletionMethods = [onDelete]
|
||||
self.key = self.calculateKey( target )
|
||||
self.weakSelf = weakref.ref(target.im_self, remove)
|
||||
self.weakFunc = weakref.ref(target.im_func, remove)
|
||||
self.selfName = str(target.im_self)
|
||||
self.funcName = str(target.im_func.__name__)
|
||||
|
||||
def calculateKey( cls, target ):
|
||||
"""Calculate the reference key for this reference
|
||||
|
||||
Currently this is a two-tuple of the id()'s of the
|
||||
target object and the target function respectively.
|
||||
"""
|
||||
return (id(target.im_self),id(target.im_func))
|
||||
calculateKey = classmethod( calculateKey )
|
||||
|
||||
def __str__(self):
|
||||
"""Give a friendly representation of the object"""
|
||||
return """%s( %s.%s )"""%(
|
||||
self.__class__.__name__,
|
||||
self.selfName,
|
||||
self.funcName,
|
||||
)
|
||||
|
||||
__repr__ = __str__
|
||||
|
||||
def __nonzero__( self ):
|
||||
"""Whether we are still a valid reference"""
|
||||
return self() is not None
|
||||
|
||||
def __cmp__( self, other ):
|
||||
"""Compare with another reference"""
|
||||
if not isinstance (other,self.__class__):
|
||||
return cmp( self.__class__, type(other) )
|
||||
return cmp( self.key, other.key)
|
||||
|
||||
def __call__(self):
|
||||
"""Return a strong reference to the bound method
|
||||
|
||||
If the target cannot be retrieved, then will
|
||||
return None, otherwise returns a bound instance
|
||||
method for our object and function.
|
||||
|
||||
Note:
|
||||
You may call this method any number of times,
|
||||
as it does not invalidate the reference.
|
||||
"""
|
||||
target = self.weakSelf()
|
||||
if target is not None:
|
||||
function = self.weakFunc()
|
||||
if function is not None:
|
||||
return function.__get__(target)
|
||||
return None
|
||||
|
||||
class BoundNonDescriptorMethodWeakref(BoundMethodWeakref):
|
||||
"""A specialized BoundMethodWeakref, for platforms where instance methods
|
||||
are not descriptors.
|
||||
|
||||
It assumes that the function name and the target attribute name are the
|
||||
same, instead of assuming that the function is a descriptor. This approach
|
||||
is equally fast, but not 100% reliable because functions can be stored on an
|
||||
attribute named differenty than the function's name such as in:
|
||||
|
||||
class A: pass
|
||||
def foo(self): return "foo"
|
||||
A.bar = foo
|
||||
|
||||
But this shouldn't be a common use case. So, on platforms where methods
|
||||
aren't descriptors (such as Jython) this implementation has the advantage
|
||||
of working in the most cases.
|
||||
"""
|
||||
def __init__(self, target, onDelete=None):
|
||||
"""Return a weak-reference-like instance for a bound method
|
||||
|
||||
target -- the instance-method target for the weak
|
||||
reference, must have im_self and im_func attributes
|
||||
and be reconstructable via:
|
||||
target.im_func.__get__( target.im_self )
|
||||
which is true of built-in instance methods.
|
||||
onDelete -- optional callback which will be called
|
||||
when this weak reference ceases to be valid
|
||||
(i.e. either the object or the function is garbage
|
||||
collected). Should take a single argument,
|
||||
which will be passed a pointer to this object.
|
||||
"""
|
||||
assert getattr(target.im_self, target.__name__) == target, \
|
||||
("method %s isn't available as the attribute %s of %s" %
|
||||
(target, target.__name__, target.im_self))
|
||||
super(BoundNonDescriptorMethodWeakref, self).__init__(target, onDelete)
|
||||
|
||||
def __call__(self):
|
||||
"""Return a strong reference to the bound method
|
||||
|
||||
If the target cannot be retrieved, then will
|
||||
return None, otherwise returns a bound instance
|
||||
method for our object and function.
|
||||
|
||||
Note:
|
||||
You may call this method any number of times,
|
||||
as it does not invalidate the reference.
|
||||
"""
|
||||
target = self.weakSelf()
|
||||
if target is not None:
|
||||
function = self.weakFunc()
|
||||
if function is not None:
|
||||
# Using curry() would be another option, but it erases the
|
||||
# "signature" of the function. That is, after a function is
|
||||
# curried, the inspect module can't be used to determine how
|
||||
# many arguments the function expects, nor what keyword
|
||||
# arguments it supports, and pydispatcher needs this
|
||||
# information.
|
||||
return getattr(target, function.__name__)
|
||||
return None
|
||||
|
||||
def get_bound_method_weakref(target, onDelete):
|
||||
"""Instantiates the appropiate BoundMethodWeakRef, depending on the details of
|
||||
the underlying class method implementation"""
|
||||
if hasattr(target, '__get__'):
|
||||
# target method is a descriptor, so the default implementation works:
|
||||
return BoundMethodWeakref(target=target, onDelete=onDelete)
|
||||
else:
|
||||
# no luck, use the alternative implementation:
|
||||
return BoundNonDescriptorMethodWeakref(target=target, onDelete=onDelete)
|
||||
@ -0,0 +1,199 @@
|
||||
# Copyright (C) 2007 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this library; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
|
||||
"""Logging service setup.
|
||||
|
||||
STABLE.
|
||||
"""
|
||||
|
||||
import array
|
||||
import collections
|
||||
import errno
|
||||
import logging
|
||||
import sys
|
||||
import os
|
||||
import repr as repr_
|
||||
import decorator
|
||||
|
||||
# Let's keep this module self contained so that it can be easily
|
||||
# pasted in external sugar service like the datastore.
|
||||
|
||||
# traces function calls, use SUGAR_LOGGER_LEVEL=trace to enable
|
||||
TRACE = 5
|
||||
_LEVELS = {
|
||||
'error': logging.ERROR,
|
||||
'warning': logging.WARNING,
|
||||
'debug': logging.DEBUG,
|
||||
'info': logging.INFO,
|
||||
'trace': TRACE,
|
||||
'all': 0,
|
||||
}
|
||||
logging.addLevelName(TRACE, 'TRACE')
|
||||
|
||||
|
||||
def get_logs_dir():
|
||||
profile = os.environ.get('SUGAR_PROFILE', 'default')
|
||||
logs_dir = os.environ.get('SUGAR_LOGS_DIR',
|
||||
os.path.join(os.path.expanduser('~'),
|
||||
'.sugar', profile, 'logs'))
|
||||
return logs_dir
|
||||
|
||||
|
||||
def set_level(level):
|
||||
if level in _LEVELS:
|
||||
logging.getLogger('').setLevel(_LEVELS[level])
|
||||
return
|
||||
|
||||
try:
|
||||
logging.getLogger('').setLevel(int(level))
|
||||
except ValueError:
|
||||
logging.warning('Invalid log level: %r', level)
|
||||
|
||||
|
||||
# pylint: disable-msg=E1101,F0401
|
||||
def _except_hook(exctype, value, traceback):
|
||||
# Attempt to provide verbose IPython tracebacks.
|
||||
# Importing IPython is slow, so we import it lazily.
|
||||
try:
|
||||
from IPython.ultraTB import AutoFormattedTB
|
||||
sys.excepthook = AutoFormattedTB(mode='Verbose',
|
||||
color_scheme='NoColor')
|
||||
except ImportError:
|
||||
sys.excepthook = sys.__excepthook__
|
||||
|
||||
sys.excepthook(exctype, value, traceback)
|
||||
|
||||
|
||||
def start(log_filename=None):
|
||||
# remove existing handlers, or logging.basicConfig() won't have no effect.
|
||||
root_logger = logging.getLogger('')
|
||||
for handler in root_logger.handlers:
|
||||
root_logger.removeHandler(handler)
|
||||
|
||||
class SafeLogWrapper(object):
|
||||
"""Small file-like wrapper to gracefully handle ENOSPC errors when
|
||||
logging."""
|
||||
|
||||
def __init__(self, stream):
|
||||
self._stream = stream
|
||||
|
||||
def write(self, s):
|
||||
try:
|
||||
self._stream.write(s)
|
||||
except IOError, e:
|
||||
# gracefully deal w/ disk full
|
||||
if e.errno != errno.ENOSPC:
|
||||
raise e
|
||||
|
||||
def flush(self):
|
||||
try:
|
||||
self._stream.flush()
|
||||
except IOError, e:
|
||||
# gracefully deal w/ disk full
|
||||
if e.errno != errno.ENOSPC:
|
||||
raise e
|
||||
|
||||
logging.basicConfig(level=logging.WARNING,
|
||||
format="%(created)f %(levelname)s %(name)s: %(message)s",
|
||||
stream=SafeLogWrapper(sys.stderr))
|
||||
|
||||
if 'SUGAR_LOGGER_LEVEL' in os.environ:
|
||||
set_level(os.environ['SUGAR_LOGGER_LEVEL'])
|
||||
|
||||
if log_filename:
|
||||
try:
|
||||
log_path = os.path.join(get_logs_dir(), log_filename + '.log')
|
||||
|
||||
log_fd = os.open(log_path, os.O_WRONLY | os.O_CREAT)
|
||||
os.dup2(log_fd, sys.stdout.fileno())
|
||||
os.dup2(log_fd, sys.stderr.fileno())
|
||||
os.close(log_fd)
|
||||
|
||||
sys.stdout = SafeLogWrapper(sys.stdout)
|
||||
sys.stderr = SafeLogWrapper(sys.stderr)
|
||||
except OSError, e:
|
||||
# if we're out of space, just continue
|
||||
if e.errno != errno.ENOSPC:
|
||||
raise e
|
||||
|
||||
sys.excepthook = _except_hook
|
||||
|
||||
|
||||
class TraceRepr(repr_.Repr):
|
||||
|
||||
# better handling of subclasses of basic types, e.g. for DBus
|
||||
_TYPES = [int, long, bool, tuple, list, array.array, set, frozenset,
|
||||
collections.deque, dict, str]
|
||||
|
||||
def repr1(self, x, level):
|
||||
for t in self._TYPES:
|
||||
if isinstance(x, t):
|
||||
return getattr(self, 'repr_'+t.__name__)(x, level)
|
||||
|
||||
return repr_.Repr.repr1(self, x, level)
|
||||
|
||||
def repr_int(self, x, level):
|
||||
return repr(x)
|
||||
|
||||
def repr_bool(self, x, level):
|
||||
return repr(x)
|
||||
|
||||
|
||||
def trace(logger=None, logger_name=None, skip_args=None, skip_kwargs=None,
|
||||
maxsize_list=30, maxsize_dict=30, maxsize_string=300):
|
||||
|
||||
if skip_args is None:
|
||||
skip_args = []
|
||||
|
||||
if skip_kwargs is None:
|
||||
skip_kwargs = []
|
||||
|
||||
# size-limit repr()
|
||||
trace_repr = TraceRepr()
|
||||
trace_repr.maxlist = maxsize_list
|
||||
trace_repr.maxdict = maxsize_dict
|
||||
trace_repr.maxstring = maxsize_string
|
||||
trace_repr.maxother = maxsize_string
|
||||
trace_logger = logger or logging.getLogger(logger_name)
|
||||
|
||||
def _trace(f, *args, **kwargs):
|
||||
# don't do expensive formatting if loglevel TRACE is not enabled
|
||||
enabled = trace_logger.isEnabledFor(TRACE)
|
||||
if not enabled:
|
||||
return f(*args, **kwargs)
|
||||
|
||||
params_formatted = ", ".join(
|
||||
[trace_repr.repr(a)
|
||||
for (idx, a) in enumerate(args) if idx not in skip_args] + \
|
||||
['%s=%s' % (k, trace_repr.repr(v))
|
||||
for (k, v) in kwargs.items() if k not in skip_kwargs])
|
||||
|
||||
trace_logger.log(TRACE, "%s(%s) invoked", f.__name__,
|
||||
params_formatted)
|
||||
|
||||
try:
|
||||
res = f(*args, **kwargs)
|
||||
except:
|
||||
trace_logger.exception("Exception occured in %s", f.__name__)
|
||||
raise
|
||||
|
||||
trace_logger.log(TRACE, "%s(%s) returned %s", f.__name__,
|
||||
params_formatted, trace_repr.repr(res))
|
||||
|
||||
return res
|
||||
|
||||
return decorator.decorator(_trace)
|
||||
@ -0,0 +1,268 @@
|
||||
# Copyright (C) 2006-2007, Red Hat, Inc.
|
||||
# Copyright (C) 2007, One Laptop Per Child
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this library; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
|
||||
"""MIME helpers based on freedesktop specification.
|
||||
|
||||
STABLE.
|
||||
"""
|
||||
|
||||
import os
|
||||
import logging
|
||||
import gettext
|
||||
|
||||
from sugar3 import _sugarbaseext
|
||||
|
||||
_ = lambda msg: gettext.dgettext('sugar-base', msg)
|
||||
|
||||
GENERIC_TYPE_TEXT = 'Text'
|
||||
GENERIC_TYPE_IMAGE = 'Image'
|
||||
GENERIC_TYPE_AUDIO = 'Audio'
|
||||
GENERIC_TYPE_VIDEO = 'Video'
|
||||
GENERIC_TYPE_LINK = 'Link'
|
||||
|
||||
_extensions = {}
|
||||
_globs_timestamps = []
|
||||
_generic_types = [
|
||||
{
|
||||
'id': GENERIC_TYPE_TEXT,
|
||||
'name': _('Text'),
|
||||
'icon': 'text-x-generic',
|
||||
'types': [
|
||||
'text/plain', 'text/rtf', 'application/pdf', 'application/x-pdf',
|
||||
'text/html', 'application/vnd.oasis.opendocument.text',
|
||||
'application/rtf', 'text/rtf', 'application/epub+zip'],
|
||||
},
|
||||
{
|
||||
'id': GENERIC_TYPE_IMAGE,
|
||||
'name': _('Image'),
|
||||
'icon': 'image-x-generic',
|
||||
'types': ['image/png', 'image/gif', 'image/jpeg'],
|
||||
},
|
||||
{
|
||||
'id': GENERIC_TYPE_AUDIO,
|
||||
'name': _('Audio'),
|
||||
'icon': 'audio-x-generic',
|
||||
'types': [
|
||||
'audio/ogg', 'audio/x-wav', 'audio/wav', 'audio/x-vorbis+ogg',
|
||||
'audio/x-mpegurl', 'audio/mpegurl', 'audio/mpeg', 'audio/x-scpls'],
|
||||
},
|
||||
{
|
||||
'id': GENERIC_TYPE_VIDEO,
|
||||
'name': _('Video'),
|
||||
'icon': 'video-x-generic',
|
||||
'types': ['video/ogg', 'application/ogg', 'video/x-theora+ogg'],
|
||||
},
|
||||
{
|
||||
'id': GENERIC_TYPE_LINK,
|
||||
'name': _('Link'),
|
||||
'icon': 'text-uri-list',
|
||||
'types': ['text/x-moz-url', 'text/uri-list'],
|
||||
}]
|
||||
|
||||
|
||||
class ObjectType(object):
|
||||
|
||||
def __init__(self, type_id, name, icon, mime_types):
|
||||
self.type_id = type_id
|
||||
self.name = name
|
||||
self.icon = icon
|
||||
self.mime_types = mime_types
|
||||
|
||||
|
||||
def get_generic_type(type_id):
|
||||
types = get_all_generic_types()
|
||||
for generic_type in types:
|
||||
if type_id == generic_type.type_id:
|
||||
return generic_type
|
||||
|
||||
|
||||
def get_all_generic_types():
|
||||
types = []
|
||||
for generic_type in _generic_types:
|
||||
object_type = ObjectType(generic_type['id'], generic_type['name'],
|
||||
generic_type['icon'], generic_type['types'])
|
||||
types.append(object_type)
|
||||
return types
|
||||
|
||||
|
||||
def get_for_file(file_name):
|
||||
if file_name.startswith('file://'):
|
||||
file_name = file_name[7:]
|
||||
|
||||
file_name = os.path.realpath(file_name)
|
||||
|
||||
mime_type = _sugarbaseext.get_mime_type_for_file(file_name)
|
||||
if mime_type == 'application/octet-stream':
|
||||
if _file_looks_like_text(file_name):
|
||||
return 'text/plain'
|
||||
else:
|
||||
return 'application/octet-stream'
|
||||
|
||||
return mime_type
|
||||
|
||||
|
||||
def get_from_file_name(file_name):
|
||||
return _sugarbaseext.get_mime_type_from_file_name(file_name)
|
||||
|
||||
|
||||
def get_mime_icon(mime_type):
|
||||
generic_type = _get_generic_type_for_mime(mime_type)
|
||||
if generic_type:
|
||||
return generic_type['icon']
|
||||
|
||||
return mime_type.replace('/', '-')
|
||||
|
||||
|
||||
def get_mime_description(mime_type):
|
||||
generic_type = _get_generic_type_for_mime(mime_type)
|
||||
if generic_type:
|
||||
return generic_type['name']
|
||||
|
||||
import gio
|
||||
return gio.content_type_get_description(mime_type)
|
||||
|
||||
|
||||
def get_mime_parents(mime_type):
|
||||
return _sugarbaseext.list_mime_parents(mime_type)
|
||||
|
||||
|
||||
def get_primary_extension(mime_type):
|
||||
global _extensions
|
||||
global _globs_timestamps
|
||||
|
||||
dirs = []
|
||||
|
||||
if 'XDG_DATA_HOME' in os.environ:
|
||||
dirs.append(os.environ['XDG_DATA_HOME'])
|
||||
else:
|
||||
dirs.append(os.path.expanduser('~/.local/share/'))
|
||||
|
||||
if 'XDG_DATA_DIRS' in os.environ:
|
||||
dirs.extend(os.environ['XDG_DATA_DIRS'].split(':'))
|
||||
else:
|
||||
dirs.extend(['/usr/local/share/', '/usr/share/'])
|
||||
|
||||
timestamps = []
|
||||
globs_path_list = []
|
||||
for f in dirs:
|
||||
globs_path = os.path.join(f, 'mime', 'globs')
|
||||
if os.path.exists(globs_path):
|
||||
mtime = os.stat(globs_path).st_mtime
|
||||
timestamps.append([globs_path, mtime])
|
||||
globs_path_list.append(globs_path)
|
||||
|
||||
if timestamps != _globs_timestamps:
|
||||
# Clear the old extensions list
|
||||
_extensions = {}
|
||||
|
||||
# FIXME Properly support these types in the system. (#4855)
|
||||
_extensions['audio/ogg'] = 'ogg'
|
||||
_extensions['video/ogg'] = 'ogg'
|
||||
|
||||
for globs_path in globs_path_list:
|
||||
globs_file = open(globs_path)
|
||||
for line in globs_file.readlines():
|
||||
line = line.strip()
|
||||
if not line.startswith('#'):
|
||||
line_type, glob = line.split(':')
|
||||
if glob.startswith('*.'):
|
||||
_extensions[line_type] = glob[2:]
|
||||
|
||||
_globs_timestamps = timestamps
|
||||
|
||||
if mime_type in _extensions:
|
||||
return _extensions[mime_type]
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
_MIME_TYPE_BLACK_LIST = [
|
||||
# Target used only between gtk.TextBuffer instances
|
||||
'application/x-gtk-text-buffer-rich-text',
|
||||
]
|
||||
|
||||
|
||||
def choose_most_significant(mime_types):
|
||||
logging.debug('Choosing between %r.', mime_types)
|
||||
if not mime_types:
|
||||
return ''
|
||||
|
||||
if 'text/uri-list' in mime_types:
|
||||
return 'text/uri-list'
|
||||
|
||||
for mime_category in ['image/', 'application/']:
|
||||
for mime_type in mime_types:
|
||||
|
||||
if mime_type.startswith(mime_category) and \
|
||||
mime_type not in _MIME_TYPE_BLACK_LIST:
|
||||
# skip mozilla private types (second component starts with '_'
|
||||
# or ends with '-priv')
|
||||
if mime_type.split('/')[1].startswith('_') or \
|
||||
mime_type.split('/')[1].endswith('-priv'):
|
||||
continue
|
||||
|
||||
# take out the specifier after ';' that mozilla likes to add
|
||||
mime_type = mime_type.split(';')[0]
|
||||
logging.debug('Choosed %r!', mime_type)
|
||||
return mime_type
|
||||
|
||||
if 'text/x-moz-url' in mime_types:
|
||||
logging.debug('Choosed text/x-moz-url!')
|
||||
return 'text/x-moz-url'
|
||||
|
||||
if 'text/html' in mime_types:
|
||||
logging.debug('Choosed text/html!')
|
||||
return 'text/html'
|
||||
|
||||
if 'text/plain' in mime_types:
|
||||
logging.debug('Choosed text/plain!')
|
||||
return 'text/plain'
|
||||
|
||||
logging.debug('Returning first: %r.', mime_types[0])
|
||||
return mime_types[0]
|
||||
|
||||
|
||||
def split_uri_list(uri_list):
|
||||
return _sugarbaseext.uri_list_extract_uris(uri_list)
|
||||
|
||||
|
||||
def _file_looks_like_text(file_name):
|
||||
f = open(file_name, 'r')
|
||||
try:
|
||||
sample = f.read(256)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
if '\000' in sample:
|
||||
return False
|
||||
|
||||
for encoding in ('ascii', 'latin_1', 'utf_8', 'utf_16'):
|
||||
try:
|
||||
unicode(sample, encoding)
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def _get_generic_type_for_mime(mime_type):
|
||||
for generic_type in _generic_types:
|
||||
if mime_type in generic_type['types']:
|
||||
return generic_type
|
||||
return None
|
||||
@ -0,0 +1,850 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmime.c: XDG Mime Spec mime resolver. Based on version 0.11 of the spec.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003,2004 Red Hat, Inc.
|
||||
* Copyright (C) 2003,2004 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmime.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include "xdgmimeglob.h"
|
||||
#include "xdgmimemagic.h"
|
||||
#include "xdgmimealias.h"
|
||||
#include "xdgmimeparent.h"
|
||||
#include "xdgmimecache.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
|
||||
typedef struct XdgDirTimeList XdgDirTimeList;
|
||||
typedef struct XdgCallbackList XdgCallbackList;
|
||||
|
||||
static int need_reread = TRUE;
|
||||
static time_t last_stat_time = 0;
|
||||
|
||||
static XdgGlobHash *global_hash = NULL;
|
||||
static XdgMimeMagic *global_magic = NULL;
|
||||
static XdgAliasList *alias_list = NULL;
|
||||
static XdgParentList *parent_list = NULL;
|
||||
static XdgDirTimeList *dir_time_list = NULL;
|
||||
static XdgCallbackList *callback_list = NULL;
|
||||
|
||||
XdgMimeCache **_caches = NULL;
|
||||
static int n_caches = 0;
|
||||
|
||||
const char xdg_mime_type_unknown[] = "application/octet-stream";
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
XDG_CHECKED_UNCHECKED,
|
||||
XDG_CHECKED_VALID,
|
||||
XDG_CHECKED_INVALID
|
||||
};
|
||||
|
||||
struct XdgDirTimeList
|
||||
{
|
||||
time_t mtime;
|
||||
char *directory_name;
|
||||
int checked;
|
||||
XdgDirTimeList *next;
|
||||
};
|
||||
|
||||
struct XdgCallbackList
|
||||
{
|
||||
XdgCallbackList *next;
|
||||
XdgCallbackList *prev;
|
||||
int callback_id;
|
||||
XdgMimeCallback callback;
|
||||
void *data;
|
||||
XdgMimeDestroy destroy;
|
||||
};
|
||||
|
||||
/* Function called by xdg_run_command_on_dirs. If it returns TRUE, further
|
||||
* directories aren't looked at */
|
||||
typedef int (*XdgDirectoryFunc) (const char *directory,
|
||||
void *user_data);
|
||||
|
||||
static XdgDirTimeList *
|
||||
xdg_dir_time_list_new (void)
|
||||
{
|
||||
XdgDirTimeList *retval;
|
||||
|
||||
retval = calloc (1, sizeof (XdgDirTimeList));
|
||||
retval->checked = XDG_CHECKED_UNCHECKED;
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void
|
||||
xdg_dir_time_list_free (XdgDirTimeList *list)
|
||||
{
|
||||
XdgDirTimeList *next;
|
||||
|
||||
while (list)
|
||||
{
|
||||
next = list->next;
|
||||
free (list->directory_name);
|
||||
free (list);
|
||||
list = next;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
xdg_mime_init_from_directory (const char *directory)
|
||||
{
|
||||
char *file_name;
|
||||
struct stat st;
|
||||
XdgDirTimeList *list;
|
||||
|
||||
assert (directory != NULL);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
XdgMimeCache *cache = _xdg_mime_cache_new_from_file (file_name);
|
||||
|
||||
if (cache != NULL)
|
||||
{
|
||||
list = xdg_dir_time_list_new ();
|
||||
list->directory_name = file_name;
|
||||
list->mtime = st.st_mtime;
|
||||
list->next = dir_time_list;
|
||||
dir_time_list = list;
|
||||
|
||||
_caches = realloc (_caches, sizeof (XdgMimeCache *) * (n_caches + 2));
|
||||
_caches[n_caches] = cache;
|
||||
_caches[n_caches + 1] = NULL;
|
||||
n_caches++;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/globs");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
_xdg_mime_glob_read_from_file (global_hash, file_name);
|
||||
|
||||
list = xdg_dir_time_list_new ();
|
||||
list->directory_name = file_name;
|
||||
list->mtime = st.st_mtime;
|
||||
list->next = dir_time_list;
|
||||
dir_time_list = list;
|
||||
}
|
||||
else
|
||||
{
|
||||
free (file_name);
|
||||
}
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/magic");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
_xdg_mime_magic_read_from_file (global_magic, file_name);
|
||||
|
||||
list = xdg_dir_time_list_new ();
|
||||
list->directory_name = file_name;
|
||||
list->mtime = st.st_mtime;
|
||||
list->next = dir_time_list;
|
||||
dir_time_list = list;
|
||||
}
|
||||
else
|
||||
{
|
||||
free (file_name);
|
||||
}
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/aliases") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/aliases");
|
||||
_xdg_mime_alias_read_from_file (alias_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/subclasses") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/subclasses");
|
||||
_xdg_mime_parent_read_from_file (parent_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
return FALSE; /* Keep processing */
|
||||
}
|
||||
|
||||
/* Runs a command on all the directories in the search path */
|
||||
static void
|
||||
xdg_run_command_on_dirs (XdgDirectoryFunc func,
|
||||
void *user_data)
|
||||
{
|
||||
const char *xdg_data_home;
|
||||
const char *xdg_data_dirs;
|
||||
const char *ptr;
|
||||
|
||||
xdg_data_home = getenv ("XDG_DATA_HOME");
|
||||
if (xdg_data_home)
|
||||
{
|
||||
if ((func) (xdg_data_home, user_data))
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
const char *home;
|
||||
|
||||
home = getenv ("HOME");
|
||||
if (home != NULL)
|
||||
{
|
||||
char *guessed_xdg_home;
|
||||
int stop_processing;
|
||||
|
||||
guessed_xdg_home = malloc (strlen (home) + strlen ("/.local/share/") + 1);
|
||||
strcpy (guessed_xdg_home, home);
|
||||
strcat (guessed_xdg_home, "/.local/share/");
|
||||
stop_processing = (func) (guessed_xdg_home, user_data);
|
||||
free (guessed_xdg_home);
|
||||
|
||||
if (stop_processing)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
xdg_data_dirs = getenv ("XDG_DATA_DIRS");
|
||||
if (xdg_data_dirs == NULL)
|
||||
xdg_data_dirs = "/usr/local/share/:/usr/share/";
|
||||
|
||||
ptr = xdg_data_dirs;
|
||||
|
||||
while (*ptr != '\000')
|
||||
{
|
||||
const char *end_ptr;
|
||||
char *dir;
|
||||
int len;
|
||||
int stop_processing;
|
||||
|
||||
end_ptr = ptr;
|
||||
while (*end_ptr != ':' && *end_ptr != '\000')
|
||||
end_ptr ++;
|
||||
|
||||
if (end_ptr == ptr)
|
||||
{
|
||||
ptr++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (*end_ptr == ':')
|
||||
len = end_ptr - ptr;
|
||||
else
|
||||
len = end_ptr - ptr + 1;
|
||||
dir = malloc (len + 1);
|
||||
strncpy (dir, ptr, len);
|
||||
dir[len] = '\0';
|
||||
stop_processing = (func) (dir, user_data);
|
||||
free (dir);
|
||||
|
||||
if (stop_processing)
|
||||
return;
|
||||
|
||||
ptr = end_ptr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Checks file_path to make sure it has the same mtime as last time it was
|
||||
* checked. If it has a different mtime, or if the file doesn't exist, it
|
||||
* returns FALSE.
|
||||
*
|
||||
* FIXME: This doesn't protect against permission changes.
|
||||
*/
|
||||
static int
|
||||
xdg_check_file (const char *file_path,
|
||||
int *exists)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
/* If the file exists */
|
||||
if (stat (file_path, &st) == 0)
|
||||
{
|
||||
XdgDirTimeList *list;
|
||||
|
||||
if (exists)
|
||||
*exists = TRUE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
{
|
||||
if (! strcmp (list->directory_name, file_path) &&
|
||||
st.st_mtime == list->mtime)
|
||||
{
|
||||
if (list->checked == XDG_CHECKED_UNCHECKED)
|
||||
list->checked = XDG_CHECKED_VALID;
|
||||
else if (list->checked == XDG_CHECKED_VALID)
|
||||
list->checked = XDG_CHECKED_INVALID;
|
||||
|
||||
return (list->checked != XDG_CHECKED_VALID);
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if (exists)
|
||||
*exists = FALSE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
xdg_check_dir (const char *directory,
|
||||
int *invalid_dir_list)
|
||||
{
|
||||
int invalid, exists;
|
||||
char *file_name;
|
||||
|
||||
assert (directory != NULL);
|
||||
|
||||
/* Check the mime.cache file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
|
||||
invalid = xdg_check_file (file_name, &exists);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
else if (exists)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Check the globs file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/globs");
|
||||
invalid = xdg_check_file (file_name, NULL);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Check the magic file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/magic");
|
||||
invalid = xdg_check_file (file_name, NULL);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE; /* Keep processing */
|
||||
}
|
||||
|
||||
/* Walks through all the mime files stat()ing them to see if they've changed.
|
||||
* Returns TRUE if they have. */
|
||||
static int
|
||||
xdg_check_dirs (void)
|
||||
{
|
||||
XdgDirTimeList *list;
|
||||
int invalid_dir_list = FALSE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
list->checked = XDG_CHECKED_UNCHECKED;
|
||||
|
||||
xdg_run_command_on_dirs ((XdgDirectoryFunc) xdg_check_dir,
|
||||
&invalid_dir_list);
|
||||
|
||||
if (invalid_dir_list)
|
||||
return TRUE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
{
|
||||
if (list->checked != XDG_CHECKED_VALID)
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* We want to avoid stat()ing on every single mime call, so we only look for
|
||||
* newer files every 5 seconds. This will return TRUE if we need to reread the
|
||||
* mime data from disk.
|
||||
*/
|
||||
static int
|
||||
xdg_check_time_and_dirs (void)
|
||||
{
|
||||
struct timeval tv;
|
||||
time_t current_time;
|
||||
int retval = FALSE;
|
||||
|
||||
gettimeofday (&tv, NULL);
|
||||
current_time = tv.tv_sec;
|
||||
|
||||
if (current_time >= last_stat_time + 5)
|
||||
{
|
||||
retval = xdg_check_dirs ();
|
||||
last_stat_time = current_time;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Called in every public function. It reloads the hash function if need be.
|
||||
*/
|
||||
static void
|
||||
xdg_mime_init (void)
|
||||
{
|
||||
if (xdg_check_time_and_dirs ())
|
||||
{
|
||||
xdg_mime_shutdown ();
|
||||
}
|
||||
|
||||
if (need_reread)
|
||||
{
|
||||
global_hash = _xdg_glob_hash_new ();
|
||||
global_magic = _xdg_mime_magic_new ();
|
||||
alias_list = _xdg_mime_alias_list_new ();
|
||||
parent_list = _xdg_mime_parent_list_new ();
|
||||
|
||||
xdg_run_command_on_dirs ((XdgDirectoryFunc) xdg_mime_init_from_directory,
|
||||
NULL);
|
||||
|
||||
need_reread = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_for_data (const void *data,
|
||||
size_t len)
|
||||
{
|
||||
const char *mime_type;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_type_for_data (data, len);
|
||||
|
||||
mime_type = _xdg_mime_magic_lookup_data (global_magic, data, len, NULL, 0);
|
||||
|
||||
if (mime_type)
|
||||
return mime_type;
|
||||
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf)
|
||||
{
|
||||
const char *mime_type;
|
||||
/* currently, only a few globs occur twice, and none
|
||||
* more often, so 5 seems plenty.
|
||||
*/
|
||||
const char *mime_types[5];
|
||||
FILE *file;
|
||||
unsigned char *data;
|
||||
int max_extent;
|
||||
int bytes_read;
|
||||
struct stat buf;
|
||||
const char *base_name;
|
||||
int n;
|
||||
|
||||
if (file_name == NULL)
|
||||
return NULL;
|
||||
if (! _xdg_utf8_validate (file_name))
|
||||
return NULL;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_type_for_file (file_name, statbuf);
|
||||
|
||||
base_name = _xdg_get_base_name (file_name);
|
||||
n = _xdg_glob_hash_lookup_file_name (global_hash, base_name, mime_types, 5);
|
||||
|
||||
if (n == 1)
|
||||
return mime_types[0];
|
||||
|
||||
if (!statbuf)
|
||||
{
|
||||
if (stat (file_name, &buf) != 0)
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
statbuf = &buf;
|
||||
}
|
||||
|
||||
if (!S_ISREG (statbuf->st_mode))
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
/* FIXME: Need to make sure that max_extent isn't totally broken. This could
|
||||
* be large and need getting from a stream instead of just reading it all
|
||||
* in. */
|
||||
max_extent = _xdg_mime_magic_get_buffer_extents (global_magic);
|
||||
data = malloc (max_extent);
|
||||
if (data == NULL)
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
if (file == NULL)
|
||||
{
|
||||
free (data);
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
bytes_read = fread (data, 1, max_extent, file);
|
||||
if (ferror (file))
|
||||
{
|
||||
free (data);
|
||||
fclose (file);
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
mime_type = _xdg_mime_magic_lookup_data (global_magic, data, bytes_read,
|
||||
mime_types, n);
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
if (mime_type)
|
||||
return mime_type;
|
||||
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_from_file_name (const char *file_name)
|
||||
{
|
||||
const char *mime_type;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_type_from_file_name (file_name);
|
||||
|
||||
if (_xdg_glob_hash_lookup_file_name (global_hash, file_name, &mime_type, 1))
|
||||
return mime_type;
|
||||
else
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_is_valid_mime_type (const char *mime_type)
|
||||
{
|
||||
/* FIXME: We should make this a better test
|
||||
*/
|
||||
return _xdg_utf8_validate (mime_type);
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_shutdown (void)
|
||||
{
|
||||
XdgCallbackList *list;
|
||||
|
||||
/* FIXME: Need to make this (and the whole library) thread safe */
|
||||
if (dir_time_list)
|
||||
{
|
||||
xdg_dir_time_list_free (dir_time_list);
|
||||
dir_time_list = NULL;
|
||||
}
|
||||
|
||||
if (global_hash)
|
||||
{
|
||||
_xdg_glob_hash_free (global_hash);
|
||||
global_hash = NULL;
|
||||
}
|
||||
if (global_magic)
|
||||
{
|
||||
_xdg_mime_magic_free (global_magic);
|
||||
global_magic = NULL;
|
||||
}
|
||||
|
||||
if (alias_list)
|
||||
{
|
||||
_xdg_mime_alias_list_free (alias_list);
|
||||
alias_list = NULL;
|
||||
}
|
||||
|
||||
if (parent_list)
|
||||
{
|
||||
_xdg_mime_parent_list_free (parent_list);
|
||||
parent_list = NULL;
|
||||
}
|
||||
|
||||
if (_caches)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_caches; i++)
|
||||
_xdg_mime_cache_unref (_caches[i]);
|
||||
free (_caches);
|
||||
_caches = NULL;
|
||||
n_caches = 0;
|
||||
}
|
||||
|
||||
for (list = callback_list; list; list = list->next)
|
||||
(list->callback) (list->data);
|
||||
|
||||
need_reread = TRUE;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_get_max_buffer_extents (void)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_max_buffer_extents ();
|
||||
|
||||
return _xdg_mime_magic_get_buffer_extents (global_magic);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_unalias_mime_type (const char *mime_type)
|
||||
{
|
||||
const char *lookup;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_unalias_mime_type (mime_type);
|
||||
|
||||
if ((lookup = _xdg_mime_alias_list_lookup (alias_list, mime_type)) != NULL)
|
||||
return lookup;
|
||||
|
||||
return mime_type;
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_unalias_mime_type (const char *mime_type)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_unalias_mime_type (mime_type);
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
const char *unalias_a, *unalias_b;
|
||||
|
||||
unalias_a = _xdg_mime_unalias_mime_type (mime_a);
|
||||
unalias_b = _xdg_mime_unalias_mime_type (mime_b);
|
||||
|
||||
if (strcmp (unalias_a, unalias_b) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_mime_type_equal (mime_a, mime_b);
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_media_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
char *sep;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
sep = strchr (mime_a, '/');
|
||||
|
||||
if (sep && strncmp (mime_a, mime_b, sep - mime_a + 1) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 1
|
||||
static int
|
||||
xdg_mime_is_super_type (const char *mime)
|
||||
{
|
||||
int length;
|
||||
const char *type;
|
||||
|
||||
length = strlen (mime);
|
||||
type = &(mime[length - 2]);
|
||||
|
||||
if (strcmp (type, "/*") == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
_xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base)
|
||||
{
|
||||
const char *umime, *ubase;
|
||||
const char **parents;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_mime_type_subclass (mime, base);
|
||||
|
||||
umime = _xdg_mime_unalias_mime_type (mime);
|
||||
ubase = _xdg_mime_unalias_mime_type (base);
|
||||
|
||||
if (strcmp (umime, ubase) == 0)
|
||||
return 1;
|
||||
|
||||
#if 1
|
||||
/* Handle supertypes */
|
||||
if (xdg_mime_is_super_type (ubase) &&
|
||||
xdg_mime_media_type_equal (umime, ubase))
|
||||
return 1;
|
||||
#endif
|
||||
|
||||
/* Handle special cases text/plain and application/octet-stream */
|
||||
if (strcmp (ubase, "text/plain") == 0 &&
|
||||
strncmp (umime, "text/", 5) == 0)
|
||||
return 1;
|
||||
|
||||
if (strcmp (ubase, "application/octet-stream") == 0)
|
||||
return 1;
|
||||
|
||||
parents = _xdg_mime_parent_list_lookup (parent_list, umime);
|
||||
for (; parents && *parents; parents++)
|
||||
{
|
||||
if (_xdg_mime_mime_type_subclass (*parents, ubase))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_mime_type_subclass (mime, base);
|
||||
}
|
||||
|
||||
char **
|
||||
xdg_mime_list_mime_parents (const char *mime)
|
||||
{
|
||||
const char **parents;
|
||||
char **result;
|
||||
int i, n;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_list_mime_parents (mime);
|
||||
|
||||
parents = xdg_mime_get_mime_parents (mime);
|
||||
|
||||
if (!parents)
|
||||
return NULL;
|
||||
|
||||
for (i = 0; parents[i]; i++) ;
|
||||
|
||||
n = (i + 1) * sizeof (char *);
|
||||
result = (char **) malloc (n);
|
||||
memcpy (result, parents, n);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const char **
|
||||
xdg_mime_get_mime_parents (const char *mime)
|
||||
{
|
||||
const char *umime;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
umime = _xdg_mime_unalias_mime_type (mime);
|
||||
|
||||
return _xdg_mime_parent_list_lookup (parent_list, umime);
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_dump (void)
|
||||
{
|
||||
printf ("*** ALIASES ***\n\n");
|
||||
_xdg_mime_alias_list_dump (alias_list);
|
||||
printf ("\n*** PARENTS ***\n\n");
|
||||
_xdg_mime_parent_list_dump (parent_list);
|
||||
}
|
||||
|
||||
|
||||
/* Registers a function to be called every time the mime database reloads its files
|
||||
*/
|
||||
int
|
||||
xdg_mime_register_reload_callback (XdgMimeCallback callback,
|
||||
void *data,
|
||||
XdgMimeDestroy destroy)
|
||||
{
|
||||
XdgCallbackList *list_el;
|
||||
static int callback_id = 1;
|
||||
|
||||
/* Make a new list element */
|
||||
list_el = calloc (1, sizeof (XdgCallbackList));
|
||||
list_el->callback_id = callback_id;
|
||||
list_el->callback = callback;
|
||||
list_el->data = data;
|
||||
list_el->destroy = destroy;
|
||||
list_el->next = callback_list;
|
||||
if (list_el->next)
|
||||
list_el->next->prev = list_el;
|
||||
|
||||
callback_list = list_el;
|
||||
callback_id ++;
|
||||
|
||||
return callback_id - 1;
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_remove_callback (int callback_id)
|
||||
{
|
||||
XdgCallbackList *list;
|
||||
|
||||
for (list = callback_list; list; list = list->next)
|
||||
{
|
||||
if (list->callback_id == callback_id)
|
||||
{
|
||||
if (list->next)
|
||||
list->next = list->prev;
|
||||
|
||||
if (list->prev)
|
||||
list->prev->next = list->next;
|
||||
else
|
||||
callback_list = list->next;
|
||||
|
||||
/* invoke the destroy handler */
|
||||
(list->destroy) (list->data);
|
||||
free (list);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,111 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmime.h: XDG Mime Spec mime resolver. Based on version 0.11 of the spec.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __XDG_MIME_H__
|
||||
#define __XDG_MIME_H__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define XDG_ENTRY(func) _XDG_ENTRY2(XDG_PREFIX,func)
|
||||
#define _XDG_ENTRY2(prefix,func) _XDG_ENTRY3(prefix,func)
|
||||
#define _XDG_ENTRY3(prefix,func) prefix##_##func
|
||||
#endif
|
||||
|
||||
typedef void (*XdgMimeCallback) (void *user_data);
|
||||
typedef void (*XdgMimeDestroy) (void *user_data);
|
||||
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define xdg_mime_get_mime_type_for_data XDG_ENTRY(get_mime_type_for_data)
|
||||
#define xdg_mime_get_mime_type_for_file XDG_ENTRY(get_mime_type_for_file)
|
||||
#define xdg_mime_get_mime_type_from_file_name XDG_ENTRY(get_mime_type_from_file_name)
|
||||
#define xdg_mime_is_valid_mime_type XDG_ENTRY(is_valid_mime_type)
|
||||
#define xdg_mime_mime_type_equal XDG_ENTRY(mime_type_equal)
|
||||
#define xdg_mime_media_type_equal XDG_ENTRY(media_type_equal)
|
||||
#define xdg_mime_mime_type_subclass XDG_ENTRY(mime_type_subclass)
|
||||
#define xdg_mime_get_mime_parents XDG_ENTRY(get_mime_parents)
|
||||
#define xdg_mime_list_mime_parents XDG_ENTRY(list_mime_parents)
|
||||
#define xdg_mime_unalias_mime_type XDG_ENTRY(unalias_mime_type)
|
||||
#define xdg_mime_get_max_buffer_extents XDG_ENTRY(get_max_buffer_extents)
|
||||
#define xdg_mime_shutdown XDG_ENTRY(shutdown)
|
||||
#define xdg_mime_dump XDG_ENTRY(dump)
|
||||
#define xdg_mime_register_reload_callback XDG_ENTRY(register_reload_callback)
|
||||
#define xdg_mime_remove_callback XDG_ENTRY(remove_callback)
|
||||
#define xdg_mime_type_unknown XDG_ENTRY(type_unknown)
|
||||
#endif
|
||||
|
||||
extern const char xdg_mime_type_unknown[];
|
||||
#define XDG_MIME_TYPE_UNKNOWN xdg_mime_type_unknown
|
||||
|
||||
const char *xdg_mime_get_mime_type_for_data (const void *data,
|
||||
size_t len);
|
||||
const char *xdg_mime_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf);
|
||||
const char *xdg_mime_get_mime_type_from_file_name (const char *file_name);
|
||||
int xdg_mime_is_valid_mime_type (const char *mime_type);
|
||||
int xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int xdg_mime_media_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int xdg_mime_mime_type_subclass (const char *mime_a,
|
||||
const char *mime_b);
|
||||
/* xdg_mime_get_mime_parents() is deprecated since it does
|
||||
* not work correctly with caches. Use xdg_mime_list_parents()
|
||||
* instead, but notice that that function expects you to free
|
||||
* the array it returns.
|
||||
*/
|
||||
const char **xdg_mime_get_mime_parents (const char *mime);
|
||||
char ** xdg_mime_list_mime_parents (const char *mime);
|
||||
const char *xdg_mime_unalias_mime_type (const char *mime);
|
||||
int xdg_mime_get_max_buffer_extents (void);
|
||||
void xdg_mime_shutdown (void);
|
||||
void xdg_mime_dump (void);
|
||||
int xdg_mime_register_reload_callback (XdgMimeCallback callback,
|
||||
void *data,
|
||||
XdgMimeDestroy destroy);
|
||||
void xdg_mime_remove_callback (int callback_id);
|
||||
|
||||
/* Private versions of functions that don't call xdg_mime_init () */
|
||||
int _xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_media_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __XDG_MIME_H__ */
|
||||
@ -0,0 +1,184 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.c: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 2004 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimealias.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgAlias XdgAlias;
|
||||
|
||||
struct XdgAlias
|
||||
{
|
||||
char *alias;
|
||||
char *mime_type;
|
||||
};
|
||||
|
||||
struct XdgAliasList
|
||||
{
|
||||
struct XdgAlias *aliases;
|
||||
int n_aliases;
|
||||
};
|
||||
|
||||
XdgAliasList *
|
||||
_xdg_mime_alias_list_new (void)
|
||||
{
|
||||
XdgAliasList *list;
|
||||
|
||||
list = malloc (sizeof (XdgAliasList));
|
||||
|
||||
list->aliases = NULL;
|
||||
list->n_aliases = 0;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_alias_list_free (XdgAliasList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->aliases)
|
||||
{
|
||||
for (i = 0; i < list->n_aliases; i++)
|
||||
{
|
||||
free (list->aliases[i].alias);
|
||||
free (list->aliases[i].mime_type);
|
||||
}
|
||||
free (list->aliases);
|
||||
}
|
||||
free (list);
|
||||
}
|
||||
|
||||
static int
|
||||
alias_entry_cmp (const void *v1, const void *v2)
|
||||
{
|
||||
return strcmp (((XdgAlias *)v1)->alias, ((XdgAlias *)v2)->alias);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_alias_list_lookup (XdgAliasList *list,
|
||||
const char *alias)
|
||||
{
|
||||
XdgAlias *entry;
|
||||
XdgAlias key;
|
||||
|
||||
if (list->n_aliases > 0)
|
||||
{
|
||||
key.alias = (char *)alias;
|
||||
key.mime_type = 0;
|
||||
|
||||
entry = bsearch (&key, list->aliases, list->n_aliases,
|
||||
sizeof (XdgAlias), alias_entry_cmp);
|
||||
if (entry)
|
||||
return entry->mime_type;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_alias_read_from_file (XdgAliasList *list,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int alloc;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
|
||||
if (file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
alloc = list->n_aliases + 16;
|
||||
list->aliases = realloc (list->aliases, alloc * sizeof (XdgAlias));
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
char *sep;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
sep = strchr (line, ' ');
|
||||
if (sep == NULL)
|
||||
continue;
|
||||
*(sep++) = '\000';
|
||||
sep[strlen (sep) -1] = '\000';
|
||||
if (list->n_aliases == alloc)
|
||||
{
|
||||
alloc <<= 1;
|
||||
list->aliases = realloc (list->aliases,
|
||||
alloc * sizeof (XdgAlias));
|
||||
}
|
||||
list->aliases[list->n_aliases].alias = strdup (line);
|
||||
list->aliases[list->n_aliases].mime_type = strdup (sep);
|
||||
list->n_aliases++;
|
||||
}
|
||||
list->aliases = realloc (list->aliases,
|
||||
list->n_aliases * sizeof (XdgAlias));
|
||||
|
||||
fclose (file);
|
||||
|
||||
if (list->n_aliases > 1)
|
||||
qsort (list->aliases, list->n_aliases,
|
||||
sizeof (XdgAlias), alias_entry_cmp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_alias_list_dump (XdgAliasList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->aliases)
|
||||
{
|
||||
for (i = 0; i < list->n_aliases; i++)
|
||||
{
|
||||
printf ("%s %s\n",
|
||||
list->aliases[i].alias,
|
||||
list->aliases[i].mime_type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,50 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.h: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 200 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_ALIAS_H__
|
||||
#define __XDG_MIME_ALIAS_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgAliasList XdgAliasList;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_alias_read_from_file XDG_ENTRY(alias_read_from_file)
|
||||
#define _xdg_mime_alias_list_new XDG_ENTRY(alias_list_new)
|
||||
#define _xdg_mime_alias_list_free XDG_ENTRY(alias_list_free)
|
||||
#define _xdg_mime_alias_list_lookup XDG_ENTRY(alias_list_lookup)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_alias_read_from_file (XdgAliasList *list,
|
||||
const char *file_name);
|
||||
XdgAliasList *_xdg_mime_alias_list_new (void);
|
||||
void _xdg_mime_alias_list_free (XdgAliasList *list);
|
||||
const char *_xdg_mime_alias_list_lookup (XdgAliasList *list,
|
||||
const char *alias);
|
||||
void _xdg_mime_alias_list_dump (XdgAliasList *list);
|
||||
|
||||
#endif /* __XDG_MIME_ALIAS_H__ */
|
||||
@ -0,0 +1,895 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.c: Private file. mmappable caches for mime data
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <fnmatch.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <netinet/in.h> /* for ntohl/ntohs */
|
||||
|
||||
#ifdef HAVE_MMAP
|
||||
#include <sys/mman.h>
|
||||
#endif
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "xdgmimecache.h"
|
||||
#include "xdgmimeint.h"
|
||||
|
||||
#ifndef MAX
|
||||
#define MAX(a,b) ((a) > (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
#ifndef _O_BINARY
|
||||
#define _O_BINARY 0
|
||||
#endif
|
||||
|
||||
#ifndef MAP_FAILED
|
||||
#define MAP_FAILED ((void *) -1)
|
||||
#endif
|
||||
|
||||
#define MAJOR_VERSION 1
|
||||
#define MINOR_VERSION 0
|
||||
|
||||
struct _XdgMimeCache
|
||||
{
|
||||
int ref_count;
|
||||
|
||||
size_t size;
|
||||
char *buffer;
|
||||
};
|
||||
|
||||
#define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
|
||||
#define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
|
||||
|
||||
XdgMimeCache *
|
||||
_xdg_mime_cache_ref (XdgMimeCache *cache)
|
||||
{
|
||||
cache->ref_count++;
|
||||
return cache;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_cache_unref (XdgMimeCache *cache)
|
||||
{
|
||||
cache->ref_count--;
|
||||
|
||||
if (cache->ref_count == 0)
|
||||
{
|
||||
#ifdef HAVE_MMAP
|
||||
munmap (cache->buffer, cache->size);
|
||||
#endif
|
||||
free (cache);
|
||||
}
|
||||
}
|
||||
|
||||
XdgMimeCache *
|
||||
_xdg_mime_cache_new_from_file (const char *file_name)
|
||||
{
|
||||
XdgMimeCache *cache = NULL;
|
||||
|
||||
#ifdef HAVE_MMAP
|
||||
int fd = -1;
|
||||
struct stat st;
|
||||
char *buffer = NULL;
|
||||
|
||||
/* Open the file and map it into memory */
|
||||
fd = open (file_name, O_RDONLY|_O_BINARY, 0);
|
||||
|
||||
if (fd < 0)
|
||||
return NULL;
|
||||
|
||||
if (fstat (fd, &st) < 0 || st.st_size < 4)
|
||||
goto done;
|
||||
|
||||
buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
|
||||
|
||||
if (buffer == MAP_FAILED)
|
||||
goto done;
|
||||
|
||||
/* Verify version */
|
||||
if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
|
||||
GET_UINT16 (buffer, 2) != MINOR_VERSION)
|
||||
{
|
||||
munmap (buffer, st.st_size);
|
||||
|
||||
goto done;
|
||||
}
|
||||
|
||||
cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
|
||||
cache->ref_count = 1;
|
||||
cache->buffer = buffer;
|
||||
cache->size = st.st_size;
|
||||
|
||||
done:
|
||||
if (fd != -1)
|
||||
close (fd);
|
||||
|
||||
#endif /* HAVE_MMAP */
|
||||
|
||||
return cache;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
|
||||
xdg_uint32_t offset,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
|
||||
xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
|
||||
xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
|
||||
xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
|
||||
xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
|
||||
|
||||
int i, j;
|
||||
|
||||
for (i = range_start; i <= range_start + range_length; i++)
|
||||
{
|
||||
int valid_matchlet = TRUE;
|
||||
|
||||
if (i + data_length > len)
|
||||
return FALSE;
|
||||
|
||||
if (mask_offset)
|
||||
{
|
||||
for (j = 0; j < data_length; j++)
|
||||
{
|
||||
if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
|
||||
((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (j = 0; j < data_length; j++)
|
||||
{
|
||||
if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (valid_matchlet)
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_magic_matchlet_compare (XdgMimeCache *cache,
|
||||
xdg_uint32_t offset,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
|
||||
xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
|
||||
|
||||
int i;
|
||||
|
||||
if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
|
||||
{
|
||||
if (n_children == 0)
|
||||
return TRUE;
|
||||
|
||||
for (i = 0; i < n_children; i++)
|
||||
{
|
||||
if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
|
||||
data, len))
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static const char *
|
||||
cache_magic_compare_to_data (XdgMimeCache *cache,
|
||||
xdg_uint32_t offset,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int *prio)
|
||||
{
|
||||
xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
|
||||
xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
|
||||
xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
|
||||
xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_matchlets; i++)
|
||||
{
|
||||
if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
|
||||
data, len))
|
||||
{
|
||||
*prio = priority;
|
||||
|
||||
return cache->buffer + mimetype_offset;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const char *
|
||||
cache_magic_lookup_data (XdgMimeCache *cache,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int *prio,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
xdg_uint32_t list_offset;
|
||||
xdg_uint32_t n_entries;
|
||||
xdg_uint32_t offset;
|
||||
|
||||
int j, n;
|
||||
|
||||
*prio = 0;
|
||||
|
||||
list_offset = GET_UINT32 (cache->buffer, 24);
|
||||
n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 8);
|
||||
|
||||
for (j = 0; j < n_entries; j++)
|
||||
{
|
||||
const char *match;
|
||||
|
||||
match = cache_magic_compare_to_data (cache, offset + 16 * j,
|
||||
data, len, prio);
|
||||
if (match)
|
||||
return match;
|
||||
else
|
||||
{
|
||||
xdg_uint32_t mimetype_offset;
|
||||
const char *non_match;
|
||||
|
||||
mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
|
||||
non_match = cache->buffer + mimetype_offset;
|
||||
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n] &&
|
||||
xdg_mime_mime_type_equal (mime_types[n], non_match))
|
||||
mime_types[n] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const char *
|
||||
cache_alias_lookup (const char *alias)
|
||||
{
|
||||
const char *ptr;
|
||||
int i, min, max, mid, cmp;
|
||||
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
xdg_uint32_t offset;
|
||||
|
||||
min = 0;
|
||||
max = n_entries - 1;
|
||||
while (max >= min)
|
||||
{
|
||||
mid = (min + max) / 2;
|
||||
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
|
||||
ptr = cache->buffer + offset;
|
||||
cmp = strcmp (ptr, alias);
|
||||
|
||||
if (cmp < 0)
|
||||
min = mid + 1;
|
||||
else if (cmp > 0)
|
||||
max = mid - 1;
|
||||
else
|
||||
{
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
|
||||
return cache->buffer + offset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_glob_lookup_literal (const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
const char *ptr;
|
||||
int i, min, max, mid, cmp;
|
||||
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
xdg_uint32_t offset;
|
||||
|
||||
min = 0;
|
||||
max = n_entries - 1;
|
||||
while (max >= min)
|
||||
{
|
||||
mid = (min + max) / 2;
|
||||
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
|
||||
ptr = cache->buffer + offset;
|
||||
cmp = strcmp (ptr, file_name);
|
||||
|
||||
if (cmp < 0)
|
||||
min = mid + 1;
|
||||
else if (cmp > 0)
|
||||
max = mid - 1;
|
||||
else
|
||||
{
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
|
||||
mime_types[0] = (const char *)(cache->buffer + offset);
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_glob_lookup_fnmatch (const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
const char *mime_type;
|
||||
const char *ptr;
|
||||
|
||||
int i, j, n;
|
||||
|
||||
n = 0;
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
|
||||
for (j = 0; j < n_entries && n < n_mime_types; j++)
|
||||
{
|
||||
xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
|
||||
xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
|
||||
ptr = cache->buffer + offset;
|
||||
mime_type = cache->buffer + mimetype_offset;
|
||||
|
||||
/* FIXME: Not UTF-8 safe */
|
||||
if (fnmatch (ptr, file_name, 0) == 0)
|
||||
mime_types[n++] = mime_type;
|
||||
}
|
||||
|
||||
if (n > 0)
|
||||
return n;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_glob_node_lookup_suffix (XdgMimeCache *cache,
|
||||
xdg_uint32_t n_entries,
|
||||
xdg_uint32_t offset,
|
||||
const char *suffix,
|
||||
int ignore_case,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
xdg_unichar_t character;
|
||||
xdg_unichar_t match_char;
|
||||
xdg_uint32_t mimetype_offset;
|
||||
xdg_uint32_t n_children;
|
||||
xdg_uint32_t child_offset;
|
||||
|
||||
int min, max, mid, n, i;
|
||||
|
||||
character = _xdg_utf8_to_ucs4 (suffix);
|
||||
if (ignore_case)
|
||||
character = _xdg_ucs4_to_lower (character);
|
||||
|
||||
min = 0;
|
||||
max = n_entries - 1;
|
||||
while (max >= min)
|
||||
{
|
||||
mid = (min + max) / 2;
|
||||
|
||||
match_char = GET_UINT32 (cache->buffer, offset + 16 * mid);
|
||||
|
||||
if (match_char < character)
|
||||
min = mid + 1;
|
||||
else if (match_char > character)
|
||||
max = mid - 1;
|
||||
else
|
||||
{
|
||||
suffix = _xdg_utf8_next_char (suffix);
|
||||
if (*suffix == '\0')
|
||||
{
|
||||
mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 4);
|
||||
n = 0;
|
||||
if (mimetype_offset)
|
||||
mime_types[n++] = cache->buffer + mimetype_offset;
|
||||
|
||||
n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
|
||||
child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
|
||||
i = 0;
|
||||
while (n < n_mime_types && i < n_children)
|
||||
{
|
||||
match_char = GET_UINT32 (cache->buffer, child_offset + 16 * i);
|
||||
mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * i + 4);
|
||||
if (match_char != 0)
|
||||
break;
|
||||
|
||||
mime_types[n++] = cache->buffer + mimetype_offset;
|
||||
i++;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
else
|
||||
{
|
||||
n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
|
||||
child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
|
||||
|
||||
return cache_glob_node_lookup_suffix (cache,
|
||||
n_children, child_offset,
|
||||
suffix, ignore_case,
|
||||
mime_types,
|
||||
n_mime_types);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
cache_glob_lookup_suffix (const char *suffix,
|
||||
int ignore_case,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
int i, n;
|
||||
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
|
||||
|
||||
n = cache_glob_node_lookup_suffix (cache,
|
||||
n_entries, offset,
|
||||
suffix, ignore_case,
|
||||
mime_types,
|
||||
n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
find_stopchars (char *stopchars)
|
||||
{
|
||||
int i, j, k, l;
|
||||
|
||||
k = 0;
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
|
||||
|
||||
for (j = 0; j < n_entries; j++)
|
||||
{
|
||||
xdg_uint32_t match_char = GET_UINT32 (cache->buffer, offset);
|
||||
|
||||
if (match_char < 128)
|
||||
{
|
||||
for (l = 0; l < k; l++)
|
||||
if (stopchars[l] == match_char)
|
||||
break;
|
||||
if (l == k)
|
||||
{
|
||||
stopchars[k] = (char) match_char;
|
||||
k++;
|
||||
}
|
||||
}
|
||||
|
||||
offset += 16;
|
||||
}
|
||||
}
|
||||
|
||||
stopchars[k] = '\0';
|
||||
}
|
||||
|
||||
static int
|
||||
cache_glob_lookup_file_name (const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
const char *ptr;
|
||||
char stopchars[128];
|
||||
int n;
|
||||
|
||||
assert (file_name != NULL);
|
||||
|
||||
/* First, check the literals */
|
||||
n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
|
||||
find_stopchars (stopchars);
|
||||
|
||||
/* Next, check suffixes */
|
||||
ptr = strpbrk (file_name, stopchars);
|
||||
while (ptr)
|
||||
{
|
||||
n = cache_glob_lookup_suffix (ptr, FALSE, mime_types, n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
|
||||
n = cache_glob_lookup_suffix (ptr, TRUE, mime_types, n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
|
||||
ptr = strpbrk (ptr + 1, stopchars);
|
||||
}
|
||||
|
||||
/* Last, try fnmatch */
|
||||
return cache_glob_lookup_fnmatch (file_name, mime_types, n_mime_types);
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_mime_cache_get_max_buffer_extents (void)
|
||||
{
|
||||
xdg_uint32_t offset;
|
||||
xdg_uint32_t max_extent;
|
||||
int i;
|
||||
|
||||
max_extent = 0;
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
offset = GET_UINT32 (cache->buffer, 24);
|
||||
max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
|
||||
}
|
||||
|
||||
return max_extent;
|
||||
}
|
||||
|
||||
static const char *
|
||||
cache_get_mime_type_for_data (const void *data,
|
||||
size_t len,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
const char *mime_type;
|
||||
int i, n, priority;
|
||||
|
||||
priority = 0;
|
||||
mime_type = NULL;
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
int prio;
|
||||
const char *match;
|
||||
|
||||
match = cache_magic_lookup_data (cache, data, len, &prio,
|
||||
mime_types, n_mime_types);
|
||||
if (prio > priority)
|
||||
{
|
||||
priority = prio;
|
||||
mime_type = match;
|
||||
}
|
||||
}
|
||||
|
||||
if (priority > 0)
|
||||
return mime_type;
|
||||
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n])
|
||||
return mime_types[n];
|
||||
}
|
||||
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_cache_get_mime_type_for_data (const void *data,
|
||||
size_t len)
|
||||
{
|
||||
return cache_get_mime_type_for_data (data, len, NULL, 0);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_cache_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf)
|
||||
{
|
||||
const char *mime_type;
|
||||
const char *mime_types[2];
|
||||
FILE *file;
|
||||
unsigned char *data;
|
||||
int max_extent;
|
||||
int bytes_read;
|
||||
struct stat buf;
|
||||
const char *base_name;
|
||||
int n;
|
||||
|
||||
if (file_name == NULL)
|
||||
return NULL;
|
||||
|
||||
if (! _xdg_utf8_validate (file_name))
|
||||
return NULL;
|
||||
|
||||
base_name = _xdg_get_base_name (file_name);
|
||||
n = cache_glob_lookup_file_name (base_name, mime_types, 2);
|
||||
|
||||
if (n == 1)
|
||||
return mime_types[0];
|
||||
|
||||
if (!statbuf)
|
||||
{
|
||||
if (stat (file_name, &buf) != 0)
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
statbuf = &buf;
|
||||
}
|
||||
|
||||
if (!S_ISREG (statbuf->st_mode))
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
/* FIXME: Need to make sure that max_extent isn't totally broken. This could
|
||||
* be large and need getting from a stream instead of just reading it all
|
||||
* in. */
|
||||
max_extent = _xdg_mime_cache_get_max_buffer_extents ();
|
||||
data = malloc (max_extent);
|
||||
if (data == NULL)
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
if (file == NULL)
|
||||
{
|
||||
free (data);
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
bytes_read = fread (data, 1, max_extent, file);
|
||||
if (ferror (file))
|
||||
{
|
||||
free (data);
|
||||
fclose (file);
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
mime_type = cache_get_mime_type_for_data (data, bytes_read,
|
||||
mime_types, n);
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
return mime_type;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
|
||||
{
|
||||
const char *mime_type;
|
||||
|
||||
if (cache_glob_lookup_file_name (file_name, &mime_type, 1))
|
||||
return mime_type;
|
||||
else
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
#if 1
|
||||
static int
|
||||
is_super_type (const char *mime)
|
||||
{
|
||||
int length;
|
||||
const char *type;
|
||||
|
||||
length = strlen (mime);
|
||||
type = &(mime[length - 2]);
|
||||
|
||||
if (strcmp (type, "/*") == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
_xdg_mime_cache_mime_type_subclass (const char *mime,
|
||||
const char *base)
|
||||
{
|
||||
const char *umime, *ubase;
|
||||
|
||||
int i, j, min, max, med, cmp;
|
||||
|
||||
umime = _xdg_mime_cache_unalias_mime_type (mime);
|
||||
ubase = _xdg_mime_cache_unalias_mime_type (base);
|
||||
|
||||
if (strcmp (umime, ubase) == 0)
|
||||
return 1;
|
||||
|
||||
/* We really want to handle text/ * in GtkFileFilter, so we just
|
||||
* turn on the supertype matching
|
||||
*/
|
||||
#if 1
|
||||
/* Handle supertypes */
|
||||
if (is_super_type (ubase) &&
|
||||
xdg_mime_media_type_equal (umime, ubase))
|
||||
return 1;
|
||||
#endif
|
||||
|
||||
/* Handle special cases text/plain and application/octet-stream */
|
||||
if (strcmp (ubase, "text/plain") == 0 &&
|
||||
strncmp (umime, "text/", 5) == 0)
|
||||
return 1;
|
||||
|
||||
if (strcmp (ubase, "application/octet-stream") == 0)
|
||||
return 1;
|
||||
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
xdg_uint32_t offset, n_parents, parent_offset;
|
||||
|
||||
min = 0;
|
||||
max = n_entries - 1;
|
||||
while (max >= min)
|
||||
{
|
||||
med = (min + max)/2;
|
||||
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
|
||||
cmp = strcmp (cache->buffer + offset, umime);
|
||||
if (cmp < 0)
|
||||
min = med + 1;
|
||||
else if (cmp > 0)
|
||||
max = med - 1;
|
||||
else
|
||||
{
|
||||
offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
|
||||
n_parents = GET_UINT32 (cache->buffer, offset);
|
||||
|
||||
for (j = 0; j < n_parents; j++)
|
||||
{
|
||||
parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
|
||||
if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
|
||||
return 1;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_cache_unalias_mime_type (const char *mime)
|
||||
{
|
||||
const char *lookup;
|
||||
|
||||
lookup = cache_alias_lookup (mime);
|
||||
|
||||
if (lookup)
|
||||
return lookup;
|
||||
|
||||
return mime;
|
||||
}
|
||||
|
||||
char **
|
||||
_xdg_mime_cache_list_mime_parents (const char *mime)
|
||||
{
|
||||
int i, j, k, p;
|
||||
char *all_parents[128]; /* we'll stop at 128 */
|
||||
char **result;
|
||||
|
||||
mime = xdg_mime_unalias_mime_type (mime);
|
||||
|
||||
p = 0;
|
||||
for (i = 0; _caches[i]; i++)
|
||||
{
|
||||
XdgMimeCache *cache = _caches[i];
|
||||
|
||||
xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
|
||||
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
|
||||
|
||||
for (j = 0; j < n_entries; j++)
|
||||
{
|
||||
xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
|
||||
xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
|
||||
|
||||
if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
|
||||
{
|
||||
xdg_uint32_t parent_mime_offset;
|
||||
xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
|
||||
|
||||
for (k = 0; k < n_parents && p < 127; k++)
|
||||
{
|
||||
parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
|
||||
all_parents[p++] = cache->buffer + parent_mime_offset;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
all_parents[p++] = 0;
|
||||
|
||||
result = (char **) malloc (p * sizeof (char *));
|
||||
memcpy (result, all_parents, p * sizeof (char *));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -0,0 +1,63 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimecache.h: Private file. Datastructure for mmapped caches.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_CACHE_H__
|
||||
#define __XDG_MIME_CACHE_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct _XdgMimeCache XdgMimeCache;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_cache_new_from_file XDG_ENTRY(cache_new_from_file)
|
||||
#define _xdg_mime_cache_ref XDG_ENTRY(cache_ref)
|
||||
#define _xdg_mime_cache_unref XDG_ENTRY(cache_unref)
|
||||
#endif
|
||||
|
||||
extern XdgMimeCache **_caches;
|
||||
|
||||
XdgMimeCache *_xdg_mime_cache_new_from_file (const char *file_name);
|
||||
XdgMimeCache *_xdg_mime_cache_ref (XdgMimeCache *cache);
|
||||
void _xdg_mime_cache_unref (XdgMimeCache *cache);
|
||||
|
||||
|
||||
const char *_xdg_mime_cache_get_mime_type_for_data (const void *data,
|
||||
size_t len);
|
||||
const char *_xdg_mime_cache_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf);
|
||||
const char *_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name);
|
||||
int _xdg_mime_cache_is_valid_mime_type (const char *mime_type);
|
||||
int _xdg_mime_cache_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_cache_media_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_cache_mime_type_subclass (const char *mime_a,
|
||||
const char *mime_b);
|
||||
char **_xdg_mime_cache_list_mime_parents (const char *mime);
|
||||
const char *_xdg_mime_cache_unalias_mime_type (const char *mime);
|
||||
int _xdg_mime_cache_get_max_buffer_extents (void);
|
||||
|
||||
#endif /* __XDG_MIME_CACHE_H__ */
|
||||
@ -0,0 +1,547 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeglob.c: Private file. Datastructure for storing the globs.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeglob.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgGlobHashNode XdgGlobHashNode;
|
||||
typedef struct XdgGlobList XdgGlobList;
|
||||
|
||||
struct XdgGlobHashNode
|
||||
{
|
||||
xdg_unichar_t character;
|
||||
const char *mime_type;
|
||||
XdgGlobHashNode *next;
|
||||
XdgGlobHashNode *child;
|
||||
};
|
||||
struct XdgGlobList
|
||||
{
|
||||
const char *data;
|
||||
const char *mime_type;
|
||||
XdgGlobList *next;
|
||||
};
|
||||
|
||||
struct XdgGlobHash
|
||||
{
|
||||
XdgGlobList *literal_list;
|
||||
XdgGlobHashNode *simple_node;
|
||||
XdgGlobList *full_list;
|
||||
};
|
||||
|
||||
|
||||
/* XdgGlobList
|
||||
*/
|
||||
static XdgGlobList *
|
||||
_xdg_glob_list_new (void)
|
||||
{
|
||||
XdgGlobList *new_element;
|
||||
|
||||
new_element = calloc (1, sizeof (XdgGlobList));
|
||||
|
||||
return new_element;
|
||||
}
|
||||
|
||||
/* Frees glob_list and all of it's children */
|
||||
static void
|
||||
_xdg_glob_list_free (XdgGlobList *glob_list)
|
||||
{
|
||||
XdgGlobList *ptr, *next;
|
||||
|
||||
ptr = glob_list;
|
||||
|
||||
while (ptr != NULL)
|
||||
{
|
||||
next = ptr->next;
|
||||
|
||||
if (ptr->data)
|
||||
free ((void *) ptr->data);
|
||||
if (ptr->mime_type)
|
||||
free ((void *) ptr->mime_type);
|
||||
free (ptr);
|
||||
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
|
||||
static XdgGlobList *
|
||||
_xdg_glob_list_append (XdgGlobList *glob_list,
|
||||
void *data,
|
||||
const char *mime_type)
|
||||
{
|
||||
XdgGlobList *new_element;
|
||||
XdgGlobList *tmp_element;
|
||||
|
||||
new_element = _xdg_glob_list_new ();
|
||||
new_element->data = data;
|
||||
new_element->mime_type = mime_type;
|
||||
if (glob_list == NULL)
|
||||
return new_element;
|
||||
|
||||
tmp_element = glob_list;
|
||||
while (tmp_element->next != NULL)
|
||||
tmp_element = tmp_element->next;
|
||||
|
||||
tmp_element->next = new_element;
|
||||
|
||||
return glob_list;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static XdgGlobList *
|
||||
_xdg_glob_list_prepend (XdgGlobList *glob_list,
|
||||
void *data,
|
||||
const char *mime_type)
|
||||
{
|
||||
XdgGlobList *new_element;
|
||||
|
||||
new_element = _xdg_glob_list_new ();
|
||||
new_element->data = data;
|
||||
new_element->next = glob_list;
|
||||
new_element->mime_type = mime_type;
|
||||
|
||||
return new_element;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* XdgGlobHashNode
|
||||
*/
|
||||
|
||||
static XdgGlobHashNode *
|
||||
_xdg_glob_hash_node_new (void)
|
||||
{
|
||||
XdgGlobHashNode *glob_hash_node;
|
||||
|
||||
glob_hash_node = calloc (1, sizeof (XdgGlobHashNode));
|
||||
|
||||
return glob_hash_node;
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node,
|
||||
int depth)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < depth; i++)
|
||||
printf (" ");
|
||||
|
||||
printf ("%c", (char)glob_hash_node->character);
|
||||
if (glob_hash_node->mime_type)
|
||||
printf (" - %s\n", glob_hash_node->mime_type);
|
||||
else
|
||||
printf ("\n");
|
||||
if (glob_hash_node->child)
|
||||
_xdg_glob_hash_node_dump (glob_hash_node->child, depth + 1);
|
||||
if (glob_hash_node->next)
|
||||
_xdg_glob_hash_node_dump (glob_hash_node->next, depth);
|
||||
}
|
||||
|
||||
static XdgGlobHashNode *
|
||||
_xdg_glob_hash_insert_text (XdgGlobHashNode *glob_hash_node,
|
||||
const char *text,
|
||||
const char *mime_type)
|
||||
{
|
||||
XdgGlobHashNode *node;
|
||||
xdg_unichar_t character;
|
||||
|
||||
character = _xdg_utf8_to_ucs4 (text);
|
||||
|
||||
if ((glob_hash_node == NULL) ||
|
||||
(character < glob_hash_node->character))
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = glob_hash_node;
|
||||
glob_hash_node = node;
|
||||
}
|
||||
else if (character == glob_hash_node->character)
|
||||
{
|
||||
node = glob_hash_node;
|
||||
}
|
||||
else
|
||||
{
|
||||
XdgGlobHashNode *prev_node;
|
||||
int found_node = FALSE;
|
||||
|
||||
/* Look for the first character of text in glob_hash_node, and insert it if we
|
||||
* have to.*/
|
||||
prev_node = glob_hash_node;
|
||||
node = prev_node->next;
|
||||
|
||||
while (node != NULL)
|
||||
{
|
||||
if (character < node->character)
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = prev_node->next;
|
||||
prev_node->next = node;
|
||||
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
else if (character == node->character)
|
||||
{
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
prev_node = node;
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
if (! found_node)
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = prev_node->next;
|
||||
prev_node->next = node;
|
||||
}
|
||||
}
|
||||
|
||||
text = _xdg_utf8_next_char (text);
|
||||
if (*text == '\000')
|
||||
{
|
||||
if (node->mime_type)
|
||||
{
|
||||
if (strcmp (node->mime_type, mime_type))
|
||||
{
|
||||
XdgGlobHashNode *child;
|
||||
int found_node = FALSE;
|
||||
|
||||
child = node->child;
|
||||
while (child && child->character == '\0')
|
||||
{
|
||||
if (strcmp (child->mime_type, mime_type) == 0)
|
||||
{
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
child = child->next;
|
||||
}
|
||||
|
||||
if (!found_node)
|
||||
{
|
||||
child = _xdg_glob_hash_node_new ();
|
||||
child->character = '\000';
|
||||
child->mime_type = mime_type;
|
||||
child->child = NULL;
|
||||
child->next = node->child;
|
||||
node->child = child;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
node->mime_type = mime_type;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
node->child = _xdg_glob_hash_insert_text (node->child, text, mime_type);
|
||||
}
|
||||
return glob_hash_node;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
|
||||
const char *file_name,
|
||||
int ignore_case,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
int n;
|
||||
XdgGlobHashNode *node;
|
||||
xdg_unichar_t character;
|
||||
|
||||
if (glob_hash_node == NULL)
|
||||
return 0;
|
||||
|
||||
character = _xdg_utf8_to_ucs4 (file_name);
|
||||
if (ignore_case)
|
||||
character = _xdg_ucs4_to_lower(character);
|
||||
|
||||
for (node = glob_hash_node; node && character >= node->character; node = node->next)
|
||||
{
|
||||
if (character == node->character)
|
||||
{
|
||||
file_name = _xdg_utf8_next_char (file_name);
|
||||
if (*file_name == '\000')
|
||||
{
|
||||
n = 0;
|
||||
if (node->mime_type)
|
||||
mime_types[n++] = node->mime_type;
|
||||
node = node->child;
|
||||
while (n < n_mime_types && node && node->character == 0)
|
||||
{
|
||||
if (node->mime_type)
|
||||
mime_types[n++] = node->mime_type;
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
n = _xdg_glob_hash_node_lookup_file_name (node->child,
|
||||
file_name,
|
||||
ignore_case,
|
||||
mime_types,
|
||||
n_mime_types);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
|
||||
const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
XdgGlobList *list;
|
||||
const char *ptr;
|
||||
char stopchars[128];
|
||||
int i, n;
|
||||
XdgGlobHashNode *node;
|
||||
|
||||
/* First, check the literals */
|
||||
|
||||
assert (file_name != NULL && n_mime_types > 0);
|
||||
|
||||
for (list = glob_hash->literal_list; list; list = list->next)
|
||||
{
|
||||
if (strcmp ((const char *)list->data, file_name) == 0)
|
||||
{
|
||||
mime_types[0] = list->mime_type;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
for (node = glob_hash->simple_node; node; node = node->next)
|
||||
{
|
||||
if (node->character < 128)
|
||||
stopchars[i++] = (char)node->character;
|
||||
}
|
||||
stopchars[i] = '\0';
|
||||
|
||||
ptr = strpbrk (file_name, stopchars);
|
||||
while (ptr)
|
||||
{
|
||||
n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ptr, FALSE,
|
||||
mime_types, n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
|
||||
n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ptr, TRUE,
|
||||
mime_types, n_mime_types);
|
||||
if (n > 0)
|
||||
return n;
|
||||
|
||||
ptr = strpbrk (ptr + 1, stopchars);
|
||||
}
|
||||
|
||||
/* FIXME: Not UTF-8 safe */
|
||||
n = 0;
|
||||
for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
|
||||
{
|
||||
if (fnmatch ((const char *)list->data, file_name, 0) == 0)
|
||||
mime_types[n++] = list->mime_type;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* XdgGlobHash
|
||||
*/
|
||||
|
||||
XdgGlobHash *
|
||||
_xdg_glob_hash_new (void)
|
||||
{
|
||||
XdgGlobHash *glob_hash;
|
||||
|
||||
glob_hash = calloc (1, sizeof (XdgGlobHash));
|
||||
|
||||
return glob_hash;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
_xdg_glob_hash_free_nodes (XdgGlobHashNode *node)
|
||||
{
|
||||
if (node)
|
||||
{
|
||||
if (node->child)
|
||||
_xdg_glob_hash_free_nodes (node->child);
|
||||
if (node->next)
|
||||
_xdg_glob_hash_free_nodes (node->next);
|
||||
if (node->mime_type)
|
||||
free ((void *) node->mime_type);
|
||||
free (node);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_glob_hash_free (XdgGlobHash *glob_hash)
|
||||
{
|
||||
_xdg_glob_list_free (glob_hash->literal_list);
|
||||
_xdg_glob_list_free (glob_hash->full_list);
|
||||
_xdg_glob_hash_free_nodes (glob_hash->simple_node);
|
||||
free (glob_hash);
|
||||
}
|
||||
|
||||
XdgGlobType
|
||||
_xdg_glob_determine_type (const char *glob)
|
||||
{
|
||||
const char *ptr;
|
||||
int maybe_in_simple_glob = FALSE;
|
||||
int first_char = TRUE;
|
||||
|
||||
ptr = glob;
|
||||
|
||||
while (*ptr != '\000')
|
||||
{
|
||||
if (*ptr == '*' && first_char)
|
||||
maybe_in_simple_glob = TRUE;
|
||||
else if (*ptr == '\\' || *ptr == '[' || *ptr == '?' || *ptr == '*')
|
||||
return XDG_GLOB_FULL;
|
||||
|
||||
first_char = FALSE;
|
||||
ptr = _xdg_utf8_next_char (ptr);
|
||||
}
|
||||
if (maybe_in_simple_glob)
|
||||
return XDG_GLOB_SIMPLE;
|
||||
else
|
||||
return XDG_GLOB_LITERAL;
|
||||
}
|
||||
|
||||
/* glob must be valid UTF-8 */
|
||||
void
|
||||
_xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
|
||||
const char *glob,
|
||||
const char *mime_type)
|
||||
{
|
||||
XdgGlobType type;
|
||||
|
||||
assert (glob_hash != NULL);
|
||||
assert (glob != NULL);
|
||||
|
||||
type = _xdg_glob_determine_type (glob);
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case XDG_GLOB_LITERAL:
|
||||
glob_hash->literal_list = _xdg_glob_list_append (glob_hash->literal_list, strdup (glob), strdup (mime_type));
|
||||
break;
|
||||
case XDG_GLOB_SIMPLE:
|
||||
glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, strdup (mime_type));
|
||||
break;
|
||||
case XDG_GLOB_FULL:
|
||||
glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_glob_hash_dump (XdgGlobHash *glob_hash)
|
||||
{
|
||||
XdgGlobList *list;
|
||||
printf ("LITERAL STRINGS\n");
|
||||
if (glob_hash->literal_list == NULL)
|
||||
{
|
||||
printf (" None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (list = glob_hash->literal_list; list; list = list->next)
|
||||
printf (" %s - %s\n", (char *)list->data, list->mime_type);
|
||||
}
|
||||
printf ("\nSIMPLE GLOBS\n");
|
||||
_xdg_glob_hash_node_dump (glob_hash->simple_node, 4);
|
||||
|
||||
printf ("\nFULL GLOBS\n");
|
||||
if (glob_hash->full_list == NULL)
|
||||
{
|
||||
printf (" None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (list = glob_hash->full_list; list; list = list->next)
|
||||
printf (" %s - %s\n", (char *)list->data, list->mime_type);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *glob_file;
|
||||
char line[255];
|
||||
|
||||
glob_file = fopen (file_name, "r");
|
||||
|
||||
if (glob_file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
while (fgets (line, 255, glob_file) != NULL)
|
||||
{
|
||||
char *colon;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
colon = strchr (line, ':');
|
||||
if (colon == NULL)
|
||||
continue;
|
||||
*(colon++) = '\000';
|
||||
colon[strlen (colon) -1] = '\000';
|
||||
_xdg_glob_hash_append_glob (glob_hash, colon, line);
|
||||
}
|
||||
|
||||
fclose (glob_file);
|
||||
}
|
||||
@ -0,0 +1,67 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeglob.h: Private file. Datastructure for storing the globs.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_GLOB_H__
|
||||
#define __XDG_MIME_GLOB_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgGlobHash XdgGlobHash;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
XDG_GLOB_LITERAL, /* Makefile */
|
||||
XDG_GLOB_SIMPLE, /* *.gif */
|
||||
XDG_GLOB_FULL /* x*.[ch] */
|
||||
} XdgGlobType;
|
||||
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_glob_read_from_file XDG_ENTRY(glob_read_from_file)
|
||||
#define _xdg_glob_hash_new XDG_ENTRY(hash_new)
|
||||
#define _xdg_glob_hash_free XDG_ENTRY(hash_free)
|
||||
#define _xdg_glob_hash_lookup_file_name XDG_ENTRY(hash_lookup_file_name)
|
||||
#define _xdg_glob_hash_append_glob XDG_ENTRY(hash_append_glob)
|
||||
#define _xdg_glob_determine_type XDG_ENTRY(determine_type)
|
||||
#define _xdg_glob_hash_dump XDG_ENTRY(hash_dump)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
|
||||
const char *file_name);
|
||||
XdgGlobHash *_xdg_glob_hash_new (void);
|
||||
void _xdg_glob_hash_free (XdgGlobHash *glob_hash);
|
||||
int _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
|
||||
const char *text,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
void _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
|
||||
const char *glob,
|
||||
const char *mime_type);
|
||||
XdgGlobType _xdg_glob_determine_type (const char *glob);
|
||||
void _xdg_glob_hash_dump (XdgGlobHash *glob_hash);
|
||||
|
||||
#endif /* __XDG_MIME_GLOB_H__ */
|
||||
@ -0,0 +1,154 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeint.c: Internal defines and functions.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeint.h"
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
static const char _xdg_utf8_skip_data[256] = {
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
|
||||
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
|
||||
};
|
||||
|
||||
const char * const _xdg_utf8_skip = _xdg_utf8_skip_data;
|
||||
|
||||
|
||||
|
||||
/* Returns the number of unprocessed characters. */
|
||||
xdg_unichar_t
|
||||
_xdg_utf8_to_ucs4(const char *source)
|
||||
{
|
||||
xdg_unichar_t ucs32;
|
||||
if( ! ( *source & 0x80 ) )
|
||||
{
|
||||
ucs32 = *source;
|
||||
}
|
||||
else
|
||||
{
|
||||
int bytelength = 0;
|
||||
xdg_unichar_t result;
|
||||
if ( ! (*source & 0x40) )
|
||||
{
|
||||
ucs32 = *source;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( ! (*source & 0x20) )
|
||||
{
|
||||
result = *source++ & 0x1F;
|
||||
bytelength = 2;
|
||||
}
|
||||
else if ( ! (*source & 0x10) )
|
||||
{
|
||||
result = *source++ & 0x0F;
|
||||
bytelength = 3;
|
||||
}
|
||||
else if ( ! (*source & 0x08) )
|
||||
{
|
||||
result = *source++ & 0x07;
|
||||
bytelength = 4;
|
||||
}
|
||||
else if ( ! (*source & 0x04) )
|
||||
{
|
||||
result = *source++ & 0x03;
|
||||
bytelength = 5;
|
||||
}
|
||||
else if ( ! (*source & 0x02) )
|
||||
{
|
||||
result = *source++ & 0x01;
|
||||
bytelength = 6;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = *source++;
|
||||
bytelength = 1;
|
||||
}
|
||||
|
||||
for ( bytelength --; bytelength > 0; bytelength -- )
|
||||
{
|
||||
result <<= 6;
|
||||
result |= *source++ & 0x3F;
|
||||
}
|
||||
ucs32 = result;
|
||||
}
|
||||
}
|
||||
return ucs32;
|
||||
}
|
||||
|
||||
|
||||
/* hullo. this is great code. don't rewrite it */
|
||||
|
||||
xdg_unichar_t
|
||||
_xdg_ucs4_to_lower (xdg_unichar_t source)
|
||||
{
|
||||
/* FIXME: Do a real to_upper sometime */
|
||||
/* CaseFolding-3.2.0.txt has a table of rules. */
|
||||
if ((source & 0xFF) == source)
|
||||
return (xdg_unichar_t) tolower ((unsigned char) source);
|
||||
return source;
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_utf8_validate (const char *source)
|
||||
{
|
||||
/* FIXME: actually write */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_get_base_name (const char *file_name)
|
||||
{
|
||||
const char *base_name;
|
||||
|
||||
if (file_name == NULL)
|
||||
return NULL;
|
||||
|
||||
base_name = strrchr (file_name, '/');
|
||||
|
||||
if (base_name == NULL)
|
||||
return file_name;
|
||||
else
|
||||
return base_name + 1;
|
||||
}
|
||||
@ -0,0 +1,73 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeint.h: Internal defines and functions.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_INT_H__
|
||||
#define __XDG_MIME_INT_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
/* FIXME: Needs to be configure check */
|
||||
typedef unsigned int xdg_unichar_t;
|
||||
typedef unsigned char xdg_uchar8_t;
|
||||
typedef unsigned short xdg_uint16_t;
|
||||
typedef unsigned int xdg_uint32_t;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_utf8_skip XDG_ENTRY(utf8_skip)
|
||||
#define _xdg_utf8_to_ucs4 XDG_ENTRY(utf8_to_ucs4)
|
||||
#define _xdg_ucs4_to_lower XDG_ENTRY(ucs4_to_lower)
|
||||
#define _xdg_utf8_validate XDG_ENTRY(utf8_validate)
|
||||
#define _xdg_get_base_name XDG_ENTRY(get_ase_name)
|
||||
#endif
|
||||
|
||||
#define SWAP_BE16_TO_LE16(val) (xdg_uint16_t)(((xdg_uint16_t)(val) << 8)|((xdg_uint16_t)(val) >> 8))
|
||||
|
||||
#define SWAP_BE32_TO_LE32(val) (xdg_uint32_t)((((xdg_uint32_t)(val) & 0xFF000000U) >> 24) | \
|
||||
(((xdg_uint32_t)(val) & 0x00FF0000U) >> 8) | \
|
||||
(((xdg_uint32_t)(val) & 0x0000FF00U) << 8) | \
|
||||
(((xdg_uint32_t)(val) & 0x000000FFU) << 24))
|
||||
/* UTF-8 utils
|
||||
*/
|
||||
extern const char *const _xdg_utf8_skip;
|
||||
#define _xdg_utf8_next_char(p) (char *)((p) + _xdg_utf8_skip[*(unsigned char *)(p)])
|
||||
#define _xdg_utf8_char_size(p) (int) (_xdg_utf8_skip[*(unsigned char *)(p)])
|
||||
|
||||
xdg_unichar_t _xdg_utf8_to_ucs4 (const char *source);
|
||||
xdg_unichar_t _xdg_ucs4_to_lower (xdg_unichar_t source);
|
||||
int _xdg_utf8_validate (const char *source);
|
||||
const char *_xdg_get_base_name (const char *file_name);
|
||||
|
||||
#endif /* __XDG_MIME_INT_H__ */
|
||||
@ -0,0 +1,807 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimemagic.: Private file. Datastructure for storing magic files.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include "xdgmimemagic.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
#if !defined getc_unlocked && !defined HAVE_GETC_UNLOCKED
|
||||
# define getc_unlocked(fp) getc (fp)
|
||||
#endif
|
||||
|
||||
typedef struct XdgMimeMagicMatch XdgMimeMagicMatch;
|
||||
typedef struct XdgMimeMagicMatchlet XdgMimeMagicMatchlet;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
XDG_MIME_MAGIC_SECTION,
|
||||
XDG_MIME_MAGIC_MAGIC,
|
||||
XDG_MIME_MAGIC_ERROR,
|
||||
XDG_MIME_MAGIC_EOF
|
||||
} XdgMimeMagicState;
|
||||
|
||||
struct XdgMimeMagicMatch
|
||||
{
|
||||
const char *mime_type;
|
||||
int priority;
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
XdgMimeMagicMatch *next;
|
||||
};
|
||||
|
||||
|
||||
struct XdgMimeMagicMatchlet
|
||||
{
|
||||
int indent;
|
||||
int offset;
|
||||
unsigned int value_length;
|
||||
unsigned char *value;
|
||||
unsigned char *mask;
|
||||
unsigned int range_length;
|
||||
unsigned int word_size;
|
||||
XdgMimeMagicMatchlet *next;
|
||||
};
|
||||
|
||||
|
||||
struct XdgMimeMagic
|
||||
{
|
||||
XdgMimeMagicMatch *match_list;
|
||||
int max_extent;
|
||||
};
|
||||
|
||||
static XdgMimeMagicMatch *
|
||||
_xdg_mime_magic_match_new (void)
|
||||
{
|
||||
return calloc (1, sizeof (XdgMimeMagicMatch));
|
||||
}
|
||||
|
||||
|
||||
static XdgMimeMagicMatchlet *
|
||||
_xdg_mime_magic_matchlet_new (void)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
matchlet = malloc (sizeof (XdgMimeMagicMatchlet));
|
||||
|
||||
matchlet->indent = 0;
|
||||
matchlet->offset = 0;
|
||||
matchlet->value_length = 0;
|
||||
matchlet->value = NULL;
|
||||
matchlet->mask = NULL;
|
||||
matchlet->range_length = 1;
|
||||
matchlet->word_size = 1;
|
||||
matchlet->next = NULL;
|
||||
|
||||
return matchlet;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_matchlet_free (XdgMimeMagicMatchlet *mime_magic_matchlet)
|
||||
{
|
||||
if (mime_magic_matchlet)
|
||||
{
|
||||
if (mime_magic_matchlet->next)
|
||||
_xdg_mime_magic_matchlet_free (mime_magic_matchlet->next);
|
||||
if (mime_magic_matchlet->value)
|
||||
free (mime_magic_matchlet->value);
|
||||
if (mime_magic_matchlet->mask)
|
||||
free (mime_magic_matchlet->mask);
|
||||
free (mime_magic_matchlet);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Frees mime_magic_match and the remainder of its list
|
||||
*/
|
||||
static void
|
||||
_xdg_mime_magic_match_free (XdgMimeMagicMatch *mime_magic_match)
|
||||
{
|
||||
XdgMimeMagicMatch *ptr, *next;
|
||||
|
||||
ptr = mime_magic_match;
|
||||
while (ptr)
|
||||
{
|
||||
next = ptr->next;
|
||||
|
||||
if (ptr->mime_type)
|
||||
free ((void *) ptr->mime_type);
|
||||
if (ptr->matchlet)
|
||||
_xdg_mime_magic_matchlet_free (ptr->matchlet);
|
||||
free (ptr);
|
||||
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
|
||||
/* Reads in a hunk of data until a newline character or a '\000' is hit. The
|
||||
* returned string is null terminated, and doesn't include the newline.
|
||||
*/
|
||||
static unsigned char *
|
||||
_xdg_mime_magic_read_to_newline (FILE *magic_file,
|
||||
int *end_of_file)
|
||||
{
|
||||
unsigned char *retval;
|
||||
int c;
|
||||
int len, pos;
|
||||
|
||||
len = 128;
|
||||
pos = 0;
|
||||
retval = malloc (len);
|
||||
*end_of_file = FALSE;
|
||||
|
||||
while (TRUE)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
*end_of_file = TRUE;
|
||||
break;
|
||||
}
|
||||
if (c == '\n' || c == '\000')
|
||||
break;
|
||||
retval[pos++] = (unsigned char) c;
|
||||
if (pos % 128 == 127)
|
||||
{
|
||||
len = len + 128;
|
||||
retval = realloc (retval, len);
|
||||
}
|
||||
}
|
||||
|
||||
retval[pos] = '\000';
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Returns the number read from the file, or -1 if no number could be read.
|
||||
*/
|
||||
static int
|
||||
_xdg_mime_magic_read_a_number (FILE *magic_file,
|
||||
int *end_of_file)
|
||||
{
|
||||
/* LONG_MAX is about 20 characters on my system */
|
||||
#define MAX_NUMBER_SIZE 30
|
||||
char number_string[MAX_NUMBER_SIZE + 1];
|
||||
int pos = 0;
|
||||
int c;
|
||||
long retval = -1;
|
||||
|
||||
while (TRUE)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
|
||||
if (c == EOF)
|
||||
{
|
||||
*end_of_file = TRUE;
|
||||
break;
|
||||
}
|
||||
if (! isdigit (c))
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
break;
|
||||
}
|
||||
number_string[pos] = (char) c;
|
||||
pos++;
|
||||
if (pos == MAX_NUMBER_SIZE)
|
||||
break;
|
||||
}
|
||||
if (pos > 0)
|
||||
{
|
||||
number_string[pos] = '\000';
|
||||
errno = 0;
|
||||
retval = strtol (number_string, NULL, 10);
|
||||
|
||||
if ((retval < INT_MIN) || (retval > INT_MAX) || (errno != 0))
|
||||
return -1;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Headers are of the format:
|
||||
* [<priority>:<mime-type>]
|
||||
*/
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_header (FILE *magic_file, XdgMimeMagicMatch *match)
|
||||
{
|
||||
int c;
|
||||
char *buffer;
|
||||
char *end_ptr;
|
||||
int end_of_file = 0;
|
||||
|
||||
assert (magic_file != NULL);
|
||||
assert (match != NULL);
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c != '[')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
match->priority = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (match->priority == -1)
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c != ':')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
buffer = (char *)_xdg_mime_magic_read_to_newline (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
|
||||
end_ptr = buffer;
|
||||
while (*end_ptr != ']' && *end_ptr != '\000' && *end_ptr != '\n')
|
||||
end_ptr++;
|
||||
if (*end_ptr != ']')
|
||||
{
|
||||
free (buffer);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
*end_ptr = '\000';
|
||||
|
||||
match->mime_type = strdup (buffer);
|
||||
free (buffer);
|
||||
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
}
|
||||
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_error (FILE *magic_file)
|
||||
{
|
||||
int c;
|
||||
|
||||
while (1)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c == '\n')
|
||||
return XDG_MIME_MAGIC_SECTION;
|
||||
}
|
||||
}
|
||||
|
||||
/* Headers are of the format:
|
||||
* [ indent ] ">" start-offset "=" value
|
||||
* [ "&" mask ] [ "~" word-size ] [ "+" range-length ] "\n"
|
||||
*/
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_magic_line (FILE *magic_file,
|
||||
XdgMimeMagicMatch *match)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
int c;
|
||||
int end_of_file;
|
||||
int indent = 0;
|
||||
int bytes_read;
|
||||
|
||||
assert (magic_file != NULL);
|
||||
|
||||
/* Sniff the buffer to make sure it's a valid line */
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else if (c == '[')
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
return XDG_MIME_MAGIC_SECTION;
|
||||
}
|
||||
else if (c == '\n')
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
|
||||
/* At this point, it must be a digit or a '>' */
|
||||
end_of_file = FALSE;
|
||||
if (isdigit (c))
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
indent = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (indent == -1)
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
|
||||
if (c != '>')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
matchlet = _xdg_mime_magic_matchlet_new ();
|
||||
matchlet->indent = indent;
|
||||
matchlet->offset = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->offset == -1)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
else if (c != '=')
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
/* Next two bytes determine how long the value is */
|
||||
matchlet->value_length = 0;
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
matchlet->value_length = c & 0xFF;
|
||||
matchlet->value_length = matchlet->value_length << 8;
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
matchlet->value_length = matchlet->value_length + (c & 0xFF);
|
||||
|
||||
matchlet->value = malloc (matchlet->value_length);
|
||||
|
||||
/* OOM */
|
||||
if (matchlet->value == NULL)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file);
|
||||
if (bytes_read != matchlet->value_length)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (feof (magic_file))
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == '&')
|
||||
{
|
||||
matchlet->mask = malloc (matchlet->value_length);
|
||||
/* OOM */
|
||||
if (matchlet->mask == NULL)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file);
|
||||
if (bytes_read != matchlet->value_length)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (feof (magic_file))
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
if (c == '~')
|
||||
{
|
||||
matchlet->word_size = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->word_size != 0 &&
|
||||
matchlet->word_size != 1 &&
|
||||
matchlet->word_size != 2 &&
|
||||
matchlet->word_size != 4)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
if (c == '+')
|
||||
{
|
||||
matchlet->range_length = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->range_length == -1)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
|
||||
if (c == '\n')
|
||||
{
|
||||
/* We clean up the matchlet, byte swapping if needed */
|
||||
if (matchlet->word_size > 1)
|
||||
{
|
||||
int i;
|
||||
if (matchlet->value_length % matchlet->word_size != 0)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
/* FIXME: need to get this defined in a <config.h> style file */
|
||||
#if LITTLE_ENDIAN
|
||||
for (i = 0; i < matchlet->value_length; i = i + matchlet->word_size)
|
||||
{
|
||||
if (matchlet->word_size == 2)
|
||||
*((xdg_uint16_t *) matchlet->value + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->value + i)));
|
||||
else if (matchlet->word_size == 4)
|
||||
*((xdg_uint32_t *) matchlet->value + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->value + i)));
|
||||
if (matchlet->mask)
|
||||
{
|
||||
if (matchlet->word_size == 2)
|
||||
*((xdg_uint16_t *) matchlet->mask + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->mask + i)));
|
||||
else if (matchlet->word_size == 4)
|
||||
*((xdg_uint32_t *) matchlet->mask + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->mask + i)));
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
matchlet->next = match->matchlet;
|
||||
match->matchlet = matchlet;
|
||||
|
||||
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
}
|
||||
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_matchlet_compare_to_data (XdgMimeMagicMatchlet *matchlet,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
int i, j;
|
||||
for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++)
|
||||
{
|
||||
int valid_matchlet = TRUE;
|
||||
|
||||
if (i + matchlet->value_length > len)
|
||||
return FALSE;
|
||||
|
||||
if (matchlet->mask)
|
||||
{
|
||||
for (j = 0; j < matchlet->value_length; j++)
|
||||
{
|
||||
if ((matchlet->value[j] & matchlet->mask[j]) !=
|
||||
((((unsigned char *) data)[j + i]) & matchlet->mask[j]))
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (j = 0; j < matchlet->value_length; j++)
|
||||
{
|
||||
if (matchlet->value[j] != ((unsigned char *) data)[j + i])
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (valid_matchlet)
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_matchlet_compare_level (XdgMimeMagicMatchlet *matchlet,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int indent)
|
||||
{
|
||||
while ((matchlet != NULL) && (matchlet->indent == indent))
|
||||
{
|
||||
if (_xdg_mime_magic_matchlet_compare_to_data (matchlet, data, len))
|
||||
{
|
||||
if ((matchlet->next == NULL) ||
|
||||
(matchlet->next->indent <= indent))
|
||||
return TRUE;
|
||||
|
||||
if (_xdg_mime_magic_matchlet_compare_level (matchlet->next,
|
||||
data,
|
||||
len,
|
||||
indent + 1))
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
matchlet = matchlet->next;
|
||||
}
|
||||
while (matchlet && matchlet->indent > indent);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_match_compare_to_data (XdgMimeMagicMatch *match,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
return _xdg_mime_magic_matchlet_compare_level (match->matchlet, data, len, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_insert_match (XdgMimeMagic *mime_magic,
|
||||
XdgMimeMagicMatch *match)
|
||||
{
|
||||
XdgMimeMagicMatch *list;
|
||||
|
||||
if (mime_magic->match_list == NULL)
|
||||
{
|
||||
mime_magic->match_list = match;
|
||||
return;
|
||||
}
|
||||
|
||||
if (match->priority > mime_magic->match_list->priority)
|
||||
{
|
||||
match->next = mime_magic->match_list;
|
||||
mime_magic->match_list = match;
|
||||
return;
|
||||
}
|
||||
|
||||
list = mime_magic->match_list;
|
||||
while (list->next != NULL)
|
||||
{
|
||||
if (list->next->priority < match->priority)
|
||||
{
|
||||
match->next = list->next;
|
||||
list->next = match;
|
||||
return;
|
||||
}
|
||||
list = list->next;
|
||||
}
|
||||
list->next = match;
|
||||
match->next = NULL;
|
||||
}
|
||||
|
||||
XdgMimeMagic *
|
||||
_xdg_mime_magic_new (void)
|
||||
{
|
||||
return calloc (1, sizeof (XdgMimeMagic));
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_magic_free (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
if (mime_magic) {
|
||||
_xdg_mime_magic_match_free (mime_magic->match_list);
|
||||
free (mime_magic);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
return mime_magic->max_extent;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
|
||||
const void *data,
|
||||
size_t len,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
XdgMimeMagicMatch *match;
|
||||
const char *mime_type;
|
||||
int n;
|
||||
|
||||
mime_type = NULL;
|
||||
for (match = mime_magic->match_list; match; match = match->next)
|
||||
{
|
||||
if (_xdg_mime_magic_match_compare_to_data (match, data, len))
|
||||
{
|
||||
if ((mime_type == NULL) || (_xdg_mime_mime_type_subclass (match->mime_type, mime_type))) {
|
||||
mime_type = match->mime_type;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n] &&
|
||||
_xdg_mime_mime_type_equal (mime_types[n], match->mime_type))
|
||||
mime_types[n] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mime_type == NULL)
|
||||
{
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n])
|
||||
mime_type = mime_types[n];
|
||||
}
|
||||
}
|
||||
|
||||
return mime_type;
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_update_mime_magic_extents (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
XdgMimeMagicMatch *match;
|
||||
int max_extent = 0;
|
||||
|
||||
for (match = mime_magic->match_list; match; match = match->next)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
for (matchlet = match->matchlet; matchlet; matchlet = matchlet->next)
|
||||
{
|
||||
int extent;
|
||||
|
||||
extent = matchlet->value_length + matchlet->offset + matchlet->range_length;
|
||||
if (max_extent < extent)
|
||||
max_extent = extent;
|
||||
}
|
||||
}
|
||||
|
||||
mime_magic->max_extent = max_extent;
|
||||
}
|
||||
|
||||
static XdgMimeMagicMatchlet *
|
||||
_xdg_mime_magic_matchlet_mirror (XdgMimeMagicMatchlet *matchlets)
|
||||
{
|
||||
XdgMimeMagicMatchlet *new_list;
|
||||
XdgMimeMagicMatchlet *tmp;
|
||||
|
||||
if ((matchlets == NULL) || (matchlets->next == NULL))
|
||||
return matchlets;
|
||||
|
||||
new_list = NULL;
|
||||
tmp = matchlets;
|
||||
while (tmp != NULL)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
matchlet = tmp;
|
||||
tmp = tmp->next;
|
||||
matchlet->next = new_list;
|
||||
new_list = matchlet;
|
||||
}
|
||||
|
||||
return new_list;
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_read_magic_file (XdgMimeMagic *mime_magic,
|
||||
FILE *magic_file)
|
||||
{
|
||||
XdgMimeMagicState state;
|
||||
XdgMimeMagicMatch *match = NULL; /* Quiet compiler */
|
||||
|
||||
state = XDG_MIME_MAGIC_SECTION;
|
||||
|
||||
while (state != XDG_MIME_MAGIC_EOF)
|
||||
{
|
||||
switch (state)
|
||||
{
|
||||
case XDG_MIME_MAGIC_SECTION:
|
||||
match = _xdg_mime_magic_match_new ();
|
||||
state = _xdg_mime_magic_parse_header (magic_file, match);
|
||||
if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
|
||||
_xdg_mime_magic_match_free (match);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_MAGIC:
|
||||
state = _xdg_mime_magic_parse_magic_line (magic_file, match);
|
||||
if (state == XDG_MIME_MAGIC_SECTION ||
|
||||
(state == XDG_MIME_MAGIC_EOF && match->mime_type))
|
||||
{
|
||||
match->matchlet = _xdg_mime_magic_matchlet_mirror (match->matchlet);
|
||||
_xdg_mime_magic_insert_match (mime_magic, match);
|
||||
}
|
||||
else if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
|
||||
_xdg_mime_magic_match_free (match);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_ERROR:
|
||||
state = _xdg_mime_magic_parse_error (magic_file);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_EOF:
|
||||
default:
|
||||
/* Make the compiler happy */
|
||||
assert (0);
|
||||
}
|
||||
}
|
||||
_xdg_mime_update_mime_magic_extents (mime_magic);
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *magic_file;
|
||||
char header[12];
|
||||
|
||||
magic_file = fopen (file_name, "r");
|
||||
|
||||
if (magic_file == NULL)
|
||||
return;
|
||||
|
||||
if (fread (header, 1, 12, magic_file) == 12)
|
||||
{
|
||||
if (memcmp ("MIME-Magic\0\n", header, 12) == 0)
|
||||
_xdg_mime_magic_read_magic_file (mime_magic, magic_file);
|
||||
}
|
||||
|
||||
fclose (magic_file);
|
||||
}
|
||||
@ -0,0 +1,56 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimemagic.h: Private file. Datastructure for storing the magic files.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_MAGIC_H__
|
||||
#define __XDG_MIME_MAGIC_H__
|
||||
|
||||
#include <unistd.h>
|
||||
#include "xdgmime.h"
|
||||
typedef struct XdgMimeMagic XdgMimeMagic;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_glob_read_from_file XDG_ENTRY(glob_read_from_file)
|
||||
#define _xdg_mime_magic_new XDG_ENTRY(magic_new)
|
||||
#define _xdg_mime_magic_read_from_file XDG_ENTRY(magic_read_from_file)
|
||||
#define _xdg_mime_magic_free XDG_ENTRY(magic_free)
|
||||
#define _xdg_mime_magic_get_buffer_extents XDG_ENTRY(magic_get_buffer_extents)
|
||||
#define _xdg_mime_magic_lookup_data XDG_ENTRY(magic_lookup_data)
|
||||
#endif
|
||||
|
||||
|
||||
XdgMimeMagic *_xdg_mime_magic_new (void);
|
||||
void _xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
|
||||
const char *file_name);
|
||||
void _xdg_mime_magic_free (XdgMimeMagic *mime_magic);
|
||||
int _xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic);
|
||||
const char *_xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
|
||||
const void *data,
|
||||
size_t len,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
|
||||
#endif /* __XDG_MIME_MAGIC_H__ */
|
||||
@ -0,0 +1,219 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.c: Private file. Datastructure for storing the hierarchy.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 2004 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeparent.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgMimeParents XdgMimeParents;
|
||||
|
||||
struct XdgMimeParents
|
||||
{
|
||||
char *mime;
|
||||
char **parents;
|
||||
int n_parents;
|
||||
};
|
||||
|
||||
struct XdgParentList
|
||||
{
|
||||
struct XdgMimeParents *parents;
|
||||
int n_mimes;
|
||||
};
|
||||
|
||||
XdgParentList *
|
||||
_xdg_mime_parent_list_new (void)
|
||||
{
|
||||
XdgParentList *list;
|
||||
|
||||
list = malloc (sizeof (XdgParentList));
|
||||
|
||||
list->parents = NULL;
|
||||
list->n_mimes = 0;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_parent_list_free (XdgParentList *list)
|
||||
{
|
||||
int i;
|
||||
char **p;
|
||||
|
||||
if (list->parents)
|
||||
{
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
for (p = list->parents[i].parents; *p; p++)
|
||||
free (*p);
|
||||
|
||||
free (list->parents[i].parents);
|
||||
free (list->parents[i].mime);
|
||||
}
|
||||
free (list->parents);
|
||||
}
|
||||
free (list);
|
||||
}
|
||||
|
||||
static int
|
||||
parent_entry_cmp (const void *v1, const void *v2)
|
||||
{
|
||||
return strcmp (((XdgMimeParents *)v1)->mime, ((XdgMimeParents *)v2)->mime);
|
||||
}
|
||||
|
||||
const char **
|
||||
_xdg_mime_parent_list_lookup (XdgParentList *list,
|
||||
const char *mime)
|
||||
{
|
||||
XdgMimeParents *entry;
|
||||
XdgMimeParents key;
|
||||
|
||||
if (list->n_mimes > 0)
|
||||
{
|
||||
key.mime = (char *)mime;
|
||||
key.parents = NULL;
|
||||
|
||||
entry = bsearch (&key, list->parents, list->n_mimes,
|
||||
sizeof (XdgMimeParents), &parent_entry_cmp);
|
||||
if (entry)
|
||||
return (const char **)entry->parents;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_parent_read_from_file (XdgParentList *list,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int i, alloc;
|
||||
XdgMimeParents *entry;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
|
||||
if (file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
alloc = list->n_mimes + 16;
|
||||
list->parents = realloc (list->parents, alloc * sizeof (XdgMimeParents));
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
char *sep;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
sep = strchr (line, ' ');
|
||||
if (sep == NULL)
|
||||
continue;
|
||||
*(sep++) = '\000';
|
||||
sep[strlen (sep) -1] = '\000';
|
||||
entry = NULL;
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
if (strcmp (list->parents[i].mime, line) == 0)
|
||||
{
|
||||
entry = &(list->parents[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!entry)
|
||||
{
|
||||
if (list->n_mimes == alloc)
|
||||
{
|
||||
alloc <<= 1;
|
||||
list->parents = realloc (list->parents,
|
||||
alloc * sizeof (XdgMimeParents));
|
||||
}
|
||||
list->parents[list->n_mimes].mime = strdup (line);
|
||||
list->parents[list->n_mimes].parents = NULL;
|
||||
entry = &(list->parents[list->n_mimes]);
|
||||
list->n_mimes++;
|
||||
}
|
||||
|
||||
if (!entry->parents)
|
||||
{
|
||||
entry->n_parents = 1;
|
||||
entry->parents = malloc ((entry->n_parents + 1) * sizeof (char *));
|
||||
}
|
||||
else
|
||||
{
|
||||
entry->n_parents += 1;
|
||||
entry->parents = realloc (entry->parents,
|
||||
(entry->n_parents + 2) * sizeof (char *));
|
||||
}
|
||||
entry->parents[entry->n_parents - 1] = strdup (sep);
|
||||
entry->parents[entry->n_parents] = NULL;
|
||||
}
|
||||
|
||||
list->parents = realloc (list->parents,
|
||||
list->n_mimes * sizeof (XdgMimeParents));
|
||||
|
||||
fclose (file);
|
||||
|
||||
if (list->n_mimes > 1)
|
||||
qsort (list->parents, list->n_mimes,
|
||||
sizeof (XdgMimeParents), &parent_entry_cmp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_parent_list_dump (XdgParentList *list)
|
||||
{
|
||||
int i;
|
||||
char **p;
|
||||
|
||||
if (list->parents)
|
||||
{
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
for (p = list->parents[i].parents; *p; p++)
|
||||
printf ("%s %s\n", list->parents[i].mime, *p);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,50 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeparent.h: Private file. Datastructure for storing the hierarchy.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 200 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_PARENT_H__
|
||||
#define __XDG_MIME_PARENT_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgParentList XdgParentList;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_parent_read_from_file XDG_ENTRY(parent_read_from_file)
|
||||
#define _xdg_mime_parent_list_new XDG_ENTRY(parent_list_new)
|
||||
#define _xdg_mime_parent_list_free XDG_ENTRY(parent_list_free)
|
||||
#define _xdg_mime_parent_list_lookup XDG_ENTRY(parent_list_lookup)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_parent_read_from_file (XdgParentList *list,
|
||||
const char *file_name);
|
||||
XdgParentList *_xdg_mime_parent_list_new (void);
|
||||
void _xdg_mime_parent_list_free (XdgParentList *list);
|
||||
const char **_xdg_mime_parent_list_lookup (XdgParentList *list,
|
||||
const char *mime);
|
||||
void _xdg_mime_parent_list_dump (XdgParentList *list);
|
||||
|
||||
#endif /* __XDG_MIME_PARENT_H__ */
|
||||
Loading…
Reference in New Issue