Attachment #1161 for bug #1199

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 1199
Collapse All | Expand All

Lines 32-37 Link Here

(-)kdebase/ksmserver/shutdowndlg.h.rhel4 (+3 lines)
32		32
33	#include <config.h>	33	#include <config.h>
34		34
		35	// RHEL 4 dirty hack to remove HAL support in ksmshutdown
		36	#undef COMPILE_HALBACKEND
		37
35	#ifndef NO_QT3_DBUS_SUPPORT	38	#ifndef NO_QT3_DBUS_SUPPORT
36	/* We acknowledge the the dbus API is unstable */	39	/* We acknowledge the the dbus API is unstable */
37	#define DBUS_API_SUBJECT_TO_CHANGE	40	#define DBUS_API_SUBJECT_TO_CHANGE




#include <kprocess.h>

#define MOUNT_SUFFIX    (                                                                       \
    (medium->isMounted() ? TQString("_mounted") : TQString("_unmounted"))   \
    (medium->isEncrypted() ? (halClearVolume ? "_decrypted" : "_encrypted") : "" )          \
    )
#define MOUNT_ICON_SUFFIX   (                                                              \
    (medium->isMounted() ? TQString("_mount") : TQString("_unmount"))   \
    (medium->isEncrypted() ? (halClearVolume ? "_decrypt" : "_encrypt") : "" )      \
    )

/* Static instance of this class, for static HAL callbacks */

{
    char*   _ppt_string;
    TQString _ppt_QString;
    _ppt_string = hal_device_get_property_string(ctx, udi, key);
    if ( _ppt_string )
        _ppt_QString = _ppt_string;
    hal_free_string(_ppt_string);
    return _ppt_QString;
}



        /* Remove all the registered media first */
        int numDevices;
        char** halDeviceList = hal_get_all_devices( m_halContext, &numDevices );

        if ( halDeviceList )
        {

            }
        }

        hal_free_string_array( halDeviceList );

        hal_shutdown(m_halContext);
        dbus_error_init(&error);
        libhal_ctx_shutdown(m_halContext, &error);
        libhal_ctx_free(m_halContext);
    }

    if (m_halStoragePolicy)
        hal_storage_policy_free(m_halStoragePolicy);
}

/* Connect to the HAL */
bool HALBackend::InitHal()
{
    kdDebug(1219) << "Context new" << endl;

    /* libhal initialization */
    m_halFunctions.main_loop_integration	= HALBackend::hal_main_loop_integration;
    m_halFunctions.device_added		= HALBackend::hal_device_added;
    m_halFunctions.device_removed		= HALBackend::hal_device_removed;
    m_halFunctions.device_new_capability	= NULL;
    m_halFunctions.device_lost_capability	= NULL;
    m_halFunctions.device_property_modified	= HALBackend::hal_device_property_modified;
    m_halFunctions.device_condition		= HALBackend::hal_device_condition;

    m_halContext = hal_initialize(&m_halFunctions, false);
    if (!m_halContext)
    {
        kdDebug(1219) << "Failed to initialize HAL!" << endl;
        return false;
    }

    // Main loop integration
    kdDebug(1219) << "Main loop integration" << endl;
    DBusError error;
    dbus_error_init(&error);
    dbus_connection = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);

    if (!dbus_connection || dbus_error_is_set(&error)) {
        dbus_error_free(&error);
        libhal_ctx_free(m_halContext);
        m_halContext = NULL;
        return false;
    }

    dbus_connection_set_exit_on_disconnect (dbus_connection, FALSE);

    MainLoopIntegration(dbus_connection);
    libhal_ctx_set_dbus_connection(m_halContext, dbus_connection);

    // HAL callback functions
    kdDebug(1219) << "Callback functions" << endl;
    libhal_ctx_set_device_added(m_halContext, HALBackend::hal_device_added);
    libhal_ctx_set_device_removed(m_halContext, HALBackend::hal_device_removed);
    libhal_ctx_set_device_new_capability (m_halContext, NULL);
    libhal_ctx_set_device_lost_capability (m_halContext, NULL);
    libhal_ctx_set_device_property_modified (m_halContext, HALBackend::hal_device_property_modified);
    libhal_ctx_set_device_condition(m_halContext, HALBackend::hal_device_condition);

    kdDebug(1219) << "Context Init" << endl;
    if (!libhal_ctx_init(m_halContext, &error))
    {
        if (dbus_error_is_set(&error))
            dbus_error_free(&error);
        libhal_ctx_free(m_halContext);
        m_halContext = NULL;
        kdDebug(1219) << "Failed to init HAL context!" << endl;
        return false;
    }

    /** @todo customize watch policy */
    kdDebug(1219) << "Watch properties" << endl;
    if (hal_device_property_watch_all(m_halContext))
    {
        kdDebug(1219) << "Failed to watch HAL properties!" << endl;
        return false;


    /* libhal-storage initialization */
    kdDebug(1219) << "Storage Policy" << endl;
    m_halStoragePolicy = hal_storage_policy_new();
    /** @todo define libhal-storage icon policy */

    /* List devices at startup */

    kdDebug(1219) << "ListDevices" << endl;

    int numDevices;
    char** halDeviceList = hal_get_all_devices(m_halContext, &numDevices);

    if (!halDeviceList)
        return false;

    kdDebug(1219) << "HALBackend::ListDevices : " << numDevices << " devices found" << endl;
    for (int i = 0; i < numDevices; i++) {
		kdDebug(1219) << "HALBackend::ListDevices : adding device " << i << endl;
        AddDevice(halDeviceList[i], false);
		kdDebug(1219) << "HALBackend::ListDevices : end adding device " << i << endl;
    }

    hal_free_string_array( halDeviceList );

    return true;
}

