Replace all Linux_ prefixes with Cura_ prefixes.

6 files changed, 234 insertions, 234 deletions

diff --git a/src/fan/CMakeLists.txt b/src/fan/CMakeLists.txt
index 405c6ef..16b3115 100644
--- a/src/fan/CMakeLists.txt
+++ b/src/fan/CMakeLists.txt
@@ -1,11 +1,11 @@
 
 set(PROVIDER_NAME Fan)
 set(LIBRARY_NAME cmpi${PROVIDER_NAME})
-set(MOF Linux_Fan.mof)
+set(MOF Cura_Fan.mof)
 
 set(provider_SRCS
     fan.c
-    Linux_FanProvider.c
+    Cura_FanProvider.c
 )
 
 konkretcmpi_generate(${MOF}
diff --git a/src/fan/Linux_FanAssociatedSensorProvider.c b/src/fan/Cura_FanAssociatedSensorProvider.c
index ddb55c1..185518a 100644
--- a/src/fan/Linux_FanAssociatedSensorProvider.c
+++ b/src/fan/Cura_FanAssociatedSensorProvider.c
@@ -1,16 +1,16 @@
 #include <konkret/konkret.h>
-#include "Linux_FanAssociatedSensor.h"
+#include "Cura_FanAssociatedSensor.h"
 #include "fan.h"
 #include <globals.h>
 
 static const CMPIBroker* _cb;
 
-static void Linux_FanAssociatedSensorInitialize()
+static void Cura_FanAssociatedSensorInitialize()
 {
     init_linux_fan_module();
 }
 
-static CMPIStatus Linux_FanAssociatedSensorCleanup( 
+static CMPIStatus Cura_FanAssociatedSensorCleanup(
     CMPIInstanceMI* mi,
     const CMPIContext* cc, 
     CMPIBoolean term)
@@ -18,7 +18,7 @@ static CMPIStatus Linux_FanAssociatedSensorCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorEnumInstanceNames( 
+static CMPIStatus Cura_FanAssociatedSensorEnumInstanceNames(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -28,7 +28,7 @@ static CMPIStatus Linux_FanAssociatedSensorEnumInstanceNames(
         _cb, mi, cc, cr, cop);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorEnumInstances( 
+static CMPIStatus Cura_FanAssociatedSensorEnumInstances(
     CMPIInstanceMI* mi,
     const CMPIContext* cc, 
     const CMPIResult* cr, 
@@ -47,25 +47,25 @@ static CMPIStatus Linux_FanAssociatedSensorEnumInstances(
     // iterate fan list
     while (lptr) {
         sptr = lptr->f;
-        Linux_FanAssociatedSensor w;
-        Linux_FanAssociatedSensor_Init(&w, _cb, ns);
-
-        Linux_FanRef fan;
-        Linux_FanRef_Init(&fan, _cb, ns);
-        Linux_FanRef_Set_CreationClassName(&fan, "Linux_Fan");
-        Linux_FanRef_Set_DeviceID(&fan, sptr->device_id);
-        Linux_FanRef_Set_SystemCreationClassName(&fan, get_system_creation_class_name());
-        Linux_FanRef_Set_SystemName(&fan, get_system_name());
-
-        Linux_FanSensorRef fanSensor;
-        Linux_FanSensorRef_Init(&fanSensor, _cb, ns);
-        Linux_FanSensorRef_Set_CreationClassName(&fanSensor, "Linux_FanSensor");
-        Linux_FanSensorRef_Set_DeviceID(&fanSensor, sptr->device_id);
-        Linux_FanSensorRef_Set_SystemCreationClassName(&fanSensor, get_system_creation_class_name());
-        Linux_FanSensorRef_Set_SystemName(&fanSensor, get_system_name());
-
-        Linux_FanAssociatedSensor_Set_Antecedent(&w, &fanSensor);
-        Linux_FanAssociatedSensor_Set_Dependent(&w, &fan);
+        Cura_FanAssociatedSensor w;
+        Cura_FanAssociatedSensor_Init(&w, _cb, ns);
+
+        Cura_FanRef fan;
+        Cura_FanRef_Init(&fan, _cb, ns);
+        Cura_FanRef_Set_CreationClassName(&fan, "Cura_Fan");
+        Cura_FanRef_Set_DeviceID(&fan, sptr->device_id);
+        Cura_FanRef_Set_SystemCreationClassName(&fan, get_system_creation_class_name());
+        Cura_FanRef_Set_SystemName(&fan, get_system_name());
+
+        Cura_FanSensorRef fanSensor;
+        Cura_FanSensorRef_Init(&fanSensor, _cb, ns);
+        Cura_FanSensorRef_Set_CreationClassName(&fanSensor, "Cura_FanSensor");
+        Cura_FanSensorRef_Set_DeviceID(&fanSensor, sptr->device_id);
+        Cura_FanSensorRef_Set_SystemCreationClassName(&fanSensor, get_system_creation_class_name());
+        Cura_FanSensorRef_Set_SystemName(&fanSensor, get_system_name());
+
+        Cura_FanAssociatedSensor_Set_Antecedent(&w, &fanSensor);
+        Cura_FanAssociatedSensor_Set_Dependent(&w, &fan);
 
         KReturnInstance(cr, w);
         lptr = lptr->next;
@@ -73,7 +73,7 @@ static CMPIStatus Linux_FanAssociatedSensorEnumInstances(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorGetInstance( 
+static CMPIStatus Cura_FanAssociatedSensorGetInstance(
     CMPIInstanceMI* mi, 
     const CMPIContext* cc,
     const CMPIResult* cr, 
@@ -84,7 +84,7 @@ static CMPIStatus Linux_FanAssociatedSensorGetInstance(
         _cb, mi, cc, cr, cop, properties);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorCreateInstance( 
+static CMPIStatus Cura_FanAssociatedSensorCreateInstance(
     CMPIInstanceMI* mi, 
     const CMPIContext* cc, 
     const CMPIResult* cr, 
@@ -94,7 +94,7 @@ static CMPIStatus Linux_FanAssociatedSensorCreateInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorModifyInstance( 
+static CMPIStatus Cura_FanAssociatedSensorModifyInstance(
     CMPIInstanceMI* mi, 
     const CMPIContext* cc, 
     const CMPIResult* cr, 
@@ -105,7 +105,7 @@ static CMPIStatus Linux_FanAssociatedSensorModifyInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorDeleteInstance( 
+static CMPIStatus Cura_FanAssociatedSensorDeleteInstance(
     CMPIInstanceMI* mi, 
     const CMPIContext* cc, 
     const CMPIResult* cr, 
@@ -114,7 +114,7 @@ static CMPIStatus Linux_FanAssociatedSensorDeleteInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorExecQuery(
+static CMPIStatus Cura_FanAssociatedSensorExecQuery(
     CMPIInstanceMI* mi, 
     const CMPIContext* cc, 
     const CMPIResult* cr, 
@@ -125,7 +125,7 @@ static CMPIStatus Linux_FanAssociatedSensorExecQuery(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorAssociationCleanup( 
+static CMPIStatus Cura_FanAssociatedSensorAssociationCleanup(
     CMPIAssociationMI* mi,
     const CMPIContext* cc, 
     CMPIBoolean term) 
@@ -133,7 +133,7 @@ static CMPIStatus Linux_FanAssociatedSensorAssociationCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorAssociators(
+static CMPIStatus Cura_FanAssociatedSensorAssociators(
     CMPIAssociationMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -150,7 +150,7 @@ static CMPIStatus Linux_FanAssociatedSensorAssociators(
         cc,
         cr,
         cop,
-        Linux_FanAssociatedSensor_ClassName,
+        Cura_FanAssociatedSensor_ClassName,
         assocClass,
         resultClass,
         role,
@@ -158,7 +158,7 @@ static CMPIStatus Linux_FanAssociatedSensorAssociators(
         properties);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorAssociatorNames(
+static CMPIStatus Cura_FanAssociatedSensorAssociatorNames(
     CMPIAssociationMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -174,14 +174,14 @@ static CMPIStatus Linux_FanAssociatedSensorAssociatorNames(
         cc,
         cr,
         cop,
-        Linux_FanAssociatedSensor_ClassName,
+        Cura_FanAssociatedSensor_ClassName,
         assocClass,
         resultClass,
         role,
         resultRole);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorReferences(
+static CMPIStatus Cura_FanAssociatedSensorReferences(
     CMPIAssociationMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -196,13 +196,13 @@ static CMPIStatus Linux_FanAssociatedSensorReferences(
         cc,
         cr,
         cop,
-        Linux_FanAssociatedSensor_ClassName,
+        Cura_FanAssociatedSensor_ClassName,
         assocClass,
         role,
         properties);
 }
 
-static CMPIStatus Linux_FanAssociatedSensorReferenceNames(
+static CMPIStatus Cura_FanAssociatedSensorReferenceNames(
     CMPIAssociationMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -216,25 +216,25 @@ static CMPIStatus Linux_FanAssociatedSensorReferenceNames(
         cc,
         cr,
         cop,
-        Linux_FanAssociatedSensor_ClassName,
+        Cura_FanAssociatedSensor_ClassName,
         assocClass,
         role);
 }
 
 CMInstanceMIStub( 
-    Linux_FanAssociatedSensor,
-    Linux_FanAssociatedSensor,
+    Cura_FanAssociatedSensor,
+    Cura_FanAssociatedSensor,
     _cb,
-    Linux_FanAssociatedSensorInitialize())
+    Cura_FanAssociatedSensorInitialize())
 
 CMAssociationMIStub( 
-    Linux_FanAssociatedSensor,
-    Linux_FanAssociatedSensor,
+    Cura_FanAssociatedSensor,
+    Cura_FanAssociatedSensor,
     _cb,
-    Linux_FanAssociatedSensorInitialize())
+    Cura_FanAssociatedSensorInitialize())
 
 KONKRET_REGISTRATION(
     "root/cimv2",
-    "Linux_FanAssociatedSensor",
-    "Linux_FanAssociatedSensor",
+    "Cura_FanAssociatedSensor",
+    "Cura_FanAssociatedSensor",
     "instance association")
diff --git a/src/fan/Linux_FanProvider.c b/src/fan/Cura_FanProvider.c
index fe7a0fa..4538b98 100644
--- a/src/fan/Linux_FanProvider.c
+++ b/src/fan/Cura_FanProvider.c
@@ -1,6 +1,6 @@
 #include <konkret/konkret.h>
 #include <stdint.h>
-#include "Linux_Fan.h"
+#include "Cura_Fan.h"
 #include "globals.h"
 #include "fan.h"
 static const CMPIBroker* _cb = NULL;
@@ -26,13 +26,13 @@ void print_backtrace(int signal)
     }
 }
 
-static void Linux_FanInitialize()
+static void Cura_FanInitialize()
 {
     init_linux_fan_module();
     signal(SIGSEGV, print_backtrace);
 }
 
-static CMPIStatus Linux_FanCleanup(
+static CMPIStatus Cura_FanCleanup(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     CMPIBoolean term)
@@ -40,7 +40,7 @@ static CMPIStatus Linux_FanCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanEnumInstanceNames(
+static CMPIStatus Cura_FanEnumInstanceNames(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -50,7 +50,7 @@ static CMPIStatus Linux_FanEnumInstanceNames(
         _cb, mi, cc, cr, cop);
 }
 
-static CMPIStatus Linux_FanEnumInstances(
+static CMPIStatus Cura_FanEnumInstances(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -72,30 +72,30 @@ static CMPIStatus Linux_FanEnumInstances(
     lptr = fans;
     while (lptr != NULL) {
         sptr = lptr->f;
-        Linux_Fan w;
-        Linux_Fan_Init(&w, _cb, ns);
-        Linux_Fan_Set_CreationClassName(&w, "Linux_Fan");
-        Linux_Fan_Set_SystemCreationClassName(&w, get_system_creation_class_name());
-        Linux_Fan_Set_SystemName(&w, get_system_name());
-        Linux_Fan_Set_DeviceID(&w, sptr->device_id);
-
-        Linux_Fan_Set_Caption(&w, "Computer's fan");
-        Linux_Fan_Set_Description(&w,"Computer's fan.");
+        Cura_Fan w;
+        Cura_Fan_Init(&w, _cb, ns);
+        Cura_Fan_Set_CreationClassName(&w, "Cura_Fan");
+        Cura_Fan_Set_SystemCreationClassName(&w, get_system_creation_class_name());
+        Cura_Fan_Set_SystemName(&w, get_system_name());
+        Cura_Fan_Set_DeviceID(&w, sptr->device_id);
+
+        Cura_Fan_Set_Caption(&w, "Computer's fan");
+        Cura_Fan_Set_Description(&w,"Computer's fan.");
         snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name);
-        Linux_Fan_Set_ElementName(&w, buf);
+        Cura_Fan_Set_ElementName(&w, buf);
 
         // ManagedSystemElement
-        Linux_Fan_Set_Name(&w, sptr->name);
-        Linux_Fan_Init_OperationalStatus(&w, 2);
-        Linux_Fan_Set_OperationalStatus(&w, 0, sptr->fault ?
-                Linux_Fan_OperationalStatus_Error :
-                Linux_Fan_OperationalStatus_OK);
+        Cura_Fan_Set_Name(&w, sptr->name);
+        Cura_Fan_Init_OperationalStatus(&w, 2);
+        Cura_Fan_Set_OperationalStatus(&w, 0, sptr->fault ?
+                Cura_Fan_OperationalStatus_Error :
+                Cura_Fan_OperationalStatus_OK);
         if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) {
-            Linux_Fan_Set_OperationalStatus(&w, 1, Linux_Fan_OperationalStatus_Stressed);
+            Cura_Fan_Set_OperationalStatus(&w, 1, Cura_Fan_OperationalStatus_Stressed);
         }
 
-        Linux_Fan_Init_StatusDescriptions(&w, 2);
-        Linux_Fan_Set_StatusDescriptions(&w, 0, sptr->fault ?
+        Cura_Fan_Init_StatusDescriptions(&w, 2);
+        Cura_Fan_Set_StatusDescriptions(&w, 0, sptr->fault ?
                 "Chip indicates, that fan is in fault state."
                 " Possible causes are open diodes, unconnected fan etc."
                 " Thus the measurement for this channel should not be trusted."
@@ -106,66 +106,66 @@ static CMPIStatus Linux_FanEnumInstances(
                      sptr->alarm ? "1":"0",
                      sptr->alarm_min ? "1":"0",
                      sptr->alarm_max ? "1":"0");
-            Linux_Fan_Set_StatusDescriptions(&w, 1, buf);
+            Cura_Fan_Set_StatusDescriptions(&w, 1, buf);
         }
 
 
-        Linux_Fan_Set_HealthState(&w, sptr->fault ?
-                Linux_Fan_HealthState_Major_failure :
-                Linux_Fan_HealthState_OK);
+        Cura_Fan_Set_HealthState(&w, sptr->fault ?
+                Cura_Fan_HealthState_Major_failure :
+                Cura_Fan_HealthState_OK);
 
-        Linux_Fan_Set_OperatingStatus(&w, sptr->fault ?
-                Linux_Fan_OperatingStatus_Stopped :
-                Linux_Fan_OperatingStatus_In_Service);
+        Cura_Fan_Set_OperatingStatus(&w, sptr->fault ?
+                Cura_Fan_OperatingStatus_Stopped :
+                Cura_Fan_OperatingStatus_In_Service);
 
-        Linux_Fan_Set_PrimaryStatus(&w, sptr->fault ?
-                Linux_Fan_PrimaryStatus_Error :
-                Linux_Fan_PrimaryStatus_OK);
+        Cura_Fan_Set_PrimaryStatus(&w, sptr->fault ?
+                Cura_Fan_PrimaryStatus_Error :
+                Cura_Fan_PrimaryStatus_OK);
 
         // EnabledLogicalElement
-        Linux_Fan_Init_OtherIdentifyingInfo(&w, 2);
-        Linux_Fan_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name);
-        Linux_Fan_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path);
+        Cura_Fan_Init_OtherIdentifyingInfo(&w, 2);
+        Cura_Fan_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name);
+        Cura_Fan_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path);
 
-        Linux_Fan_Init_IdentifyingDescriptions(&w, 2);
-        Linux_Fan_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip.");
-        Linux_Fan_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip.");
+        Cura_Fan_Init_IdentifyingDescriptions(&w, 2);
+        Cura_Fan_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip.");
+        Cura_Fan_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip.");
 
-        Linux_Fan_Set_ActiveCooling(&w, true);
+        Cura_Fan_Set_ActiveCooling(&w, true);
 
         uint32_t i = 1;
         int index = 0;
         debug("accessible_features: %d", sptr->accessible_features);
-        Linux_Fan_Init_AccessibleFeatures(&w, 8);
+        Cura_Fan_Init_AccessibleFeatures(&w, 8);
         while (i <= CIM_FAN_AF_FEATURE_MAX) {
             if (i & sptr->accessible_features) {
-                Linux_Fan_Set_AccessibleFeatures(&w, index++, i);
+                Cura_Fan_Set_AccessibleFeatures(&w, index++, i);
             }
             i = i << 1;
         }
         if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) {
-            Linux_Fan_Set_MinSpeed(&w, (uint64_t) sptr->min_speed);
+            Cura_Fan_Set_MinSpeed(&w, (uint64_t) sptr->min_speed);
         }
         if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) {
-            Linux_Fan_Set_MaxSpeed(&w, (uint64_t) sptr->max_speed);
+            Cura_Fan_Set_MaxSpeed(&w, (uint64_t) sptr->max_speed);
         }
         if (sptr->accessible_features & CIM_FAN_AF_DIV) {
-            Linux_Fan_Set_Divisor(&w, sptr->divisor);
+            Cura_Fan_Set_Divisor(&w, sptr->divisor);
         }
         if (sptr->accessible_features & CIM_FAN_AF_PULSES) {
-            Linux_Fan_Set_Pulses(&w, sptr->pulses);
+            Cura_Fan_Set_Pulses(&w, sptr->pulses);
         }
         if (sptr->accessible_features & CIM_FAN_AF_BEEP) {
-            Linux_Fan_Set_Beep(&w, sptr->beep);
+            Cura_Fan_Set_Beep(&w, sptr->beep);
         }
         if (sptr->accessible_features & CIM_FAN_AF_ALARM) {
-            Linux_Fan_Set_Alarm(&w, sptr->alarm);
+            Cura_Fan_Set_Alarm(&w, sptr->alarm);
         }
         if (sptr->accessible_features & CIM_FAN_AF_ALARM_MIN) {
-            Linux_Fan_Set_MinAlarm(&w, sptr->alarm_min);
+            Cura_Fan_Set_MinAlarm(&w, sptr->alarm_min);
         }
         if (sptr->accessible_features & CIM_FAN_AF_ALARM_MAX) {
-            Linux_Fan_Set_MaxAlarm(&w, sptr->alarm_max);
+            Cura_Fan_Set_MaxAlarm(&w, sptr->alarm_max);
         }
 
         KReturnInstance(cr, w);
@@ -175,7 +175,7 @@ static CMPIStatus Linux_FanEnumInstances(
     KReturn(OK);
 }
 
-static CMPIStatus Linux_FanGetInstance(
+static CMPIStatus Cura_FanGetInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -186,7 +186,7 @@ static CMPIStatus Linux_FanGetInstance(
         _cb, mi, cc, cr, cop, properties);
 }
 
-static CMPIStatus Linux_FanCreateInstance(
+static CMPIStatus Cura_FanCreateInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -196,7 +196,7 @@ static CMPIStatus Linux_FanCreateInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanModifyInstance(
+static CMPIStatus Cura_FanModifyInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -207,7 +207,7 @@ static CMPIStatus Linux_FanModifyInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanDeleteInstance(
+static CMPIStatus Cura_FanDeleteInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -216,7 +216,7 @@ static CMPIStatus Linux_FanDeleteInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanExecQuery(
+static CMPIStatus Cura_FanExecQuery(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -228,12 +228,12 @@ static CMPIStatus Linux_FanExecQuery(
 }
 
 CMInstanceMIStub(
-    Linux_Fan,
-    Linux_Fan,
+    Cura_Fan,
+    Cura_Fan,
     _cb,
-    Linux_FanInitialize())
+    Cura_FanInitialize())
 
-static CMPIStatus Linux_FanMethodCleanup(
+static CMPIStatus Cura_FanMethodCleanup(
     CMPIMethodMI* mi,
     const CMPIContext* cc,
     CMPIBoolean term)
@@ -241,7 +241,7 @@ static CMPIStatus Linux_FanMethodCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanInvokeMethod(
+static CMPIStatus Cura_FanInvokeMethod(
     CMPIMethodMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -250,21 +250,21 @@ static CMPIStatus Linux_FanInvokeMethod(
     const CMPIArgs* in,
     CMPIArgs* out)
 {
-    return Linux_Fan_DispatchMethod(
+    return Cura_Fan_DispatchMethod(
         _cb, mi, cc, cr, cop, meth, in, out);
 }
 
 CMMethodMIStub(
-    Linux_Fan,
-    Linux_Fan,
+    Cura_Fan,
+    Cura_Fan,
     _cb,
-    Linux_FanInitialize())
+    Cura_FanInitialize())
 
-KUint32 Linux_Fan_RequestStateChange(
+KUint32 Cura_Fan_RequestStateChange(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KUint16* RequestedState,
     KRef* Job,
     const KDateTime* TimeoutPeriod,
@@ -276,11 +276,11 @@ KUint32 Linux_Fan_RequestStateChange(
     return result;
 }
 
-KUint32 Linux_Fan_SetPowerState(
+KUint32 Cura_Fan_SetPowerState(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KUint16* PowerState,
     const KDateTime* Time,
     CMPIStatus* status)
@@ -291,11 +291,11 @@ KUint32 Linux_Fan_SetPowerState(
     return result;
 }
 
-KUint32 Linux_Fan_Reset(
+KUint32 Cura_Fan_Reset(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -304,11 +304,11 @@ KUint32 Linux_Fan_Reset(
     return result;
 }
 
-KUint32 Linux_Fan_EnableDevice(
+KUint32 Cura_Fan_EnableDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KBoolean* Enabled,
     CMPIStatus* status)
 {
@@ -318,11 +318,11 @@ KUint32 Linux_Fan_EnableDevice(
     return result;
 }
 
-KUint32 Linux_Fan_OnlineDevice(
+KUint32 Cura_Fan_OnlineDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KBoolean* Online,
     CMPIStatus* status)
 {
@@ -332,11 +332,11 @@ KUint32 Linux_Fan_OnlineDevice(
     return result;
 }
 
-KUint32 Linux_Fan_QuiesceDevice(
+KUint32 Cura_Fan_QuiesceDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KBoolean* Quiesce,
     CMPIStatus* status)
 {
@@ -346,11 +346,11 @@ KUint32 Linux_Fan_QuiesceDevice(
     return result;
 }
 
-KUint32 Linux_Fan_SaveProperties(
+KUint32 Cura_Fan_SaveProperties(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -359,11 +359,11 @@ KUint32 Linux_Fan_SaveProperties(
     return result;
 }
 
-KUint32 Linux_Fan_RestoreProperties(
+KUint32 Cura_Fan_RestoreProperties(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -372,11 +372,11 @@ KUint32 Linux_Fan_RestoreProperties(
     return result;
 }
 
-KUint32 Linux_Fan_SetSpeed(
+KUint32 Cura_Fan_SetSpeed(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanRef* self,
+    const Cura_FanRef* self,
     const KUint64* DesiredSpeed,
     CMPIStatus* status)
 {
@@ -388,6 +388,6 @@ KUint32 Linux_Fan_SetSpeed(
 
 KONKRET_REGISTRATION(
     "root/cimv2",
-    "Linux_Fan",
-    "Linux_Fan",
+    "Cura_Fan",
+    "Cura_Fan",
     "instance method")
diff --git a/src/fan/Linux_FanSensorProvider.c b/src/fan/Cura_FanSensorProvider.c
index 390e5cf..efbc1a5 100644
--- a/src/fan/Linux_FanSensorProvider.c
+++ b/src/fan/Cura_FanSensorProvider.c
@@ -1,16 +1,16 @@
 #include <konkret/konkret.h>
-#include "Linux_FanSensor.h"
+#include "Cura_FanSensor.h"
 #include "fan.h"
 #include <globals.h>
 
 static const CMPIBroker* _cb = NULL;
 
-static void Linux_FanSensorInitialize()
+static void Cura_FanSensorInitialize()
 {
     init_linux_fan_module();
 }
 
-static CMPIStatus Linux_FanSensorCleanup(
+static CMPIStatus Cura_FanSensorCleanup(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     CMPIBoolean term)
@@ -18,7 +18,7 @@ static CMPIStatus Linux_FanSensorCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanSensorEnumInstanceNames(
+static CMPIStatus Cura_FanSensorEnumInstanceNames(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -28,7 +28,7 @@ static CMPIStatus Linux_FanSensorEnumInstanceNames(
         _cb, mi, cc, cr, cop);
 }
 
-static CMPIStatus Linux_FanSensorEnumInstances(
+static CMPIStatus Cura_FanSensorEnumInstances(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -46,31 +46,31 @@ static CMPIStatus Linux_FanSensorEnumInstances(
     // iterate fan list
     while (lptr) {
         sptr = lptr->f;
-        Linux_FanSensor w;
-        Linux_FanSensor_Init(&w, _cb, KNameSpace(cop));
-        Linux_FanSensor_Set_CreationClassName(&w, "Linux_FanSensor");
-        Linux_FanSensor_Set_SystemCreationClassName(&w, get_system_creation_class_name());
-        Linux_FanSensor_Set_SystemName(&w, get_system_name());
-        Linux_FanSensor_Set_DeviceID(&w, sptr->device_id);
-
-        Linux_FanSensor_Set_Caption(&w, "Computer's fan");
-        Linux_FanSensor_Set_Description(&w,"Computer's fan.");
+        Cura_FanSensor w;
+        Cura_FanSensor_Init(&w, _cb, KNameSpace(cop));
+        Cura_FanSensor_Set_CreationClassName(&w, "Cura_FanSensor");
+        Cura_FanSensor_Set_SystemCreationClassName(&w, get_system_creation_class_name());
+        Cura_FanSensor_Set_SystemName(&w, get_system_name());
+        Cura_FanSensor_Set_DeviceID(&w, sptr->device_id);
+
+        Cura_FanSensor_Set_Caption(&w, "Computer's fan");
+        Cura_FanSensor_Set_Description(&w,"Computer's fan.");
         snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name);
-        Linux_FanSensor_Set_ElementName(&w, buf);
+        Cura_FanSensor_Set_ElementName(&w, buf);
 
         // ManagedSystemElement
-        Linux_FanSensor_Set_Name(&w, sptr->name);
+        Cura_FanSensor_Set_Name(&w, sptr->name);
 
-        Linux_FanSensor_Init_OperationalStatus(&w, 2);
-        Linux_FanSensor_Set_OperationalStatus(&w, 0, sptr->fault ?
-                Linux_FanSensor_OperationalStatus_Error :
-                Linux_FanSensor_OperationalStatus_OK);
+        Cura_FanSensor_Init_OperationalStatus(&w, 2);
+        Cura_FanSensor_Set_OperationalStatus(&w, 0, sptr->fault ?
+                Cura_FanSensor_OperationalStatus_Error :
+                Cura_FanSensor_OperationalStatus_OK);
         if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) {
-            Linux_FanSensor_Set_OperationalStatus(&w, 1, Linux_FanSensor_OperationalStatus_Stressed);
+            Cura_FanSensor_Set_OperationalStatus(&w, 1, Cura_FanSensor_OperationalStatus_Stressed);
         }
 
-        Linux_FanSensor_Init_StatusDescriptions(&w, 2);
-        Linux_FanSensor_Set_StatusDescriptions(&w, 0, sptr->fault ?
+        Cura_FanSensor_Init_StatusDescriptions(&w, 2);
+        Cura_FanSensor_Set_StatusDescriptions(&w, 0, sptr->fault ?
                 "Chip indicates, that fan is in fault state."
                 " Possible causes are open diodes, unconnected fan etc."
                 " Thus the measurement for this channel should not be trusted."
@@ -81,66 +81,66 @@ static CMPIStatus Linux_FanSensorEnumInstances(
                      sptr->alarm ? "1":"0",
                      sptr->alarm_min ? "1":"0",
                      sptr->alarm_max ? "1":"0");
-            Linux_FanSensor_Set_StatusDescriptions(&w, 1, buf);
+            Cura_FanSensor_Set_StatusDescriptions(&w, 1, buf);
         }
 
-        Linux_FanSensor_Set_HealthState(&w, sptr->fault ?
-                Linux_FanSensor_HealthState_Major_failure :
-                Linux_FanSensor_HealthState_OK);
+        Cura_FanSensor_Set_HealthState(&w, sptr->fault ?
+                Cura_FanSensor_HealthState_Major_failure :
+                Cura_FanSensor_HealthState_OK);
 
-        Linux_FanSensor_Set_OperatingStatus(&w, sptr->fault ?
-                Linux_FanSensor_OperatingStatus_Stopped :
-                Linux_FanSensor_OperatingStatus_In_Service);
+        Cura_FanSensor_Set_OperatingStatus(&w, sptr->fault ?
+                Cura_FanSensor_OperatingStatus_Stopped :
+                Cura_FanSensor_OperatingStatus_In_Service);
 
-        Linux_FanSensor_Set_PrimaryStatus(&w, sptr->fault ?
-                Linux_FanSensor_PrimaryStatus_Error :
-                Linux_FanSensor_PrimaryStatus_OK);
+        Cura_FanSensor_Set_PrimaryStatus(&w, sptr->fault ?
+                Cura_FanSensor_PrimaryStatus_Error :
+                Cura_FanSensor_PrimaryStatus_OK);
 
         // EnabledLogicalElement
-        Linux_FanSensor_Init_OtherIdentifyingInfo(&w, 2);
-        Linux_FanSensor_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name);
-        Linux_FanSensor_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path);
+        Cura_FanSensor_Init_OtherIdentifyingInfo(&w, 2);
+        Cura_FanSensor_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name);
+        Cura_FanSensor_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path);
 
-        Linux_FanSensor_Init_IdentifyingDescriptions(&w, 2);
-        Linux_FanSensor_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip.");
-        Linux_FanSensor_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip.");
+        Cura_FanSensor_Init_IdentifyingDescriptions(&w, 2);
+        Cura_FanSensor_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip.");
+        Cura_FanSensor_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip.");
 
         // ManagedElement
-        Linux_FanSensor_Set_Caption(&w, "Fan's tachometer");
-        Linux_FanSensor_Set_Description(&w,"Associated sensor of fan. Giving information about its speed.");
+        Cura_FanSensor_Set_Caption(&w, "Fan's tachometer");
+        Cura_FanSensor_Set_Description(&w,"Associated sensor of fan. Giving information about its speed.");
 
         snprintf(buf, 200, "Tachometer of fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name);
-        Linux_FanSensor_Set_ElementName(&w, buf);
+        Cura_FanSensor_Set_ElementName(&w, buf);
 
         // Sensor
-        Linux_FanSensor_Set_SensorType(&w, Linux_FanSensor_SensorType_Tachometer);
-        Linux_FanSensor_Set_CurrentState(&w, fan_get_current_state(sptr));
+        Cura_FanSensor_Set_SensorType(&w, Cura_FanSensor_SensorType_Tachometer);
+        Cura_FanSensor_Set_CurrentState(&w, fan_get_current_state(sptr));
 
-        Linux_FanSensor_Init_PossibleStates(&w, 5);
+        Cura_FanSensor_Init_PossibleStates(&w, 5);
         int index = 0;
         if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) {
-            Linux_FanSensor_Set_PossibleStates(&w, index++, "Below Minimum");
-            Linux_FanSensor_Set_PossibleStates(&w, index++, "At Minimum");
+            Cura_FanSensor_Set_PossibleStates(&w, index++, "Below Minimum");
+            Cura_FanSensor_Set_PossibleStates(&w, index++, "At Minimum");
         }
-        Linux_FanSensor_Set_PossibleStates(&w, index++, "Normal");
+        Cura_FanSensor_Set_PossibleStates(&w, index++, "Normal");
         if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) {
-            Linux_FanSensor_Set_PossibleStates(&w, index++, "At Maximum");
-            Linux_FanSensor_Set_PossibleStates(&w, index++, "Above Maximum");
+            Cura_FanSensor_Set_PossibleStates(&w, index++, "At Maximum");
+            Cura_FanSensor_Set_PossibleStates(&w, index++, "Above Maximum");
         }
 
         // NumericSensor
-        Linux_FanSensor_Set_BaseUnits(&w, Linux_FanSensor_BaseUnits_Revolutions);
-        Linux_FanSensor_Set_UnitModifier(&w, 0);
-        Linux_FanSensor_Set_RateUnits(&w, Linux_FanSensor_RateUnits_Per_Minute);
-        Linux_FanSensor_Set_CurrentReading(&w, sptr->speed);
+        Cura_FanSensor_Set_BaseUnits(&w, Cura_FanSensor_BaseUnits_Revolutions);
+        Cura_FanSensor_Set_UnitModifier(&w, 0);
+        Cura_FanSensor_Set_RateUnits(&w, Cura_FanSensor_RateUnits_Per_Minute);
+        Cura_FanSensor_Set_CurrentReading(&w, sptr->speed);
         if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) {
-            Linux_FanSensor_Set_NormalMax(&w, sptr->max_speed);
+            Cura_FanSensor_Set_NormalMax(&w, sptr->max_speed);
         }
         if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) {
-            Linux_FanSensor_Set_NormalMin(&w, sptr->min_speed);
+            Cura_FanSensor_Set_NormalMin(&w, sptr->min_speed);
         }
-        Linux_FanSensor_Set_MinReadable(&w, 0);
-        Linux_FanSensor_Set_IsLinear(&w, true);
+        Cura_FanSensor_Set_MinReadable(&w, 0);
+        Cura_FanSensor_Set_IsLinear(&w, true);
 
         KReturnInstance(cr, w);
         lptr = lptr->next;
@@ -148,7 +148,7 @@ static CMPIStatus Linux_FanSensorEnumInstances(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanSensorGetInstance(
+static CMPIStatus Cura_FanSensorGetInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -159,7 +159,7 @@ static CMPIStatus Linux_FanSensorGetInstance(
         _cb, mi, cc, cr, cop, properties);
 }
 
-static CMPIStatus Linux_FanSensorCreateInstance(
+static CMPIStatus Cura_FanSensorCreateInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -169,7 +169,7 @@ static CMPIStatus Linux_FanSensorCreateInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanSensorModifyInstance(
+static CMPIStatus Cura_FanSensorModifyInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -180,7 +180,7 @@ static CMPIStatus Linux_FanSensorModifyInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanSensorDeleteInstance(
+static CMPIStatus Cura_FanSensorDeleteInstance(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -189,7 +189,7 @@ static CMPIStatus Linux_FanSensorDeleteInstance(
     CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
 }
 
-static CMPIStatus Linux_FanSensorExecQuery(
+static CMPIStatus Cura_FanSensorExecQuery(
     CMPIInstanceMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -201,12 +201,12 @@ static CMPIStatus Linux_FanSensorExecQuery(
 }
 
 CMInstanceMIStub(
-    Linux_FanSensor,
-    Linux_FanSensor,
+    Cura_FanSensor,
+    Cura_FanSensor,
     _cb,
-    Linux_FanSensorInitialize())
+    Cura_FanSensorInitialize())
 
-static CMPIStatus Linux_FanSensorMethodCleanup(
+static CMPIStatus Cura_FanSensorMethodCleanup(
     CMPIMethodMI* mi,
     const CMPIContext* cc,
     CMPIBoolean term)
@@ -214,7 +214,7 @@ static CMPIStatus Linux_FanSensorMethodCleanup(
     CMReturn(CMPI_RC_OK);
 }
 
-static CMPIStatus Linux_FanSensorInvokeMethod(
+static CMPIStatus Cura_FanSensorInvokeMethod(
     CMPIMethodMI* mi,
     const CMPIContext* cc,
     const CMPIResult* cr,
@@ -223,21 +223,21 @@ static CMPIStatus Linux_FanSensorInvokeMethod(
     const CMPIArgs* in,
     CMPIArgs* out)
 {
-    return Linux_FanSensor_DispatchMethod(
+    return Cura_FanSensor_DispatchMethod(
         _cb, mi, cc, cr, cop, meth, in, out);
 }
 
 CMMethodMIStub(
-    Linux_FanSensor,
-    Linux_FanSensor,
+    Cura_FanSensor,
+    Cura_FanSensor,
     _cb,
-    Linux_FanSensorInitialize())
+    Cura_FanSensorInitialize())
 
-KUint32 Linux_FanSensor_RequestStateChange(
+KUint32 Cura_FanSensor_RequestStateChange(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KUint16* RequestedState,
     KRef* Job,
     const KDateTime* TimeoutPeriod,
@@ -249,11 +249,11 @@ KUint32 Linux_FanSensor_RequestStateChange(
     return result;
 }
 
-KUint32 Linux_FanSensor_SetPowerState(
+KUint32 Cura_FanSensor_SetPowerState(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KUint16* PowerState,
     const KDateTime* Time,
     CMPIStatus* status)
@@ -264,11 +264,11 @@ KUint32 Linux_FanSensor_SetPowerState(
     return result;
 }
 
-KUint32 Linux_FanSensor_Reset(
+KUint32 Cura_FanSensor_Reset(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -277,11 +277,11 @@ KUint32 Linux_FanSensor_Reset(
     return result;
 }
 
-KUint32 Linux_FanSensor_EnableDevice(
+KUint32 Cura_FanSensor_EnableDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KBoolean* Enabled,
     CMPIStatus* status)
 {
@@ -291,11 +291,11 @@ KUint32 Linux_FanSensor_EnableDevice(
     return result;
 }
 
-KUint32 Linux_FanSensor_OnlineDevice(
+KUint32 Cura_FanSensor_OnlineDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KBoolean* Online,
     CMPIStatus* status)
 {
@@ -305,11 +305,11 @@ KUint32 Linux_FanSensor_OnlineDevice(
     return result;
 }
 
-KUint32 Linux_FanSensor_QuiesceDevice(
+KUint32 Cura_FanSensor_QuiesceDevice(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KBoolean* Quiesce,
     CMPIStatus* status)
 {
@@ -319,11 +319,11 @@ KUint32 Linux_FanSensor_QuiesceDevice(
     return result;
 }
 
-KUint32 Linux_FanSensor_SaveProperties(
+KUint32 Cura_FanSensor_SaveProperties(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -332,11 +332,11 @@ KUint32 Linux_FanSensor_SaveProperties(
     return result;
 }
 
-KUint32 Linux_FanSensor_RestoreProperties(
+KUint32 Cura_FanSensor_RestoreProperties(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -345,11 +345,11 @@ KUint32 Linux_FanSensor_RestoreProperties(
     return result;
 }
 
-KUint32 Linux_FanSensor_RestoreDefaultThresholds(
+KUint32 Cura_FanSensor_RestoreDefaultThresholds(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     CMPIStatus* status)
 {
     KUint32 result = KUINT32_INIT;
@@ -358,11 +358,11 @@ KUint32 Linux_FanSensor_RestoreDefaultThresholds(
     return result;
 }
 
-KUint32 Linux_FanSensor_GetNonLinearFactors(
+KUint32 Cura_FanSensor_GetNonLinearFactors(
     const CMPIBroker* cb,
     CMPIMethodMI* mi,
     const CMPIContext* context,
-    const Linux_FanSensorRef* self,
+    const Cura_FanSensorRef* self,
     const KSint32* SensorReading,
     KSint32* Accuracy,
     KUint32* Resolution,
@@ -378,6 +378,6 @@ KUint32 Linux_FanSensor_GetNonLinearFactors(
 
 KONKRET_REGISTRATION(
     "root/cimv2",
-    "Linux_FanSensor",
-    "Linux_FanSensor",
+    "Cura_FanSensor",
+    "Cura_FanSensor",
     "instance method")
diff --git a/src/fan/fan.c b/src/fan/fan.c
index e8e9559..4ce9495 100644
--- a/src/fan/fan.c
+++ b/src/fan/fan.c
@@ -1,17 +1,17 @@
-/* This file is part of cmpiLinux_FanProvider.
+/* This file is part of cmpiCura_FanProvider.
  *
- * cmpiLinux_FanProvider is free software: you can redistribute it and/or
+ * cmpiCura_FanProvider is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
- * cmpiLinux_FanProvider is distributed in the hope that it will be useful,
+ * cmpiCura_FanProvider 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with cmpiLinux_FanProvider. If not, see
+ * along with cmpiCura_FanProvider. If not, see
  * <http://www.gnu.org/licenses/>.
  */
 #include <stdlib.h>
diff --git a/src/fan/fan.h b/src/fan/fan.h
index f376ea6..a2da25c 100644
--- a/src/fan/fan.h
+++ b/src/fan/fan.h
@@ -1,17 +1,17 @@
-/* This file is part of cmpiLinux_FanProvider.
+/* This file is part of cmpiCura_FanProvider.
  *
- * cmpiLinux_FanProvider is free software: you can redistribute it and/or
+ * cmpiCura_FanProvider is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
- * cmpiLinux_FanProvider is distributed in the hope that it will be useful,
+ * cmpiCura_FanProvider 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with cmpiLinux_FanProvider. If not, see
+ * along with cmpiCura_FanProvider. If not, see
  * <http://www.gnu.org/licenses/>.
  */
 #ifndef LINUX_FAN_H_