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

Diff for /libaitsess/src/sess.c between versions 1.2.2.2 and 1.5.4.1

version 1.2.2.2, 2011/05/10 21:06:13 version 1.5.4.1, 2013/01/17 13:10:49
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, 2011Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2013
         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 44  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF TH Line 44  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF TH
 SUCH DAMAGE.  SUCH DAMAGE.
 */  */
 #include "global.h"  #include "global.h"
 #include "aitsess.h"  
   
   
 /*  /*
  * sess_FreeValues() Free all values from value array allocated from sess_GetValues()   * sess_FreeValues() Free all values from value array allocated from sess_GetValues()
    *
  * @ppsVals = Array strings   * @ppsVals = Array strings
  * return: none   * return: none
*/ */
 inline void  inline void
 sess_FreeValues(char *** __restrict ppsVals)  sess_FreeValues(char *** __restrict ppsVals)
 {  {
         char **ptr;          char **ptr;
   
           assert(ppsVals);
           if (!ppsVals)
                   return;
   
         for (ptr = *ppsVals; *ptr; ptr++)          for (ptr = *ppsVals; *ptr; ptr++)
                free(*ptr);                e_free(*ptr);
        free(*ppsVals);        e_free(*ppsVals);
         *ppsVals = NULL;          *ppsVals = NULL;
 }  }
   
 /*  /*
  * sess_GetValues() Get all values from session shared memory   * sess_GetValues() Get all values from session shared memory
    *
  * @s = Session item   * @s = Session item
  * @ppsVals = Return array strings   * @ppsVals = Return array strings
  * return: -1 error: in parameter, !=-1 count of returned strings in ppsVals (must be free after use!)   * return: -1 error: in parameter, !=-1 count of returned strings in ppsVals (must be free after use!)
*/ */
 int  int
sess_GetValues(tagSess * __restrict s, char ***ppsVals)sess_GetValues(ait_sess_t * __restrict s, char ***ppsVals)
 {  {
         register int i;          register int i;
         char **valz, *Shared = NULL;          char **valz, *Shared = NULL;
Line 78  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 83  sess_GetValues(tagSess * __restrict s, char ***ppsVals
   
         if (!s || !ppsVals)          if (!s || !ppsVals)
                 return -1;                  return -1;
        valz = malloc(sizeof(caddr_t));        valz = e_malloc(sizeof(caddr_t));
         if (!valz) {          if (!valz) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 86  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 91  sess_GetValues(tagSess * __restrict s, char ***ppsVals
                 *valz = NULL;                  *valz = NULL;
   
         // allocated memory & mirrored shared memory into this          // allocated memory & mirrored shared memory into this
        Shared = malloc(s->eom);        Shared = e_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(valz);                e_free(valz);
                 return -1;                  return -1;
         } else          } else
                 memcpy(Shared, s->addr, s->eom);                  memcpy(Shared, s->addr, s->eom);
Line 101  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 106  sess_GetValues(tagSess * __restrict s, char ***ppsVals
                 else                  else
                         i++;                          i++;
   
                valz = realloc(valz, (i + 1) * sizeof(caddr_t));                valz = e_realloc(valz, (i + 1) * sizeof(caddr_t));
                 if (!valz) {                  if (!valz) {
                         LOGERR;                          LOGERR;
                        free(Shared);                        e_free(Shared);
                         return -1;                          return -1;
                 } else                  } else
                         valz[i] = NULL;                          valz[i] = NULL;
   
                valz[i - 1] = strdup(peer);                valz[i - 1] = e_strdup(peer);
         }          }
   
        free(Shared);        e_free(Shared);
         *ppsVals = valz;          *ppsVals = valz;
         return i;          return i;
 }  }
   
 /*  /*
  * sess_GetValue() Get value from session shared memory from attribute   * sess_GetValue() Get value from session shared memory from attribute
    *
  * @s = Session item   * @s = Session item
  * @csAttr = Attribute for search   * @csAttr = Attribute for search
  * @psVal = Return string buffer   * @psVal = Return string buffer
  * @pnLen = Length of return string buffer,    * @pnLen = Length of return string buffer, 
         // *{pnLen} input is max_size of buffer & output is really taken bytes          // *{pnLen} input is max_size of buffer & output is really taken bytes
  * return: 0 not found, -1 error: in parameter, >0 get position, if define item merged with IS_DEF   * return: 0 not found, -1 error: in parameter, >0 get position, if define item merged with IS_DEF
*/ */
 int  int
