[BACK]Return to queue.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitcfg / src

Diff for /libaitcfg/src/queue.c between versions 1.6.4.2 and 1.20

version 1.6.4.2, 2012/04/02 15:12:15 version 1.20, 2025/01/31 00:03:15
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012Copyright 2004 - 2024
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
 static inline struct tagCfg *  static inline struct tagCfg *
 _selectAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)  _selectAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {  {
        struct tagCfg fav;        struct tagCfg fav, *c, *n;
   
         if (!cfg)          if (!cfg)
                 return NULL;                  return NULL;
Line 58  _selectAttribute(cfg_root_t * __restrict cfg, const ch Line 58  _selectAttribute(cfg_root_t * __restrict cfg, const ch
   
         if (csSec && *csSec)          if (csSec && *csSec)
                 AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,                   AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec, 
                                io_align(strlen(csSec), 1) / 2);                                E_ALIGN(strlen(csSec), 2) / 2);
         if (csAttr)          if (csAttr)
                 AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,                   AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr, 
                                io_align(strlen(csAttr), 1) / 2);                                E_ALIGN(strlen(csAttr), 2) / 2);
   
        /*        if (!csAttr) {
        struct tagCfg *av;                c = RB_NFIND(tagRC, cfg, &fav);
                if (!c)
        RB_FOREACH(av, tagRC, cfg) {                        return NULL;    /* not found */
                printf("sec=%s(%d) attr=%s(%d) val=%s\n", AIT_GET_LIKE(&av->cfg_sec, char*), AIT_KEY(&av->cfg_sec),                 if (csSec && !AIT_ISEMPTY(&c->cfg_sec) && 
                                AIT_GET_LIKE(&av->cfg_attr, char*), AIT_KEY(&av->cfg_attr), AIT_GET_STR(&av->cfg_val));                                strcmp(csSec, AIT_GET_STR(&c->cfg_sec)))
                         TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
                                 if (!AIT_ISEMPTY(&c->cfg_sec) && 
                                                 !strcmp(csSec, AIT_GET_STR(&c->cfg_sec)))
                                         break;
                         }
                 return c;
         } else {
                 c = RB_FIND(tagRC, cfg, &fav);
                 if (!c)
                         return NULL;    /* not found */
                 /* if cannot find right section */
                 if (csSec && !AIT_ISEMPTY(&c->cfg_sec) && 
                                 strcmp(csSec, AIT_GET_STR(&c->cfg_sec))) {
                         TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
                                 if (!AIT_ISEMPTY(&c->cfg_sec) && csAttr && 
                                                 !strcmp(csSec, AIT_GET_STR(&c->cfg_sec)) && 
                                                 !strcmp(csAttr, AIT_GET_STR(&c->cfg_attr)))
                                         return c;       /* FOUND! */
                         }
                         return NULL;    /* not found */
                 }
                 do {
                         if (!strcmp(AIT_GET_STR(&c->cfg_attr), csAttr))
                                 return c;       /* FOUND! */
                 } while ((c = RB_NEXT(tagRC, cfg, c)) && c && !cfg_tree_cmp(c, &fav));
                 /* if cannot find right attribute */
                 TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
                         if ((!csSec && AIT_ISEMPTY(&c->cfg_sec)) || 
                                         (csSec && !AIT_ISEMPTY(&c->cfg_sec) && 
                                          !strcmp(csSec, AIT_GET_STR(&c->cfg_sec))))
                                 if (!AIT_ISEMPTY(&c->cfg_attr) && csAttr && 
                                                 !strcmp(csAttr, AIT_GET_STR(&c->cfg_attr)))
                                         return c;       /* FOUND! */
                 }
                 return NULL;    /* not found */
         }          }
   
         printf("ssss=%d aaaa=%d\n", AIT_KEY(&fav.cfg_sec), AIT_KEY(&fav.cfg_attr));  
         */  
         if (!csAttr)  
                 return RB_NFIND(tagRC, cfg, &fav);  
         else  
                 return RB_FIND(tagRC, cfg, &fav);  
 }  }
   
