---

rmSysInfo.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <wchar.h>

#include <cassert>

#include <ResourceMonitor/ResourceMonitor.h>

#include "rmSysInfo.h"
#include "rmClientError.h"

int
subsystemInfo::init(resourceInfo * aResourceInfo, statisticInfo * aStatisticInfo)
{
  // init pointers to other info tables.
  mResourceInfo = aResourceInfo;
  mStatisticInfo = aStatisticInfo;

  size_t count;
  int ret;
  unsigned long id;
  SubsystemInfo info;

  count = ResourceMonitor::rmGetSubsystemCount();
  if(count == 0)
    return RMCLIENT_SUCCESS;

  rmSubsystemInfo *subInfo;
  subInfo = new rmSubsystemInfo[count];
  if(!subInfo)
    return RMCLIENT_ERROR_MEMORY;

  ret = ResourceMonitor::rmGetAvailableSubsystems(subInfo, count);
  if(ret)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  for(size_t i = 0; i<count; i++) {

    info.info = subInfo[i];
    ret = newElement(info, id);
    if(ret)
      return ret;

  }

  delete [] subInfo;
  return RMCLIENT_SUCCESS;
}

int
subsystemInfo::getUUIDString(RMAttribute aName, unsigned long aID, char * aUUIDStr)
{
  if(aUUIDStr == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  aUUIDStr[0] = '\0';

  const SubsystemInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  switch(aName) {
    case SUBSYSTEMINFO_UUID:
      uuid_unparse((unsigned char*)info->info.id, aUUIDStr);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  aUUIDStr[UUID_STRING_LENGTH - 1] = '\0';
  return RMCLIENT_SUCCESS;
}

int
subsystemInfo::getUUID(RMAttribute aName, unsigned long aID, uuid_t aUUID)
{
  if(aUUID == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  uuid_clear(aUUID);

  const SubsystemInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  switch(aName) {
    case SUBSYSTEMINFO_UUID:
      uuid_copy(aUUID, (unsigned char*)info->info.id);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
subsystemInfo::getUnsigned(RMAttribute aName, unsigned long aID, unsigned long & aValue)
{
  aValue = 0;

  const SubsystemInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  switch(aName) {
    case SUBSYSTEMINFO_RESOURCECOUNT:
      aValue = info->info.noResources;
      break;

    case SUBSYSTEMINFO_STATISTICCOUNT:
      aValue = info->info.noStatistics;
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
subsystemInfo::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;

  unsigned long len;
  char * str;

  const SubsystemInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  switch(aName) {
    case SUBSYSTEMINFO_NAME:
      str = ResourceMonitor::rmGetSubsystemDescription(info->info.id, rmShortDescription);
      break;

    case SUBSYSTEMINFO_DESCRIPTION:
      str = ResourceMonitor::rmGetSubsystemDescription(info->info.id, rmLongDescription);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  if(!str)
    return RMCLIENT_ERROR_SUBSYSTEM_STRING;

  aBuf = str;

  return RMCLIENT_SUCCESS;
}

unsigned long
subsystemInfo::getSubsystemIDByUUID(const uuid_t aUUID) 
{
  int ret;

  unsigned long id(0), nid(0);
  const SubsystemInfo * info;

  while(!getNextId(id, nid)) {

    id = nid;
    info = getConstElement(id);

    ret = uuid_compare((unsigned char*)aUUID, (unsigned char*)info->info.id);
    if(!ret) {
      return id;
    }
  }
  return 0;
}

int
subsystemInfo::addSubsystemByUUID(const uuid_t aUUID)
{
  int ret;

  // make sure it is a new subsystem
  unsigned long id = getSubsystemIDByUUID(aUUID);
  if(id != 0)
    return RMCLIENT_ERROR_SUBSYSTEM_ID;

  rmSubsystemInfo subInfo;
  ret = ResourceMonitor::rmGetSubsystemInfo(aUUID, &subInfo);
  if(ret)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  SubsystemInfo info;
  info.info = subInfo;

  // adding subsystem
  ret = newElement(info, id);
  if(ret)
    return ret;

  // adding resources
  return mResourceInfo->initResourceInfoBySubsystemID(id, true);
}

int
subsystemInfo::removeSubsystemByUUID(const uuid_t aUUID)
{
  int ret;
  unsigned long id(0), nid(0), sid;

  const ResourceInfo * rinfo;
  const StatisticInfo * sinfo;

  sid = getSubsystemIDByUUID(aUUID);
  if (sid == 0)
    return RMCLIENT_ERROR_SUBSYSTEM_ID;

  // statistics first
  while (!mStatisticInfo->getNextId(id, nid)) {
    id = nid;

    sinfo = mStatisticInfo->getConstElement(id);
    if (sinfo->subsystemId == sid) {
      mStatisticInfo->removeElement(id);
    }
  }

  // resources next
  id = 0;
  nid = 0;
  while (!mResourceInfo->getNextId(id, nid)) {
    id = nid;

    rinfo = mResourceInfo->getConstElement(id);
    if (rinfo->subsystemId == sid) {
      mResourceInfo->removeElement(id);
    }
  }

  return removeElement(sid);
}

int
resourceInfo::init(subsystemInfo * aSubsystemInfo, statisticInfo * aStatisticInfo)
{
  mSubsystemInfo = aSubsystemInfo;
  mStatisticInfo = aStatisticInfo;

  int ret;
  unsigned long id(0), nid(0);

  while(!mSubsystemInfo->getNextId(id, nid)) {

    id = nid;
    ret = initResourceInfoBySubsystemID(id);
    if(ret)
      return ret;
  }

  return RMCLIENT_SUCCESS;
}

int
resourceInfo::initResourceInfoBySubsystemID(unsigned long aID, bool initStatistics = false)
{
  int ret;
  const SubsystemInfo * sinfo;
  size_t resCount;
  unsigned long resid;

  rmResourceInfo * resInfo(NULL);
  ResourceInfo info;

  sinfo = mSubsystemInfo->getConstElement(aID);
  if(!sinfo)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  resCount = sinfo->info.noResources;

  if(resCount) {

    resInfo = new rmResourceInfo[resCount];
    if(!resInfo)
      return RMCLIENT_ERROR_MEMORY;

    ret = ResourceMonitor::rmGetActiveResources(sinfo->info.id, resInfo, resCount);
    if(ret)
      return RMCLIENT_ERROR_RESOURCE_INFO;

    for(size_t j=0; j < resCount; j++) {
      info.info = resInfo[j];
      info.subsystemId = aID;

      ret = newElement(info, resid);
      if(ret)
        return ret;

      if(initStatistics == true) {
        ret = mStatisticInfo->initStatisticInfoByResourceID(resid);
        if(ret)
          return ret;
      }
    }

    delete [] resInfo;
  }

  return RMCLIENT_SUCCESS;
}

int
resourceInfo::getUUIDString(RMAttribute aName, unsigned long aID, char * aUUIDStr)
{
  if(aUUIDStr == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  aUUIDStr[0] = '\0';

  const ResourceInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_RESOURCE_INFO;

  switch(aName) {
    case RESOURCEINFO_SUBSYSTEMUUID:

      uuid_unparse((unsigned char*)info->info.SubsystemId, aUUIDStr);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  aUUIDStr[UUID_STRING_LENGTH - 1] = '\0';
  return RMCLIENT_SUCCESS;
}

int
resourceInfo::getUUID(RMAttribute aName, unsigned long aID, uuid_t aUUID)
{
  if(aUUID == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  uuid_clear(aUUID);

  const ResourceInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_RESOURCE_INFO;

  switch(aName) {
    case RESOURCEINFO_SUBSYSTEMUUID:
      uuid_copy(aUUID, (unsigned char*)info->info.SubsystemId);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
resourceInfo::getUnsigned(RMAttribute aName, unsigned long aID, unsigned long & aValue)
{
  aValue = 0;

  const ResourceInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_RESOURCE_INFO;

  switch(aName) {
    case RESOURCEINFO_RESOURCEID:
      aValue = info->info.id;
      break;

    case RESOURCEINFO_SUBSYSTEMID:
      aValue = info->subsystemId;
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
resourceInfo::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;

  unsigned long len;
  char * str;

  const ResourceInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  switch(aName) {
    case RESORUCEINFO_NAME:
      str = ResourceMonitor::rmGetResourceDescription(info->info.SubsystemId,
                              info->info.id, rmShortDescription);
      break;

    case RESOURCEINFO_DESCRIPTION:
      str = ResourceMonitor::rmGetResourceDescription(info->info.SubsystemId,
                               info->info.id, rmLongDescription);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  if(!str)
    return RMCLIENT_ERROR_RESOURCE_STRING;

  aBuf = str;

  return RMCLIENT_SUCCESS;
}

int
resourceInfo::addResource(const uuid_t aUUID, unsigned long aID)
{
  int ret;
  unsigned long resid;

  unsigned long id = mSubsystemInfo->getSubsystemIDByUUID(aUUID);
  if(id == 0) {
    // hum, somehow the subsystem is not present at this moment.
    // let's see if we need to fix it later. for now, just return.
    return RMCLIENT_ERROR_SUBSYSTEM_ID;
  }

  rmResourceInfo resInfo;
  ret = ResourceMonitor::rmGetResourceInfo(aUUID, aID, &resInfo);
  if(ret)
    return RMCLIENT_ERROR_RESOURCE_INFO;

  ResourceInfo info;
  info.info = resInfo;
  info.subsystemId = id;

  ret = newElement(info, resid);
  if(ret)
    return ret;

  // adding statistics
  return mStatisticInfo->initStatisticInfoByResourceID(resid);
}

int
resourceInfo::removeResource(const uuid_t aUUID, unsigned long aID)
{
  int ret;
  unsigned long id(0), nid(0), subid;
  const ResourceInfo * rinfo;
  const StatisticInfo * sinfo;

  subid = mSubsystemInfo->getSubsystemIDByUUID(aUUID);
  if(subid == 0) {
    // hum, didn't find that subsystem.
    return RMCLIENT_ERROR_SUBSYSTEM_ID;
  }

  bool found = false;
  while(!getNextId(id, nid)) {
    id = nid;

    rinfo = getConstElement(id);
    if (subid == rinfo->subsystemId && aID == rinfo->info.id) {
      // found it.
      found = true;
      break;
    }
  }

  if(!found)
    return RMCLIENT_ERROR_RESOURCE_ID;

  unsigned long sid(0), snid(0);
  while(!mStatisticInfo->getNextId(sid, snid)) {
    sid = snid;

    sinfo = mStatisticInfo->getConstElement(sid);
    if(sinfo->resourceId == id) {

      if(sinfo->subsystemId != subid)
        return RMCLIENT_ERROR_STATISTIC_ID;

      mStatisticInfo->removeElement(sid);
    }
  }
  return removeElement(id);
}


int
statisticInfo::init(subsystemInfo * aSubsystemInfo, resourceInfo * aResourceInfo)
{
  mSubsystemInfo = aSubsystemInfo;
  mResourceInfo = aResourceInfo;

  int ret;
  unsigned long id(0), nid(0);

  while(!mResourceInfo->getNextId(id, nid)) {

    id = nid;

    ret = initStatisticInfoByResourceID(id);
    if(ret)
      return ret;
  }

  return RMCLIENT_SUCCESS;
}

int
statisticInfo::initStatisticInfoByResourceID(unsigned long aID)
{
  int ret;
  size_t statCount;
  unsigned long resid(0), statid, subid;
  const SubsystemInfo * sinfo;

  rmStatisticInfo * statInfo(NULL);
  StatisticInfo info;

  ret = mResourceInfo->getUnsigned(RESOURCEINFO_SUBSYSTEMID, aID, subid);
  if(ret)
    return ret;

  ret = mResourceInfo->getUnsigned(RESOURCEINFO_RESOURCEID, aID, resid);
  if(ret)
    return ret;

  sinfo = mSubsystemInfo->getConstElement(subid);
  if(!sinfo)
    return RMCLIENT_ERROR_SUBSYSTEM_INFO;

  statCount = sinfo->info.noStatistics;

  if(statCount) {

    statInfo = new rmStatisticInfo[statCount];
    if(!statInfo)
      return RMCLIENT_ERROR_MEMORY;

    ret = ResourceMonitor::rmGetAvailableStatistics(sinfo->info.id, statInfo, statCount);
    if(ret)
      return RMCLIENT_ERROR_STATISTIC_INFO;

    for(size_t j=0; j < statCount; j++) {
      info.info = statInfo[j];
      info.subsystemId = subid;
      info.resourceId = resid;
      info.guageUpperBound.rmValueU64 = 0;
      info.counterValue.rmValueU64 = 0;

      ret = newElement(info, statid);
      if(ret)
        return ret;
    }
  }
  delete [] statInfo;

  return RMCLIENT_SUCCESS;
}

int
statisticInfo::getUUIDString(RMAttribute aName, unsigned long aID, char * aUUIDStr)
{
  if(aUUIDStr == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  aUUIDStr[0] = '\0';

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_SUBSYSTEMUUID:
      uuid_unparse((unsigned char*)info->info.SubsystemId, aUUIDStr);
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  aUUIDStr[UUID_STRING_LENGTH - 1] = '\0';
  return RMCLIENT_SUCCESS;
}

int
statisticInfo::getUUID(RMAttribute aName, unsigned long aID, uuid_t aUUID)
{
  if(aUUID == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  uuid_clear(aUUID);

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_SUBSYSTEMUUID:
      uuid_copy(aUUID, (unsigned char*)info->info.SubsystemId);
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;

}

int
statisticInfo::getInteger32(RMAttribute aName, unsigned long aID, long & aValue)
{
  aValue = -1;

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_TYPE:
      aValue = info->info.type;
      break;

    case STATISTICINFO_SIZE:
      aValue = info->info.size;
      break;

    case STATISTICINFO_SCALE:
      aValue = info->info.scale;
      break;

    case STATISTICINFO_COUNTERRESET:
      aValue = 0;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
statisticInfo::setInteger32(RMAttribute aName, unsigned long aID, long aValue)
{
  int ret;
  rmStatisticId statid;

  StatisticInfo * info = getElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_COUNTERRESET:
      statid.ResourceId = info->resourceId;
      statid.StatisticId = info->info.id;

      uuid_clear(statid.SubsystemId);
      ret = mSubsystemInfo->getUUID(SUBSYSTEMINFO_UUID, info->subsystemId, statid.SubsystemId);
      if(ret)
        return RMCLIENT_ERROR_SUBSYSTEM_UUID;

      ret = ResourceMonitor::rmResetCounterStatistic(statid, &info->counterValue);
      if(ret)
        return RMCLIENT_ERROR_STATISTIC_UPPERBOUND;

      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}
  
int
statisticInfo::setUnsigned(RMAttribute aName, unsigned long aID, unsigned long aValue)
{
  int ret;

  StatisticInfo * info = getElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_COUNTERRESETVALUE32:
      info->counterValue.rmValueU32 = aValue;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
statisticInfo::setUnsigned64(RMAttribute aName, unsigned long aID, u_int64_t aValue)
{
  int ret;

  StatisticInfo * info = getElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_COUNTERRESETVALUE64:
      info->counterValue.rmValueU64 = aValue;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}  

int
statisticInfo::getUnsigned(RMAttribute aName, unsigned long aID, unsigned long & aValue)
{
  aValue = 0;

  int ret;
  rmValue value;
  rmStatisticId statid;

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_ID:
      aValue = info->info.id;
      break;

    case STATISTICINFO_SUBSYSTEMID:
      aValue = info->subsystemId;
      break;

    case STATISTICINFO_RESOURCEID:
      aValue = info->resourceId;
      break;

    case STATISTICINFO_COUNTERRESETVALUE32:
      aValue = info->counterValue.rmValueU32;
      break;

    case STATISTICINFO_GAUGEUPPERBOUND32:
      statid.ResourceId = info->resourceId;
      statid.StatisticId = info->info.id;

      uuid_clear(statid.SubsystemId);
      ret = mSubsystemInfo->getUUID(SUBSYSTEMINFO_UUID, info->subsystemId, statid.SubsystemId);
      if(ret)
        return RMCLIENT_ERROR_SUBSYSTEM_UUID;

      ret = ResourceMonitor::rmGetUpperBound(statid, &value);
      if(ret)
        return RMCLIENT_ERROR_STATISTIC_UPPERBOUND;

      aValue = value.rmValueU32;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
statisticInfo::getUnsigned64(RMAttribute aName, unsigned long aID, u_int64_t & aValue)
{
  aValue = 0;

  int ret;
  rmValue value;
  rmStatisticId statid;

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_COUNTERRESETVALUE64:
      aValue = info->counterValue.rmValueU64;
      break;

    case STATISTICINFO_GAUGEUPPERBOUND64:
      statid.ResourceId = info->resourceId;
      statid.StatisticId = info->info.id;

      uuid_clear(statid.SubsystemId);
      ret = mSubsystemInfo->getUUID(SUBSYSTEMINFO_UUID, info->subsystemId, statid.SubsystemId);
      if(ret)
        return RMCLIENT_ERROR_SUBSYSTEM_UUID;

      ret = ResourceMonitor::rmGetUpperBound(statid, &value);
      if(ret)
        return RMCLIENT_ERROR_STATISTIC_UPPERBOUND;

      aValue = value.rmValueU64;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}
  
int
statisticInfo::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;

  unsigned long len;
  char * str;

  const StatisticInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_STATISTIC_INFO;

  switch(aName) {

    case STATISTICINFO_NAME:
      str = ResourceMonitor::rmGetStatisticDescription(info->info.SubsystemId,
                              info->info.id, rmShortDescription);
      break;

    case STATISTICINFO_DESCRIPTION:
      str = ResourceMonitor::rmGetStatisticDescription(info->info.SubsystemId,
                              info->info.id, rmLongDescription);
      break;

    case STATISTICINFO_UNITS:
      str = ResourceMonitor::rmGetStatisticDescription(info->info.SubsystemId,
                              info->info.id, rmUnitsDescription);
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  if(!str)
    return RMCLIENT_ERROR_STATISTIC_STRING;

  aBuf = str;

  return RMCLIENT_SUCCESS;
}

int
dataCaptureInfo::init()
{
  mElementArray.clear();

  int ret;
  FILE * rmtab;
  char * cfile = "/etc/opt/resourcemon/rmtab";
  char buf[1024];

  string str, uuidstr, name;
  string::size_type idx;
  unsigned long id;
  rmUID uuid;

  DataCaptureInfo info;
  DataCaptureInfo * pinfo;

  if ((rmtab = fopen(cfile, "r")) == NULL) {
    return RMCLIENT_ERROR_DATACAPTURE_PLUGIN_FILE;
  }

  while (fgets(buf, 1024, rmtab)){
    str = buf;

    idx = str.find_first_of(" \t\f\r\v");
    uuidstr = str.substr(0, idx);

    idx = str.find_last_of(" \t\f\r\v");
    name = str.substr(idx+1);

    idx = name.find('\n');
    if(idx != string::npos)
      name = name.substr(0, idx);

    // fprintf(stdout, "uuid = %s, size = %d, name = %s, size = %d\n", uuidstr.c_str(), uuidstr.size(), name.c_str(), name.size());
    uuid_parse((char *)uuidstr.c_str(), uuid);
    id = mSubsystemInfo->getSubsystemIDByUUID(uuid);
    if(id)
      continue; // this is a subsystem, not a plugin.

    info.uuid = uuid;
    ret = newElement(info, id);
    if(ret)
      return ret;
    
    pinfo = getElement(id);
    pinfo->name = name;
  }

  fclose(rmtab);

  return RMCLIENT_SUCCESS;
}

int
dataCaptureInfo::getUUIDString(RMAttribute aName, unsigned long aID, char * aUUIDStr)
{
  if(aUUIDStr == NULL)
    return RMCLIENT_ERROR_BAD_POINTER;

  aUUIDStr[0] = '\0';

  const DataCaptureInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_DATACAPTURE_PLUGIN;

  switch(aName) {
    case DATACAPTUREPLUGININFO_UUID:
      uuid_unparse((unsigned char*)info->uuid, aUUIDStr);
      break;

    default:
      return  RMCLIENT_ERROR_NOSUCHNAME;
  }

  aUUIDStr[UUID_STRING_LENGTH - 1] = '\0';
  return RMCLIENT_SUCCESS;
}

int
dataCaptureInfo::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;

  unsigned long len;
  char * str(NULL);

  const DataCaptureInfo * info = getConstElement(aID);
  if(!info)
    return RMCLIENT_ERROR_DATACAPTURE_PLUGIN;

  switch(aName) {

    case DATACAPTUREPLUGININFO_NAME:
      len = info->name.size() + 1;

      if(!info->name.empty()) {
        str = (char *) malloc(sizeof(char) * len);
        if(!str)
          return RMCLIENT_ERROR_MEMORY;

        strncpy(str, info->name.c_str(), len);
      }

      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  aBuf = str;

  return RMCLIENT_SUCCESS;
}

unsigned long 
dataCaptureInfo::getIDByUUID(const rmUID aUUID)
{
  int ret;

  unsigned long id, nid;
  const DataCaptureInfo * info;

  id = 0; nid = 0;

  while(!getNextId(id, nid)) {
    id = nid;

    info = getConstElement(id);

    ret = uuid_compare((unsigned char *) aUUID, (unsigned char *)info->uuid);
    if(!ret) {
      return id;
    }
  }

  return 0;
}

---