[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.1 and 1.6.4.6

version 1.6.4.1, 2012/04/02 14:39:03 version 1.6.4.6, 2012/04/03 07:31:06
Line 50  static inline struct tagCfg * Line 50  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;
         struct tagCfg *av;  
   
         if (!cfg)          if (!cfg)
                 return NULL;                  return NULL;
Line 64  _selectAttribute(cfg_root_t * __restrict cfg, const ch Line 63  _selectAttribute(cfg_root_t * __restrict cfg, const ch
                 AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,                   AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr, 
                                 io_align(strlen(csAttr), 1) / 2);                                  io_align(strlen(csAttr), 1) / 2);
   
         /*  
         RB_FOREACH(av, tagRC, cfg) {  
                 printf("sec=%s(%d) attr=%s(%d) val=%s\n", AIT_GET_LIKE(&av->cfg_sec, char*), AIT_KEY(&av->cfg_sec),   
                                 AIT_GET_LIKE(&av->cfg_attr, char*), AIT_KEY(&av->cfg_attr), AIT_GET_STR(&av->cfg_val));  
         }  
   
         printf("ssss=%d aaaa=%d\n", AIT_KEY(&fav.cfg_sec), AIT_KEY(&fav.cfg_attr));  
         */  
         if (!csAttr)          if (!csAttr)
                 return RB_NFIND(tagRC, cfg, &fav);                  return RB_NFIND(tagRC, cfg, &fav);
         else          else
                 return RB_FIND(tagRC, cfg, &fav);                  return RB_FIND(tagRC, cfg, &fav);
 }  }
   
static inline void/* --------------------------------------------------------------- */
_destroyAttribute(struct tagCfg *av) 
{ 
        if (!av) 
                return; 
   
         AIT_FREE_VAL(&av->cfg_val);  
         AIT_FREE_VAL(&av->cfg_attr);  
         AIT_FREE_VAL(&av->cfg_sec);  
         free(av);  
 }  
   
 // ----------------------------------------------  
   
 /*  /*
  * cfg_findAttribute() - Find attribute position in config file   * cfg_findAttribute() - Find attribute position in config file
  *   *
  * @cfg = Config root   * @cfg = Config root
  * @csSec = Config section //[{csSec}]   * @csSec = Config section //[{csSec}]
  * @csAttr = Config attribute //{csAttr} = ...   * @csAttr = Config attribute //{csAttr} = ...
 * return: 0 not found item; -1 error: null parameters; >0 position in list * return: 0 not found item, -1 error or >0 position in list
  */   */
 inline int  inline int
 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)