static inline void/* --------------------------------------------------------------- */
_destroyAttribute(struct tagCfg *av)
 /*
  * cfg_dumpCfg() - dump config data
  *
  * @cfg = Config root
  * return: none
  */
 void
 cfg_dumpCfg(cfg_root_t * __restrict cfg)
 {  {
        if (!av)        struct tagCfg *r, *c, *ctmp, *q, *qtmp;
                return;        int syn = 0;
   
        AIT_FREE_VAL(&av->cfg_val);        r = RB_ROOT(cfg);
        AIT_FREE_VAL(&av->cfg_attr);        printf("ROOT:: KEY=%.8x [%s] %s=%s\n", ((AIT_KEY(&r->cfg_sec) << 15) | AIT_KEY(&r->cfg_attr)), 
        AIT_FREE_VAL(&av->cfg_sec);                        AIT_ADDR(&r->cfg_sec), AIT_ADDR(&r->cfg_attr), AIT_ADDR(&r->cfg_val));
        free(av);
         RB_FOREACH_SAFE(c, tagRC, cfg, ctmp) {
                 syn ^= syn;
                 TAILQ_FOREACH_SAFE(q, cfg, cfg_next, qtmp) {
                         if (c == q) {
                                 syn = 42;
                                 break;
                         }
                 }
 
                 printf("%s KEY=%.8x [%s] %s=%s sync=%d\n", c == r ? "*" : "", 
                                 ((AIT_KEY(&c->cfg_sec) << 15) | AIT_KEY(&c->cfg_attr)), 
                                 AIT_ADDR(&c->cfg_sec), AIT_ADDR(&c->cfg_attr), AIT_ADDR(&c->cfg_val), syn);
         }
 }  }
   
// ----------------------------------------------/*
  * cfg_getSection() - Get entire section attributes into array
  *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}]
  * return: NULL not found or !=NULL allocated array, must free with array_Destroy() after use!
  */
 array_t *
 cfg_getSection(cfg_root_t * __restrict cfg, const char *csSec)
 {
         array_t *arr = NULL;
         struct tagCfg *av, fav;
   
           if (!cfg) {
                   cfg_SetErr(EINVAL, "Invalid argument(s)");
                   return NULL;
           } else
                   memset(&fav, 0, sizeof fav);
           if (csSec && !*csSec)
                   csSec = NULL;
   
           if (csSec && *csSec)
                   AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec, 
                                   E_ALIGN(strlen(csSec), 2) / 2);
   
           arr = array_Init(0);
           if (!arr) {
                   cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                   return NULL;
           }
   
           TAILQ_FOREACH(av, cfg, cfg_next)
                   if (AIT_KEY(&av->cfg_sec) == AIT_KEY(&fav.cfg_sec)) {
                           if (!csSec) {
                                   if (AIT_ISEMPTY(&av->cfg_sec))
                                           array_Push(arr, av, 0);
                           } else {
                                   if (!AIT_ISEMPTY(&av->cfg_sec) && 
                                                   !strcmp(AIT_GET_STR(&av->cfg_sec), csSec))
                                           array_Push(arr, av, 0);
                           }
                   }
   
           if (!array_Size(arr))
                   array_Destroy(&arr);
   
           return arr;
   }
   
 /*  /*
  * cfg_findAttribute() - Find attribute position in config file   * cfg_findAttribute() - Find attribute position in config file
  *   *
Line 101  _destroyAttribute(struct tagCfg *av) Line 197  _destroyAttribute(struct tagCfg *av)
  * @csAttr = Config attribute //{csAttr} = ...   * @csAttr = Config attribute //{csAttr} = ...
  * return: 0 not found item, -1 error or >0 position in list   * return: 0 not found item, -1 error or >0 position in list
  */   */
