n_reg.c

picoos源码。The RTOS and the TCP/IP stack will be built automatically.

  if (status != E_OK)
  {
    n_regFree(re);
  }
  else
  {
#if NOSCFG_FEATURE_REGQUERY != 0
    re->next = NULL;
    ri = reglist_syselem_g[type];
    if (ri == NULL)
    {
      reglist_syselem_g[type] = re;
    }
    else
    {
      for (; ri->next != NULL; ri = ri->next);
      ri->next = re;
    }
#else
    re->next = reglist_syselem_g[type];
    reglist_syselem_g[type] = re;
#endif
    *reret = re;
  }

  return status;
}


/*-------------------------------------------------------------------------*/


#if NOSCFG_FEATURE_USERREG != 0

VAR_t nosRegGet(const char *keyname, KEYVALUE_t *keyvalue)
{
  REGELEM_t re;

  if ((keyname == NULL) || (keyvalue == NULL))
    return -E_ARG;

  posSemaGet(reglist_sema_g);

  re = n_findKeyByName(REGTYPE_USER, keyname);
  if (re != NULL)
  {
    if (IS_VISIBLE(re)) {
      *keyvalue = re->handle.ukv;
    } else {
      re = NULL;
    }
  }

  posSemaSignal(reglist_sema_g);
  return (re == NULL) ? -E_FAIL : E_OK;
}


VAR_t nosRegSet(const char *keyname, KEYVALUE_t keyvalue)
{
  REGELEM_t re;
  VAR_t  status = E_OK;

  if (keyname == NULL)
    return -E_ARG;

  posSemaGet(reglist_sema_g);

  re = n_findKeyByName(REGTYPE_USER, keyname);
  if (re == NULL)
  {
    status = n_newKey(REGTYPE_USER, keyname, &re);
  }
  if (status == E_OK)
  {
    re->handle.ukv = keyvalue;
    MARK_VISIBLE(re);
  }

  posSemaSignal(reglist_sema_g);
  return status;
}


VAR_t nosRegDel(const char *keyname)
{
  REGELEM_t re, rl;
  VAR_t i;

  posSemaGet(reglist_sema_g);

  for (re = reglist_syselem_g[REGTYPE_USER], rl = NULL;
       re != NULL; rl = re, re = re->next)
  {
    if (!IS_DELETED(re))
    {
      for (i=0; i<NOS_MAX_REGKEYLEN; ++i)
      {
        if (re->name[i] != keyname[i])
          break;
        if ((keyname[i] == 0) || (i == NOS_MAX_REGKEYLEN-1))
        {
          MARK_DELETED(re);
          n_remove(re, rl, REGTYPE_USER);
          posSemaSignal(reglist_sema_g);
          return E_OK;
        }
      }
    }
  }

  posSemaSignal(reglist_sema_g);
  return -E_FAIL;
}

#endif /* NOSCFG_FEATURE_USERREG */


/*-------------------------------------------------------------------------*/


#if NOSCFG_FEATURE_REGQUERY != 0

NOSREGQHANDLE_t  nosRegQueryBegin(NOSREGTYPE_t type)
{
  REGQUERY_t  rq;

  if (type > MAX_REGTYPE)
    return NULL;

  rq = (REGQUERY_t) nosMemAlloc(sizeof(struct regquery));
  if (rq != NULL)
  {
    rq->queryElem = NULL;
    rq->type = type;
  }
  return (NOSREGQHANDLE_t) rq;
}


VAR_t nosRegQueryElem(NOSREGQHANDLE_t qh, NOSGENERICHANDLE_t *genh,
                      char* namebuf, VAR_t bufsize)
{
  REGQUERY_t rq = (REGQUERY_t) qh;
  REGELEM_t re;
  VAR_t i;

  if ((rq == NULL) || (genh == NULL) || (namebuf == NULL))
    return -E_ARG;

  posSemaGet(reglist_sema_g);

  if (rq->queryElem == NULL)
  {
    re = reglist_syselem_g[rq->type];
  }
  else
  {
    re = rq->queryElem->next;
    DEC_REFCOUNT(rq->queryElem, rq->type);
  }

  for(;;)
  {
    rq->queryElem = re;

    if (re == NULL)
    {
      posSemaSignal(reglist_sema_g);
      return -E_NOMORE;
    }

    if (IS_VISIBLE(re))
      break;

    re = re->next;
  }

  INC_REFCOUNT(re);

  *genh = re->handle.generic;
  for (i=0; (i < NOS_MAX_REGKEYLEN) && 
            (i < (bufsize-1)) && (re->name[i] != 0); ++i)
  {
    namebuf[i] = re->name[i];
  }
  namebuf[i] = 0;

  posSemaSignal(reglist_sema_g);
  return E_OK;
}


