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

Diff for /libaitsess/src/aitsess.c between versions 1.2.2.2 and 1.2.2.3

version 1.2.2.2, 2011/05/10 21:06:13 version 1.2.2.3, 2011/08/21 14:00:43
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
   
 #pragma GCC visibility push(hidden)  #pragma GCC visibility push(hidden)
   
int sessErrno;int sess_Errno;
char sessError[MAX_STR + 1];char sess_Error[STRSIZ];
   
 #pragma GCC visibility pop  #pragma GCC visibility pop
   
Line 62  char sessError[MAX_STR + 1]; Line 62  char sessError[MAX_STR + 1];
 inline int  inline int
 sess_GetErrno()  sess_GetErrno()
 {  {
        return sessErrno;        return sess_Errno;
 }  }
 // sess_GetError() Get error text of last operation  // sess_GetError() Get error text of last operation
 inline const char *  inline const char *
 sess_GetError()  sess_GetError()
 {  {
        return sessError;        return sess_Error;
 }  }
// sessDbg() Debug/Logging operations// sess_SetErr() Set error to variables for internal use!!!
static inline intinline void
sessDbg(FILE *f, char *fmt, ...)sess_SetErr(int eno, char *estr, ...)
 {  {
         int ret = 0;  
         va_list lst;          va_list lst;
   
        va_start(lst, fmt);        sess_Errno = eno;
        ret = vfprintf(f, fmt, lst);        memset(sess_Error, 0, sizeof sess_Error);
         va_start(lst, estr);
         vsnprintf(sess_Error, sizeof sess_Error, estr, lst);
         va_end(lst);          va_end(lst);
   
         return ret;  
 }  }
   
 // -----------------------------------------------------------  // -----------------------------------------------------------
   
 /*  /*
  * initSession() Initializing session structure, if session file not exists creating with specified tech   * initSession() Initializing session structure, if session file not exists creating with specified tech
 * @cnID = Technology using in session. SHARED_IPC IPC tech; SHARED_MAP BSD MemoryMap tech * @pnID = Technology using in session. 
         SHARED_IPC IPC tech; SHARED_MAP BSD MemoryMap tech or if =NULL SHARED_IPC
  * @csFName = Session filename for build key and identified   * @csFName = Session filename for build key and identified
 * @Sess = Session item * @Sess = Session item, if =NULL allocate memory for session after use must be free!
  * return: 0 OK new key created, -1 error: no memory or file not created, 1 OK key finded   * return: 0 OK new key created, -1 error: no memory or file not created, 1 OK key finded
 */  */
 inline int  inline int