{
    /* We don't deal with devices that do not expose their capabilities.
       If we don't check this, we will get a lot of warning messages from libhal */
    if (!hal_device_property_exists(m_halContext, udi, "info.capabilities")) {
        kdDebug(1219) << "HALBackend::AddDevice : Device does not expose capability. Skipping." << endl;   
        return;
    }

    /* If the device is already listed, do not process.
       This should not happen, but who knows... */
    /** @todo : refresh properties instead ? */
    if (m_mediaList.findById(udi)) {
        kdDebug(1219) << "HALBackend::AddDevice : Device is already listed. Skipping." << endl;   
        return;
    }

    if (hal_device_get_property_bool(m_halContext, "/org/freedesktop/Hal/devices/computer", "storage.disable_volume_handling"))
        allowNotification=false;

    /* Add volume block devices */
    if (hal_device_query_capability(m_halContext, udi, "volume"))
    {
		kdDebug(1219) << "HALBackend::AddDevice : Device is a volume." << endl;   
        /* We only list volumes that...
         *  - are encrypted with LUKS or
         *  - have a filesystem or
         *  - have an audio track
         */
        if ( (libhal_device_get_property_QString(m_halContext, udi, "volume.fsusage") != "filesystem") &&
             (!hal_device_get_property_bool(m_halContext, udi, "volume.disc.has_audio")) &&
             (!hal_device_get_property_bool(m_halContext, udi, "volume.disc.is_blank")) ) {
            kdDebug(1219) << "HALBackend::AddDevice : no filesystem, no audio track on device. Skipping." << endl;   
             !libhal_device_get_property_bool(m_halContext, udi, "volume.disc.has_audio", NULL) &&
             !libhal_device_get_property_bool(m_halContext, udi, "volume.disc.is_blank", NULL) )
            return;
        }

        /* Query drive udi */
        TQString driveUdi = libhal_device_get_property_QString(m_halContext, udi, "block.storage_device");
        if ( driveUdi.isNull() ) { // no storage - no fun
            kdDebug(1219) << "HALBackend::AddDevice : UDI is null. Skipping." << endl;   
            return;
        }

        // if the device is locked do not act upon it
        if (hal_device_get_property_bool(m_halContext, driveUdi.ascii(), "info.locked"))
            allowNotification=false;

        // if the device is locked do not act upon it
        if (hal_device_get_property_bool(m_halContext, driveUdi.ascii(), "storage.partition_table_changed"))
            allowNotification=false;

        /** @todo check exclusion list **/

        /* Special handling for clear crypto volumes */
        LibHalVolume* halVolume = libhal_volume_from_udi(m_halContext, udi);
        if (!halVolume)
            return;
        const char* backingVolumeUdi = libhal_volume_crypto_get_backing_volume_udi(halVolume);
        if ( backingVolumeUdi != NULL )
        {
            /* The crypto drive was unlocked and may now be mounted... */
            kdDebug(1219) << "HALBackend::AddDevice : ClearVolume appeared for " << backingVolumeUdi << endl;
            ResetProperties(backingVolumeUdi, allowNotification);
            libhal_volume_free(halVolume);
            return;
        }
        libhal_volume_free(halVolume);

        /* Create medium */
        Medium* medium = new Medium(udi, "");

        {
            // if it's not mountable by user and not by HAL, don't show it at all
            if ( ( libhal_device_get_property_QString(m_halContext, udi, "volume.fsusage") == "filesystem" &&
                   !hal_device_get_property_bool(m_halContext, udi, "volume.is_mounted") ) &&
                 ( hal_device_get_property_bool(m_halContext, udi, "volume.ignore") ) )
            {
                kdDebug(1219) << "HALBackend::AddDevice : Device is not mountable. Skipping." << endl;   
                delete medium;
                return;
            }
        }
        
	    // insert medium into list
        kdDebug(1219) << "HALBackend::AddDevice : Adding medium into list." << endl;   
	    m_mediaList.addMedium(medium, allowNotification);

	    // finally check for automount
        TQMap<TQString,TQString> options = MediaManagerUtils::splitOptions(mountoptions(udi));
        kdDebug() << "automount " << options["automount"] << endl;
        if (options["automount"] == "true" && allowNotification ) {


        return;
    }
    else
    {
		kdDebug(1219) << "HALBackend::AddDevice : Device is not a volume." << endl;   
    }

    /* Floppy & zip drives */
    if (hal_device_query_capability(m_halContext, udi, "storage"))
        if ((libhal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "floppy") ||
            (libhal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "zip") ||
            (libhal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "jaz"))
        {
            if (! hal_device_get_property_bool(m_halContext, udi, "storage.removable.media_available") )
                allowNotification = false;
            /* Create medium */
            Medium* medium = new Medium(udi, "");

        }

    /* Camera handled by gphoto2*/
    if (hal_device_query_capability(m_halContext, udi, "camera") &&
         hal_device_property_exists(m_halContext, udi, "camera.libgphoto2.support") &&
         hal_device_get_property_bool(m_halContext, udi, "camera.libgphoto3.support")
         (libhal_device_property_exists(m_halContext, udi, "camera.libgphoto2.support", NULL) &&
          libhal_device_get_property_bool(m_halContext, udi, "camera.libgphoto2.support", NULL)))
        )
    {
        /* Create medium */

        m_mediaList.addMedium(medium, allowNotification);
        return;
    }
    kdDebug(1219) << "HALBackend::AddDevice : Device was intentionally not added. Skipping." << endl;   
}

