diff options
author | Peter Schiffer <pschiffe@redhat.com> | 2013-06-27 11:54:39 +0200 |
---|---|---|
committer | Peter Schiffer <pschiffe@redhat.com> | 2013-06-27 11:54:39 +0200 |
commit | c6d97a2d474ba80e6c7449f5127635f8f5663830 (patch) | |
tree | 1ac3e6abb0d5d80efdabd7e3274acf4a0b468604 /src | |
parent | e7cee30c0f2ff6a63e78c48e6b56755c84a96788 (diff) | |
download | openlmi-providers-c6d97a2d474ba80e6c7449f5127635f8f5663830.tar.gz openlmi-providers-c6d97a2d474ba80e6c7449f5127635f8f5663830.tar.xz openlmi-providers-c6d97a2d474ba80e6c7449f5127635f8f5663830.zip |
Hardware: Added battery providers
New providers:
* LMI_BatteryProvider
* LMI_BatteryPhysicalPackageProvider
* LMI_PhysicalBatteryContainerProvider
* LMI_PhysicalBatteryRealizesProvider
Diffstat (limited to 'src')
-rw-r--r-- | src/hardware/LMI_BatteryPhysicalPackageProvider.c | 217 | ||||
-rw-r--r-- | src/hardware/LMI_BatteryProvider.c | 352 | ||||
-rw-r--r-- | src/hardware/LMI_Hardware.h | 2 | ||||
-rw-r--r-- | src/hardware/LMI_PhysicalBatteryContainerProvider.c | 272 | ||||
-rw-r--r-- | src/hardware/LMI_PhysicalBatteryRealizesProvider.c | 264 | ||||
-rw-r--r-- | src/hardware/LMI_PointingDeviceProvider.c | 1 | ||||
-rw-r--r-- | src/hardware/dmidecode.c | 261 | ||||
-rw-r--r-- | src/hardware/dmidecode.h | 29 |
8 files changed, 1396 insertions, 2 deletions
diff --git a/src/hardware/LMI_BatteryPhysicalPackageProvider.c b/src/hardware/LMI_BatteryPhysicalPackageProvider.c new file mode 100644 index 0000000..fbd4888 --- /dev/null +++ b/src/hardware/LMI_BatteryPhysicalPackageProvider.c @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer <pschiffe@redhat.com> + */ + +#include <time.h> +#include <konkret/konkret.h> +#include "LMI_BatteryPhysicalPackage.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +static const CMPIBroker* _cb = NULL; + +static void LMI_BatteryPhysicalPackageInitialize() +{ +} + +static CMPIStatus LMI_BatteryPhysicalPackageCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryPhysicalPackageEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_BatteryPhysicalPackageEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_BatteryPhysicalPackage lmi_batt_phys; + const char *ns = KNameSpace(cop); + char instance_id[INSTANCE_ID_LEN]; + struct tm tm; + unsigned i; + DmiBattery *dmi_batt = NULL; + unsigned dmi_batt_nb = 0; + + if (dmi_get_batteries(&dmi_batt, &dmi_batt_nb) != 0 || dmi_batt_nb < 1) { + goto done; + } + + for (i = 0; i < dmi_batt_nb; i++) { + LMI_BatteryPhysicalPackage_Init(&lmi_batt_phys, _cb, ns); + + LMI_BatteryPhysicalPackage_Set_CreationClassName(&lmi_batt_phys, + ORGID "_" BATTERY_PHYS_PKG_CLASS_NAME); + LMI_BatteryPhysicalPackage_Set_PackageType(&lmi_batt_phys, + LMI_BatteryPhysicalPackage_PackageType_Battery); + LMI_BatteryPhysicalPackage_Set_Caption(&lmi_batt_phys, + "Physical Battery Package"); + LMI_BatteryPhysicalPackage_Set_Description(&lmi_batt_phys, + "This object represents one physical battery package in system."); + + snprintf(instance_id, INSTANCE_ID_LEN, + ORGID ":" ORGID "_" BATTERY_PHYS_PKG_CLASS_NAME ":%s", + dmi_batt[i].name); + + LMI_BatteryPhysicalPackage_Set_Tag(&lmi_batt_phys, dmi_batt[i].name); + LMI_BatteryPhysicalPackage_Set_ElementName(&lmi_batt_phys, + dmi_batt[i].name); + LMI_BatteryPhysicalPackage_Set_Name(&lmi_batt_phys, dmi_batt[i].name); + LMI_BatteryPhysicalPackage_Set_Manufacturer(&lmi_batt_phys, + dmi_batt[i].manufacturer); + LMI_BatteryPhysicalPackage_Set_SerialNumber(&lmi_batt_phys, + dmi_batt[i].serial_number); + LMI_BatteryPhysicalPackage_Set_Version(&lmi_batt_phys, + dmi_batt[i].version); + LMI_BatteryPhysicalPackage_Set_InstanceID(&lmi_batt_phys, instance_id); + + memset(&tm, 0, sizeof(struct tm)); + if (strptime(dmi_batt[i].manufacture_date, "%F", &tm)) { + LMI_BatteryPhysicalPackage_Set_ManufactureDate(&lmi_batt_phys, + CMNewDateTimeFromBinary(_cb, mktime(&tm) * 1000000, 0, NULL)); + } + + KReturnInstance(cr, lmi_batt_phys); + } + +done: + dmi_free_batteries(&dmi_batt, &dmi_batt_nb); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryPhysicalPackageGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_BatteryPhysicalPackageCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryPhysicalPackageModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char** properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryPhysicalPackageDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryPhysicalPackageExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + LMI_BatteryPhysicalPackage, + LMI_BatteryPhysicalPackage, + _cb, + LMI_BatteryPhysicalPackageInitialize()) + +static CMPIStatus LMI_BatteryPhysicalPackageMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryPhysicalPackageInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return LMI_BatteryPhysicalPackage_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + LMI_BatteryPhysicalPackage, + LMI_BatteryPhysicalPackage, + _cb, + LMI_BatteryPhysicalPackageInitialize()) + +KUint32 LMI_BatteryPhysicalPackage_IsCompatible( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryPhysicalPackageRef* self, + const KRef* ElementToCheck, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_BatteryPhysicalPackage", + "LMI_BatteryPhysicalPackage", + "instance method") diff --git a/src/hardware/LMI_BatteryProvider.c b/src/hardware/LMI_BatteryProvider.c new file mode 100644 index 0000000..f5b8e77 --- /dev/null +++ b/src/hardware/LMI_BatteryProvider.c @@ -0,0 +1,352 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer <pschiffe@redhat.com> + */ + +#include <konkret/konkret.h> +#include "LMI_Battery.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +CMPIUint16 get_chemistry(const char *dmi_val); + +static const CMPIBroker* _cb = NULL; + +static void LMI_BatteryInitialize() +{ +} + +static CMPIStatus LMI_BatteryCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_BatteryEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_Battery lmi_batt; + const char *ns = KNameSpace(cop); + char instance_id[INSTANCE_ID_LEN]; + unsigned i; + DmiBattery *dmi_batt = NULL; + unsigned dmi_batt_nb = 0; + + if (dmi_get_batteries(&dmi_batt, &dmi_batt_nb) != 0 || dmi_batt_nb < 1) { + goto done; + } + + for (i = 0; i < dmi_batt_nb; i++) { + LMI_Battery_Init(&lmi_batt, _cb, ns); + + LMI_Battery_Set_SystemCreationClassName(&lmi_batt, + get_system_creation_class_name()); + LMI_Battery_Set_SystemName(&lmi_batt, get_system_name()); + LMI_Battery_Set_CreationClassName(&lmi_batt, + ORGID "_" BATTERY_CLASS_NAME); + LMI_Battery_Set_BatteryStatus(&lmi_batt, + LMI_Battery_BatteryStatus_Unknown); + LMI_Battery_Init_OperationalStatus(&lmi_batt, 1); + LMI_Battery_Set_OperationalStatus(&lmi_batt, 0, + LMI_Battery_OperationalStatus_Unknown); + LMI_Battery_Set_HealthState(&lmi_batt, + LMI_Battery_HealthState_Unknown); + LMI_Battery_Set_EnabledState(&lmi_batt, + LMI_Battery_EnabledState_Unknown); + LMI_Battery_Set_Caption(&lmi_batt, BATTERY_CLASS_NAME); + LMI_Battery_Set_Description(&lmi_batt, + "This object represents one battery in system."); + + snprintf(instance_id, INSTANCE_ID_LEN, + ORGID ":" ORGID "_" BATTERY_CLASS_NAME ":%s", + dmi_batt[i].name); + + LMI_Battery_Set_DeviceID(&lmi_batt, dmi_batt[i].name); + LMI_Battery_Set_ElementName(&lmi_batt, dmi_batt[i].name); + LMI_Battery_Set_Name(&lmi_batt, dmi_batt[i].name); + LMI_Battery_Set_InstanceID(&lmi_batt, instance_id); + LMI_Battery_Set_Chemistry(&lmi_batt, + get_chemistry(dmi_batt[i].chemistry)); + LMI_Battery_Set_DesignCapacity(&lmi_batt, dmi_batt[i].design_capacity); + LMI_Battery_Set_DesignVoltage(&lmi_batt, dmi_batt[i].design_voltage); + + KReturnInstance(cr, lmi_batt); + } + +done: + dmi_free_batteries(&dmi_batt, &dmi_batt_nb); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_BatteryCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char** properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BatteryExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + LMI_Battery, + LMI_Battery, + _cb, + LMI_BatteryInitialize()) + +static CMPIStatus LMI_BatteryMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BatteryInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return LMI_Battery_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + LMI_Battery, + LMI_Battery, + _cb, + LMI_BatteryInitialize()) + +KUint32 LMI_Battery_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + const KUint16* RequestedState, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_SetPowerState( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + const KUint16* PowerState, + const KDateTime* Time, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_Reset( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_EnableDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + const KBoolean* Enabled, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_OnlineDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + const KBoolean* Online, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_QuiesceDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + const KBoolean* Quiesce, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_SaveProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Battery_RestoreProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BatteryRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +/* + * Get battery chemistry according to the dmidecode. + * @param dmi_val from dmidecode + * @return CIM id of pointing type + */ +CMPIUint16 get_chemistry(const char *dmi_val) +{ + if (!dmi_val || !strlen(dmi_val)) { + return 2; /* Unknown */ + } + + static struct { + CMPIUint16 cim_val; /* CIM value */ + char *dmi_val; /* dmidecode value */ + } values[] = { + {1, "Other"}, + {2, "Unknown"}, + {3, "Lead Acid"}, + {4, "Nickel Cadmium"}, + {5, "Nickel Metal Hydride"}, + {6, "Lithium Ion"}, + {6, "LION"}, + {7, "Zinc Air"}, + {8, "Lithium Polymer"}, + }; + + size_t i, val_length = sizeof(values) / sizeof(values[0]); + + for (i = 0; i < val_length; i++) { + if (strcmp(dmi_val, values[i].dmi_val) == 0) { + return values[i].cim_val; + } + } + + return 1; /* Other */ +} + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_Battery", + "LMI_Battery", + "instance method") diff --git a/src/hardware/LMI_Hardware.h b/src/hardware/LMI_Hardware.h index f88e6b6..227ca51 100644 --- a/src/hardware/LMI_Hardware.h +++ b/src/hardware/LMI_Hardware.h @@ -37,5 +37,7 @@ #define PORT_PHYS_CONN_CLASS_NAME "PortPhysicalConnector" #define SYSTEM_SLOT_CLASS_NAME "SystemSlot" #define POINTING_DEVICE_CLASS_NAME "PointingDevice" +#define BATTERY_CLASS_NAME "Battery" +#define BATTERY_PHYS_PKG_CLASS_NAME "BatteryPhysicalPackage" #endif /* LMI_HARDWARE_H_ */ diff --git a/src/hardware/LMI_PhysicalBatteryContainerProvider.c b/src/hardware/LMI_PhysicalBatteryContainerProvider.c new file mode 100644 index 0000000..46bcad4 --- /dev/null +++ b/src/hardware/LMI_PhysicalBatteryContainerProvider.c @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer <pschiffe@redhat.com> + */ + +#include <konkret/konkret.h> +#include "LMI_PhysicalBatteryContainer.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +static const CMPIBroker* _cb; + +static void LMI_PhysicalBatteryContainerInitialize() +{ +} + +static CMPIStatus LMI_PhysicalBatteryContainerCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryContainerEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_PhysicalBatteryContainerEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_PhysicalBatteryContainer lmi_batt_container; + LMI_BatteryPhysicalPackageRef lmi_batt_phys; + LMI_ChassisRef lmi_chassis; + const char *ns = KNameSpace(cop); + unsigned i; + DmiChassis dmi_chassis; + DmiBattery *dmi_batt = NULL; + unsigned dmi_batt_nb = 0; + + if (dmi_get_chassis(&dmi_chassis) != 0) { + goto done; + } + if (dmi_get_batteries(&dmi_batt, &dmi_batt_nb) != 0 || dmi_batt_nb < 1) { + goto done; + } + + LMI_ChassisRef_Init(&lmi_chassis, _cb, ns); + LMI_ChassisRef_Set_CreationClassName(&lmi_chassis, + ORGID "_" CHASSIS_CLASS_NAME); + if (strcmp(dmi_chassis.serial_number, "Not Specified") == 0) { + LMI_ChassisRef_Set_Tag(&lmi_chassis, "0"); + } else { + LMI_ChassisRef_Set_Tag(&lmi_chassis, dmi_chassis.serial_number); + } + + for (i = 0; i < dmi_batt_nb; i++) { + LMI_PhysicalBatteryContainer_Init(&lmi_batt_container, _cb, ns); + + LMI_BatteryPhysicalPackageRef_Init(&lmi_batt_phys, _cb, ns); + LMI_BatteryPhysicalPackageRef_Set_CreationClassName(&lmi_batt_phys, + ORGID "_" BATTERY_PHYS_PKG_CLASS_NAME); + LMI_BatteryPhysicalPackageRef_Set_Tag(&lmi_batt_phys, dmi_batt[i].name); + + LMI_PhysicalBatteryContainer_Set_GroupComponent( + &lmi_batt_container, &lmi_chassis); + LMI_PhysicalBatteryContainer_Set_PartComponent( + &lmi_batt_container, &lmi_batt_phys); + LMI_PhysicalBatteryContainer_Set_LocationWithinContainer( + &lmi_batt_container, dmi_batt[i].location); + + KReturnInstance(cr, lmi_batt_container); + } + +done: + dmi_free_chassis(&dmi_chassis); + dmi_free_batteries(&dmi_batt, &dmi_batt_nb); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryContainerGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_PhysicalBatteryContainerCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryContainerModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char**properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryContainerDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryContainerExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryContainerAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryContainerAssociators( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole, + const char** properties) +{ + return KDefaultAssociators( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryContainer_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus LMI_PhysicalBatteryContainerAssociatorNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole) +{ + return KDefaultAssociatorNames( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryContainer_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus LMI_PhysicalBatteryContainerReferences( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role, + const char** properties) +{ + return KDefaultReferences( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryContainer_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus LMI_PhysicalBatteryContainerReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryContainer_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + LMI_PhysicalBatteryContainer, + LMI_PhysicalBatteryContainer, + _cb, + LMI_PhysicalBatteryContainerInitialize()) + +CMAssociationMIStub( + LMI_PhysicalBatteryContainer, + LMI_PhysicalBatteryContainer, + _cb, + LMI_PhysicalBatteryContainerInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_PhysicalBatteryContainer", + "LMI_PhysicalBatteryContainer", + "instance association") diff --git a/src/hardware/LMI_PhysicalBatteryRealizesProvider.c b/src/hardware/LMI_PhysicalBatteryRealizesProvider.c new file mode 100644 index 0000000..c554fd5 --- /dev/null +++ b/src/hardware/LMI_PhysicalBatteryRealizesProvider.c @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer <pschiffe@redhat.com> + */ + +#include <konkret/konkret.h> +#include "LMI_PhysicalBatteryRealizes.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +static const CMPIBroker* _cb; + +static void LMI_PhysicalBatteryRealizesInitialize() +{ +} + +static CMPIStatus LMI_PhysicalBatteryRealizesCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_PhysicalBatteryRealizes lmi_phys_batt_realizes; + LMI_BatteryPhysicalPackageRef lmi_batt_phys; + LMI_BatteryRef lmi_batt; + const char *ns = KNameSpace(cop); + unsigned i; + DmiBattery *dmi_batt = NULL; + unsigned dmi_batt_nb = 0; + + if (dmi_get_batteries(&dmi_batt, &dmi_batt_nb) != 0 || dmi_batt_nb < 1) { + goto done; + } + + for (i = 0; i < dmi_batt_nb; i++) { + LMI_PhysicalBatteryRealizes_Init(&lmi_phys_batt_realizes, _cb, ns); + + LMI_BatteryRef_Init(&lmi_batt, _cb, ns); + LMI_BatteryRef_Set_SystemCreationClassName(&lmi_batt, + get_system_creation_class_name()); + LMI_BatteryRef_Set_SystemName(&lmi_batt, get_system_name()); + LMI_BatteryRef_Set_CreationClassName(&lmi_batt, + ORGID "_" BATTERY_CLASS_NAME); + LMI_BatteryRef_Set_DeviceID(&lmi_batt, dmi_batt[i].name); + + LMI_BatteryPhysicalPackageRef_Init(&lmi_batt_phys, _cb, ns); + LMI_BatteryPhysicalPackageRef_Set_CreationClassName(&lmi_batt_phys, + ORGID "_" BATTERY_PHYS_PKG_CLASS_NAME); + LMI_BatteryPhysicalPackageRef_Set_Tag(&lmi_batt_phys, dmi_batt[i].name); + + LMI_PhysicalBatteryRealizes_Set_Antecedent(&lmi_phys_batt_realizes, + &lmi_batt_phys); + LMI_PhysicalBatteryRealizes_Set_Dependent(&lmi_phys_batt_realizes, + &lmi_batt); + + KReturnInstance(cr, lmi_phys_batt_realizes); + } + +done: + dmi_free_batteries(&dmi_batt, &dmi_batt_nb); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char**properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesAssociators( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole, + const char** properties) +{ + return KDefaultAssociators( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryRealizes_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesAssociatorNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole) +{ + return KDefaultAssociatorNames( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryRealizes_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesReferences( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role, + const char** properties) +{ + return KDefaultReferences( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryRealizes_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus LMI_PhysicalBatteryRealizesReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + LMI_PhysicalBatteryRealizes_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + LMI_PhysicalBatteryRealizes, + LMI_PhysicalBatteryRealizes, + _cb, + LMI_PhysicalBatteryRealizesInitialize()) + +CMAssociationMIStub( + LMI_PhysicalBatteryRealizes, + LMI_PhysicalBatteryRealizes, + _cb, + LMI_PhysicalBatteryRealizesInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_PhysicalBatteryRealizes", + "LMI_PhysicalBatteryRealizes", + "instance association") diff --git a/src/hardware/LMI_PointingDeviceProvider.c b/src/hardware/LMI_PointingDeviceProvider.c index f3c89d6..d5203d2 100644 --- a/src/hardware/LMI_PointingDeviceProvider.c +++ b/src/hardware/LMI_PointingDeviceProvider.c @@ -59,7 +59,6 @@ static CMPIStatus LMI_PointingDeviceEnumInstances( { LMI_PointingDevice lmi_dev; const char *ns = KNameSpace(cop); - //CMPIUint16 conn_layout, maxlinkwidth; char instance_id[INSTANCE_ID_LEN]; unsigned i; DmiPointingDevice *dmi_dev = NULL; diff --git a/src/hardware/dmidecode.c b/src/hardware/dmidecode.c index d989a09..a171707 100644 --- a/src/hardware/dmidecode.c +++ b/src/hardware/dmidecode.c @@ -1969,7 +1969,7 @@ short dmi_get_pointing_devices(DmiPointingDevice **devices, unsigned *devices_nb /* fill in default attributes if needed */ for (i = 0; i < *devices_nb; i++) { if (check_dmipointingdev_attributes(&(*devices)[i]) != 0) { - ret = -8; + ret = -5; goto done; } } @@ -2001,3 +2001,262 @@ void dmi_free_pointing_devices(DmiPointingDevice **devices, unsigned *devices_nb *devices_nb = 0; *devices = NULL; } + + +/****************************************************************************** + * DmiBattery + */ + +/* + * Initialize DmiBattery attributes. + * @param batt + */ +void init_dmibattery_struct(DmiBattery *batt) +{ + batt->name = NULL; + batt->chemistry = NULL; + batt->design_capacity = 0; + batt->design_voltage = 0; + batt->manufacturer = NULL; + batt->serial_number = NULL; + batt->version = NULL; + batt->manufacture_date = NULL; + batt->location = NULL; +} + +/* + * Check attributes of battery structure and fill in defaults if needed. + * @param batt + * @return 0 if success, negative value otherwise + */ +short check_dmibattery_attributes(DmiBattery *batt) +{ + short ret = -1; + + if (!batt->name) { + if (!(batt->name = strdup("Battery"))) { + ret = -2; + goto done; + } + } + if (!batt->chemistry) { + if (!(batt->chemistry = strdup("Unknown"))) { + ret = -3; + goto done; + } + } + if (!batt->manufacturer) { + if (!(batt->manufacturer = strdup(""))) { + ret = -4; + goto done; + } + } + if (!batt->serial_number) { + if (!(batt->serial_number = strdup(""))) { + ret = -5; + goto done; + } + } + if (!batt->version) { + if (!(batt->version = strdup(""))) { + ret = -6; + goto done; + } + } + if (!batt->manufacture_date) { + if (!(batt->manufacture_date = strdup(""))) { + ret = -7; + goto done; + } + } + if (!batt->location) { + if (!(batt->location = strdup(""))) { + ret = -8; + goto done; + } + } + + ret = 0; + +done: + if (ret != 0) { + warn("Failed to allocate memory."); + } + + return ret; +} + +short dmi_get_batteries(DmiBattery **batteries, unsigned *batteries_nb) +{ + short ret = -1; + int curr_batt = -1; + unsigned i, buffer_size = 0; + char **buffer = NULL, *buf; + + *batteries_nb = 0; + + /* get dmidecode output */ + if (run_command("dmidecode -t 22", &buffer, &buffer_size) != 0) { + ret = -2; + goto done; + } + + /* count batteries */ + for (i = 0; i < buffer_size; i++) { + if (strncmp(buffer[i], "Handle 0x", 9) == 0) { + (*batteries_nb)++; + } + } + + /* if no battery was found */ + if (*batteries_nb < 1) { + warn("Dmidecode didn't recognize any batteries."); + ret = -3; + goto done; + } + + /* allocate memory for batteries */ + *batteries = (DmiBattery *)calloc(*batteries_nb, sizeof(DmiBattery)); + if (!(*batteries)) { + warn("Failed to allocate memory."); + ret = -4; + goto done; + } + + /* parse information about batteries */ + for (i = 0; i < buffer_size; i++) { + if (strncmp(buffer[i], "Handle 0x", 9) == 0) { + curr_batt++; + init_dmibattery_struct(&(*batteries)[curr_batt]); + continue; + } + /* ignore first useless lines */ + if (curr_batt < 0) { + continue; + } + /* Name */ + buf = copy_string_part_after_delim(buffer[i], "Name: "); + if (buf) { + (*batteries)[curr_batt].name = buf; + buf = NULL; + continue; + } + /* Chemistry */ + buf = copy_string_part_after_delim(buffer[i], "Chemistry: "); + if (buf) { + if (!(*batteries)[curr_batt].chemistry) { + (*batteries)[curr_batt].chemistry = buf; + } else { + free(buf); + } + buf = NULL; + continue; + } + /* Design capacity */ + buf = copy_string_part_after_delim(buffer[i], "Design Capacity: "); + if (buf) { + sscanf(buf, "%u", &(*batteries)[curr_batt].design_capacity); + free(buf); + buf = NULL; + continue; + } + /* Design voltage */ + buf = copy_string_part_after_delim(buffer[i], "Design Voltage: "); + if (buf) { + sscanf(buf, "%u", &(*batteries)[curr_batt].design_voltage); + free(buf); + buf = NULL; + continue; + } + /* Manufacturer */ + buf = copy_string_part_after_delim(buffer[i], "Manufacturer: "); + if (buf) { + (*batteries)[curr_batt].manufacturer = buf; + buf = NULL; + continue; + } + /* Serial number */ + buf = copy_string_part_after_delim(buffer[i], "Serial Number: "); + if (buf) { + if (!(*batteries)[curr_batt].serial_number) { + (*batteries)[curr_batt].serial_number = buf; + } else { + free(buf); + } + buf = NULL; + continue; + } + /* Version */ + buf = copy_string_part_after_delim(buffer[i], "Version: "); + if (buf) { + (*batteries)[curr_batt].version = buf; + buf = NULL; + continue; + } + /* Manufacture date */ + buf = copy_string_part_after_delim(buffer[i], "Manufacture Date: "); + if (buf) { + if (!(*batteries)[curr_batt].manufacture_date) { + (*batteries)[curr_batt].manufacture_date = buf; + } else { + free(buf); + } + buf = NULL; + continue; + } + /* Location */ + buf = copy_string_part_after_delim(buffer[i], "Location: "); + if (buf) { + (*batteries)[curr_batt].location = buf; + buf = NULL; + continue; + } + } + + /* fill in default attributes if needed */ + for (i = 0; i < *batteries_nb; i++) { + if (check_dmibattery_attributes(&(*batteries)[i]) != 0) { + ret = -5; + goto done; + } + } + + ret = 0; + +done: + free_2d_buffer(&buffer, &buffer_size); + + if (ret != 0) { + dmi_free_batteries(batteries, batteries_nb); + } + + return ret; +} + +void dmi_free_batteries(DmiBattery **batteries, unsigned *batteries_nb) +{ + unsigned i; + + if (*batteries_nb > 0) { + for (i = 0; i < *batteries_nb; i++) { + free((*batteries)[i].name); + (*batteries)[i].name = NULL; + free((*batteries)[i].chemistry); + (*batteries)[i].chemistry = NULL; + free((*batteries)[i].manufacturer); + (*batteries)[i].manufacturer = NULL; + free((*batteries)[i].serial_number); + (*batteries)[i].serial_number = NULL; + free((*batteries)[i].version); + (*batteries)[i].version = NULL; + free((*batteries)[i].manufacture_date); + (*batteries)[i].manufacture_date = NULL; + free((*batteries)[i].location); + (*batteries)[i].location = NULL; + } + free(*batteries); + } + + *batteries_nb = 0; + *batteries = NULL; +} diff --git a/src/hardware/dmidecode.h b/src/hardware/dmidecode.h index 34bfd47..a29d90d 100644 --- a/src/hardware/dmidecode.h +++ b/src/hardware/dmidecode.h @@ -141,6 +141,19 @@ typedef struct _DmiPointingDevice { unsigned buttons; /* Number of buttons */ } DmiPointingDevice; +/* Battery from dmidecode. */ +typedef struct _DmiBattery { + char *name; /* Battery name */ + char *chemistry; /* Battery chemistry */ + unsigned design_capacity; /* Design capacity */ + unsigned design_voltage; /* Design voltage */ + char *manufacturer; /* Manufacturer */ + char *serial_number; /* Serial number */ + char *version; /* Version */ + char *manufacture_date; /* Manufacture date */ + char *location; /* Battery location */ +} DmiBattery; + /* * Get array of processors according to the dmidecode program. * @param cpu array of cpus, this function will allocate necessary memory, @@ -263,5 +276,21 @@ short dmi_get_pointing_devices(DmiPointingDevice **devices, unsigned *devices_nb */ void dmi_free_pointing_devices(DmiPointingDevice **devices, unsigned *devices_nb); +/* + * Get array of batteries according to the dmidecode program. + * @param batteries array of batteries, this function will allocate necessary memory, + * but caller is responsible for freeing it + * @param batteries_nb number of batteries + * @return 0 if success, negative value otherwise + */ +short dmi_get_batteries(DmiBattery **batteries, unsigned *batteries_nb); + +/* + * Free array of batteries structures. + * @param batteries array of batteries + * @param batteries_nb number of batteries + */ +void dmi_free_batteries(DmiBattery **batteries, unsigned *batteries_nb); + #endif /* DMIDECODE_H_ */ |