void nosRegQueryEnd(NOSREGQHANDLE_t qh)
{
  REGQUERY_t rq = (REGQUERY_t) qh;

  if (rq != NULL)
  {
    if (rq->queryElem != NULL)
    {
      posSemaGet(reglist_sema_g);
      DEC_REFCOUNT(rq->queryElem, rq->type);
      posSemaSignal(reglist_sema_g);
    }
    nosMemFree(rq);
  }
}

#endif /* NOSCFG_FEATURE_REGQUERY */


/*-------------------------------------------------------------------------*/


NOSGENERICHANDLE_t  nosGetHandleByName(NOSREGTYPE_t objtype, 
                                        const char *objname)
{
  REGELEM_t re;

  if ((objtype > MAX_REGTYPE) || (objname ==NULL))
    return NULL;
  if (n_strlen(objname) > NOS_MAX_REGKEYLEN)
    return NULL;

  posSemaGet(reglist_sema_g);
  re = n_findKeyByName(objtype, objname);
  posSemaSignal(reglist_sema_g);

  if (re == NULL)
    return NULL;
  return IS_VISIBLE(re) ? re->handle.generic : NULL;
}


VAR_t nosGetNameByHandle(NOSGENERICHANDLE_t handle,
                         char *buffer, VAR_t bufsize,
                         NOSREGTYPE_t what)
{
  NOSREGTYPE_t  rt;
  REGELEM_t re = NULL;
  VAR_t status = -E_NOTFOUND;
  VAR_t i;
  char  c;

  posSemaGet(reglist_sema_g);

  if (what != REGTYPE_SEARCHALL)
  {
    if (what <= MAX_REGTYPE)
    {
      re = n_findKeyByHandle(what, handle);
    }
    else
    {
      status = -E_ARG;
    }
  }
  else  
  for (rt = MIN_REGTYPE; rt <= MAX_REGTYPE; ++rt)
  {
#if NOSCFG_FEATURE_USERREG
    if (rt != REGTYPE_USER)
#endif
    {
      re = n_findKeyByHandle(rt, handle);
      if (re != NULL)
        break;
    }
  }

  if (re != NULL)
  {
    if (IS_VISIBLE(re))
    {
      status = E_OK;
      if ((buffer != NULL) && (bufsize > 0))
      {
        for (i=0; (i<bufsize-1) && (i<NOS_MAX_REGKEYLEN); ++i)
        {
          c = re->name[i];
          if (c == 0)  break;
          buffer[i] = c;
        }
        buffer[i] = 0;
      }
    }
  }

  posSemaSignal(reglist_sema_g);
  return status;
}


/*-------------------------------------------------------------------------*/


void nos_regDelSysKey(NOSREGTYPE_t type, NOSGENERICHANDLE_t handle,
                      REGELEM_t re)
{
  REGELEM_t rl = REEUNKNOWN;

  posSemaGet(reglist_sema_g);
  if (re == NULL)
  {
    for (re = reglist_syselem_g[type], rl = NULL;
         re != NULL; rl = re, re = re->next)
    {
      if (!IS_DELETED(re) && (re->handle.generic == handle))
        break;
    }
  }
  if (re != NULL)
  {
    if (!IS_DELETED(re))
    {
      MARK_DELETED(re);
      n_remove(re, rl, type);
    }
  }
  posSemaSignal(reglist_sema_g);
}


REGELEM_t nos_regNewSysKey(NOSREGTYPE_t type, const char* name)
{
  REGELEM_t re = NULL;
  posSemaGet(reglist_sema_g);
  (void) n_newKey(type, name, &re);
  posSemaSignal(reglist_sema_g);
  return re;
}


void nos_regEnableSysKey(REGELEM_t re, NOSGENERICHANDLE_t handle)
{
  re->handle.generic = handle;
  MARK_VISIBLE(re);
}


void nos_initRegistry(void)
{
  NOSREGTYPE_t  rt;

  reglist_free_g = NULL;
  reglist_sema_g = posSemaCreate(1);
  while (reglist_sema_g == NULL);
  POS_SETEVENTNAME(reglist_sema_g, "registry sync");

  for (rt = MIN_REGTYPE; rt <= MAX_REGTYPE; ++rt)
    reglist_syselem_g[rt] = NULL;
}

#else /* NOSCFG_FEATURE_REGISTRY */

void nos_initRegistry(void);
void nos_initRegistry(void)
{
}

#endif /* NOSCFG_FEATURE_REGISTRY */