NS_IMETHODIMP
nsGIOMimeApp::GetSupportedURISchemes(nsIUTF8StringEnumerator** aSchemes)
{
*aSchemes = nsnull;
nsRefPtr<GIOUTF8StringEnumerator> array = new GIOUTF8StringEnumerator();
NS_ENSURE_TRUE(array, NS_ERROR_OUT_OF_MEMORY);
GVfs *gvfs = g_vfs_get_default();
if (!gvfs) {
g_warning("Cannot get GVfs object.");
return NS_ERROR_OUT_OF_MEMORY;
}
const gchar* const * uri_schemes = g_vfs_get_supported_uri_schemes(gvfs);
while (*uri_schemes != NULL) {
if (!array->mStrings.AppendElement(*uri_schemes)) {
return NS_ERROR_OUT_OF_MEMORY;
}
uri_schemes++;
}
NS_ADDREF(*aSchemes = array);
return NS_OK;
}
NS_IMETHODIMP
nsGIOProtocolHandler::NewURI(const nsACString &aSpec,
const char *aOriginCharset,
nsIURI *aBaseURI,
nsIURI **aResult)
{
const nsCString flatSpec(aSpec);
LOG(("gio: NewURI [spec=%s]\n", flatSpec.get()));
if (!aBaseURI)
{
// XXX Is it good to support all GIO protocols?
if (!IsSupportedProtocol(flatSpec))
return NS_ERROR_UNKNOWN_PROTOCOL;
int32_t colon_location = flatSpec.FindChar(':');
if (colon_location <= 0)
return NS_ERROR_UNKNOWN_PROTOCOL;
// Verify that GIO supports this URI scheme.
bool uri_scheme_supported = false;
GVfs *gvfs = g_vfs_get_default();
if (!gvfs) {
g_warning("Cannot get GVfs object.");
return NS_ERROR_UNKNOWN_PROTOCOL;
}
const gchar* const * uri_schemes = g_vfs_get_supported_uri_schemes(gvfs);
while (*uri_schemes != nullptr) {
// While flatSpec ends with ':' the uri_scheme does not. Therefore do not
// compare last character.
if (StringHead(flatSpec, colon_location).Equals(*uri_schemes)) {
uri_scheme_supported = true;
break;
}
uri_schemes++;
}
if (!uri_scheme_supported) {
return NS_ERROR_UNKNOWN_PROTOCOL;
}
}
nsresult rv;
nsCOMPtr<nsIStandardURL> url =
do_CreateInstance(NS_STANDARDURL_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
rv = url->Init(nsIStandardURL::URLTYPE_STANDARD, -1, flatSpec,
aOriginCharset, aBaseURI);
if (NS_SUCCEEDED(rv))
rv = CallQueryInterface(url, aResult);
return rv;
}
// check if GVFS can support this uri scheme (lower case)
// NOTE: this does not work reliably due to some problems in gio/gvfs and causes bug lxde/lxqt#512
// https://github.com/lxde/lxqt/issues/512
// Use uriExists() whenever possible.
bool isUriSchemeSupported(const char* uriScheme) {
const gchar * const * schemes = g_vfs_get_supported_uri_schemes(g_vfs_get_default());
if(Q_UNLIKELY(schemes == NULL))
return false;
for(const gchar * const * scheme = schemes; *scheme; ++scheme)
if(strcmp(uriScheme, *scheme) == 0)
return true;
return false;
}
static gboolean
xmms_gvfs_plugin_setup (xmms_xform_plugin_t *xform_plugin)
{
GVfs *vfs;
const gchar * const *schemes, * const *i;
gint j;
xmms_xform_methods_t methods;
g_type_init ();
vfs = g_vfs_get_default ();
if (!g_vfs_is_active (vfs)) {
xmms_log_info ("GVfs not active - disabling gvfs transport");
return FALSE;
}
XMMS_XFORM_METHODS_INIT (methods);
methods.init = xmms_gvfs_init;
methods.destroy = xmms_gvfs_destroy;
methods.read = xmms_gvfs_read;
methods.seek = xmms_gvfs_seek;
methods.browse = xmms_gvfs_browse;
xmms_xform_plugin_methods_set (xform_plugin, &methods);
xmms_xform_plugin_indata_add (xform_plugin,
XMMS_STREAM_TYPE_MIMETYPE,
"application/x-url",
XMMS_STREAM_TYPE_URL,
"file://*",
XMMS_STREAM_TYPE_END);
schemes = g_vfs_get_supported_uri_schemes (vfs);
for (i = schemes; *i; i++) {
gchar *tmp = g_strconcat (*i, "://*", NULL);
gint priority = XMMS_STREAM_TYPE_PRIORITY_FALLBACK;
for (j = 0; j < G_N_ELEMENTS (scheme_priorities); j++) {
if (g_ascii_strcasecmp (scheme_priorities[j].scheme, *i) == 0) {
priority = scheme_priorities[j].priority;
}
}
xmms_xform_plugin_indata_add (xform_plugin,
XMMS_STREAM_TYPE_PRIORITY,
priority,
XMMS_STREAM_TYPE_MIMETYPE,
"application/x-url",
XMMS_STREAM_TYPE_URL,
tmp,
XMMS_STREAM_TYPE_END);
g_free (tmp);
}
return TRUE;
}
NS_IMETHODIMP
nsGIOProtocolHandler::NewURI(const nsACString &aSpec,
const char *aOriginCharset,
nsIURI *aBaseURI,
nsIURI **aResult)
{
const nsCString flatSpec(aSpec);
LOG(("gio: NewURI [spec=%s]\n", flatSpec.get()));
if (!aBaseURI)
{
// XXX Is it good to support all GIO protocols?
if (!IsSupportedProtocol(flatSpec))
return NS_ERROR_UNKNOWN_PROTOCOL;
int32_t colon_location = flatSpec.FindChar(':');
if (colon_location <= 0)
return NS_ERROR_UNKNOWN_PROTOCOL;
// Verify that GIO supports this URI scheme.
bool uri_scheme_supported = false;
GVfs *gvfs = g_vfs_get_default();
if (!gvfs) {
g_warning("Cannot get GVfs object.");
return NS_ERROR_UNKNOWN_PROTOCOL;
}
const gchar* const * uri_schemes = g_vfs_get_supported_uri_schemes(gvfs);
while (*uri_schemes != nullptr) {
// While flatSpec ends with ':' the uri_scheme does not. Therefore do not
// compare last character.
if (StringHead(flatSpec, colon_location).Equals(*uri_schemes)) {
uri_scheme_supported = true;
break;
}
uri_schemes++;
}
if (!uri_scheme_supported) {
return NS_ERROR_UNKNOWN_PROTOCOL;
}
}
return NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
.Apply<nsIStandardURLMutator>(&nsIStandardURLMutator::Init,
nsIStandardURL::URLTYPE_STANDARD, -1,
flatSpec, aOriginCharset, aBaseURI,
nullptr)
.Finalize(aResult);
}
static gchar *
get_protocols (void)
{
const gchar * const *schemes;
GString *string = g_string_new (NULL);
gint i;
schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
for (i = 0; schemes && schemes[i]; i++)
{
if (string->len > 0)
g_string_append_c (string, ',');
g_string_append (string, schemes[i]);
g_string_append_c (string, ':');
}
return g_string_free (string, FALSE);
}
static gboolean
is_supported_scheme (const char *scheme)
{
GVfs *vfs;
const gchar * const * schemes;
guint i;
if (scheme == NULL)
return FALSE;
vfs = g_vfs_get_default ();
schemes = g_vfs_get_supported_uri_schemes (vfs);
if (!schemes) {
return FALSE;
}
for (i = 0; schemes[i] != NULL; i++) {
if (g_str_equal (schemes[i], scheme))
return TRUE;
}
return FALSE;
}
static gboolean
have_burn_uri (void)
{
static gboolean initialized = FALSE;
static gboolean res;
GVfs *vfs;
int i;
const gchar * const * supported_uri_schemes;
if (!initialized) {
vfs = g_vfs_get_default ();
supported_uri_schemes = g_vfs_get_supported_uri_schemes (vfs);
res = FALSE;
for (i = 0; supported_uri_schemes != NULL && supported_uri_schemes[i] != NULL; i++) {
if (strcmp ("burn", supported_uri_schemes[i]) == 0) {
res = TRUE;
break;
}
}
initialized = TRUE;
}
return res;
}
static VALUE
vfs_get_supported_uri_schemes(VALUE self)
{
return STRVECTOR2ARY(g_vfs_get_supported_uri_schemes(_SELF(self)));
}
static gboolean
exo_open_uri (const gchar *uri,
GError **error)
{
GFile *file;
gchar *scheme;
GFileInfo *file_info;
gboolean succeed = FALSE;
gboolean retval = FALSE;
GFileType file_type;
const gchar *content_type;
GAppInfo *app_info;
gchar *path;
const gchar *executable;
GList fake_list;
const gchar * const *schemes;
GError *err = NULL;
guint i;
g_return_val_if_fail (uri != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
#ifndef NDEBUG
schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
scheme = g_strjoinv (", ", (gchar **) schemes);
g_debug ("vfs supported schemes: %s", scheme);
g_free (scheme);
#endif
file = g_file_new_for_uri (uri);
scheme = g_file_get_uri_scheme (file);
/* try to launch common schemes for know preferred applications */
if (scheme != NULL && exo_open_uri_known_category (uri, scheme, &retval))
{
g_free (scheme);
return retval;
}
/* handle the uri as a file, maybe we succeed... */
file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, &err);
if (file_info != NULL)
{
file_type = g_file_info_get_file_type (file_info);
if (file_type == G_FILE_TYPE_DIRECTORY)
{
#ifndef NDEBUG
g_debug ("file is directory, use filemanager");
#endif
/* directories should go fine with a file manager */
retval = exo_open_launch_category ("FileManager", uri);
succeed = TRUE;
}
else
{
content_type = g_file_info_get_content_type (file_info);
#ifndef NDEBUG
g_debug ("content type=%s", content_type);
#endif
if (G_LIKELY (content_type))
{
/* try to find a suitable application for this content type */
path = g_file_get_path (file);
app_info = g_app_info_get_default_for_type (content_type, path == NULL);
g_free (path);
if (app_info != NULL)
{
/* make sure we don't loop somehow */
executable = g_app_info_get_executable (app_info);
#ifndef NDEBUG
g_debug ("default executable=%s", executable);
#endif
if (executable == NULL
|| strcmp (executable, "exo-open") != 0)
{
fake_list.data = (gpointer) uri;
fake_list.prev = fake_list.next = NULL;
/* launch it */
retval = g_app_info_launch_uris (app_info, &fake_list, NULL, &err);
succeed = TRUE;
}
g_object_unref (G_OBJECT (app_info));
}
}
}
g_object_unref (G_OBJECT (file_info));
}
else if (err != NULL
&& scheme != NULL
&& err->code == G_IO_ERROR_NOT_MOUNTED)
{
/* check if the scheme is supported by gio */
schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
if (G_LIKELY (schemes != NULL))
{
for (i = 0; schemes[i] != NULL; i++)
{
/* found scheme, open in file manager */
if (strcmp (scheme, schemes[i]) == 0)
{
retval = succeed = exo_open_launch_category ("FileManager", uri);
break;
}
}
}
}
g_object_unref (G_OBJECT (file));
/* our last try... */
if (!succeed)
{
#ifndef NDEBUG
g_debug ("nothing worked, try ftp(s) or gtk_show_uri()");
#endif
/* try ftp uris if the file manager/gio failed to recognize it */
if (scheme != NULL
&& (strcmp (scheme, "ftp") == 0 || strcmp (scheme, "ftps") == 0))
retval = exo_open_launch_category ("WebBrowser", uri);
else
retval = gtk_show_uri (NULL, uri, 0, error);
}
g_free (scheme);
if (!retval && error != NULL)
*error = err;
else if (err != NULL)
g_error_free (err);
return retval;
}
