+++ /dev/null
-/*---------------------------------------------------------------------\
-| ____ _ __ __ ___ |
-| |__ / \ / / . \ . \ |
-| / / \ V /| _/ _/ |
-| / /__ | | | | | | |
-| /_____||_| |_| |_| |
-| |
-\---------------------------------------------------------------------*/
-/** \file zypp/target/hal/HalContext.cc
- *
- * \brief Hardware abstaction layer library wrapper implementation.
- */
-#include <zypp/target/hal/HalException.h>
-//////////////////////////////////////////////////////////////////////
-namespace zypp
-{ ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
- namespace target
- { //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- namespace hal
- { ////////////////////////////////////////////////////////////////
- NoHalException::NoHalException()
- : Exception(_("Sorry, but this version of libzypp was built without HAL support."))
- {}
- ////////////////////////////////////////////////////////////////
- } // namespace hal
- //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- } // namespace target
- ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
-} // namespace zypp
-//////////////////////////////////////////////////////////////////////
-
-#ifndef NO_HAL // disables zypp's HAL dependency
-
-#include <zypp/target/hal/HalContext.h>
-#include <zypp/thread/Mutex.h>
-#include <zypp/thread/MutexLock.h>
-#include <zypp/base/NonCopyable.h>
-#include <zypp/base/Logger.h>
-#include <zypp/base/String.h>
-#include <zypp/base/Gettext.h>
-
-#include <hal/libhal.h>
-#include <hal/libhal-storage.h>
-
-#include <iostream>
-
-using namespace std;
-
-//////////////////////////////////////////////////////////////////////
-namespace zypp
-{ ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
- namespace target
- { //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- namespace hal
- { ////////////////////////////////////////////////////////////////
-
- using zypp::thread::Mutex;
- using zypp::thread::MutexLock;
-
- ////////////////////////////////////////////////////////////////
- namespace // anonymous
- { //////////////////////////////////////////////////////////////
-
-
- //////////////////////////////////////////////////////////////
- // STATIC
- /**
- ** hmm... currently a global one..
- */
- static Mutex g_Mutex;
-
-
- //////////////////////////////////////////////////////////////
- /**
- * Internal hal (dbus ) error helper class.
- */
- class HalError
- {
- public:
- DBusError error;
-
- HalError() { dbus_error_init(&error); }
- ~HalError() { dbus_error_free(&error); }
-
- inline bool isSet() const
- {
- return dbus_error_is_set(&error);
- }
-
- inline HalException halException(const std::string &msg = std::string()) const
- {
- if( isSet() && error.name != NULL && error.message != NULL) {
- return HalException(error.name, error.message);
- }
- else if( !msg.empty()) {
- return HalException(msg);
- }
- else {
- return HalException();
- }
- }
- };
-
-
- // -----------------------------------------------------------
- inline void
- VERIFY_CONTEXT(const zypp::RW_pointer<HalContext_Impl> &h)
- {
- if( !h)
- {
- ZYPP_THROW(HalException(_("HalContext not connected")));
- }
- }
-
- // -----------------------------------------------------------
- inline void
- VERIFY_DRIVE(const zypp::RW_pointer<HalDrive_Impl> &d)
- {
- if( !d)
- {
- ZYPP_THROW(HalException(_("HalDrive not initialized")));
- }
- }
-
- // -----------------------------------------------------------
- inline void
- VERIFY_VOLUME(const zypp::RW_pointer<HalVolume_Impl> &v)
- {
- if( !v)
- {
- ZYPP_THROW(HalException(_("HalVolume not initialized")));
- }
- }
-
- //////////////////////////////////////////////////////////////
- } // anonymous
- ////////////////////////////////////////////////////////////////
-
- ////////////////////////////////////////////////////////////////
- std::ostream &
- HalException::dumpOn( std::ostream & str ) const
- {
- if(!e_name.empty() && !e_msg.empty())
- return str << msg() << ": " << e_msg << " (" << e_name << ")";
- else if(!e_msg.empty())
- return str << msg() << ": " << e_msg;
- else
- return str << msg();
- }
-
- ////////////////////////////////////////////////////////////////
- class HalContext_Impl
- {
- public:
- HalContext_Impl();
- ~HalContext_Impl();
-
- DBusConnection *conn;
- LibHalContext *hctx;
- bool pcon; // private connection
- };
-
-
- ////////////////////////////////////////////////////////////////
- class HalDrive_Impl
- {
- public:
- zypp::RW_pointer<HalContext_Impl> hal;
- LibHalDrive *drv;
-
- HalDrive_Impl()
- : hal(), drv(NULL)
- {
- }
-
- HalDrive_Impl(const zypp::RW_pointer<HalContext_Impl> &r,
- LibHalDrive *d)
- : hal(r), drv(d)
- {
- }
-
- ~HalDrive_Impl()
- {
- if( drv)
- libhal_drive_free(drv);
- }
- };
-
-
- ////////////////////////////////////////////////////////////////
- class HalVolume_Impl
- {
- public:
- LibHalVolume *vol;
-
- HalVolume_Impl(LibHalVolume *v=NULL)
- : vol(v)
- {
- }
-
- ~HalVolume_Impl()
- {
- if( vol)
- libhal_volume_free(vol);
- }
- };
-
-
- ////////////////////////////////////////////////////////////////
- HalContext_Impl::HalContext_Impl()
- : conn(NULL)
- , hctx(NULL)
- , pcon(false) // we allways use shared connections at the moment
- {
- HalError err;
-
- if( pcon)
- conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err.error);
- else
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err.error);
- if( !conn) {
- ZYPP_THROW(err.halException(
- _("Unable to create dbus connection")
- ));
- }
-
- hctx = libhal_ctx_new();
- if( !hctx)
- {
- if( pcon)
- dbus_connection_close(conn);
- dbus_connection_unref(conn);
- conn = NULL;
-
- ZYPP_THROW(HalException(
- _("libhal_ctx_new: Can't create libhal context")
- ));
- }
-
- if( !libhal_ctx_set_dbus_connection(hctx, conn))
- {
- libhal_ctx_free(hctx);
- hctx = NULL;
-
- if( pcon)
- dbus_connection_close(conn);
- dbus_connection_unref(conn);
- conn = NULL;
-
- ZYPP_THROW(HalException(
- _("libhal_set_dbus_connection: Can't set dbus connection")
- ));
- }
-
- if( !libhal_ctx_init(hctx, &err.error))
- {
- libhal_ctx_free(hctx);
- hctx = NULL;
-
- if( pcon)
- dbus_connection_close(conn);
- dbus_connection_unref(conn);
- conn = NULL;
-
- ZYPP_THROW(err.halException(
- _("Unable to initalize HAL context -- hald not running?")
- ));
- }
- }
-
- // -------------------------------------------------------------
- HalContext_Impl::~HalContext_Impl()
- {
- if( hctx)
- {
- HalError err;
- libhal_ctx_shutdown(hctx, &err.error);
- libhal_ctx_free( hctx);
- }
- if( conn)
- {
- if( pcon)
- dbus_connection_close(conn);
- dbus_connection_unref(conn);
- }
- }
-
-
- ////////////////////////////////////////////////////////////////
- HalContext::HalContext(bool autoconnect)
- : h_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- if( autoconnect)
- h_impl.reset( new HalContext_Impl());
- }
-
- // -------------------------------------------------------------
- HalContext::HalContext(const HalContext &context)
- : h_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- zypp::RW_pointer<HalContext_Impl>(context.h_impl).swap(h_impl);
- }
-
- // -------------------------------------------------------------
- HalContext::~HalContext()
- {
- MutexLock lock(g_Mutex);
-
- h_impl.reset();
- }
-
- // --------------------------------------------------------------
- HalContext &
- HalContext::operator=(const HalContext &context)
- {
- MutexLock lock(g_Mutex);
-
- if( this == &context)
- return *this;
-
- zypp::RW_pointer<HalContext_Impl>(context.h_impl).swap(h_impl);
- return *this;
- }
-
- // --------------------------------------------------------------
- HalContext::operator HalContext::bool_type() const
- {
- MutexLock lock(g_Mutex);
-
- return h_impl;
- }
-
- // --------------------------------------------------------------
- void
- HalContext::connect()
- {
- MutexLock lock(g_Mutex);
-
- if( !h_impl)
- h_impl.reset( new HalContext_Impl());
- }
-
- // --------------------------------------------------------------
- std::vector<std::string>
- HalContext::getAllDevices() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- char **names;
- int count = 0;
-
- names = libhal_get_all_devices( h_impl->hctx, &count, &err.error);
- if( !names)
- {
- ZYPP_THROW(err.halException());
- }
-
- std::vector<std::string> ret(names, names + count);
- libhal_free_string_array(names);
- return ret;
- }
-
- // --------------------------------------------------------------
- HalDrive
- HalContext::getDriveFromUDI(const std::string &udi) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- LibHalDrive *drv = libhal_drive_from_udi(h_impl->hctx, udi.c_str());
- if( drv != NULL)
- return HalDrive(new HalDrive_Impl( h_impl, drv));
- else
- return HalDrive();
- }
-
- // --------------------------------------------------------------
- HalVolume
- HalContext::getVolumeFromUDI(const std::string &udi) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- LibHalVolume *vol = libhal_volume_from_udi(h_impl->hctx, udi.c_str());
- if( vol)
- return HalVolume( new HalVolume_Impl(vol));
- else
- return HalVolume();
- }
-
- // --------------------------------------------------------------
- HalVolume
- HalContext::getVolumeFromDeviceFile(const std::string &device_file) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- LibHalVolume *vol = libhal_volume_from_device_file(h_impl->hctx,
- device_file.c_str());
- if( vol)
- return HalVolume( new HalVolume_Impl(vol));
- else
- return HalVolume();
- }
-
- // --------------------------------------------------------------
- std::vector<std::string>
- HalContext::findDevicesByCapability(const std::string &capability) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- char **names;
- int count = 0;
-
- names = libhal_find_device_by_capability(h_impl->hctx,
- capability.c_str(),
- &count, &err.error);
- if( !names)
- {
- ZYPP_THROW(err.halException());
- }
-
- std::vector<std::string> ret(names, names + count);
- libhal_free_string_array(names);
- return ret;
- }
-
- // --------------------------------------------------------------
- bool
- HalContext::getDevicePropertyBool (const std::string &udi,
- const std::string &key) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_get_property_bool (h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( err.isSet())
- {
- ZYPP_THROW(err.halException());
- }
- return ret;
- }
-
- // --------------------------------------------------------------
- int32_t
- HalContext::getDevicePropertyInt32 (const std::string &udi,
- const std::string &key) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_int32_t ret;
-
- ret = libhal_device_get_property_int (h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( err.isSet())
- {
- ZYPP_THROW(err.halException());
- }
- return ret;
- }
-
- // --------------------------------------------------------------
- uint64_t
- HalContext::getDevicePropertyUInt64(const std::string &udi,
- const std::string &key) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_uint64_t ret;
-
- ret = libhal_device_get_property_uint64(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( err.isSet())
- {
- ZYPP_THROW(err.halException());
- }
- return ret;
- }
-
- // --------------------------------------------------------------
- double
- HalContext::getDevicePropertyDouble(const std::string &udi,
- const std::string &key) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- double ret;
-
- ret = libhal_device_get_property_bool (h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( err.isSet())
- {
- ZYPP_THROW(err.halException());
- }
- return ret;
- }
-
-
- // --------------------------------------------------------------
- std::string
- HalContext::getDevicePropertyString(const std::string &udi,
- const std::string &key) const
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- std::string ret;
- char *ptr;
-
- ptr = libhal_device_get_property_string(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( err.isSet())
- {
- ZYPP_THROW(err.halException());
- }
- if( ptr != NULL)
- {
- ret = ptr;
- free(ptr);
- }
- return ret;
- }
-
- // --------------------------------------------------------------
- void
- HalContext::setDevicePropertyBool (const std::string &udi,
- const std::string &key,
- bool value)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_set_property_bool (h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- value ? 1 : 0,
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- // --------------------------------------------------------------
- void
- HalContext::setDevicePropertyInt32 (const std::string &udi,
- const std::string &key,
- int32_t value)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_set_property_int (h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- value,
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- // --------------------------------------------------------------
- void
- HalContext::setDevicePropertyUInt64(const std::string &udi,
- const std::string &key,
- uint64_t value)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_set_property_uint64(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- value,
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- // --------------------------------------------------------------
- void
- HalContext::setDevicePropertyDouble(const std::string &udi,
- const std::string &key,
- double value)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_set_property_double(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- value,
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- // --------------------------------------------------------------
- void
- HalContext::setDevicePropertyString(const std::string &udi,
- const std::string &key,
- const std::string &value)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_set_property_string(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- value.c_str(),
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- // --------------------------------------------------------------
- void
- HalContext::removeDeviceProperty(const std::string &udi,
- const std::string &key)
- {
- MutexLock lock(g_Mutex);
- VERIFY_CONTEXT(h_impl);
-
- HalError err;
- dbus_bool_t ret;
-
- ret = libhal_device_remove_property(h_impl->hctx,
- udi.c_str(),
- key.c_str(),
- &err.error);
- if( !ret)
- {
- ZYPP_THROW(err.halException());
- }
- }
-
- ////////////////////////////////////////////////////////////////
- HalDrive::HalDrive()
- : d_impl( NULL)
- {
- }
-
- // --------------------------------------------------------------
- HalDrive::HalDrive(HalDrive_Impl *impl)
- : d_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- d_impl.reset(impl);
- }
-
- // --------------------------------------------------------------
- HalDrive::HalDrive(const HalDrive &drive)
- : d_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- zypp::RW_pointer<HalDrive_Impl>(drive.d_impl).swap(d_impl);
- }
-
- // --------------------------------------------------------------
- HalDrive::~HalDrive()
- {
- MutexLock lock(g_Mutex);
-
- d_impl.reset();
- }
-
- // --------------------------------------------------------------
- HalDrive &
- HalDrive::operator=(const HalDrive &drive)
- {
- MutexLock lock(g_Mutex);
-
- if( this == &drive)
- return *this;
-
- zypp::RW_pointer<HalDrive_Impl>(drive.d_impl).swap(d_impl);
- return *this;
- }
-
- // --------------------------------------------------------------
- HalDrive::operator HalDrive::bool_type() const
- {
- MutexLock lock(g_Mutex);
-
- return d_impl;
- }
-
- // --------------------------------------------------------------
- std::string
- HalDrive::getUDI() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- const char *ptr = libhal_drive_get_udi(d_impl->drv);
- return std::string(ptr ? ptr : "");
- }
-
- // --------------------------------------------------------------
- std::string
- HalDrive::getTypeName() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- const char *ptr = libhal_drive_get_type_textual(d_impl->drv);
- return std::string(ptr ? ptr : "");
- }
-
- // --------------------------------------------------------------
- std::string
- HalDrive::getDeviceFile() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- return std::string(libhal_drive_get_device_file(d_impl->drv));
- }
-
- // --------------------------------------------------------------
- unsigned int
- HalDrive::getDeviceMajor() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- return libhal_drive_get_device_major(d_impl->drv);
- }
-
- // --------------------------------------------------------------
- unsigned int
- HalDrive::getDeviceMinor() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- return libhal_drive_get_device_minor(d_impl->drv);
- }
-
- // --------------------------------------------------------------
- bool
- HalDrive::usesRemovableMedia() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- return libhal_drive_uses_removable_media(d_impl->drv);
- }
-
- // --------------------------------------------------------------
- std::vector<std::string>
- HalDrive::getCdromCapabilityNames() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- std::vector<std::string> ret;
- LibHalDriveCdromCaps caps;
-
- /*
- ** FIXME: there is no textual variant :-(
- ** using property key names...
- */
- caps = libhal_drive_get_cdrom_caps(d_impl->drv);
-
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_CDROM)
- ret.push_back("cdrom");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_CDR)
- ret.push_back("cdr");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_CDRW)
- ret.push_back("cdrw");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDRAM)
- ret.push_back("dvdram");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDROM)
- ret.push_back("dvd");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDR)
- ret.push_back("dvdr");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDRW)
- ret.push_back("dvdrw");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDPLUSR)
- ret.push_back("dvdplusr");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDPLUSRW)
- ret.push_back("dvdplusrw");
- if(caps & LIBHAL_DRIVE_CDROM_CAPS_DVDPLUSRDL)
- ret.push_back("dvdplusrdl");
-
- return ret;
-
-#if 0
- if( libhal_drive_get_type(d_impl->drv) != LIBHAL_DRIVE_TYPE_CDROM)
- ZYPP_THROW(HalException(_("Not a CDROM drive")));
-
- /*
- ** FIXME: we use property keys matching
- ** "storage.cdrom.cd*"
- ** "storage.cdrom.dvd*"
- ** but this may print other bool keys,
- ** that are not CDROM caps.
- */
- LibHalPropertySet *props;
- HalError err;
-
- props = libhal_device_get_all_properties(d_impl->hal->hctx,
- getUDI().c_str(),
- &err.error);
- if( !props)
- ZYPP_THROW(err.halException());
-
- std::vector<std::string> ret(1, getTypeName());
- std::string key;
- std::string dvd("storage.cdrom.dvd");
- std::string cd ("storage.cdrom.cd");
-
- LibHalPropertySetIterator it;
- for(libhal_psi_init(&it, props);
- libhal_psi_has_more(&it);
- libhal_psi_next(&it))
- {
- if( libhal_psi_get_type(&it) == LIBHAL_PROPERTY_TYPE_BOOLEAN &&
- libhal_psi_get_bool(&it))
- {
- key = libhal_psi_get_key(&it);
- if( key.compare(0, cd.size(), cd) == 0)
- {
- ret.push_back(key.substr(sizeof("storage.cdrom.")-1));
- }
- else
- if( key.compare(0, dvd.size(), dvd) == 0)
- {
- ret.push_back(key.substr(sizeof("storage.cdrom.")-1));
- }
- }
- }
- libhal_free_property_set(props);
-
- return ret;
-#endif
- }
-
- // --------------------------------------------------------------
- std::vector<std::string>
- HalDrive::findAllVolumes() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_DRIVE(d_impl);
-
- char **names;
- int count = 0;
-
- names = libhal_drive_find_all_volumes(d_impl->hal->hctx,
- d_impl->drv,
- &count);
-
- std::vector<std::string> ret;
- ret.assign(names, names + count);
- libhal_free_string_array(names);
- return ret;
- }
-
-
- ////////////////////////////////////////////////////////////////
- HalVolume::HalVolume()
- : v_impl( NULL)
- {}
-
- HalVolume::HalVolume(HalVolume_Impl *impl)
- : v_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- v_impl.reset(impl);
- }
-
- // --------------------------------------------------------------
- HalVolume::HalVolume(const HalVolume &volume)
- : v_impl( NULL)
- {
- MutexLock lock(g_Mutex);
-
- zypp::RW_pointer<HalVolume_Impl>(volume.v_impl).swap(v_impl);
- }
-
- // --------------------------------------------------------------
- HalVolume::~HalVolume()
- {
- MutexLock lock(g_Mutex);
-
- v_impl.reset();
- }
-
- // --------------------------------------------------------------
- HalVolume &
- HalVolume::operator=(const HalVolume &volume)
- {
- MutexLock lock(g_Mutex);
-
- if( this == &volume)
- return *this;
-
- zypp::RW_pointer<HalVolume_Impl>(volume.v_impl).swap(v_impl);
- return *this;
- }
-
- // --------------------------------------------------------------
- HalVolume::operator HalVolume::bool_type() const
- {
- MutexLock lock(g_Mutex);
-
- return v_impl;
- }
-
- // --------------------------------------------------------------
- std::string
- HalVolume::getUDI() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- const char *ptr = libhal_volume_get_udi(v_impl->vol);
- return std::string(ptr ? ptr : "");
- }
-
- // --------------------------------------------------------------
- std::string
- HalVolume::getDeviceFile() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return std::string(libhal_volume_get_device_file(v_impl->vol));
- }
-
- // --------------------------------------------------------------
- unsigned int
- HalVolume::getDeviceMajor() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return libhal_volume_get_device_major(v_impl->vol);
- }
-
- // --------------------------------------------------------------
- unsigned int
- HalVolume::getDeviceMinor() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return libhal_volume_get_device_minor(v_impl->vol);
- }
-
- // --------------------------------------------------------------
- bool
- HalVolume::isDisc() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return libhal_volume_is_disc(v_impl->vol);
- }
-
- // --------------------------------------------------------------
- bool
- HalVolume::isPartition() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return libhal_volume_is_partition(v_impl->vol);
- }
-
- // --------------------------------------------------------------
- bool
- HalVolume::isMounted() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return libhal_volume_is_mounted(v_impl->vol);
- }
-
- // --------------------------------------------------------------
- std::string
- HalVolume::getFSType() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- return std::string( libhal_volume_get_fstype(v_impl->vol));
- }
-
- // --------------------------------------------------------------
- std::string
- HalVolume::getFSUsage() const
- {
- MutexLock lock(g_Mutex);
- VERIFY_VOLUME(v_impl);
-
- LibHalVolumeUsage usage( libhal_volume_get_fsusage(v_impl->vol));
- std::string ret;
- switch( usage)
- {
- case LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM:
- ret = "filesystem";
- break;
- case LIBHAL_VOLUME_USAGE_PARTITION_TABLE:
- ret = "partitiontable";
- break;
- case LIBHAL_VOLUME_USAGE_RAID_MEMBER:
- return "raid";
- break;
- case LIBHAL_VOLUME_USAGE_CRYPTO:
- ret = "crypto";
- break;
- case LIBHAL_VOLUME_USAGE_UNKNOWN:
- default:
- break;
- }
- return ret;
- }
-
- // --------------------------------------------------------------
- std::string
- HalVolume::getMountPoint() const
- {
- VERIFY_VOLUME(v_impl);
-
- return std::string( libhal_volume_get_mount_point(v_impl->vol));
- }
-
-
- ////////////////////////////////////////////////////////////////
- } // namespace hal
- //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- } // namespace target
- ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
-} // namespace zypp
-//////////////////////////////////////////////////////////////////////
-#else // NO_HAL
-#include <zypp/target/hal/HalContext.h>
-#include <zypp/target/hal/HalException.h>
-namespace zypp
-{ ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
- namespace target
- { //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- namespace hal
- { ////////////////////////////////////////////////////////////////
-
- std::ostream &
- HalException::dumpOn( std::ostream & str ) const
- { return str; }
-
- // --------------------------------------------------------------
- class HalContext_Impl
- {};
- class HalDrive_Impl
- {};
- class HalVolume_Impl
- {};
-
- // --------------------------------------------------------------
- HalContext::HalContext(bool)
- { ZYPP_THROW( NoHalException() ); }
- HalContext::~HalContext()
- {}
- HalContext &
- HalContext::operator=(const HalContext &)
- { return *this; }
- HalContext::operator HalContext::bool_type() const
- { return 0; }
- void
- HalContext::connect()
- {}
- std::vector<std::string>
- HalContext::getAllDevices() const
- { return std::vector<std::string>(); }
- HalDrive
- HalContext::getDriveFromUDI(const std::string &) const
- { return HalDrive(); }
- HalVolume
- HalContext::getVolumeFromUDI(const std::string &) const
- { return HalVolume(); }
- HalVolume
- HalContext::getVolumeFromDeviceFile(const std::string &) const
- { return HalVolume(); }
- std::vector<std::string>
- HalContext::findDevicesByCapability(const std::string &) const
- { return std::vector<std::string>(); }
- bool
- HalContext::getDevicePropertyBool(const std::string &, const std::string &) const
- { return false; }
- void
- HalContext::setDevicePropertyBool (const std::string &, const std::string &, bool value)
- {}
- void
- HalContext::removeDeviceProperty(const std::string &, const std::string &)
- {}
- std::string
- HalContext::getDevicePropertyString(const std::string &, const std::string &) const
- { return ""; }
- // --------------------------------------------------------------
- HalDrive::HalDrive()
- { ZYPP_THROW( NoHalException() ); }
- HalDrive::~HalDrive()
- {}
- HalDrive &
- HalDrive::operator=(const HalDrive &)
- { return *this; }
- HalDrive::operator HalDrive::bool_type() const
- { return 0; }
- std::string
- HalDrive::getUDI() const
- { return std::string(); }
- std::string
- HalDrive::getTypeName() const
- { return std::string(); }
- std::string
- HalDrive::getDeviceFile() const
- { return std::string(); }
- unsigned int
- HalDrive::getDeviceMinor() const
- { return 0; }
- unsigned int
- HalDrive::getDeviceMajor() const
- { return 0; }
- bool
- HalDrive::usesRemovableMedia() const
- { return false; }
- std::vector<std::string>
- HalDrive::getCdromCapabilityNames() const
- { return std::vector<std::string>(); }
- std::vector<std::string>
- HalDrive::findAllVolumes() const
- { return std::vector<std::string>(); }
-
- // --------------------------------------------------------------
- HalVolume::HalVolume()
- { ZYPP_THROW( NoHalException() ); }
- HalVolume::~HalVolume()
- {}
- HalVolume &
- HalVolume::operator=(const HalVolume &)
- { return *this; }
- HalVolume::operator HalVolume::bool_type() const
- { return 0; }
- std::string
- HalVolume::getUDI() const
- { return std::string(); }
- std::string
- HalVolume::getDeviceFile() const
- { return std::string(); }
- unsigned int
- HalVolume::getDeviceMinor() const
- { return 0; }
- unsigned int
- HalVolume::getDeviceMajor() const
- { return 0; }
- bool
- HalVolume::isDisc() const
- { return false; }
- bool
- HalVolume::isPartition() const
- { return false; }
- bool
- HalVolume::isMounted() const
- { return false; }
- std::string
- HalVolume::getFSType() const
- { return std::string(); }
- std::string
- HalVolume::getFSUsage() const
- { return std::string(); }
- std::string
- HalVolume::getMountPoint() const
- { return std::string(); }
-
- ////////////////////////////////////////////////////////////////
- } // namespace hal
- //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- } // namespace target
- ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
-} // namespace zypp
-//////////////////////////////////////////////////////////////////////
-#endif // NO_HAL
-
-/*
-** vim: set ts=2 sts=2 sw=2 ai et:
-*/
+++ /dev/null
-/*---------------------------------------------------------------------\
-| ____ _ __ __ ___ |
-| |__ / \ / / . \ . \ |
-| / / \ V /| _/ _/ |
-| / /__ | | | | | | |
-| /_____||_| |_| |_| |
-| |
-\---------------------------------------------------------------------*/
-/** \file zypp/target/hal/HalContext.h
- *
- * \brief Hardware abstaction layer library wrapper.
- */
-#ifndef ZYPP_TARGET_HAL_HALCONTEXT_H
-#define ZYPP_TARGET_HAL_HALCONTEXT_H
-
-#include <zypp/target/hal/HalException.h>
-#include <zypp/base/PtrTypes.h>
-#include <string>
-#include <vector>
-#include <stdint.h>
-
-//////////////////////////////////////////////////////////////////////
-namespace zypp
-{ ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
- namespace target
- { //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- namespace hal
- { ////////////////////////////////////////////////////////////////
-
-
- // -------------------------------------------------------------
- /** @{
- * Forward declarations.
- */
- class HalDrive;
- class HalVolume;
-
- class HalDrive_Impl;
- class HalVolume_Impl;
- class HalContext_Impl;
- /** }@ */
-
-
- ////////////////////////////////////////////////////////////////
- //
- // CLASS NAME : HalContext
- //
- /** Hardware abstaction layer context.
- *
- * Hal context wrapper. It manages the dbus connection and is
- * the entry point to query drives, volumes and other information.
- *
- * @todo: wrap more functions.
- */
- class HalContext
- {
- public:
- typedef
- zypp::RW_pointer<HalContext_Impl>::unspecified_bool_type bool_type;
-
- HalContext(bool autoconnect=false);
- HalContext(const HalContext &context);
- ~HalContext();
-
- HalContext&
- operator=(const HalContext &context);
-
- /**
- * Verifies if the context is initialized.
- */
- operator bool_type() const;
-
- /**
- */
- void
- connect();
-
- /**
- * Retrieve UDI's of all devices.
- * \return Vector with device UDI's.
- */
- std::vector<std::string>
- getAllDevices() const;
-
- /**
- * Construct a HalDrive object for the specified UDI.
- * \param The \p udi of the drive.
- * \return The HalDrive object.
- */
- HalDrive
- getDriveFromUDI(const std::string &udi) const;
-
- /**
- * Construct a HalVolume object for the specified UDI.
- * \param The \p udi of the volume.
- * \return The HalVolume object.
- */
- HalVolume
- getVolumeFromUDI(const std::string &udi) const;
-
- HalVolume
- getVolumeFromDeviceFile(const std::string &device_file) const;
-
- /**
- * Retrieve UDI's of all devices with a capability.
- * \param The \p capability name
- * \return Vector with device UDI's.
- */
- std::vector<std::string>
- findDevicesByCapability(const std::string &capability) const;
-
- bool
- getDevicePropertyBool (const std::string &udi,
- const std::string &key) const;
-
- int32_t
- getDevicePropertyInt32 (const std::string &udi,
- const std::string &key) const;
-
- uint64_t
- getDevicePropertyUInt64(const std::string &udi,
- const std::string &key) const;
-
- double
- getDevicePropertyDouble(const std::string &udi,
- const std::string &key) const;
-
- std::string
- getDevicePropertyString(const std::string &udi,
- const std::string &key) const;
-
- void
- setDevicePropertyBool (const std::string &udi,
- const std::string &key,
- bool value);
-
- void
- setDevicePropertyInt32 (const std::string &udi,
- const std::string &key,
- int32_t value);
-
- void
- setDevicePropertyUInt64(const std::string &udi,
- const std::string &key,
- uint64_t value);
-
- void
- setDevicePropertyDouble(const std::string &udi,
- const std::string &key,
- double value);
-
- void
- setDevicePropertyString(const std::string &udi,
- const std::string &key,
- const std::string &value);
-
- void
- removeDeviceProperty(const std::string &udi,
- const std::string &key);
-
- private:
-
- zypp::RW_pointer<HalContext_Impl> h_impl;
- };
-
-
- ////////////////////////////////////////////////////////////////
- //
- // CLASS NAME : HalDrive
- //
- /** Hardware abstaction layer storage drive object.
- *
- * @todo: wrap more functions.
- */
- class HalDrive
- {
- public:
- typedef
- zypp::RW_pointer<HalDrive_Impl>::unspecified_bool_type bool_type;
-
- HalDrive();
- HalDrive(const HalDrive &drive);
- ~HalDrive();
-
- HalDrive&
- operator=(const HalDrive &drive);
-
- operator bool_type() const;
-
- std::string
- getUDI() const;
-
- std::string
- getTypeName() const;
-
- /**
- * \return The drive's device file name.
- */
- std::string
- getDeviceFile() const;
-
- /**
- * \return The drive's device file major number.
- */
- unsigned int
- getDeviceMajor() const;
-
- /**
- * \return The drive's device minor number.
- */
- unsigned int
- getDeviceMinor() const;
-
- /**
- * \return True, if drive uses removable media.
- */
- bool
- usesRemovableMedia() const;
-
- /*
- ** Returns the media type names supported by the drive.
- **
- ** Since hal does not implement a textual form here, we
- ** are using the drive type and property names from
- ** "storage.cdrom.*" namespace:
- ** cdrom, cdr, cdrw, dvd, dvdr, dvdrw, dvdram,
- ** dvdplusr, dvdplusrw, dvdplusrdl
- **
- ** FIXME: Should we provide own LibHalDriveCdromCaps?
- */
- std::vector<std::string>
- getCdromCapabilityNames() const;
-
- /**
- * Retrieve UDI's of all volumes of this drive.
- * \return Vector with volume UDI's.
- */
- std::vector<std::string>
- findAllVolumes() const;
-
- private:
- friend class HalContext;
-
- HalDrive(HalDrive_Impl *impl);
-
- zypp::RW_pointer<HalDrive_Impl> d_impl;
- };
-
-
- ////////////////////////////////////////////////////////////////
- //
- // CLASS NAME : HalVolume
- //
- /** Hardware abstaction layer storage volume object.
- *
- * @todo: wrap more functions.
- */
- class HalVolume
- {
- public:
- typedef
- zypp::RW_pointer<HalVolume_Impl>::unspecified_bool_type bool_type;
-
- HalVolume();
- HalVolume(const HalVolume &volume);
- ~HalVolume();
-
- HalVolume&
- operator=(const HalVolume &volume);
-
- operator bool_type() const;
-
- std::string
- getUDI() const;
-
- /**
- * \return The Volume drive's device file name.
- */
- std::string
- getDeviceFile() const;
-
- /**
- * \return The Volume drive's device major number.
- */
- unsigned int
- getDeviceMajor() const;
-
- /**
- * \return The Volume drive's device minor number.
- */
- unsigned int
- getDeviceMinor() const;
-
- bool
- isDisc() const;
-
- bool
- isPartition() const;
-
- bool
- isMounted() const;
-
- /**
- * \return The filesystem name on the volume.
- */
- std::string
- getFSType() const;
-
- /**
- * \return The filesystem usage purpose.
- */
- std::string
- getFSUsage() const;
-
- /**
- * \return The mount point of the volume.
- */
- std::string
- getMountPoint() const;
-
- private:
- friend class HalContext;
- friend class HalDrive;
- HalVolume(HalVolume_Impl *impl);
-
- zypp::RW_pointer<HalVolume_Impl> v_impl;
- };
-
-
- ////////////////////////////////////////////////////////////////
- } // namespace hal
- //////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////
- } // namespace target
- ////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////
-} // namespace zypp
-//////////////////////////////////////////////////////////////////////
-
-#endif // ZYPP_TARGET_HAL_HALCONTEXT_H
-
-/*
-** vim: set ts=2 sts=2 sw=2 ai et:
-*/
projects / platform / upstream / libzypp.git / commitdiff