initSession(const int cnID, const char *csFName, tagSess ** __restrict Sess)initSession(int *pnID, const char *csFName, tagSess ** __restrict Sess)
 {  {
        int h, ret = 0;        int h, ret = 0, id = SHARED_IPC;
        char szStr[MAX_STR + 1];        char szStr[STRSIZ];
   
         if (!*Sess) {          if (!*Sess) {
                 *Sess = malloc(sizeof(tagSess));                  *Sess = malloc(sizeof(tagSess));
Line 105  initSession(const int cnID, const char *csFName, tagSe Line 105  initSession(const int cnID, const char *csFName, tagSe
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
                 }                  }
        }        } else
        memset(*Sess, 0, sizeof(tagSess));                memset(*Sess, 0, sizeof(tagSess));
         if (pnID && *pnID)
                 id = *pnID;
   
        // If key file exist, session already connected        h = open(csFName, O_WRONLY | O_CREAT | O_EXCL, MEM_MODE);
        if (!access(csFName, F_OK)) 
                ret = 1; 
        // Build new key & new session 
        h = open(csFName, O_WRONLY | O_CREAT, MEM_MODE); 
         if (h == -1) {          if (h == -1) {
                LOGERR;                if (errno != EEXIST) {
                free(*Sess); 
                return -1; 
        } 
 
        bzero(szStr, MAX_STR + 1); 
        switch (cnID) { 
                case SHARED_IPC: 
                        strcpy(szStr, "IPC@"); 
                        break; 
                case SHARED_MAP: 
                        strcpy(szStr, "MAP@"); 
                        break; 
                default: 
                        errno = EPROTONOSUPPORT; 
                         LOGERR;                          LOGERR;
                        free(*Sess);
                         return -1;
                 }
                 /* If key file exist, session already connected */
                 h = open(csFName, O_RDONLY);
                 if (h == -1) {
                         LOGERR;
                         free(*Sess);
                         return -1;
                 }
                 ret = read(h, szStr, sizeof szStr);
                 if (ret == -1) {
                         LOGERR;
                         close(h);                          close(h);
                         unlink(csFName);  
                         free(*Sess);                          free(*Sess);
                         return -1;                          return -1;
                   }
                   if (!strncmp(szStr, "IPC@", 4))
                           id = SHARED_IPC;
                   else if (!strncmp(szStr, "MAP@", 4))
                           id = SHARED_MAP;
                   else {
                           sess_SetErr(EPROTONOSUPPORT, "Error:: Session type not supported");
                           close(h);
                           free(*Sess);
                           return -1;
                   }
   
                   ret = 1;        /* key found */
           } else {
                   /* Build new key & new session */
                   switch (id) {
                           case SHARED_IPC:
                                   strlcpy(szStr, "IPC@", sizeof szStr);
                                   break;
                           case SHARED_MAP:
                                   strlcpy(szStr, "MAP@", sizeof szStr);
                                   break;
                           default:
                                   sess_SetErr(EPROTONOSUPPORT, "Error:: Session type not supported");
                                   close(h);
                                   unlink(csFName);
                                   free(*Sess);
                                   return -1;
                   }
                   strlcat(szStr, "ELWIX_Session ("PACKAGE_STRING")\n", sizeof szStr);
                   write(h, szStr, strlen(szStr));
   
                   ret = 0;        /* new key created */
         }          }
         strcat(szStr, "AN_Session ver");  
         strcat(szStr, "\n");  
         write(h, szStr, strlen(szStr));  
         close(h);          close(h);
   
        (*Sess)->type = cnID;        (*Sess)->type = id;
         return ret;          return ret;
 }  }
   
