static void do_mount_tests (GDrive *drive, GVolume *volume, GMount *mount) { GDrive *d; GVolume *v; gchar *name; gchar *uuid; name = g_mount_get_name (mount); g_assert (name != NULL); g_free (name); v = g_mount_get_volume (mount); g_assert (v == volume); if (v != NULL) g_object_unref (v); d = g_mount_get_drive (mount); g_assert (d == drive); if (d != NULL) g_object_unref (d); uuid = g_mount_get_uuid (mount); if (uuid) { GMount *m; m = g_volume_monitor_get_mount_for_uuid (monitor, uuid); g_assert (m == mount); g_object_unref (m); g_free (uuid); } }
void on_mount_added(GVolumeMonitor* vm, GMount* mount, gpointer user_data) { FmPlacesModel* model = FM_PLACES_MODEL(user_data); GVolume* vol = g_mount_get_volume(mount); if(vol) { FmPlaceItem *item; GtkTreeIter it; item = find_vol(model, vol, &it); if(item && item->type == FM_PLACES_ITEM_VOL && !item->fi->path) { GtkTreePath* tp; GFile* gf = g_mount_get_root(mount); FmPath* path = fm_path_new_for_gfile(gf); g_debug("mount path: %s", path->name); g_object_unref(gf); fm_file_info_set_path(item->fi, path); if(path) fm_path_unref(path); item->vol_mounted = TRUE; /* inform the view to update mount indicator */ tp = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &it); gtk_tree_model_row_changed(GTK_TREE_MODEL(model), tp, &it); gtk_tree_path_free(tp); } g_object_unref(vol); } }
static RBSource * create_source_cb (RBRemovableMediaManager *rmm, GMount *mount, MPIDDevice *device_info, RBAudioCdPlugin *plugin) { RBSource *source = NULL; GVolume *volume = NULL; if (rb_audiocd_is_mount_audiocd (mount)) { volume = g_mount_get_volume (mount); if (volume != NULL) { source = RB_SOURCE (rb_audiocd_source_new (RB_PLUGIN (plugin), plugin->shell, volume)); g_object_unref (volume); } } if (source != NULL) { g_hash_table_insert (plugin->sources, g_object_ref (volume), g_object_ref (source)); g_signal_connect_object (G_OBJECT (source), "deleted", G_CALLBACK (rb_audiocd_plugin_source_deleted), plugin, 0); } return source; }
static void test_mounts (void) { GList *mounts, *l; mounts = g_volume_monitor_get_mounts (monitor); for (l = mounts; l; l = l->next) { GMount *mount = l->data; GVolume *volume; GDrive *drive; drive = g_mount_get_drive (mount); volume = g_mount_get_volume (mount); do_mount_tests (drive, volume, mount); if (drive != NULL) g_object_unref (drive); if (volume != NULL) g_object_unref (volume); } g_list_free_full (mounts, g_object_unref); }
static void unmount_done_cb (GObject *object, GAsyncResult *result, gpointer psource) { GMount *mount; RBMtpSource *source; gboolean ok; GError *error = NULL; RBMtpSourcePrivate *priv; mount = G_MOUNT (object); source = RB_MTP_SOURCE (psource); priv = MTP_SOURCE_GET_PRIVATE (source); ok = g_mount_unmount_with_operation_finish (mount, result, &error); if (ok) { rb_debug ("successfully unmounted mtp device"); priv->remount_volume = g_mount_get_volume (mount); open_device (source); } else { g_warning ("Unable to unmount MTP device: %s", error->message); g_error_free (error); } g_object_unref (mount); g_object_unref (source); }
void GioLister::MountChanged(GMount* mount) { QString id; { QMutexLocker l(&mutex_); id = FindUniqueIdByMount(mount); if (id.isNull()) return; g_object_ref(mount); DeviceInfo new_info; new_info.ReadMountInfo(mount); new_info.ReadVolumeInfo(g_mount_get_volume(mount)); new_info.ReadDriveInfo(g_mount_get_drive(mount)); // Ignore the change if the new info is useless if (new_info.invalid_enclosing_mount || (devices_[id].filesystem_size != 0 && new_info.filesystem_size == 0) || (!devices_[id].filesystem_type.isEmpty() && new_info.filesystem_type.isEmpty())) return; devices_[id] = new_info; } emit DeviceChanged(id); }
static gboolean ignore_mount (GMount *mount) { GFile *root; GVolume *volume; gboolean ret = TRUE; root = g_mount_get_root (mount); if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) { /* We don't add Audio CDs, or blank media */ g_object_unref (root); GRL_DEBUG ("%s: Not adding mount %s as is burn or cdda", __FUNCTION__, g_mount_get_name (mount)); return TRUE; } g_object_unref (root); volume = g_mount_get_volume (mount); if (volume == NULL) return ret; ret = ignore_volume (volume); g_object_unref (volume); return ret; }
ASVolume *ASVolume_newGMount (GMount *g_m) { ASVolume *v; if (g_m == NULL || g_mount_is_shadowed (g_m)) return NULL; else { GVolume *volume = g_mount_get_volume (g_m); if (volume) { g_object_unref (volume); return NULL; } } v = ASVolume_create(); v->gMount = g_m; v->name = g_mount_get_name (v->gMount); if (g_mount_can_eject (g_m)) set_flags (v->flags, ASVolume_Ejectable); set_flags (v->flags, ASVolume_Mounted); v->icon = g_mount_get_icon (g_m); ASVolume_parseGnomeIconString (v); { char *mount_str = ASVolume_toString(v); show_activity("%s\n", mount_str); safefree(mount_str); } return v; }
static void rb_removable_media_manager_add_mount (RBRemovableMediaManager *mgr, GMount *mount) { RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr); RBSource *source = NULL; GVolume *volume; GFile *mount_root; char *mountpoint; MPIDDevice *device_info; g_assert (mount != NULL); if (g_hash_table_lookup (priv->mount_mapping, mount) != NULL) { return; } if (g_mount_is_shadowed (mount) != FALSE) { return; } volume = g_mount_get_volume (mount); if (volume == NULL) { rb_debug ("Unhandled media, no volume for mount"); return; } /* if we've already created a source for the volume, * don't do anything with the mount. */ if (g_hash_table_lookup (priv->volume_mapping, volume) != NULL) { rb_debug ("already created a source for the volume, so ignoring the mount"); g_object_unref (volume); return; } dump_volume_identifiers (volume); g_object_unref (volume); /* look the device up in the device info database */ mount_root = g_mount_get_root (mount); if (mount_root == NULL) { rb_debug ("unable to get mount root, can't create a source for this mount"); return; } mountpoint = g_file_get_path (mount_root); g_object_unref (mount_root); device_info = mpid_device_new (mountpoint); g_free (mountpoint); g_signal_emit (G_OBJECT (mgr), rb_removable_media_manager_signals[CREATE_SOURCE_MOUNT], 0, mount, device_info, &source); if (source) { g_hash_table_insert (priv->mount_mapping, mount, source); rb_removable_media_manager_append_media_source (mgr, source); } else { rb_debug ("Unhandled media"); } g_object_unref (device_info); }
// -------------------------------------------------------------------------------- // void guGIO_VolumeMonitor::OnMountAdded( GMount * mount ) { guLogMessage( wxT( "Mount Added..." ) ); if( FindMount( mount ) == wxNOT_FOUND ) { if( g_mount_is_shadowed( mount ) ) { //g_object_unref( mount ); guLogMessage( wxT( "ignored shadowed mount" ) ); return; } GVolume * Volume = g_mount_get_volume( mount ); if( !Volume ) { guLogMessage( wxT( "mount without volume?" ) ); //g_object_unref( mount ); return; } g_object_unref( Volume ); GFile * MountRoot = g_mount_get_root( mount ); if( MountRoot ) { char * mount_path = g_file_get_path( MountRoot ); if( mount_path ) { wxString MountPath = wxString( mount_path, wxConvUTF8 ); guGIO_Mount * Mount = new guGIO_Mount( mount, MountPath ); if( Mount ) { m_MountedVolumes->Add( Mount ); wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_VOLUMEMANAGER_MOUNT_CHANGED ); event.SetInt( 1 ); wxPostEvent( m_MainFrame, event ); } g_free( mount_path ); } g_object_unref( MountRoot ); } else { guLogMessage( wxT( "ignored mount without mount root" ) ); g_object_unref( mount ); return; } } else { guLogMessage( wxT( "Mount already added?" ) ); } }
static void debug_device_info (RBGenericPlayerSource *source, GMount *mount, const char *what) { char *dbg; char *path; RBGenericPlayerSourcePrivate *priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source); GVolume *volume; volume = g_mount_get_volume (mount); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); rb_debug ("device information for %s from %s", path, what); g_free (path); g_object_unref (volume); if (priv->audio_folders != NULL) { dbg = g_strjoinv (", ", priv->audio_folders); rb_debug ("audio folders: %s", dbg); g_free (dbg); } else { rb_debug ("no audio folders set"); } if (priv->output_mime_types != NULL) { dbg = g_strjoinv (", ", priv->output_mime_types); rb_debug ("output types: %s", dbg); g_free (dbg); } else { rb_debug ("no output types set"); } if (priv->playlist_format_unknown) { rb_debug ("playlist format is unknown"); } else { if (priv->playlist_format_m3u) rb_debug ("M3U playlist format is supported"); if (priv->playlist_format_pls) rb_debug ("PLS playlist format is supported"); if (priv->playlist_format_iriver_pla) rb_debug ("iRiver PLA playlist format is supported"); } if (priv->playlist_path != NULL) { rb_debug ("playlist path: %s", priv->playlist_path); } else { rb_debug ("no playlist path is set"); } if (priv->folder_depth == -1) { rb_debug ("audio folder depth is not set"); } else { rb_debug ("audio folder depth: %d", priv->folder_depth); } }
gboolean rb_nokia770_is_mount_player (GMount *mount) { gboolean result; GVolume *volume; volume = g_mount_get_volume (mount); if (volume == NULL) return FALSE; result = volume_is_nokia770 (volume); g_object_unref (volume); return result; }
static void on_mount_added(GObject* vm, GMount* mount, GtkWidget* window) { GFile* usb_root; GVolume* volume = g_mount_get_volume(mount); if (is_sdb(volume)) { usb_root = g_mount_get_root(mount); printf("USB drive plugged in.\n"); } g_object_unref(volume); if (usb_root != NULL) { g_signal_handlers_disconnect_by_func(vm, G_CALLBACK(on_mount_added), NULL); g_signal_connect(vm, "mount-removed", G_CALLBACK(on_mount_removed), NULL); gtk_window_close(GTK_WINDOW(window)); start_gui(usb_root); } }
RBRemovableMediaSource * rb_generic_player_source_new (RBShell *shell, GMount *mount) { RBGenericPlayerSource *source; RhythmDBEntryType entry_type; RhythmDBEntryType error_type; RhythmDBEntryType ignore_type; RhythmDB *db; GVolume *volume; char *name; char *path; g_assert (rb_generic_player_is_mount_player (mount)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("generic audio player: %s", path); entry_type = rhythmdb_entry_register_type (db, name); g_free (name); name = g_strdup_printf ("generic audio player (ignore): %s", path); ignore_type = rhythmdb_entry_register_type (db, name); g_free (name); name = g_strdup_printf ("generic audio player (errors): %s", path); error_type = rhythmdb_entry_register_type (db, name); g_free (name); g_object_unref (db); g_object_unref (volume); g_free (path); source = RB_GENERIC_PLAYER_SOURCE (g_object_new (RB_TYPE_GENERIC_PLAYER_SOURCE, "entry-type", entry_type, "ignore-entry-type", ignore_type, "error-entry-type", error_type, "mount", mount, "shell", shell, "source-group", RB_SOURCE_GROUP_DEVICES, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_REMOVABLE_MEDIA_SOURCE (source); }
char * rb_ipod_helpers_get_device (RBSource *source) { GMount *mount; GVolume *volume; char *device; g_object_get (RB_SOURCE (source), "mount", &mount, NULL); volume = g_mount_get_volume (mount); device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (G_OBJECT (volume)); g_object_unref (G_OBJECT (mount)); return device; }
static GMount * find_mount_for_device (GUdevDevice *device) { GMount *mount = NULL; const char *device_file; GVolumeMonitor *volmon; GList *mounts; GList *i; device_file = g_udev_device_get_device_file (device); if (device_file == NULL) { return NULL; } volmon = g_volume_monitor_get (); mounts = g_volume_monitor_get_mounts (volmon); g_object_unref (volmon); for (i = mounts; i != NULL; i = i->next) { GVolume *v; v = g_mount_get_volume (G_MOUNT (i->data)); if (v != NULL) { char *devname = NULL; gboolean match; devname = g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (v); if (devname == NULL) continue; match = g_str_equal (devname, device_file); g_free (devname); if (match) { mount = G_MOUNT (i->data); g_object_ref (G_OBJECT (mount)); break; } } } g_list_foreach (mounts, (GFunc)g_object_unref, NULL); g_list_free (mounts); return mount; }
void GioLister::MountAdded(GMount* mount) { g_object_ref(mount); DeviceInfo info; info.ReadVolumeInfo(g_mount_get_volume(mount)); #ifdef HAVE_AUDIOCD if (info.volume_root_uri.startsWith("cdda")) // Audio CD devices are already handled by CDDA lister return; #endif info.ReadMountInfo(mount); info.ReadDriveInfo(g_mount_get_drive(mount)); if (!info.is_suitable()) return; QString old_id; { QMutexLocker l(&mutex_); // The volume might already exist - either mounted or unmounted. foreach (const QString& id, devices_.keys()) { if (devices_[id].volume == info.volume) { old_id = id; break; } } if (!old_id.isEmpty() && old_id != info.unique_id()) { // If the ID has changed (for example, after it's been mounted), we need // to remove the old device. devices_.remove(old_id); emit DeviceRemoved(old_id); old_id = QString(); } devices_[info.unique_id()] = info; } if (!old_id.isEmpty()) emit DeviceChanged(old_id); else { emit DeviceAdded(info.unique_id()); } }
static gboolean should_autorun_mount (GMount *mount) { GFile *root; GVolume *enclosing_volume; gboolean ignore_autorun; ignore_autorun = TRUE; enclosing_volume = g_mount_get_volume (mount); if (enclosing_volume != NULL) { if (g_object_get_data (G_OBJECT (enclosing_volume), "caja-allow-autorun") != NULL) { ignore_autorun = FALSE; g_object_set_data (G_OBJECT (enclosing_volume), "caja-allow-autorun", NULL); } } if (ignore_autorun) { if (enclosing_volume != NULL) { g_object_unref (enclosing_volume); } return FALSE; } root = g_mount_get_root (mount); /* only do autorun on local files or files where g_volume_should_automount() returns TRUE */ ignore_autorun = TRUE; if ((g_file_is_native (root) && !should_skip_native_mount_root (root)) || (enclosing_volume != NULL && g_volume_should_automount (enclosing_volume))) { ignore_autorun = FALSE; } if (enclosing_volume != NULL) { g_object_unref (enclosing_volume); } g_object_unref (root); return !ignore_autorun; }
static gchar * get_device_path (NemoAction *action, NemoFile *file) { GMount *mount = nemo_file_get_mount (file); GVolume *volume = g_mount_get_volume (mount); gchar *ret = NULL; if (action->escape_space) { gchar *id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); ret = eel_str_escape_spaces (id); g_free (id); } else { ret = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); } g_object_unref (mount); g_object_unref (volume); return ret; }
RBSource * rb_psp_source_new (GObject *plugin, RBShell *shell, GMount *mount, MPIDDevice *device_info) { RBPspSource *source; RhythmDBEntryType *entry_type; RhythmDB *db; char *name; char *path; GVolume *volume; g_assert (rb_psp_is_mount_player (mount, device_info)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("psp: %s", path); entry_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE, "db", db, "name", name, "save-to-disk", FALSE, "category", RHYTHMDB_ENTRY_NORMAL, NULL); rhythmdb_register_entry_type (db, entry_type); g_object_unref (db); g_free (name); g_free (path); g_object_unref (volume); source = RB_PSP_SOURCE (g_object_new (RB_TYPE_PSP_SOURCE, "plugin", plugin, "entry-type", entry_type, "mount", mount, "shell", shell, "device-info", device_info, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_SOURCE (source); }
RBRemovableMediaSource * rb_nokia770_source_new (RBPlugin *plugin, RBShell *shell, GMount *mount, MPIDDevice *device_info) { RBNokia770Source *source; RhythmDBEntryType entry_type; RhythmDB *db; GVolume *volume; char *name; char *path; g_assert (rb_nokia770_is_mount_player (mount, device_info)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("nokia770: %s", path); entry_type = rhythmdb_entry_register_type (db, name); g_object_unref (db); g_free (name); g_free (path); g_object_unref (volume); source = RB_NOKIA770_SOURCE (g_object_new (RB_TYPE_NOKIA770_SOURCE, "plugin", plugin, "entry-type", entry_type, "ignore-entry-type", RHYTHMDB_ENTRY_TYPE_INVALID, "error-entry-type", RHYTHMDB_ENTRY_TYPE_INVALID, "mount", mount, "shell", shell, "source-group", RB_SOURCE_GROUP_DEVICES, "device-info", device_info, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_REMOVABLE_MEDIA_SOURCE (source); }
Gio_mount::Gio_mount(GMount *src) { char* p_name = g_mount_get_name(src); name = QString::fromLocal8Bit(p_name); g_free(p_name); GFile* file = g_mount_get_root(src); char* p_path = g_file_get_path(file); if (p_path) { path = QString::fromLocal8Bit(p_path); g_free(p_path); } char* p_uri = g_file_get_uri(file); if (p_uri) { uri = QString::fromLocal8Bit(p_uri); g_free(p_uri); } g_object_unref(file); file = g_mount_get_default_location(src); char* p_dl = g_file_get_uri(file); if (p_dl) { default_location = QString::fromLocal8Bit(p_dl); g_free(p_dl); } GVolume* volume = g_mount_get_volume(src); if (volume) { g_object_unref(volume); default_location = path; uri = path; } //qDebug() << "path" << path; //qDebug() << "default_location" << default_location; //qDebug() << "uri" << uri; uri = Directory::canonize(uri); default_location = Directory::canonize(default_location); g_object_unref(file); }
static void mount_add (TrackerStorage *storage, GMount *mount) { TrackerStoragePrivate *priv; GFile *root; GVolume *volume; gchar *mount_name, *mount_path, *uuid; gboolean is_optical = FALSE; gboolean is_removable = FALSE; /* Get mount name */ mount_name = g_mount_get_name (mount); /* Get root path of the mount */ root = g_mount_get_root (mount); mount_path = g_file_get_path (root); g_debug ("Found '%s' mounted on path '%s'", mount_name, mount_path); /* Do not process shadowed mounts! */ if (g_mount_is_shadowed (mount)) { g_debug (" Skipping shadowed mount '%s'", mount_name); g_object_unref (root); g_free (mount_path); g_free (mount_name); return; } priv = TRACKER_STORAGE_GET_PRIVATE (storage); /* fstab partitions may not have corresponding * GVolumes, so volume may be NULL */ volume = g_mount_get_volume (mount); if (volume) { /* GMount with GVolume */ /* Try to get UUID from the Volume. * Note that g_volume_get_uuid() is NOT equivalent */ uuid = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UUID); if (!uuid) { gchar *content_type; gboolean is_multimedia; gboolean is_blank; /* Optical discs usually won't have UUID in the GVolume */ content_type = mount_guess_content_type (mount, &is_optical, &is_multimedia, &is_blank); is_removable = TRUE; /* We don't index content which is video, music or blank */ if (!is_multimedia && !is_blank) { uuid = g_compute_checksum_for_string (G_CHECKSUM_MD5, mount_name, -1); g_debug (" No UUID, generated:'%s' (based on mount name)", uuid); g_debug (" Assuming GVolume has removable media, if wrong report a bug! " "content type is '%s'", content_type); } else { g_debug (" Being ignored because mount with volume is music/video/blank " "(content type:%s, optical:%s, multimedia:%s, blank:%s)", content_type, is_optical ? "yes" : "no", is_multimedia ? "yes" : "no", is_blank ? "yes" : "no"); } g_free (content_type); } else { /* Any other removable media will have UUID in the * GVolume. Note that this also may include some * partitions in the machine which have GVolumes * associated to the GMounts. We also check a drive * exists to be sure the device is local. */ GDrive *drive; drive = g_volume_get_drive (volume); if (drive) { /* We can't mount/unmount system volumes, so tag * them as non removable. */ is_removable = g_volume_can_mount (volume); g_debug (" Found mount with volume and drive which %s be mounted: " "Assuming it's %s removable, if wrong report a bug!", is_removable ? "can" : "cannot", is_removable ? "" : "not"); g_object_unref (drive); } else { /* Note: not sure when this can happen... */ g_debug (" Mount with volume but no drive, " "assuming not a removable device, " "if wrong report a bug!"); is_removable = FALSE; } } g_object_unref (volume); } else { /* GMount without GVolume. * Note: Never found a case where this g_mount_get_uuid() returns * non-NULL... :-) */ uuid = g_mount_get_uuid (mount); if (!uuid) { if (mount_path) { gchar *content_type; gboolean is_multimedia; gboolean is_blank; content_type = mount_guess_content_type (mount, &is_optical, &is_multimedia, &is_blank); /* Note: for GMounts without GVolume, is_blank should NOT be considered, * as it may give unwanted results... */ if (!is_multimedia) { uuid = g_compute_checksum_for_string (G_CHECKSUM_MD5, mount_path, -1); g_debug (" No UUID, generated:'%s' (based on mount path)", uuid); } else { g_debug (" Being ignored because mount is music/video " "(content type:%s, optical:%s, multimedia:%s)", content_type, is_optical ? "yes" : "no", is_multimedia ? "yes" : "no"); } g_free (content_type); } else { g_debug (" Being ignored because mount has no GVolume (i.e. not user mountable) " "and has no mount root path available"); } } } /* If we got something to be used as UUID, then add the mount * to the TrackerStorage */ if (uuid && mount_path && !g_hash_table_lookup (priv->mounts_by_uuid, uuid)) { g_debug (" Adding mount point with UUID: '%s', removable: %s, optical: %s, path: '%s'", uuid, is_removable ? "yes" : "no", is_optical ? "yes" : "no", mount_path); mount_add_new (storage, uuid, mount_path, mount_name, is_removable, is_optical); } else { g_debug (" Skipping mount point with UUID: '%s', path: '%s', already managed: '%s'", uuid ? uuid : "none", mount_path ? mount_path : "none", (uuid && g_hash_table_lookup (priv->mounts_by_uuid, uuid)) ? "yes" : "no"); } g_free (mount_name); g_free (mount_path); g_free (uuid); g_object_unref (root); }
static void list_mounts (GList *mounts, int indent, gboolean only_with_no_volume) { GList *l; int c; GMount *mount; GVolume *volume; char *name, *uuid, *uri; GFile *root, *default_location; GIcon *icon; char **x_content_types; char *type_name; const gchar *sort_key; for (c = 0, l = mounts; l != NULL; l = l->next, c++) { mount = (GMount *) l->data; if (only_with_no_volume) { volume = g_mount_get_volume (mount); if (volume != NULL) { g_object_unref (volume); continue; } } name = g_mount_get_name (mount); root = g_mount_get_root (mount); uri = g_file_get_uri (root); g_print ("%*sMount(%d): %s -> %s\n", indent, "", c, name, uri); type_name = get_type_name (mount); g_print ("%*sType: %s\n", indent+2, "", type_name); g_free (type_name); if (extra_detail) { uuid = g_mount_get_uuid (mount); if (uuid) g_print ("%*suuid=%s\n", indent + 2, "", uuid); default_location = g_mount_get_default_location (mount); if (default_location) { char *loc_uri = g_file_get_uri (default_location); g_print ("%*sdefault_location=%s\n", indent + 2, "", loc_uri); g_free (loc_uri); g_object_unref (default_location); } icon = g_mount_get_icon (mount); if (icon) { if (G_IS_THEMED_ICON (icon)) show_themed_icon_names (G_THEMED_ICON (icon), indent + 2); g_object_unref (icon); } x_content_types = g_mount_guess_content_type_sync (mount, FALSE, NULL, NULL); if (x_content_types != NULL && g_strv_length (x_content_types) > 0) { int n; g_print ("%*sx_content_types:", indent + 2, ""); for (n = 0; x_content_types[n] != NULL; n++) g_print (" %s", x_content_types[n]); g_print ("\n"); } g_strfreev (x_content_types); g_print ("%*scan_unmount=%d\n", indent + 2, "", g_mount_can_unmount (mount)); g_print ("%*scan_eject=%d\n", indent + 2, "", g_mount_can_eject (mount)); g_print ("%*sis_shadowed=%d\n", indent + 2, "", g_mount_is_shadowed (mount)); sort_key = g_mount_get_sort_key (mount); if (sort_key != NULL) g_print ("%*ssort_key=%s\n", indent + 2, "", sort_key); g_free (uuid); } g_object_unref (root); g_free (name); g_free (uri); } }
/* this is loosely based on update_places() from caja-places-sidebar.c */ static void panel_place_menu_item_append_remote_gio (PanelPlaceMenuItem *place_item, GtkWidget *menu) { GtkWidget *add_menu; GList *mounts, *l; GMount *mount; GSList *add_mounts, *sl; /* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */ mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor); add_mounts = NULL; for (l = mounts; l; l = l->next) { GVolume *volume; GFile *root; mount = l->data; if (g_mount_is_shadowed (mount)) { g_object_unref (mount); continue; } volume = g_mount_get_volume (mount); if (volume != NULL) { g_object_unref (volume); g_object_unref (mount); continue; } root = g_mount_get_root (mount); if (g_file_is_native (root)) { g_object_unref (root); g_object_unref (mount); continue; } g_object_unref (root); add_mounts = g_slist_prepend (add_mounts, mount); } add_mounts = g_slist_reverse (add_mounts); if (g_slist_length (add_mounts) <= MAX_ITEMS_OR_SUBMENU) { add_menu = menu; } else { GtkWidget *item; item = panel_image_menu_item_new (); setup_menu_item_with_icon (item, panel_menu_icon_get_size (), PANEL_ICON_NETWORK_SERVER, NULL, NULL, _("Network Places")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); add_menu = create_empty_menu (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu); } for (sl = add_mounts; sl; sl = sl->next) { mount = sl->data; panel_menu_item_append_mount (add_menu, mount); g_object_unref (mount); } g_slist_free (add_mounts); g_list_free (mounts); }
/* this is loosely based on update_places() from caja-places-sidebar.c */ static void panel_place_menu_item_append_local_gio (PanelPlaceMenuItem *place_item, GtkWidget *menu) { GList *l; GList *ll; GList *drives; GDrive *drive; GList *volumes; GVolume *volume; GList *mounts; GMount *mount; GSList *items; GSList *sl; PanelGioItem *item; GtkWidget *add_menu; items = NULL; /* first go through all connected drives */ drives = g_volume_monitor_get_connected_drives (place_item->priv->volume_monitor); for (l = drives; l != NULL; l = l->next) { drive = l->data; volumes = g_drive_get_volumes (drive); if (volumes != NULL) { for (ll = volumes; ll != NULL; ll = ll->next) { volume = ll->data; mount = g_volume_get_mount (volume); item = g_slice_new (PanelGioItem); if (mount != NULL) { item->type = PANEL_GIO_MOUNT; item->u.mount = mount; } else { /* Do show the unmounted volumes; this * is so the user can mount it (in case * automounting is off). * * Also, even if automounting is * enabled, this gives a visual cue * that the user should remember to * yank out the media if he just * unmounted it. */ item->type = PANEL_GIO_VOLUME; item->u.volume = g_object_ref (volume); } items = g_slist_prepend (items, item); g_object_unref (volume); } g_list_free (volumes); } else { if (g_drive_is_media_removable (drive) && !g_drive_is_media_check_automatic (drive)) { /* If the drive has no mountable volumes and we * cannot detect media change.. we display the * drive so the user can manually poll the * drive by clicking on it..." * * This is mainly for drives like floppies * where media detection doesn't work.. but * it's also for human beings who like to turn * off media detection in the OS to save * battery juice. */ item = g_slice_new (PanelGioItem); item->type = PANEL_GIO_DRIVE; item->u.drive = g_object_ref (drive); items = g_slist_prepend (items, item); } } g_object_unref (drive); } g_list_free (drives); /* add all volumes that is not associated with a drive */ volumes = g_volume_monitor_get_volumes (place_item->priv->volume_monitor); for (l = volumes; l != NULL; l = l->next) { volume = l->data; drive = g_volume_get_drive (volume); if (drive != NULL) { g_object_unref (volume); g_object_unref (drive); continue; } mount = g_volume_get_mount (volume); item = g_slice_new (PanelGioItem); if (mount != NULL) { item->type = PANEL_GIO_MOUNT; item->u.mount = mount; } else { /* see comment above in why we add an icon for an * unmounted mountable volume */ item->type = PANEL_GIO_VOLUME; item->u.volume = g_object_ref (volume); } items = g_slist_prepend (items, item); g_object_unref (volume); } g_list_free (volumes); /* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */ mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor); for (l = mounts; l != NULL; l = l->next) { GFile *root; mount = l->data; if (g_mount_is_shadowed (mount)) { g_object_unref (mount); continue; } volume = g_mount_get_volume (mount); if (volume != NULL) { g_object_unref (volume); g_object_unref (mount); continue; } root = g_mount_get_root (mount); if (!g_file_is_native (root)) { g_object_unref (root); g_object_unref (mount); continue; } g_object_unref (root); item = g_slice_new (PanelGioItem); item->type = PANEL_GIO_MOUNT; item->u.mount = mount; items = g_slist_prepend (items, item); } g_list_free (mounts); /* now that we have everything, add the items inline or in a submenu */ items = g_slist_reverse (items); if (g_slist_length (items) <= MAX_ITEMS_OR_SUBMENU) { add_menu = menu; } else { GtkWidget *item; item = gtk_image_menu_item_new (); setup_menu_item_with_icon (item, panel_menu_icon_get_size (), PANEL_ICON_REMOVABLE_MEDIA, NULL, NULL, _("Removable Media")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); add_menu = create_empty_menu (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu); } for (sl = items; sl; sl = sl->next) { item = sl->data; switch (item->type) { case PANEL_GIO_DRIVE: panel_menu_item_append_drive (add_menu, item->u.drive); g_object_unref (item->u.drive); break; case PANEL_GIO_VOLUME: panel_menu_item_append_volume (add_menu, item->u.volume); g_object_unref (item->u.volume); break; case PANEL_GIO_MOUNT: panel_menu_item_append_mount (add_menu, item->u.mount); g_object_unref (item->u.mount); break; default: g_assert_not_reached (); } g_slice_free (PanelGioItem, item); } g_slist_free (items); }
/** * rb_device_source_want_uri: * @source: a #RBDeviceSource * @uri: a URI to consider * * Checks whether @uri identifies a path underneath the * device's mount point. Should be used to implement * the #RBSource impl_want_uri method. * * Return value: URI match strength */ int rb_device_source_want_uri (RBDeviceSource *source, const char *uri) { GMount *mount = NULL; GVolume *volume = NULL; GFile *file; char *device_path, *uri_path; int retval; int len; retval = 0; /* ignore anything that isn't a local file */ file = g_file_new_for_uri (uri); if (g_file_has_uri_scheme (file, "file") == FALSE) { g_object_unref (file); return 0; } /* Deal with the mount root being passed, eg. file:///media/IPODNAME */ if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "mount")) { g_object_get (source, "mount", &volume, NULL); } if (mount != NULL) { GFile *root; root = g_mount_get_root (mount); retval = g_file_equal (root, file) ? 100 : 0; g_object_unref (root); if (retval) { g_object_unref (file); g_object_unref (mount); return retval; } volume = g_mount_get_volume (mount); g_object_unref (mount); } else { if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "volume")) { g_object_get (source, "volume", &volume, NULL); } } if (volume == NULL) { g_object_unref (file); return 0; } /* Deal with the path to the device node being passed */ device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (volume); if (device_path == NULL) { g_object_unref (file); return 0; } uri_path = g_file_get_path (file); g_object_unref (file); if (uri_path == NULL) return 0; len = strlen (uri_path); if (uri_path[len - 1] == '/') { if (strncmp (uri_path, device_path, len - 1) == 0) { retval = 100; } } else if (strcmp (uri_path, device_path) == 0) { retval = 100; } g_free (device_path); g_free (uri_path); return retval; }
RBSource * rb_generic_player_source_new (GObject *plugin, RBShell *shell, GMount *mount, MPIDDevice *device_info) { RBGenericPlayerSource *source; RhythmDBEntryType *entry_type; RhythmDBEntryType *error_type; RhythmDBEntryType *ignore_type; RhythmDB *db; GVolume *volume; GSettings *settings; char *name; char *path; volume = g_mount_get_volume (mount); g_object_get (shell, "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("generic audio player: %s", path); entry_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE, "db", db, "name", name, "save-to-disk", FALSE, "category", RHYTHMDB_ENTRY_NORMAL, NULL); rhythmdb_register_entry_type (db, entry_type); g_free (name); name = g_strdup_printf ("generic audio player (ignore): %s", path); ignore_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE, "db", db, "name", name, "save-to-disk", FALSE, "category", RHYTHMDB_ENTRY_VIRTUAL, NULL); rhythmdb_register_entry_type (db, ignore_type); g_free (name); name = g_strdup_printf ("generic audio player (errors): %s", path); error_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE, "db", db, "name", name, "save-to-disk", FALSE, "category", RHYTHMDB_ENTRY_VIRTUAL, NULL); rhythmdb_register_entry_type (db, error_type); g_free (name); g_object_unref (db); g_object_unref (volume); g_free (path); settings = g_settings_new ("org.gnome.rhythmbox.plugins.generic-player"); source = RB_GENERIC_PLAYER_SOURCE (g_object_new (RB_TYPE_GENERIC_PLAYER_SOURCE, "plugin", plugin, "entry-type", entry_type, "ignore-entry-type", ignore_type, "error-entry-type", error_type, "mount", mount, "shell", shell, "device-info", device_info, "load-status", RB_SOURCE_LOAD_STATUS_LOADING, "settings", g_settings_get_child (settings, "source"), "toolbar-path", "/GenericPlayerSourceToolBar", NULL)); g_object_unref (settings); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_SOURCE (source); }
static gchar * mount_guess_content_type (GMount *mount, gboolean *is_optical, gboolean *is_multimedia, gboolean *is_blank) { gchar *content_type = NULL; gchar **guess_type; *is_optical = FALSE; *is_multimedia = FALSE; *is_blank = FALSE; /* This function has 2 purposes: * * 1. Detect if we are using optical media * 2. Detect if we are video or music, we can't index those types * * We try to determine the content type because we don't want * to store Volume information in Tracker about DVDs and media * which has no real data for us to mine. * * Generally, if is_multimedia is TRUE then we end up ignoring * the media. */ guess_type = g_mount_guess_content_type_sync (mount, TRUE, NULL, NULL); if (guess_type) { gint i = 0; while (!content_type && guess_type[i]) { if (!g_strcmp0 (guess_type[i], "x-content/image-picturecd")) { /* Images */ content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/video-bluray") || !g_strcmp0 (guess_type[i], "x-content/video-dvd") || !g_strcmp0 (guess_type[i], "x-content/video-hddvd") || !g_strcmp0 (guess_type[i], "x-content/video-svcd") || !g_strcmp0 (guess_type[i], "x-content/video-vcd")) { /* Videos */ *is_multimedia = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/audio-cdda") || !g_strcmp0 (guess_type[i], "x-content/audio-dvd") || !g_strcmp0 (guess_type[i], "x-content/audio-player")) { /* Audios */ *is_multimedia = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/blank-bd") || !g_strcmp0 (guess_type[i], "x-content/blank-cd") || !g_strcmp0 (guess_type[i], "x-content/blank-dvd") || !g_strcmp0 (guess_type[i], "x-content/blank-hddvd")) { /* Blank */ *is_blank = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/software") || !g_strcmp0 (guess_type[i], "x-content/unix-software") || !g_strcmp0 (guess_type[i], "x-content/win32-software")) { /* NOTE: This one is a guess, can we * have this content type on * none-optical mount points? */ content_type = g_strdup (guess_type[i]); } else { /* else, keep on with the next guess, if any */ i++; } } /* If we didn't have an exact match on possible guessed content types, * then use the first one returned (best guess always first) if any */ if (!content_type && guess_type[0]) { content_type = g_strdup (guess_type[0]); } g_strfreev (guess_type); } if (content_type) { if (strstr (content_type, "vcd") || strstr (content_type, "cdda") || strstr (content_type, "dvd") || strstr (content_type, "bluray")) { *is_optical = TRUE; } } else { GUnixMountEntry *entry; gchar *mount_path; GFile *mount_root; /* No content type was guessed, try to find out * at least whether it's an optical media or not */ mount_root = g_mount_get_root (mount); mount_path = g_file_get_path (mount_root); /* FIXME: Try to assume we have a unix mount :( * EEK, once in a while, I have to write crack, oh well */ if (mount_path && (entry = g_unix_mount_at (mount_path, NULL)) != NULL) { const gchar *filesystem_type; gchar *device_path = NULL; GVolume *volume; volume = g_mount_get_volume (mount); filesystem_type = g_unix_mount_get_fs_type (entry); g_debug (" Using filesystem type:'%s'", filesystem_type); /* Volume may be NULL */ if (volume) { device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_debug (" Using device path:'%s'", device_path); g_object_unref (volume); } /* NOTE: This code was taken from guess_mount_type() * in GIO's gunixmounts.c and adapted purely for * guessing optical media. We don't use the guessing * code for other types such as MEMSTICKS, ZIPs, * IPODs, etc. * * This code may need updating over time since it is * very situational depending on how distributions * mount their devices and how devices are named in * /dev. */ if (strcmp (filesystem_type, "udf") == 0 || strcmp (filesystem_type, "iso9660") == 0 || strcmp (filesystem_type, "cd9660") == 0 || (device_path && (g_str_has_prefix (device_path, "/dev/cdrom") || g_str_has_prefix (device_path, "/dev/acd") || g_str_has_prefix (device_path, "/dev/cd")))) { *is_optical = TRUE; } else if (device_path && g_str_has_prefix (device_path, "/vol/")) { const gchar *name; name = mount_path + strlen ("/"); if (g_str_has_prefix (name, "cdrom")) { *is_optical = TRUE; } } else { gchar *basename = g_path_get_basename (mount_path); if (g_str_has_prefix (basename, "cdr") || g_str_has_prefix (basename, "cdwriter") || g_str_has_prefix (basename, "burn") || g_str_has_prefix (basename, "dvdr")) { *is_optical = TRUE; } g_free (basename); } g_free (device_path); g_free (mount_path); g_unix_mount_free (entry); } else { g_debug (" No GUnixMountEntry found, needed for detecting if optical media... :("); g_free (mount_path); } g_object_unref (mount_root); } return content_type; }
static VALUE rg_volume(VALUE self) { return GOBJ2RVAL_UNREF(g_mount_get_volume(_SELF(self))); }