inline intint
 cfg_findAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)  cfg_findAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {  {
        struct tagCfg *av, fav;        struct tagCfg *av, *n;
         register int cx = 0;          register int cx = 0;
   
        if (!cfg || !csAttr) {        if (!cfg) {
                 cfg_SetErr(EINVAL, "Invalid argument(s)");                  cfg_SetErr(EINVAL, "Invalid argument(s)");
                 return -1;                  return -1;
        } else        }
                memset(&fav, 0, sizeof fav); 
   
        if (csSec && *csSec)        TAILQ_FOREACH_SAFE(av, cfg, cfg_next, n) {
                AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,  
                                io_align(strlen(csSec), 1) / 2); 
        if (csAttr) 
                AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,  
                                io_align(strlen(csAttr), 1) / 2); 
 
        SLIST_FOREACH(av, cfg, cfg_next) { 
                 ++cx;                  ++cx;
                if (!cfg_tree_cmp(&fav, av))
                        return cx;                if ((!csSec && AIT_ISEMPTY(&av->cfg_sec)) || 
                                 (csSec && !AIT_ISEMPTY(&av->cfg_sec) && 
                                  !strcmp(csSec, AIT_GET_STR(&av->cfg_sec))))
                         if (!AIT_ISEMPTY(&av->cfg_attr) && csAttr && 
                                         !strcmp(csAttr, AIT_GET_STR(&av->cfg_attr)))
                                 return cx;
         }          }
   
         return 0;          return 0;
 }  }
#if 0
 /*  /*
 * cfg_UnsetAttribute() Unset item from config list and free resources * cfg_unsetAttribute() - Unset item from config and free resources
 * @cfg = Head list element *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section   * @csSec = Config section //[{csSec}], if NULL unset in *default* section
 * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute * @csAttr = Config attribute //{csAttr} = ...
 * return: 0 item not found, -1 error: null parameters; >0 position in list * return: 0 item not found, -1 error or 1 removed item
*/ */
int cfg_UnsetAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr)int
 cfg_unsetAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {  {
        struct tagPair *av, *curr;        struct tagCfg *av;
        register int cx = 0; 
   
        if (!cfg || !csAttr)        if (!cfg)
                 return -1;                  return -1;
   
        av = SelectAttribute(cfg, csSec, csAttr);        av = _selectAttribute(cfg, csSec, csAttr);
         if (!av)          if (!av)
                 return 0;                  return 0;
   
        // remove element        CFG_RC_LOCK(cfg);
        //      remove element when is first!        RB_REMOVE(tagRC, cfg, av);
        if (cfg->slh_first == av) {        TAILQ_REMOVE(cfg, av, cfg_next);
                cfg->slh_first = cfg->slh_first->sle_next;        CFG_RC_UNLOCK(cfg);
   
                DestroyAttribute(av);        AIT_FREE_VAL(&av->cfg_val);
                return 1;        AIT_FREE_VAL(&av->cfg_attr);
        }        AIT_FREE_VAL(&av->cfg_sec);
        //      remove element in other cases...        e_free(av);
        curr = cfg->slh_first;        return 1;
        while (curr->sle_next != av) { 
                ++cx; 
                curr = curr->sle_next; 
        } 
        curr->sle_next = curr->sle_next->sle_next; 
 
        DestroyAttribute(av); 
        return cx; 
 }  }
 #endif  
   
 /*  /*
  * cfg_setAttribute() - Set item in config or adding new item if not exists   * cfg_setAttribute() - Set item in config or adding new item if not exists
Line 183  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch Line 268  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
 {  {
         struct tagCfg *av, *section;          struct tagCfg *av, *section;
   
        if (!cfg || !csAttr || !csVal)        if (!cfg || !csAttr)
                 return -1;                  return -1;
   
         av = _selectAttribute(cfg, csSec, csAttr);          av = _selectAttribute(cfg, csSec, csAttr);
Line 191  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch Line 276  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
                 /* adding new element */                  /* adding new element */
                 section = _selectAttribute(cfg, csSec, NULL);                  section = _selectAttribute(cfg, csSec, NULL);
   
                av = malloc(sizeof(struct tagCfg));                av = e_malloc(sizeof(struct tagCfg));
                 if (!av) {                  if (!av) {
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
Line 200  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch Line 285  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
   
                         CFG_RC_LOCK(cfg);                          CFG_RC_LOCK(cfg);
                         if (!section)                          if (!section)
                                SLIST_INSERT_HEAD(cfg, av, cfg_next);                                TAILQ_INSERT_TAIL(cfg, av, cfg_next);
                         else                          else
                                SLIST_INSERT_AFTER(section, av, cfg_next);                                TAILQ_INSERT_BEFORE(section, av, cfg_next);
                         CFG_RC_UNLOCK(cfg);                          CFG_RC_UNLOCK(cfg);
                 }                  }
   
                 if (csSec && *csSec) {                  if (csSec && *csSec) {
                         AIT_SET_STR(&av->cfg_sec, csSec);                          AIT_SET_STR(&av->cfg_sec, csSec);
                         AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),                           AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), 
                                        io_align(AIT_LEN(&av->cfg_sec) - 1, 1) / 2);                                        E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
                 }                  }
                AIT_SET_STR(&av->cfg_val, csVal);                AIT_SET_STR(&av->cfg_val, csVal ? csVal : "");
                 AIT_SET_STR(&av->cfg_attr, csAttr);                  AIT_SET_STR(&av->cfg_attr, csAttr);
                 AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),                   AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), 
                                io_align(AIT_LEN(&av->cfg_attr) - 1, 1) / 2);                                E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
   
                 CFG_RC_LOCK(cfg);                  CFG_RC_LOCK(cfg);
                 RB_INSERT(tagRC, cfg, av);                  RB_INSERT(tagRC, cfg, av);
