MI_BEGIN_NAMESPACE static void EnumerateOneInstance(Context& context, SCX_LANEndpoint_Class& inst, bool keysOnly, SCXCoreLib::SCXHandle<SCXSystemLib::NetworkInterfaceInstance> intf) { // Add the key properperties first. inst.CreationClassName_value("SCX_LANEndpoint"); inst.Name_value(StrToMultibyte(intf->GetName()).c_str()); // Add the scoping systems keys. inst.SystemCreationClassName_value("SCX_ComputerSystem"); SCXCoreLib::NameResolver mi; inst.SystemName_value(StrToMultibyte(mi.GetHostDomainname()).c_str()); if (!keysOnly) { inst.InstanceID_value(StrToMultibyte(intf->GetName()).c_str()); inst.Caption_value("LAN endpoint caption information"); inst.Description_value("LAN Endpoint description information"); inst.ElementName_value(StrToMultibyte(intf->GetName()).c_str()); std::wstring text; if(intf->GetMACAddressRAW(text)) { inst.MACAddress_value(StrToMultibyte(text).c_str()); intf->GetMACAddress(text, '-', true); inst.FormattedMACAddress_value(StrToMultibyte(text).c_str()); } } context.Post(inst); }
/** Add a SCXInstance with the name property set frmo the ProcessInstance to the collection \param[in] processinst Process instance to get data from \param[out] inst Instance to add keys to \param[in] cimtype Type of CIM Class to return \throws SCXInvalidArgumentException - The instance can not be converted to a ProcessInstance This method contains knowledge on which are the key fields for the class. The key properties are defined in the MOF file. */ void ProcessProvider::AddKeys(SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst, SCXInstance &inst, SupportedCimClasses cimtype) // private { SCX_LOGTRACE(m_log, L"ProcessProvider AddKeys()"); if (processinst == NULL) { throw SCXInvalidArgumentException(L"einst", L"Not a ProcessInstance", SCXSRCLOCATION); } scxulong pid; if (processinst->GetPID(pid)) { SCXProperty pid_prop(L"Handle", StrFrom(pid)); inst.AddKey(pid_prop); } AddScopingOperatingSystemKeys(inst); if (eSCX_UnixProcessStatisticalInformation == cimtype) { std::string name; if (processinst->GetName(name)) { SCXProperty name_prop(L"Name", StrFromMultibyte(name)); inst.AddKey(name_prop); SCXProperty creationClass_prop(L"ProcessCreationClassName", L"SCX_UnixProcessStatisticalInformation"); inst.AddKey(creationClass_prop); } } else if (eSCX_UnixProcess == cimtype) { SCXProperty creationClass_prop(L"CreationClassName", L"SCX_UnixProcess"); inst.AddKey(creationClass_prop); } }
MI_BEGIN_NAMESPACE static void EnumerateOneInstance(Context& context, SCX_EthernetPortStatistics_Class& inst, bool keysOnly, SCXCoreLib::SCXHandle<SCXSystemLib::NetworkInterfaceInstance> intf) { // Add the key properperties first. inst.InstanceID_value(StrToMultibyte(intf->GetName()).c_str()); if (!keysOnly) { inst.Caption_value("Ethernet port information"); inst.Description_value("Statistics on transfer performance for a port"); scxulong ulong = 0; scxulong bytesReceived = intf->GetBytesReceived(ulong) ? ulong : 0; inst.BytesReceived_value(bytesReceived); scxulong bytesTransmitted = intf->GetBytesSent(ulong) ? ulong : 0; inst.BytesTransmitted_value(bytesTransmitted); inst.BytesTotal_value(bytesReceived + bytesTransmitted); inst.PacketsReceived_value(intf->GetPacketsReceived(ulong) ? ulong : 0); inst.PacketsTransmitted_value(intf->GetPacketsSent(ulong) ? ulong : 0); inst.TotalTxErrors_value(intf->GetErrorsSending(ulong) ? ulong : 0); inst.TotalRxErrors_value(intf->GetErrorsReceiving(ulong) ? ulong : 0); inst.TotalCollisions_value(intf->GetCollisions(ulong) ? ulong : 0); } context.Post(inst); }
MI_BEGIN_NAMESPACE static void EnumerateOneInstance(Context& context, SCX_IPProtocolEndpoint_Class& inst, bool keysOnly, SCXCoreLib::SCXHandle<SCXSystemLib::NetworkInterfaceInstance> intf) { // Add the key properperties first. inst.CreationClassName_value("SCX_IPProtocolEndpoint"); inst.Name_value(StrToMultibyte(intf->GetName()).c_str()); // Add the scoping systems keys. inst.SystemCreationClassName_value("SCX_ComputerSystem"); SCXCoreLib::NameResolver mi; inst.SystemName_value(StrToMultibyte(mi.GetHostDomainname()).c_str()); if (!keysOnly) { inst.Caption_value("IP protocol endpoint information"); inst.Description_value("Properties of an IP protocol connection endpoint"); inst.ElementName_value(StrToMultibyte(intf->GetName()).c_str()); wstring text; if (intf->GetIPAddress(text)) { inst.IPv4Address_value(StrToMultibyte(text).c_str()); } if (intf->GetBroadcastAddress(text)) { inst.IPv4BroadcastAddress_value(StrToMultibyte(text).c_str()); } if (intf->GetNetmask(text)) { inst.SubnetMask_value(StrToMultibyte(text).c_str()); } inst.EnabledState_value(GetEnabledState(intf)); } context.Post(inst); }
/** Set all properties from the ProcessInstance in the SCXInstance \param[in] processinst - Process instance to get data from \param[in] inst - Instance to populate \param[in] cimtype - Type of CIM Class to return \throws SCXInvalidArgumentException - If the instance can not be converted to a ProcessInstance This method knows how to map the values of the Process PAL to the CMPI class definition. */ void ProcessProvider::AddProperties(SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst, SCXInstance &inst, SupportedCimClasses cimtype) // private { if (processinst == NULL) { throw SCXInvalidArgumentException(L"einst", L"Not a ProcessInstance", SCXSRCLOCATION); } SCX_LOGTRACE(m_log, L"ProcessProvider AddPropeties()"); if (eSCX_UnixProcessStatisticalInformation == cimtype) { unsigned int uint = 0; scxulong ulong = 0; if (processinst->GetRealData(ulong)) { SCXProperty prop(L"RealData", ulong); inst.AddProperty(prop); } if (processinst->GetRealStack(ulong)) { SCXProperty prop(L"RealStack", ulong); inst.AddProperty(prop); } if (processinst->GetVirtualText(ulong)) { SCXProperty prop(L"VirtualText", ulong); inst.AddProperty(prop); } if (processinst->GetVirtualData(ulong)) { SCXProperty prop(L"VirtualData", ulong); inst.AddProperty(prop); } if (processinst->GetVirtualStack(ulong)) { SCXProperty prop(L"VirtualStack", ulong); inst.AddProperty(prop); } if (processinst->GetVirtualMemoryMappedFileSize(ulong)) { SCXProperty prop(L"VirtualMemoryMappedFileSize", ulong); inst.AddProperty(prop); } if (processinst->GetVirtualSharedMemory(ulong)) { SCXProperty prop(L"VirtualSharedMemory", ulong); inst.AddProperty(prop); } if (processinst->GetCpuTimeDeadChildren(ulong)) { SCXProperty prop(L"CpuTimeDeadChildren", ulong); inst.AddProperty(prop); } if (processinst->GetSystemTimeDeadChildren(ulong)) { SCXProperty prop(L"SystemTimeDeadChildren", ulong); inst.AddProperty(prop); } if (processinst->GetRealText(ulong)) { SCXProperty prop(L"RealText", ulong); inst.AddProperty(prop); } if (processinst->GetCPUTime(uint)) { SCXProperty prop(L"CPUTime", uint); inst.AddProperty(prop); } if (processinst->GetBlockWritesPerSecond(ulong)) { SCXProperty prop(L"BlockWritesPerSecond", ulong); inst.AddProperty(prop); } if (processinst->GetBlockReadsPerSecond(ulong)) { SCXProperty prop(L"BlockReadsPerSecond", ulong); inst.AddProperty(prop); } if (processinst->GetBlockTransfersPerSecond(ulong)) { SCXProperty prop(L"BlockTransfersPerSecond", ulong); inst.AddProperty(prop); } if (processinst->GetPercentUserTime(ulong)) { SCXProperty prop(L"PercentUserTime", (unsigned char) ulong); inst.AddProperty(prop); } if (processinst->GetPercentPrivilegedTime(ulong)) { SCXProperty prop(L"PercentPrivilegedTime", (unsigned char) ulong); inst.AddProperty(prop); } if (processinst->GetUsedMemory(ulong)) { SCXProperty prop(L"UsedMemory", ulong); inst.AddProperty(prop); } if (processinst->GetPercentUsedMemory(ulong)) { SCXProperty prop(L"PercentUsedMemory", (unsigned char) ulong); inst.AddProperty(prop); } if (processinst->GetPagesReadPerSec(ulong)) { SCXProperty prop(L"PagesReadPerSec", ulong); inst.AddProperty(prop); } } else if (eSCX_UnixProcess == cimtype) { std::string name(""); std::vector<std::string> params; std::wstring str(L""); unsigned int uint = 0; unsigned short ushort = 0; scxulong ulong = 0; SCXCoreLib::SCXCalendarTime ctime; int pid = 0; if (processinst->GetOtherExecutionDescription(str)) { SCXProperty prop(L"OtherExecutionDescription", str); inst.AddProperty(prop); } if (processinst->GetKernelModeTime(ulong)) { SCXProperty prop(L"KernelModeTime", ulong); inst.AddProperty(prop); } if (processinst->GetUserModeTime(ulong)) { SCXProperty prop(L"UserModeTime", ulong); inst.AddProperty(prop); } if (processinst->GetWorkingSetSize(ulong)) { SCXProperty prop(L"WorkingSetSize", ulong); inst.AddProperty(prop); } if (processinst->GetProcessSessionID(ulong)) { SCXProperty prop(L"ProcessSessionID", ulong); inst.AddProperty(prop); } if (processinst->GetProcessTTY(name)) { SCXProperty prop(L"ProcessTTY", StrFromMultibyte(name)); inst.AddProperty(prop); } if (processinst->GetModulePath(name)) { SCXProperty prop(L"ModulePath", StrFromMultibyte(name)); inst.AddProperty(prop); } if (processinst->GetParameters(params)) { std::vector<SCXProperty> props; for (std::vector<std::string>::const_iterator iter = params.begin(); iter != params.end(); ++iter) { SCXProperty item(L"", StrFromMultibyte(*iter)); props.push_back(item); } SCXProperty prop(L"Parameters", props); inst.AddProperty(prop); } if (processinst->GetProcessWaitingForEvent(name)) { SCXProperty prop(L"ProcessWaitingForEvent", StrFromMultibyte(name)); inst.AddProperty(prop); } if (processinst->GetName(name)) { SCXProperty name_prop(L"Name", StrFromMultibyte(name)); inst.AddProperty(name_prop); } if (processinst->GetPriority(uint)) { SCXProperty prio_prop(L"Priority", uint); inst.AddProperty(prio_prop); } if (processinst->GetExecutionState(ushort)) { SCXProperty state_prop(L"ExecutionState", ushort); inst.AddProperty(state_prop); } if (processinst->GetCreationDate(ctime)) { SCXProperty cdate_prop(L"CreationDate", ctime); inst.AddProperty(cdate_prop); } if (processinst->GetTerminationDate(ctime)) { SCXProperty edate_prop(L"TerminationDate", ctime); inst.AddProperty(edate_prop); } if (processinst->GetParentProcessID(pid)) { SCXProperty ppid_prop(L"ParentProcessID", StrFrom(pid)); inst.AddProperty(ppid_prop); } if (processinst->GetRealUserID(ulong)) { SCXProperty user_prop(L"RealUserID", ulong); inst.AddProperty(user_prop); } if (processinst->GetProcessGroupID(ulong)) { SCXProperty group_prop(L"ProcessGroupID", ulong); inst.AddProperty(group_prop); } if (processinst->GetProcessNiceValue(uint)) { SCXProperty nice_prop(L"ProcessNiceValue", uint); inst.AddProperty(nice_prop); } } }
MI_BEGIN_NAMESPACE static void EnumerateOneInstance(Context& context, SCX_UnixProcessStatisticalInformation_Class& inst, bool keysOnly, SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst) { SCXLogHandle& log = SCXCore::g_ProcessProvider.GetLogHandle(); // Add the key properties first. scxulong pid; if (processinst->GetPID(pid)) { inst.Handle_value(StrToUTF8(StrFrom(pid)).c_str()); } // Add keys of scoping operating system try { SCXCoreLib::NameResolver mi; inst.CSName_value(StrToMultibyte(mi.GetHostDomainname()).c_str()); } catch (SCXException& e){ SCX_LOGWARNING(log, StrAppend( StrAppend(L"Can't read host/domainname because ", e.What()), e.Where())); } try { SCXSystemLib::SCXOSTypeInfo osinfo; inst.OSName_value(StrToMultibyte(osinfo.GetOSName(true)).c_str()); } catch (SCXException& e){ SCX_LOGWARNING(log, StrAppend( StrAppend(L"Can't read OS name because ", e.What()), e.Where())); } inst.CSCreationClassName_value("SCX_ComputerSystem"); inst.OSCreationClassName_value("SCX_OperatingSystem"); inst.ProcessCreationClassName_value("SCX_UnixProcessStatisticalInformation"); std::string name; if (processinst->GetName(name)) { inst.Name_value(name.c_str()); } if (!keysOnly) { unsigned int uint = 0; scxulong ulong = 0; inst.Description_value("A snapshot of a current process"); inst.Caption_value("Unix process information"); if (processinst->GetRealData(ulong)) { inst.RealData_value(ulong); } if (processinst->GetRealStack(ulong)) { inst.RealStack_value(ulong); } if (processinst->GetVirtualText(ulong)) { inst.VirtualText_value(ulong); } if (processinst->GetVirtualData(ulong)) { inst.VirtualData_value(ulong); } if (processinst->GetVirtualStack(ulong)) { inst.VirtualStack_value(ulong); } if (processinst->GetVirtualMemoryMappedFileSize(ulong)) { inst.VirtualMemoryMappedFileSize_value(ulong); } if (processinst->GetVirtualSharedMemory(ulong)) { inst.VirtualSharedMemory_value(ulong); } if (processinst->GetCpuTimeDeadChildren(ulong)) { inst.CpuTimeDeadChildren_value(ulong); } if (processinst->GetSystemTimeDeadChildren(ulong)) { inst.SystemTimeDeadChildren_value(ulong); } if (processinst->GetRealText(ulong)) { inst.RealText_value(ulong); } if (processinst->GetCPUTime(uint)) { inst.CPUTime_value(uint); } if (processinst->GetBlockWritesPerSecond(ulong)) { inst.BlockWritesPerSecond_value(ulong); } if (processinst->GetBlockReadsPerSecond(ulong)) { inst.BlockReadsPerSecond_value(ulong); } if (processinst->GetBlockTransfersPerSecond(ulong)) { inst.BlockTransfersPerSecond_value(ulong); } if (processinst->GetPercentUserTime(ulong)) { inst.PercentUserTime_value((unsigned char) ulong); } if (processinst->GetPercentPrivilegedTime(ulong)) { inst.PercentPrivilegedTime_value((unsigned char) ulong); } if (processinst->GetUsedMemory(ulong)) { inst.UsedMemory_value(ulong); } if (processinst->GetPercentUsedMemory(ulong)) { inst.PercentUsedMemory_value((unsigned char) ulong); } if (processinst->GetPagesReadPerSec(ulong)) { inst.PagesReadPerSec_value(ulong); } } context.Post(inst); }