sess_GetValue(tagSess * __restrict s, const char *csAttr, char *psVal, int *pnLen)sess_GetValue(ait_sess_t * __restrict s, const char *csAttr, char *psVal, int *pnLen)
 {  {
         register int i;          register int i;
         int def = IS_VAL;          int def = IS_VAL;
Line 144  sess_GetValue(tagSess * __restrict s, const char *csAt Line 150  sess_GetValue(tagSess * __restrict s, const char *csAt
         }          }
   
         // allocated memory & mirrored shared memory into this          // allocated memory & mirrored shared memory into this
        Shared = malloc(s->eom);        Shared = e_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 154  sess_GetValue(tagSess * __restrict s, const char *csAt Line 160  sess_GetValue(tagSess * __restrict s, const char *csAt
         for (i = 1, peer = strtok_r(Shared, MEM_DELIM"\r\n", &p_brk); peer;           for (i = 1, peer = strtok_r(Shared, MEM_DELIM"\r\n", &p_brk); peer; 
                         i++, peer = strtok_r(NULL, MEM_DELIM"\r\n", &p_brk)) {                          i++, peer = strtok_r(NULL, MEM_DELIM"\r\n", &p_brk)) {
                 attr = strtok_r(peer, "=\r\n", &a_brk);                  attr = strtok_r(peer, "=\r\n", &a_brk);
                if (attr && !strncmp(attr, csAttr, MAX_ATTRIBUTE)) {                if (attr && !strncmp(attr, csAttr, MAX_ATTRIBUTE - 1)) {
                         val = strtok_r(NULL, "=\r\n", &a_brk);                          val = strtok_r(NULL, "=\r\n", &a_brk);
                         if (val && strlen(val)) {                          if (val && strlen(val)) {
                                 if (psVal)                                  if (psVal)
Line 164  sess_GetValue(tagSess * __restrict s, const char *csAt Line 170  sess_GetValue(tagSess * __restrict s, const char *csAt
                         } else                          } else
                                 def = IS_DEF;                                  def = IS_DEF;
   
                        free(Shared);                        e_free(Shared);
                         return i | def;                          return i | def;
                 }                  }
         }          }
   
        free(Shared);        e_free(Shared);
         return 0;          return 0;
 }  }
   
 /*  /*
  * sess_DelValue() Delete item from session shared memory   * sess_DelValue() Delete item from session shared memory
    *
  * @s = Session item   * @s = Session item
  * @csAttr = Attribute for erasing   * @csAttr = Attribute for erasing
  * return: 0 Ok, -1 error: in parameter   * return: 0 Ok, -1 error: in parameter
*/ */
 int  int
sess_DelValue(tagSess * __restrict s, const char *csAttr)sess_DelValue(ait_sess_t * __restrict s, const char *csAttr)
 {  {
         register int i;          register int i;
        int ret, attrlen;        int attrlen;
        char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE + 1];        char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
         char *peer, *p_brk;          char *peer, *p_brk;
   
         if (!s || !csAttr || !*csAttr)          if (!s || !csAttr || !*csAttr)
Line 192  sess_DelValue(tagSess * __restrict s, const char *csAt Line 199  sess_DelValue(tagSess * __restrict s, const char *csAt
         else          else
                 attrlen = strlen(csAttr);                  attrlen = strlen(csAttr);
         Buffer = Shared = NULL;          Buffer = Shared = NULL;
        memset(szAttr, 0, MAX_ATTRIBUTE + 1);        strlcpy(szAttr, csAttr, sizeof szAttr);
        strncpy(szAttr, csAttr, MAX_ATTRIBUTE - 1);        strlcat(szAttr, "=", sizeof szAttr);
        strcat(szAttr, "="); 
   
        Buffer = malloc(s->eom);        Buffer = e_malloc(s->eom);
         if (!Buffer) {          if (!Buffer) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(Buffer, 0, s->eom);                  memset(Buffer, 0, s->eom);
        Shared = malloc(s->eom);        Shared = e_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(Buffer);                e_free(Buffer);
                 return -1;                  return -1;
         } else {          } else {
                DEC_SEMAPHORE(s, ret);                DEC_SEM(s);
                 memcpy(Shared, s->addr, s->eom);                  memcpy(Shared, s->addr, s->eom);
         }          }
   
Line 219  sess_DelValue(tagSess * __restrict s, const char *csAt Line 225  sess_DelValue(tagSess * __restrict s, const char *csAt
                                         peer[attrlen] == '\r' || peer[attrlen] == '\n')                                          peer[attrlen] == '\r' || peer[attrlen] == '\n')
                                 continue;                                  continue;
   
                strcat(Buffer, peer);                strlcat(Buffer, peer, s->eom);
                strcat(Buffer, MEM_DELIM);                strlcat(Buffer, MEM_DELIM, s->eom);
         }          }
   
         memset(s->addr, 0, s->eom);  
         memcpy(s->addr, Buffer, s->eom);          memcpy(s->addr, Buffer, s->eom);
   
         if (s->type == SHARED_MAP)          if (s->type == SHARED_MAP)
                 msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);                  msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
   
        ADD_SEMAPHORE(s, ret);        INC_SEM(s);
        free(Shared);        e_free(Shared);
        free(Buffer);        e_free(Buffer);
         return 0;          return 0;
 }  }
   
 /*  /*
  * sess_SetValue() Set item into session shared memory or update if find it   * sess_SetValue() Set item into session shared memory or update if find it
    *
  * @s = Session item   * @s = Session item
  * @csAttr = Attribute   * @csAttr = Attribute
  * @psVal = Value   * @psVal = Value
  * return: 0 nothing, -1 error: in parameter,    * return: 0 nothing, -1 error: in parameter, 
         >0 set position, if add item merged with IS_ADD and if define item merged with IS_DEF          >0 set position, if add item merged with IS_ADD and if define item merged with IS_DEF
*/ */
 int  int
sess_SetValue(tagSess * __restrict s, const char *csAttr, const char *psVal)sess_SetValue(ait_sess_t * __restrict s, const char *csAttr, const char *psVal)
 {  {
         register int i;          register int i;
        int upd, ret, def = IS_VAL;        int upd, def = IS_VAL;
        char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE + 1];        char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
         char *peer, *p_brk;          char *peer, *p_brk;
   
         if (!s || !csAttr || !*csAttr)          if (!s || !csAttr || !*csAttr)
                 return -1;                  return -1;
         else          else
                 Buffer = Shared = NULL;                  Buffer = Shared = NULL;
        memset(szAttr, 0, MAX_ATTRIBUTE + 1);        strlcpy(szAttr, csAttr, sizeof szAttr);
        strncpy(szAttr, csAttr, MAX_ATTRIBUTE - 1);        strlcat(szAttr, "=", sizeof szAttr);
        strcat(szAttr, "="); 
   
        Buffer = malloc(s->eom);        Buffer = e_malloc(s->eom);
         if (!Buffer) {          if (!Buffer) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(Buffer, 0, s->eom);                  memset(Buffer, 0, s->eom);
        Shared = malloc(s->eom);        Shared = e_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(Buffer);                e_free(Buffer);
                 return -1;                  return -1;
         } else {          } else {
                DEC_SEMAPHORE(s, ret);                DEC_SEM(s);
                 memcpy(Shared, s->addr, s->eom);                  memcpy(Shared, s->addr, s->eom);
         }          }
   
Line 280  sess_SetValue(tagSess * __restrict s, const char *csAt Line 285  sess_SetValue(tagSess * __restrict s, const char *csAt
                 if (!strncmp(peer, szAttr, strlen(szAttr))) {                  if (!strncmp(peer, szAttr, strlen(szAttr))) {
                         upd++;                          upd++;
                         if (psVal) {                          if (psVal) {
                                strcat(Buffer, szAttr);                                strlcat(Buffer, szAttr, s->eom);
                                strcat(Buffer, psVal);                                strlcat(Buffer, psVal, s->eom);
                                strcat(Buffer, MEM_DELIM);                                strlcat(Buffer, MEM_DELIM, s->eom);
                         } else {                          } else {
                                strcat(Buffer, csAttr);                                strlcat(Buffer, csAttr, s->eom);
                                strcat(Buffer, MEM_DELIM);                                strlcat(Buffer, MEM_DELIM, s->eom);
                                 def = IS_DEF;                                  def = IS_DEF;
                         }                          }
                         continue;                          continue;
                 }                  }
   
                strcat(Buffer, peer);                strlcat(Buffer, peer, s->eom);
                strcat(Buffer, MEM_DELIM);                strlcat(Buffer, MEM_DELIM, s->eom);
         }          }
   
         if (!upd) {          if (!upd) {
                 if (psVal) {                  if (psVal) {
                        strcat(Buffer, szAttr);                        strlcat(Buffer, szAttr, s->eom);
                        strcat(Buffer, psVal);                        strlcat(Buffer, psVal, s->eom);
                        strcat(Buffer, MEM_DELIM);                        strlcat(Buffer, MEM_DELIM, s->eom);
                 } else {                  } else {
                        strcat(Buffer, csAttr);                        strlcat(Buffer, csAttr, s->eom);
                        strcat(Buffer, MEM_DELIM);                        strlcat(Buffer, MEM_DELIM, s->eom);
                         def = IS_DEF;                          def = IS_DEF;
                 }                  }
                 def |= IS_ADD;                  def |= IS_ADD;
         }          }
   
         memset(s->addr, 0, s->eom);  
         memcpy(s->addr, Buffer, s->eom);          memcpy(s->addr, Buffer, s->eom);
   
         if (s->type == SHARED_MAP)          if (s->type == SHARED_MAP)
                 msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);                  msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
   
        ADD_SEMAPHORE(s, ret);        INC_SEM(s);
        free(Shared);        e_free(Shared);
        free(Buffer);        e_free(Buffer);
         return upd | def;          return upd | def;
   }
   
   
   /*
    * sess_prepareSession() Attach to shared memory and de-marshaling data
    *
    * @s = Session
    * @useDirect = Use direct shared memory if !=0 or snapshot of data to array
    * return: NULL error or no data, !=NULL array with variables, 
    *              after use must free resources with sess_doneSession()
    */
   array_t *
   sess_prepareSession(ait_sess_t * __restrict s, char useDirect)
   {
           array_t *arr = NULL;
           sess_hdr_t *hdr;
   
           assert(s);
           if (!s) {
                   sess_SetErr(EINVAL, "Error:: invalid argument\n");
                   return NULL;
           }
           if (s->addr) {
                   sess_SetErr(EINVAL, "Error:: already attached memory\n");
                   return NULL;
           }
   
           ATTACH_MEMORY(s);
           if (!s->addr)
                   return NULL;
           else
                   hdr = (sess_hdr_t*) s->addr;
           if (hdr->hdr_magic != SESS_AIT_MAGIC) {
                   DETACH_MEMORY(s);
   
                   sess_SetErr(EINVAL, "Error:: shared memory not contains values with proper format\n");
                   return NULL;
           }
   
           DEC_SEM(s);
           s->zcpy = useDirect;
           arr = ait_map2vars(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t), 
                           hdr->hdr_argc, useDirect);
           INC_SEM(s);
   
           if (!s->zcpy)
                   DETACH_MEMORY(s);
           return arr;
   }
   
   /*
    * sess_doneSession() Free resources allocated with sess_prepareSession()
    *
    * @s = Session
    * @arr = Array with variables for free
    * return: none
    */
   void
   sess_doneSession(ait_sess_t * __restrict s, array_t ** __restrict arr)
   {
           assert(s);
           if (!s) {
                   sess_SetErr(EINVAL, "Error:: invalid argument\n");
                   return;
           }
   
           if (!s->zcpy)
                   array_Free(*arr);
           else
                   DETACH_MEMORY(s);
           array_Destroy(arr);
   }
   
   /*
    * sess_commitSession() Commit data to shared memory
    *
    * @s = Session
    * @arr = Array with variables for save
    * return -1 error or !=-1 size of stored variables into shared memory
    */
   int
   sess_commitSession(ait_sess_t * __restrict s, array_t * __restrict arr)
   {
           sess_hdr_t *hdr;
           int ret = 0;
   
           assert(s && arr);
           if (!s || !arr) {
                   sess_SetErr(EINVAL, "Error:: invalid argument\n");
                   return -1;
           }
   
           ATTACH_MEMORY(s);
           if (!s->addr) {
                   DETACH_MEMORY(s);
                   return -1;
           } else
                   hdr = (sess_hdr_t*) s->addr;
   
           DEC_SEM(s);
           if ((ret = ait_vars2map(s->addr + sizeof(sess_hdr_t), 
                                           s->eom - sizeof(sess_hdr_t), arr)) != -1) {
                   hdr->hdr_magic = SESS_AIT_MAGIC;
                   hdr->hdr_argc = array_Size(arr);
                   ret += sizeof(sess_hdr_t);
           }
           INC_SEM(s);
   
           DETACH_MEMORY(s);
           return ret;
 }  }
Removed from v.1.2.2.2  
changed lines
  Added in v.1.5.4.1

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