Line 222  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch Line 307  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
                 return 2;                  return 2;
         }          }
   
        if (strcmp((char*) csVal, (char*) AIT_GET_STR(&av->cfg_val))) {        if (csVal && AIT_ADDR(&av->cfg_val) && 
                         strcmp((char*) csVal, (char*) AIT_GET_STR(&av->cfg_val))) {
                 /* Update element */                  /* Update element */
                 AIT_FREE_VAL(&av->cfg_val);                  AIT_FREE_VAL(&av->cfg_val);
                 AIT_SET_STR(&av->cfg_val, csVal);                  AIT_SET_STR(&av->cfg_val, csVal);
Line 238  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch Line 324  cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
  *   *
  * @cfg = Config root   * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section   * @csSec = Config section //[{csSec}], if NULL unset in *default* section
 * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute * @csAttr = Config attribute //{csAttr} = ...
  * return: NULL item not found or null parameters, !=NULL value const string   * return: NULL item not found or null parameters, !=NULL value const string
  */   */
inline const char *const char *
 cfg_getAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)  cfg_getAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {  {
         struct tagCfg *av;          struct tagCfg *av;
   
        if (!cfg || !csAttr)        if (!cfg)
                 return NULL;                  return NULL;
   
         av = _selectAttribute(cfg, csSec, csAttr);          av = _selectAttribute(cfg, csSec, csAttr);
Line 255  cfg_getAttribute(cfg_root_t * __restrict cfg, const ch Line 341  cfg_getAttribute(cfg_root_t * __restrict cfg, const ch
   
         return AIT_GET_STR(&av->cfg_val);          return AIT_GET_STR(&av->cfg_val);
 }  }
 #if 0  
 // --------------------------------------------------------------  
   
 /*  /*
 * cfg_LoadAttribute() Extended get attribute, if not found item return *default value* * cfg_getAttributeLong() - Get item as long from config and return value from it
 * @cfg = Head list element *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section   * @csSec = Config section //[{csSec}], if NULL unset in *default* section
 * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute * @csAttr = Config attribute //{csAttr} = ...
 * @psVal = Return buffer for item Value //... = {psVal} * return: value
 * @ValLen = Length of buffer //{psVal} for return */
 * @csDefValue = *Default Value* for return in //{psVal}, if not found item in config listlong
 * return: 0 item not found, -1 error: null parameters; >0 number of copied bytes in //{psVal}cfg_getAttributeLong(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
*/ 
int cfg_LoadAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr,  
                u_char * __restrict psVal, int ValLen, const char *csDefValue) 
 {  {
        struct tagPair *av;        const char *str = NULL;
 
         str = cfg_getAttribute(cfg, csSec, csAttr);
         return strtol(str ? str : "", NULL, 0);
 }
 
 /*
  * cfg_getAttributeLLong() - Get item as long long from config and return value from it
  *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section
  * @csAttr = Config attribute //{csAttr} = ...
  * return: value
  */
 long long
 cfg_getAttributeLLong(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {
         const char *str = NULL;
 
         str = cfg_getAttribute(cfg, csSec, csAttr);
         return strtoll(str ? str : "", NULL, 0);
 }
 
 /*
  * cfg_getAttributeDouble() - Get item as double from config and return value from it
  *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section
  * @csAttr = Config attribute //{csAttr} = ...
  * return: value
  */
 double
 cfg_getAttributeDouble(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {
         const char *str = NULL;
 
         str = cfg_getAttribute(cfg, csSec, csAttr);
         return strtod(str ? str : "", NULL);
 }
 
 /*
  * cfg_getAttributeLDouble() - Get item as long double from config and return value from it
  *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section
  * @csAttr = Config attribute //{csAttr} = ...
  * return: value
  */
 long double
 cfg_getAttributeLDouble(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr)
 {
         const char *str = NULL;
 
         str = cfg_getAttribute(cfg, csSec, csAttr);
         return strtold(str ? str : "", NULL);
 }
 
 /*
  * cfg_loadAttribute() - Get guarded attribute, if not found item return *default value*
  *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL unset in *default* section
  * @csAttr = Config attribute //{csAttr} = ...
  * @val = Return buffer for item Value //... = {val}
  * @csDefValue = *Default Value* for return in //{val}, if not found item in config
  * return: 0 item not found, -1 error or >0 number of copied bytes in //{val}
  */
 int
 cfg_loadAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr, 
                 ait_val_t * __restrict val, const char *csDefValue)
 {
         struct tagCfg *av;
         int ret = 0;          int ret = 0;
   
        if (!cfg || !csAttr || !ValLen || !psVal)        if (!cfg || !val) {
                 cfg_SetErr(EINVAL, "Invalid argument(s)");
                 return -1;                  return -1;
           }
   
        av = SelectAttribute(cfg, csSec, csAttr);        AIT_INIT_VAL(val);
         av = _selectAttribute(cfg, csSec, csAttr);
         if (!av) {          if (!av) {
                   /* not found item */
                 if (csDefValue) {                  if (csDefValue) {
                        strlcpy((char*) psVal, csDefValue, ValLen);                        AIT_SET_STR(val, csDefValue);
                        ret = strlen((char*) psVal);                        ret = AIT_LEN(val);
                }                } else
                        AIT_INIT_VAL(val);
                 return ret;                  return ret;
         }          }
   
        if (!av->psValue || !*av->psValue) {        if (AIT_ISEMPTY(&av->cfg_val) || !AIT_ADDR(&av->cfg_val) || 
                         !*AIT_GET_LIKE(&av->cfg_val, char*)) {
                 /* empty value */
                 if (csDefValue) {                  if (csDefValue) {
                        strlcpy((char*) psVal, csDefValue, ValLen);                        AIT_SET_STR(val, csDefValue);
                        ret = strlen((char*) psVal);                        ret = AIT_LEN(val);
                }                } else
                         AIT_INIT_VAL(val);
         } else {          } else {
                strlcpy((char*) psVal, (char*) av->psValue, ValLen);                /* copy value */
                ret = strlen((char*) psVal);                AIT_SET_STR(val, AIT_GET_STR(&av->cfg_val));
                 ret = AIT_LEN(val);
         }          }
   
         return ret;          return ret;
 }  }
 #endif  
Removed from v.1.6.4.2  
changed lines
  Added in v.1.20

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>