void HALBackend::RemoveDevice(const char *udi)

        return;
    bool allowNotification = false;
    if (strcmp(key, "storage.removable.media_available") == 0)
        allowNotification = hal_device_get_property_bool(m_halContext, udi, key);
    ResetProperties(mediumUdi, allowNotification);
}


        return medium->id().ascii();

    /* Hard part : this is a volume whose drive is registered */
    if (hal_device_property_exists(m_halContext, udi, "info.capabilities"))
        if (hal_device_query_capability(m_halContext, udi, "volume"))
        {
            /* check if this belongs to an encrypted volume */
            HalVolume* halVolume = hal_volume_from_udi(m_halContext, udi);
            if (!halVolume) return NULL;
            hal_volume_free(halVolume);
            if (backingUdi != NULL) {
                const char* result = findMediumUdiFromUdi(backingUdi);
                libhal_volume_free(halVolume);
                return result;
            }
            libhal_volume_free(halVolume);

            /* this is a volume whose drive is registered */
            TQString driveUdi = libhal_device_get_property_QString(m_halContext, udi, "block.storage_device");


    Medium* m = new Medium(mediumUdi, "");

    if (hal_device_query_capability(m_halContext, mediumUdi, "volume"))
        setVolumeProperties(m);
    if (hal_device_query_capability(m_halContext, mediumUdi, "storage"))
        setFloppyProperties(m);
    if (hal_device_query_capability(m_halContext, mediumUdi, "camera"))
        setCameraProperties(m);

    m_mediaList.changeMediumState(*m, allowNotification);


    const char* udi = medium->id().ascii();
    /* Check if the device still exists */
    if (!hal_device_exists(m_halContext, udi))
        return;

    /* Get device information from libhal-storage */
    HalVolume* halVolume = hal_volume_from_udi(m_halContext, udi);
    if (!halVolume)
        return;
    TQString driveUdi = hal_volume_get_storage_device_udi(halVolume);
    HalDrive*  halDrive  = 0;
    if ( !driveUdi.isNull() )
        halDrive = hal_drive_from_udi(m_halContext, driveUdi.ascii());
    if (!halDrive) {
        // at times HAL sends an UnmountForced event before the device is removed
        hal_volume_free(halVolume);
        return;
    }

    medium->setName(
        generateName(hal_volume_get_device_file(halVolume)) );

    LibHalVolume* halClearVolume = NULL;
    if ( libhal_device_get_property_QString(m_halContext, udi, "volume.fsusage") == "crypto" )
    {
        kdDebug(1219) << "HALBackend::setVolumeProperties : crypto volume" << endl;

    kdDebug(1219) << "HALBackend::setVolumeProperties : normal volume" << endl;
    medium->mountableState(
        hal_volume_get_device_file(halVolume),		/* Device node */
        hal_volume_get_mount_point(halVolume),		/* Mount point */
        hal_volume_get_fstype(halVolume),		/* Filesystem type */
        hal_volume_is_mounted(halVolume) );		/* Mounted ? */
            // ignore if halClearVolume is NULL -> just not decrypted in this case
	    clearUdiString = clearUdi;
	    libhal_free_string(clearUdi);
        }

        if (halClearVolume)
            medium->mountableState(
                libhal_volume_get_device_file(halVolume),		/* Device node */
                clearUdiString,
                libhal_volume_get_mount_point(halClearVolume),		/* Mount point */
                libhal_volume_get_fstype(halClearVolume),		/* Filesystem type */
                libhal_volume_is_mounted(halClearVolume) );		/* Mounted ? */
        else
            medium->mountableState(
                libhal_volume_get_device_file(halVolume),		/* Device node */
                TQString::null,
                TQString::null,		/* Mount point */
                TQString::null,		/* Filesystem type */
                false );		/* Mounted ? */
    }
    else
    {
        kdDebug(1219) << "HALBackend::setVolumeProperties : normal volume" << endl;
        medium->mountableState(
            libhal_volume_get_device_file(halVolume),		/* Device node */
            libhal_volume_get_mount_point(halVolume),		/* Mount point */
            libhal_volume_get_fstype(halVolume),		/* Filesystem type */
            libhal_volume_is_mounted(halVolume) );		/* Mounted ? */
    }


    char* name = hal_volume_policy_compute_display_name(halDrive, halVolume, m_halStoragePolicy);
    TQString volume_name = TQString::fromUtf8(name);
    TQString media_name = volume_name;
    medium->setLabel(media_name);
    free(name);

    TQString mimeType;
    if (hal_volume_is_disc(halVolume))
    {
        mimeType = "media/cdrom" + MOUNT_SUFFIX;

        HalVolumeDiscType discType = hal_volume_get_disc_type(halVolume);
        if ((discType == HAL_VOLUME_DISC_TYPE_CDROM) ||
            (discType == HAL_VOLUME_DISC_TYPE_CDR) ||
            (discType == HAL_VOLUME_DISC_TYPE_CDRW))
            if (hal_volume_disc_is_blank(halVolume))
            {
                mimeType = "media/blankcd";
                medium->unmountableState("");

            else
                mimeType = "media/cdwriter" + MOUNT_SUFFIX;

        if ((discType == HAL_VOLUME_DISC_TYPE_DVDROM) || (discType == HAL_VOLUME_DISC_TYPE_DVDRAM) ||
            (discType == HAL_VOLUME_DISC_TYPE_DVDR) || (discType == HAL_VOLUME_DISC_TYPE_DVDRW) ||
            (discType == HAL_VOLUME_DISC_TYPE_DVDPLUSR) || (discType == HAL_VOLUME_DISC_TYPE_DVDPLUSRW) )
            if (hal_volume_disc_is_blank(halVolume))
            {
                mimeType = "media/blankdvd";
                medium->unmountableState("");

            else
                mimeType = "media/dvd" + MOUNT_SUFFIX;

        if (hal_volume_disc_has_audio(halVolume) && !hal_volume_disc_has_data(halVolume))
        {
            mimeType = "media/audiocd";
            medium->unmountableState( "audiocd:/?device=" + TQString(hal_volume_get_device_file(halVolume)) );
        }

        medium->setIconName(TQString::null);

        /* check if the disc id a vcd or a video dvd */
        DiscType type = LinuxCDPolling::identifyDiscType(hal_volume_get_device_file(halVolume));
        switch (type)
        {
        case DiscType::VCD:

    {
        mimeType = "media/hdd" + MOUNT_SUFFIX;
        medium->setIconName(TQString::null); // reset icon
        if (hal_drive_is_hotpluggable(halDrive))
        {
            mimeType = "media/removable" + MOUNT_SUFFIX;
            medium->needMounting();
            switch (hal_drive_get_type(halDrive)) {
            case HAL_DRIVE_TYPE_COMPACT_FLASH:
                medium->setIconName("compact_flash" + MOUNT_ICON_SUFFIX);
                break;
            case HAL_DRIVE_TYPE_MEMORY_STICK:
                medium->setIconName("memory_stick" + MOUNT_ICON_SUFFIX);
                break;
            case HAL_DRIVE_TYPE_SMART_MEDIA:
                medium->setIconName("smart_media" + MOUNT_ICON_SUFFIX);
                break;
            case HAL_DRIVE_TYPE_SD_MMC:
                medium->setIconName("sd_mmc" + MOUNT_ICON_SUFFIX);
                break;
            case HAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER:
            {
                medium->setIconName("ipod" + MOUNT_ICON_SUFFIX);


		         KProtocolInfo::isKnownProtocol( TQString("ipod") ) )
                {
                    medium->unmountableState( "ipod:/" );
                    medium->mountableState(  hal_volume_is_mounted(halVolume) );
                }
                break;
            }
            case HAL_DRIVE_TYPE_CAMERA:
            {
                mimeType = "media/camera" + MOUNT_SUFFIX;
                const char *physdev = hal_drive_get_physical_device_udi(halDrive);
                // get model from camera
                if (physdev && hal_device_query_capability(m_halContext, physdev, "camera"))
                {
                    if (hal_device_property_exists(m_halContext, physdev, "usb_device.product"))
                        medium->setLabel(libhal_device_get_property_QString(m_halContext, physdev, "usb_device.product"));
                    else if (hal_device_property_exists(m_halContext, physdev, "usb.product"))
                        medium->setLabel(libhal_device_get_property_QString(m_halContext, physdev, "usb.product"));
                }
                break;
            }
            case HAL_DRIVE_TYPE_TAPE:
                medium->setIconName(TQString::null); //FIXME need icon
                break;
            default:

    }
    medium->setMimeType(mimeType);

    hal_drive_free(halDrive);
    hal_volume_free(halVolume);
}

bool HALBackend::setFstabProperties( Medium *medium )


    const char* udi = medium->id().ascii();
    /* Check if the device still exists */
    if (!hal_device_exists(m_halContext, udi))
        return false;

    HalDrive*  halDrive  = hal_drive_from_udi(m_halContext, udi);
    if (!halDrive)
        return false;



    if (drive_type == "zip") {
        int numVolumes;
        char** volumes = hal_drive_find_all_volumes(m_halContext, halDrive, &numVolumes);
        hal_free_string_array(volumes);
        kdDebug(1219) << " found " << numVolumes << " volumes" << endl;
        if (numVolumes)
        {
            hal_drive_free(halDrive);
            return false;
        }
    }

    medium->setName( generateName(hal_drive_get_device_file(halDrive)) );
    medium->setLabel(i18n("Unknown Drive"));

    // HAL hates floppies - so we have to do it twice ;(
    medium->mountableState(hal_drive_get_device_file(halDrive), TQString::null, TQString::null, false);
    setFloppyMountState(medium);

    if (drive_type == "floppy")


    medium->setIconName(TQString::null);

    hal_drive_free(halDrive);

    return true;
}


    const char* udi = medium->id().ascii();
    /* Check if the device still exists */
    if (!hal_device_exists(m_halContext, udi))
        return;

    /** @todo find name */


    TQString device = "camera:/";

    char *cam = hal_device_get_property_string(m_halContext, udi, "camera.libgphoto2.name");
    DBusError error;
    dbus_error_init(&error);
    if (cam &&
        hal_device_property_exists(m_halContext, udi, "usb.linux.device_number") &&
        hal_device_property_exists(m_halContext, udi, "usb.bus_number"))
        device.sprintf("camera://%s@[usb:%03d,%03d]/", cam,
                       hal_device_get_property_int(m_halContext, udi, "usb.bus_number"),
                       hal_device_get_property_int(m_halContext, udi, "usb.linux.device_number"));

    hal_free_string(cam);

    /** @todo find the rest of this URL */
    medium->unmountableState(device);
    medium->setMimeType("media/gphoto2camera");
    medium->setIconName(TQString::null);
    if (hal_device_property_exists(m_halContext, udi, "usb_device.product"))
        medium->setLabel(libhal_device_get_property_QString(m_halContext, udi, "usb_device.product"));
    else if (hal_device_property_exists(m_halContext, udi, "usb.product"))
        medium->setLabel(libhal_device_get_property_QString(m_halContext, udi, "usb.product"));
    else
        medium->setLabel(i18n("Camera"));

 ** HAL CALL-BACKS                        **
 ******************************************/

void HALBackend::hal_main_loop_integration(LibHalContext *ctx,
                                         DBusConnection *dbus_connection)
{
    kdDebug(1219) << "HALBackend::hal_main_loop_integration" << endl;
    Q_UNUSED(ctx);
    s_HALBackend->MainLoopIntegration(dbus_connection);
}

void HALBackend::hal_device_added(LibHalContext *ctx, const char *udi)
{
    kdDebug(1219) << "HALBackend::hal_device_added " << udi <<  endl;


void HALBackend::hal_device_condition(LibHalContext *ctx, const char *udi,
                                      const char *condition_name,
                                      DBusMessage* message
    )
{
    kdDebug(1219) << "HALBackend::hal_device_condition " << udi << " -- " << condition_name << endl;

TQStringList HALBackend::getHALmountoptions(TQString udi)
{
    const char*   _ppt_string;
    HalVolume* volume;
    HalDrive* drive;

    TQString _ppt_TQString;

    volume = hal_volume_from_udi( m_halContext, udi.latin1() );
    if( volume )
        drive = hal_drive_from_udi( m_halContext, hal_volume_get_storage_device_udi( volume ) );
    else
        drive = hal_drive_from_udi( m_halContext, udi.latin1() );

    if( !drive )
           return TQString::null;

    if( volume )
       _ppt_string = hal_volume_policy_get_mount_options ( drive, volume, NULL );
    else
       _ppt_string = hal_drive_policy_get_mount_options ( drive, NULL );

    _ppt_TQString = TQString(_ppt_string ? _ppt_string : "");


        return TQStringList(); // not handled by HAL - fstab entry

    TQString volume_udi = name;
    if (medium->isEncrypted()) {
        // see if we have a clear volume
        LibHalVolume* halVolume = libhal_volume_from_udi(m_halContext, medium->id().latin1());
        if (halVolume) {
            char* clearUdi = libhal_volume_crypto_get_clear_volume_udi(m_halContext, halVolume);
            if (clearUdi != NULL) {
	        volume_udi = clearUdi;
		libhal_free_string(clearUdi);
	    } else {
	        // if not decrypted yet then no mountoptions
		return TQStringList();
	    }
            libhal_volume_free(halVolume);
        } else {
	    // strange...
	    return TQStringList();
	}
    }

    KConfig config("mediamanagerrc");
    

    if (use_defaults)
	config.setGroup("DefaultOptions");    

    char ** array = libhal_device_get_property_strlist(m_halContext, volume_udi.latin1(), "volume.mount.valid_options", NULL);
    TQMap<TQString,bool> valids;

    for (int index = 0; array && array[index]; ++index) {
        TQString t = array[index];
        if (t.endsWith("="))
            t = t.left(t.length() - 1);
        valids[t] = true;
        kdDebug() << "valid " << t << endl;
    }
    libhal_free_string_array(array);
    TQStringList result;
    TQString tmp;
    


    bool removable = false;
    if ( !drive_udi.isNull() )
        removable = hal_device_get_property_bool(m_halContext, drive_udi.latin1(), "storage.removable")
                     || hal_device_get_property_bool(m_halContext, drive_udi.latin1(), "storage.hotpluggable");

    bool value;
    if (use_defaults)

	config.setGroup(current_group);
    }

    if (hal_device_get_property_bool(m_halContext, volume_udi.latin1(), "volume.disc.is_blank")
        || hal_device_get_property_bool(m_halContext, volume_udi.latin1(), "volume.disc.is_vcd")
        || hal_device_get_property_bool(m_halContext, volume_udi.latin1(), "volume.disc.is_svcd")
        || hal_device_get_property_bool(m_halContext, volume_udi.latin1(), "volume.disc.is_videodvd")
        || hal_device_get_property_bool(m_halContext, volume_udi.latin1(), "volume.disc.has_audio"))
        value = false;

    result << TQString("automount=%1").arg(value ? "true" : "false");

    }
    options[noptions] = NULL;

    TQString qerror = i18n("Cannot mount encrypted drives!");

    if (!medium->isEncrypted()) {
        // normal volume
    	qerror = mount_priv(medium->id().latin1(), mount_point.utf8(), options, noptions, dbus_connection);
    } else {
        // see if we have a clear volume
        LibHalVolume* halVolume = libhal_volume_from_udi(m_halContext, medium->id().latin1());
        if (halVolume) {
            char* clearUdi = libhal_volume_crypto_get_clear_volume_udi(m_halContext, halVolume);
            if (clearUdi != NULL) {
                qerror = mount_priv(clearUdi, mount_point.utf8(), options, noptions, dbus_connection);
                libhal_free_string(clearUdi);
            }
            libhal_volume_free(halVolume);
        }
    }

    if (!qerror.isEmpty()) {
        kdError() << "mounting " << medium->id() << " returned " << qerror << endl;
        return qerror;
    }

    medium->setHalMounted(true);
    ResetProperties(medium->id().latin1());


    if (!medium)
    {   // now we get fancy: if the udi is no volume, it _might_ be a device with only one
        // volume on it (think CDs) - so we're so nice to the caller to unmount that volume
        HalDrive*  halDrive  = hal_drive_from_udi(m_halContext, _udi.latin1());
        if (halDrive)
        {
            int numVolumes;
            char** volumes = hal_drive_find_all_volumes(m_halContext, halDrive, &numVolumes);
            if (numVolumes == 1)
                medium = m_mediaList.findById( volumes[0] );
        }

    const char *options[2];
    TQString udi = TQString::null;

    udi = medium->id();
    
        udi = medium->id();
    } else {
        // see if we have a clear volume
        LibHalVolume* halVolume = libhal_volume_from_udi(m_halContext, medium->id().latin1());
        if (halVolume) {
            char *clearUdi = libhal_volume_crypto_get_clear_volume_udi(m_halContext, halVolume);
	    udi = clearUdi;
	    libhal_free_string(clearUdi);
            libhal_volume_free(halVolume);
        }
    }
    if (udi.isNull()) {
        kdDebug() << "unmount failed: no udi" << endl;
        return i18n("Internal Error");

    return TQString();
}

TQString HALBackend::decrypt(const TQString &_udi, const TQString &password)
{
    const Medium* medium = m_mediaList.findById(_udi);
    if (!medium)
        return i18n("No such medium: %1").arg(_udi);

    if (!medium->isEncrypted() || !medium->clearDeviceUdi().isNull())
        return TQString();

    const char *udi = medium->id().latin1();
    DBusMessage *msg = NULL;
    DBusMessage *reply = NULL;
    DBusError error;

    kdDebug() << "Setting up " << udi << " for crypto\n" <<endl;
	
    msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
                                        "org.freedesktop.Hal.Device.Volume.Crypto",
                                        "Setup");
    if (msg == NULL) {
        kdDebug() << "decrypt failed for " << udi << ": could not create dbus message\n";
        return i18n("Internal Error");
    }

    TQCString pwdUtf8 = password.utf8();
    const char *pwd_utf8 = pwdUtf8;
    if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &pwd_utf8, DBUS_TYPE_INVALID)) {
        kdDebug() << "decrypt failed for " << udi << ": could not append args to dbus message\n";
        dbus_message_unref (msg);
        return i18n("Internal Error");
    }

    dbus_error_init (&error);
    if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error)) || 
        dbus_error_is_set (&error))
    {
        TQString qerror = i18n("Internal Error");
        kdDebug() << "decrypt failed for " << udi << ": " << error.name << " " << error.message << endl;
        if (strcmp (error.name, "org.freedesktop.Hal.Device.Volume.Crypto.SetupPasswordError") == 0) {
            qerror = i18n("Wrong password");
        }
        dbus_error_free (&error);
        dbus_message_unref (msg);
        while (dbus_connection_dispatch(dbus_connection) == DBUS_DISPATCH_DATA_REMAINS) ;
        return qerror;
    }

    dbus_message_unref (msg);
    dbus_message_unref (reply);

    while (dbus_connection_dispatch(dbus_connection) == DBUS_DISPATCH_DATA_REMAINS) ;

    return TQString();
}