Line 153  initSession(const int cnID, const char *csFName, tagSe Line 178  initSession(const int cnID, const char *csFName, tagSe
 inline void  inline void
 freeSession(const char *csFName, tagSess ** __restrict Sess)  freeSession(const char *csFName, tagSess ** __restrict Sess)
 {  {
        (*Sess)->type ^= (*Sess)->type;        assert(Sess);
         if (!Sess)
                 return;
 
         (*Sess)->type = SHARED_UNKNOWN;
         if (csFName)          if (csFName)
                 unlink(csFName);                  unlink(csFName);
         if (*Sess)          if (*Sess)
Line 173  freeSession(const char *csFName, tagSess ** __restrict Line 202  freeSession(const char *csFName, tagSess ** __restrict
 int  int
 map_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)  map_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)
 {  {
        int ret = 0;        int ret = 0, id = SHARED_MAP;
        char szSName[2][FILENAME_MAX + 1];        char szSName[2][FILENAME_MAX];
        void *mem; 
   
        ret = initSession(SHARED_MAP, csFName, Sess);        ret = initSession(&id, csFName, Sess);
         if (ret == -1 || !*Sess)          if (ret == -1 || !*Sess)
                 return -1;                  return -1;
   
        // genkey        /* genkey */
         (*Sess)->key = ftok(csFName, cnSeed);          (*Sess)->key = ftok(csFName, cnSeed);
         if ((*Sess)->key == -1) {          if ((*Sess)->key == -1) {
                 LOGERR;                  LOGERR;
Line 189  map_createSession(const char *csFName, const int cnSee Line 217  map_createSession(const char *csFName, const int cnSee
                 return -1;                  return -1;
         }          }
   
        // build semaphore & shared memory name        /* build semaphore & shared memory name */
        memset(szSName, 0, (FILENAME_MAX + 1) * 2);        memset(szSName, 0, sizeof szSName);
        snprintf(szSName[0], MAX_SEMNAME + 1, "/%X.ANS", (u_int) (*Sess)->key);        snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) (*Sess)->key);
        snprintf(szSName[1], FILENAME_MAX + 1, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);        snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);
   
        mem = malloc(cnSize);        /* create semaphore & add 1 */
        if (!mem) { 
                LOGERR; 
                freeSession(csFName, Sess); 
                return -1; 
        } else 
                memset(mem, 0, cnSize); 
 
        // create semaphore & add 1 
         (*Sess)->id.sid = sem_open(szSName[0], O_CREAT, MEM_MODE);          (*Sess)->id.sid = sem_open(szSName[0], O_CREAT, MEM_MODE);
         if ((*Sess)->id.sid == SEM_FAILED) {          if ((*Sess)->id.sid == SEM_FAILED) {
                 LOGERR;                  LOGERR;
                 map_destroySession(csFName, Sess);                  map_destroySession(csFName, Sess);
                 free(mem);  
                 return -1;                  return -1;
         } else          } else
                 sem_post((*Sess)->id.sid);                  sem_post((*Sess)->id.sid);
   
        // create file for shared memory storage        /* create file for shared memory storage */
         (*Sess)->mem.fd = open(szSName[1], O_RDWR | O_CREAT, MEM_MODE);          (*Sess)->mem.fd = open(szSName[1], O_RDWR | O_CREAT, MEM_MODE);
         if ((*Sess)->mem.fd == -1) {          if ((*Sess)->mem.fd == -1) {
                 LOGERR;                  LOGERR;
                 map_destroySession(csFName, Sess);                  map_destroySession(csFName, Sess);
                 free(mem);  
                 return -1;                  return -1;
         }          }
        // if is new shared memory session, fill file with zeros        /* if is new shared memory session, fill file with zeros */
         if (!ret) {          if (!ret) {
                if (write((*Sess)->mem.fd, mem, cnSize) != cnSize) {                if (lseek((*Sess)->mem.fd, cnSize - 1, SEEK_SET) == -1) {
                         LOGERR;                          LOGERR;
                         map_destroySession(csFName, Sess);                          map_destroySession(csFName, Sess);
                         free(mem);  
                         return -1;                          return -1;
                }                } else
                if (lseek((*Sess)->mem.fd, 0, SEEK_SET)) {                        write((*Sess)->mem.fd, "", 1);
                        LOGERR;                lseek((*Sess)->mem.fd, 0, SEEK_SET);
                        map_destroySession(csFName, Sess); 
                        free(mem); 
                        return -1; 
                } 
         }          }
         (*Sess)->eom = cnSize;          (*Sess)->eom = cnSize;
   
         free(mem);  
         return ret;          return ret;
 }  }
   
Line 250  void Line 262  void
 map_destroySession(const char *csFName, tagSess ** __restrict Sess)  map_destroySession(const char *csFName, tagSess ** __restrict Sess)
 {  {
         int flg = 1;          int flg = 1;
        char szSName[2][FILENAME_MAX + 1];        char szSName[2][FILENAME_MAX];
   
        if (!*Sess)        assert(Sess);
         if (!Sess || !*Sess)
                 return;                  return;
   
        bzero(szSName, (FILENAME_MAX + 1) * 2);        memset(szSName, 0, sizeof szSName);
        snprintf(szSName[0], MAX_SEMNAME + 1, "/%X.ANS", (u_int) (*Sess)->key);        snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) (*Sess)->key);
        snprintf(szSName[1], FILENAME_MAX + 1, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);        snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);
   
         if ((*Sess)->id.sid != SEM_FAILED) {          if ((*Sess)->id.sid != SEM_FAILED) {
                 if (sem_close((*Sess)->id.sid) == -1)                  if (sem_close((*Sess)->id.sid) == -1)
                         flg = 0;                          flg = 0;
   
                 if (sem_unlink(szSName[0]) == -1)                  if (sem_unlink(szSName[0]) == -1)
                         /*flg = 0*/;                          /*flg = 0*/;
         }          }
         if ((*Sess)->mem.fd != -1) {          if ((*Sess)->mem.fd != -1) {
                 if (close((*Sess)->mem.fd) == -1)                  if (close((*Sess)->mem.fd) == -1)
                         flg = 0;                          flg = 0;
   
                 if (unlink(szSName[1]) == -1)                  if (unlink(szSName[1]) == -1)
                         /*flg = 0*/;                          /*flg = 0*/;
         }          }
Line 289  map_destroySession(const char *csFName, tagSess ** __r Line 300  map_destroySession(const char *csFName, tagSess ** __r
 int  int
 ipc_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)  ipc_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)
 {  {
        int ret = 0;        int ret = 0, id = SHARED_IPC;
         union semun sems;          union semun sems;
   
        ret = initSession(SHARED_IPC, csFName, Sess);        ret = initSession(&id, csFName, Sess);
         if (ret == -1 || !*Sess)          if (ret == -1 || !*Sess)
                 return -1;                  return -1;
   
        // genkey        /* genkey */
         (*Sess)->key = ftok(csFName, cnSeed);          (*Sess)->key = ftok(csFName, cnSeed);
         if ((*Sess)->key == -1) {          if ((*Sess)->key == -1) {
                 LOGERR;                  LOGERR;
Line 304  ipc_createSession(const char *csFName, const int cnSee Line 315  ipc_createSession(const char *csFName, const int cnSee
                 return -1;                  return -1;
         }          }
   
        // create semaphore        /* create semaphore */
         (*Sess)->id.semid = semget((*Sess)->key, 1, MEM_MODE | IPC_CREAT);          (*Sess)->id.semid = semget((*Sess)->key, 1, MEM_MODE | IPC_CREAT);
         if ((*Sess)->id.semid == -1) {          if ((*Sess)->id.semid == -1) {
                 LOGERR;                  LOGERR;
                 ipc_destroySession(csFName, Sess);                  ipc_destroySession(csFName, Sess);
                 return -1;                  return -1;
         }          }
        // if is new shared memory session, init sempahore with 1        /* if is new shared memory session, init sempahore with 1 */
         if (!ret) {          if (!ret) {
                 sems.val = 1;                  sems.val = 1;
                 if (semctl((*Sess)->id.semid, 0, SETVAL, sems) == -1) {                  if (semctl((*Sess)->id.semid, 0, SETVAL, sems) == -1) {
Line 321  ipc_createSession(const char *csFName, const int cnSee Line 332  ipc_createSession(const char *csFName, const int cnSee
                 }                  }
         }          }
   
        // create shared memory object        /* create shared memory object */
         (*Sess)->mem.shmid = shmget((*Sess)->key, cnSize, MEM_MODE | IPC_CREAT);          (*Sess)->mem.shmid = shmget((*Sess)->key, cnSize, MEM_MODE | IPC_CREAT);
         if ((*Sess)->mem.shmid == -1) {          if ((*Sess)->mem.shmid == -1) {
                 LOGERR;                  LOGERR;
Line 345  ipc_destroySession(const char *csFName, tagSess ** __r Line 356  ipc_destroySession(const char *csFName, tagSess ** __r
         union semun sems;          union semun sems;
         struct shmid_ds ds;          struct shmid_ds ds;
   
        if (!*Sess)        assert(Sess);
         if (!Sess || !*Sess)
                 return;                  return;
   
         if ((*Sess)->id.semid != -1)          if ((*Sess)->id.semid != -1)
Removed from v.1.2.2.2  
changed lines
  Added in v.1.2.2.3

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