[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.3.2.3 and 1.4.4.1

version 1.3.2.3, 2011/09/07 21:06:56 version 1.4.4.1, 2012/05/23 15:14:41
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
   
 /*  /*
  * 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)
 {  {
Line 62  sess_FreeValues(char *** __restrict ppsVals) Line 63  sess_FreeValues(char *** __restrict ppsVals)
                 return;                  return;
   
         for (ptr = *ppsVals; *ptr; ptr++)          for (ptr = *ppsVals; *ptr; ptr++)
                free(*ptr);                io_free(*ptr);
        free(*ppsVals);        io_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 82  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 84  sess_GetValues(tagSess * __restrict s, char ***ppsVals
   
         if (!s || !ppsVals)          if (!s || !ppsVals)
                 return -1;                  return -1;
        valz = malloc(sizeof(caddr_t));        valz = io_malloc(sizeof(caddr_t));
         if (!valz) {          if (!valz) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 90  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 92  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 = io_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(valz);                io_free(valz);
                 return -1;                  return -1;
         } else          } else
                 memcpy(Shared, s->addr, s->eom);                  memcpy(Shared, s->addr, s->eom);
Line 105  sess_GetValues(tagSess * __restrict s, char ***ppsVals Line 107  sess_GetValues(tagSess * __restrict s, char ***ppsVals
                 else                  else
                         i++;                          i++;
   
                valz = realloc(valz, (i + 1) * sizeof(caddr_t));                valz = io_realloc(valz, (i + 1) * sizeof(caddr_t));
                 if (!valz) {                  if (!valz) {
                         LOGERR;                          LOGERR;
                        free(Shared);                        io_free(Shared);
                         return -1;                          return -1;
                 } else                  } else
                         valz[i] = NULL;                          valz[i] = NULL;
   
                valz[i - 1] = strdup(peer);                valz[i - 1] = io_strdup(peer);
         }          }
   
        free(Shared);        io_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 148  sess_GetValue(tagSess * __restrict s, const char *csAt Line 151  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 = io_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 168  sess_GetValue(tagSess * __restrict s, const char *csAt Line 171  sess_GetValue(tagSess * __restrict s, const char *csAt
                         } else                          } else
                                 def = IS_DEF;                                  def = IS_DEF;
   
                        free(Shared);                        io_free(Shared);
                         return i | def;                          return i | def;
                 }                  }
         }          }
   
        free(Shared);        io_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];          char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
         char *peer, *p_brk;          char *peer, *p_brk;
   
Line 199  sess_DelValue(tagSess * __restrict s, const char *csAt Line 203  sess_DelValue(tagSess * __restrict s, const char *csAt
         strlcpy(szAttr, csAttr, sizeof szAttr);          strlcpy(szAttr, csAttr, sizeof szAttr);
         strlcat(szAttr, "=", sizeof szAttr);          strlcat(szAttr, "=", sizeof szAttr);
   
        Buffer = malloc(s->eom);        Buffer = io_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 = io_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(Buffer);                io_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 231  sess_DelValue(tagSess * __restrict s, const char *csAt Line 235  sess_DelValue(tagSess * __restrict s, const char *csAt
         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);        io_free(Shared);
        free(Buffer);        io_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];          char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
         char *peer, *p_brk;          char *peer, *p_brk;
   
Line 260  sess_SetValue(tagSess * __restrict s, const char *csAt Line 265  sess_SetValue(tagSess * __restrict s, const char *csAt
         strlcpy(szAttr, csAttr, sizeof szAttr);          strlcpy(szAttr, csAttr, sizeof szAttr);
         strlcat(szAttr, "=", sizeof szAttr);          strlcat(szAttr, "=", sizeof szAttr);
   
        Buffer = malloc(s->eom);        Buffer = io_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 = io_malloc(s->eom);
         if (!Shared) {          if (!Shared) {
                 LOGERR;                  LOGERR;
                free(Buffer);                io_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 314  sess_SetValue(tagSess * __restrict s, const char *csAt Line 319  sess_SetValue(tagSess * __restrict s, const char *csAt
         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);        io_free(Shared);
        free(Buffer);        io_free(Buffer);
         return upd | def;          return upd | def;
 }  }
   
   
 /*  /*
  * sess_prepareSession() Attach to shared memory and de-marshaling data   * sess_prepareSession() Attach to shared memory and de-marshaling data
    *
  * @s = Session   * @s = Session
  * @useDirect = Use direct shared memory if !=0 or snapshot of data to array   * @useDirect = Use direct shared memory if !=0 or snapshot of data to array
  * return: NULL error or no data, !=NULL array with variables,    * return: NULL error or no data, !=NULL array with variables, 
  *              after use must free resources with sess_doneSession()   *              after use must free resources with sess_doneSession()
  */   */
 array_t *  array_t *
sess_prepareSession(tagSess * __restrict s, u_char useDirect)sess_prepareSession(ait_sess_t * __restrict s, char useDirect)
 {  {
         array_t *arr = NULL;          array_t *arr = NULL;
         sess_hdr_t *hdr;          sess_hdr_t *hdr;
         int ret;  
   
         assert(s);          assert(s);
         if (!s) {          if (!s) {
                 sess_SetErr(EINVAL, "Error:: invalid argument\n");                  sess_SetErr(EINVAL, "Error:: invalid argument\n");
                 return NULL;                  return NULL;
         }          }
           if (s->addr) {
                   sess_SetErr(EINVAL, "Error:: already attached memory\n");
                   return NULL;
           }
   
         ATTACH_MEMORY(s);          ATTACH_MEMORY(s);
         if (!s->addr)          if (!s->addr)
Line 353  sess_prepareSession(tagSess * __restrict s, u_char use Line 362  sess_prepareSession(tagSess * __restrict s, u_char use
                 return NULL;                  return NULL;
         }          }
   
        DEC_SEMAPHORE(s, ret);        DEC_SEM(s);
        s->zcopy = useDirect;        s->zcpy = useDirect;
        arr = io_map2vals(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t),         arr = io_map2vars(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t), 
                         hdr->hdr_argc, useDirect);                          hdr->hdr_argc, useDirect);
        ADD_SEMAPHORE(s, ret);        INC_SEM(s);
   
        if (!s->zcopy)        if (!s->zcpy)
                 DETACH_MEMORY(s);                  DETACH_MEMORY(s);
         return arr;          return arr;
 }  }
   
 /*  /*
  * sess_doneSession() Free resources allocated with sess_prepareSession()   * sess_doneSession() Free resources allocated with sess_prepareSession()
    *
  * @s = Session   * @s = Session
  * @arr = Array with variables for free   * @arr = Array with variables for free
  * return: none   * return: none
  */   */
 void  void