TQString HALBackend::undecrypt(const TQString &_udi)
{
    const Medium* medium = m_mediaList.findById(_udi);
    if (!medium)
        return i18n("No such medium: %1").arg(_udi);

    if (!medium->isEncrypted() || medium->clearDeviceUdi().isNull())
        return TQString();

    const char *udi = medium->id().latin1();
    DBusMessage *msg = NULL;
    DBusMessage *reply = NULL;
    DBusError error;

    kdDebug() << "Tear down " << udi << "\n" <<endl;
	
    msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
                                        "org.freedesktop.Hal.Device.Volume.Crypto",
                                        "Teardown");
    if (msg == NULL) {
        kdDebug() << "teardown failed for " << udi << ": could not create dbus message\n";
        return i18n("Internal Error");
    }

    if (!dbus_message_append_args (msg, DBUS_TYPE_INVALID)) {
        kdDebug() << "teardown failed for " << udi << ": could not append args to dbus message\n";
        dbus_message_unref (msg);
        return i18n("Internal Error");
    }

    dbus_error_init (&error);
    if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error)) || 
        dbus_error_is_set (&error))
    {
        TQString qerror = i18n("Internal Error");
        kdDebug() << "teardown failed for " << udi << ": " << error.name << " " << error.message << endl;
        dbus_error_free (&error);
        dbus_message_unref (msg);
        while (dbus_connection_dispatch(dbus_connection) == DBUS_DISPATCH_DATA_REMAINS) ;
        return qerror;
    }

    dbus_message_unref (msg);
    dbus_message_unref (reply);

    ResetProperties(udi);

    while (dbus_connection_dispatch(dbus_connection) == DBUS_DISPATCH_DATA_REMAINS) ;

    return TQString();
}