Line 127  cfg_findAttribute(cfg_root_t * __restrict cfg, const c Line 106  cfg_findAttribute(cfg_root_t * __restrict cfg, const c
   
         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 || !csAttr)
                 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) {        SLIST_REMOVE(cfg, av, tagCfg, 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...        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; 
 }  }
   
 /*  /*
 * cfg_SetAttribute() Set item in config list or add new item if not exists * cfg_setAttribute() - Set item in config or adding new item if not exists
 * @cfg = Head list element *
  * @cfg = Config root
  * @csSec = Config section //[{csSec}], if NULL set in *default* section   * @csSec = Config section //[{csSec}], if NULL set in *default* section
 * @csAttr = Config attribute //{csAttr} = ..., if NULL set as *any* attribute * @csAttr = Config attribute //{csAttr} = ...
  * @csVal = Config value //... = {csVal} to setup   * @csVal = Config value //... = {csVal} to setup
 * return: 0 nothing changed, -1 error: not enough memory; 1 find and update item; 2 added new item * return: 0 nothing changed, -1 error, 1 found and updated item or 2 added new item
*/ */
int cfg_SetAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr, const u_char *csVal)int
 cfg_setAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr, const char *csVal)
 {  {
        struct tagPair *av, *section;        struct tagCfg *av, *section;
        int len; 
   
         if (!cfg || !csAttr)          if (!cfg || !csAttr)
                 return -1;                  return -1;
   
        av = SelectAttribute(cfg, csSec, csAttr);        av = _selectAttribute(cfg, csSec, csAttr);
         if (!av) {          if (!av) {
                section = SelectAttribute(cfg, csSec, NULL);                /* adding new element */
                 section = _selectAttribute(cfg, csSec, NULL);
   
                av = malloc(sizeof(struct tagPair));                av = malloc(sizeof(struct tagCfg));
                 if (!av) {                  if (!av) {
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
                 } else {                  } else {
                        memset(av, 0, sizeof(struct tagPair));                        memset(av, 0, sizeof(struct tagCfg));
   
                        if (!section) {                        CFG_RC_LOCK(cfg);
                                // add new element                        if (!section)
                                av->sle_next = cfg->slh_first;                                SLIST_INSERT_HEAD(cfg, av, cfg_next);
                                cfg->slh_first = av;                        else
                        } else {                                SLIST_INSERT_AFTER(section, av, cfg_next);
                                // add new element in existing section                        CFG_RC_UNLOCK(cfg);
                                av->sle_next = section->sle_next; 
                                section->sle_next = av; 
                        } 
                 }                  }
                 // added section name to element  
                 if (csSec && *csSec) {  
                         len = strlen((char*) csSec) + 1;  
                         av->psSection = malloc(len);  
                         if (!av->psSection) {  
                                 LOGERR;  
                                 free(av);  
                                 return -1;  
                         } else {  
                                 strlcpy((char*) av->psSection, (char*) csSec, len);  
                         }  
                 } else  
                         av->psSection = NULL;  
   
                // added attribute to element                if (csSec && *csSec) {
                len = strlen((char*) csAttr) + 1;                        AIT_SET_STR(&av->cfg_sec, csSec);
                av->psAttribute = malloc(len);                        AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), 
                if (!av->psAttribute) {                                        io_align(AIT_LEN(&av->cfg_sec) - 1, 1) / 2);
                        LOGERR; 
                        free(av->psSection); 
                        free(av); 
                        return -1; 
                } else { 
                        strlcpy((char*) av->psAttribute, (char*) csAttr, len); 
                 }                  }
                // added value to element                AIT_SET_STR(&av->cfg_val, csVal ? csVal : "");
                if (csVal && *csVal) {                AIT_SET_STR(&av->cfg_attr, csAttr);
                        len = strlen((char*) csVal) + 1;                AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), 
                        av->psValue = malloc(len);                                io_align(AIT_LEN(&av->cfg_attr) - 1, 1) / 2);
                        if (!av->psValue) { 
                                LOGERR; 
                                free(av->psAttribute); 
                                free(av->psSection); 
                                free(av); 
                                return -1; 
                        } else { 
                                strlcpy((char*) av->psValue, (char*) csVal, len); 
                        } 
                } else { 
                        av->psValue = malloc(1); 
                        *av->psValue = 0; 
                } 
   
                // Added new element                CFG_RC_LOCK(cfg);
                 RB_INSERT(tagRC, cfg, av);
                 CFG_RC_UNLOCK(cfg);
                 return 2;                  return 2;
         }          }
   
        if (strcmp((char*) csVal, (char*) av->psValue)) {        if (csVal && strcmp((char*) csVal, (char*) AIT_GET_STR(&av->cfg_val))) {
                len = strlen((char*) csVal) + 1;                /* Update element */
                av->psValue = realloc(av->psValue, len);                AIT_FREE_VAL(&av->cfg_val);
                strlcpy((char*) av->psValue, (char*) csVal, len);                AIT_SET_STR(&av->cfg_val, csVal);
 
                // Update element 
                 return 1;                  return 1;
         }          }
   
        // Nothing happens ... finded & values is equal!        /* Nothing happens ... found & values is equal! */
         return 0;          return 0;
 }  }
   
 #endif  
   
 /*  /*
  * cfg_getAttribute() - Get item from config and return value from it   * cfg_getAttribute() - Get item from config and return value from it
  *   *
  * @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} = ..., if NULL unset as *any* attribute
 * 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 *  inline 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)
Line 288  cfg_getAttribute(cfg_root_t * __restrict cfg, const ch Line 225  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_loadAttribute() - Get guarded attribute, if not found item return *default value*
 * @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} * @val = Return buffer for item Value //... = {val}
 * @ValLen = Length of buffer //{psVal} for return * @csDefValue = *Default Value* for return in //{val}, if not found item in config
 * @csDefValue = *Default Value* for return in //{psVal}, if not found item in config list * return: 0 item not found, -1 error or >0 number of copied bytes in //{val}
 * return: 0 item not found, -1 error: null parameters; >0 number of copied bytes in //{psVal} */
*/int
int cfg_LoadAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr, cfg_loadAttribute(cfg_root_t * __restrict cfg, const char *csSec, const char *csAttr, 
                u_char * __restrict psVal, int ValLen, const char *csDefValue)                ait_val_t * __restrict val, const char *csDefValue)
 {  {
        struct tagPair *av;        struct tagCfg *av;
         int ret = 0;          int ret = 0;
   
        if (!cfg || !csAttr || !ValLen || !psVal)        if (!cfg || !csAttr || !val) {
                 cfg_SetErr(EINVAL, "Invalid argument(s)");
                 return -1;                  return -1;
           }
   
        av = SelectAttribute(cfg, csSec, csAttr);        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);
                 }                  }
   
                 return ret;                  return ret;
         }          }
   
        if (!av->psValue || !*av->psValue) {        if (AIT_ISEMPTY(&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 {          } 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.1  
changed lines
  Added in v.1.6.4.6

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