sess_doneSession(tagSess * __restrict s, array_t ** __restrict arr)sess_doneSession(ait_sess_t * __restrict s, array_t ** __restrict arr)
 {  {
         assert(s);          assert(s);
         if (!s) {          if (!s) {
Line 379  sess_doneSession(tagSess * __restrict s, array_t ** __ Line 389  sess_doneSession(tagSess * __restrict s, array_t ** __
                 return;                  return;
         }          }
   
        if (!s->zcopy)        if (!s->zcpy)
                 io_arrayFree(*arr);                  io_arrayFree(*arr);
         else          else
                 DETACH_MEMORY(s);                  DETACH_MEMORY(s);
Line 388  sess_doneSession(tagSess * __restrict s, array_t ** __ Line 398  sess_doneSession(tagSess * __restrict s, array_t ** __
   
 /*  /*
  * sess_commitSession() Commit data to shared memory   * sess_commitSession() Commit data to shared memory
    *
  * @s = Session   * @s = Session
  * @arr = Array with variables for save   * @arr = Array with variables for save
  * return -1 error or !=-1 size of stored variables into shared memory   * return -1 error or !=-1 size of stored variables into shared memory
  */   */
 int  int
sess_commitSession(tagSess * __restrict s, array_t * __restrict arr)sess_commitSession(ait_sess_t * __restrict s, array_t * __restrict arr)
 {  {
         sess_hdr_t *hdr;          sess_hdr_t *hdr;
        int rs, ret = 0;        int ret = 0;
   
         assert(s && arr);          assert(s && arr);
         if (!s || !arr) {          if (!s || !arr) {
Line 404  sess_commitSession(tagSess * __restrict s, array_t * _ Line 415  sess_commitSession(tagSess * __restrict s, array_t * _
                 return -1;                  return -1;
         }          }
   
        if (!s->zcopy)        ATTACH_MEMORY(s);
                ATTACH_MEMORY(s); 
         if (!s->addr) {          if (!s->addr) {
                if (!s->zcopy)                DETACH_MEMORY(s);
                        DETACH_MEMORY(s); 
 
                 return -1;                  return -1;
         } else          } else
                 hdr = (sess_hdr_t*) s->addr;                  hdr = (sess_hdr_t*) s->addr;
   
        DEC_SEMAPHORE(s, rs);        DEC_SEM(s);
        if ((ret = io_vals2map(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t), arr)) != -1) {        if ((ret = io_vars2map(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t), arr)) != -1) {
                 hdr->hdr_magic = SESS_AIT_MAGIC;                  hdr->hdr_magic = SESS_AIT_MAGIC;
                 hdr->hdr_argc = io_arraySize(arr);                  hdr->hdr_argc = io_arraySize(arr);
                 ret += sizeof(sess_hdr_t);                  ret += sizeof(sess_hdr_t);
         }          }
        ADD_SEMAPHORE(s, rs);        INC_SEM(s);
   
        if (!s->zcopy)        DETACH_MEMORY(s);
                DETACH_MEMORY(s); 
         return ret;          return ret;
 }  }
Removed from v.1.3.2.3  
changed lines
  Added in v.1.4.4.1

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