#include "halbackend.moc"

Lines 85-92 Link Here

(-)kdebase/kioslave/media/mediamanager/halbackend.h.hal04 (-4 / +14 lines)
85	TQString mount(const TQString &id);	85	TQString mount(const TQString &id);
86	TQString mount(const Medium *medium);	86	TQString mount(const Medium *medium);
87	TQString unmount(const TQString &id);	87	TQString unmount(const TQString &id);
88	TQString decrypt(const TQString &id, const TQString &password);
89	TQString undecrypt(const TQString &id);
90		88
91	private:	89	private:
92	/**	90	/**
Lines 152-157 Link Here
152		150
153	/* Hal call-backs -- from gvm*/	151	/* Hal call-backs -- from gvm*/
154	public:	152	public:
		153	/** Invoked by libhal for integration with our mainloop.
		154	*
		155	* @param ctx LibHal context
		156	* @param dbus_connection D-BUS connection to integrate
		157	*/
		158	static void hal_main_loop_integration(LibHalContext ctx, DBusConnection dbus_connection);
		159
155	/** Invoked when a device is added to the Global Device List.	160	/** Invoked when a device is added to the Global Device List.
156	*	161	*
157	* @param ctx LibHal context	162	* @param ctx LibHal context
Lines 184-190 Link Here
184	*/	189	*/
185	static void hal_device_condition(LibHalContext ctx, const char udi,	190	static void hal_device_condition(LibHalContext ctx, const char udi,
186	const char *condition_name,	191	const char *condition_name,
187	const char* message	192	DBusMessage* message
188	);	193	);
189		194
190	TQStringList getHALmountoptions(TQString udi);	195	TQStringList getHALmountoptions(TQString udi);
Lines 196-204 Link Here
196	LibHalContext* m_halContext;	201	LibHalContext* m_halContext;
197		202
198	/**	203	/**
		204	* Structure defining the hal callback function for devices events
		205	*/
		206	LibHalFunctions m_halFunctions;
		207
		208	/**
199	* libhal-storage HAL policy, e.g. for icon names	209	* libhal-storage HAL policy, e.g. for icon names
200	*/	210	*/
201	LibHalStoragePolicy* m_halStoragePolicy;	211	HalStoragePolicy* m_halStoragePolicy;
202		212
203	/**	213	/**
204	* The DBus-Qt bindings connection for mainloop integration	214	* The DBus-Qt bindings connection for mainloop integration

Return to bug 1199