version 1.2, 2013/03/13 14:54:39
|
version 1.3, 2013/03/19 17:31:38
|
Line 56 SUCH DAMAGE.
|
Line 56 SUCH DAMAGE.
|
* 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 |
*/ |
*/ |
int |
int |
sess_initSession(int id, const char *csFName, ait_sess_t ** __restrict Sess) | sess_initSession(int id, const char *csFName, sess_t ** __restrict Sess) |
{ |
{ |
int h, ret = 0; |
int h, ret = 0; |
char szStr[STRSIZ]; |
char szStr[STRSIZ]; |
Line 71 sess_initSession(int id, const char *csFName, ait_sess
|
Line 71 sess_initSession(int id, const char *csFName, ait_sess
|
} |
} |
|
|
if (!*Sess) { |
if (!*Sess) { |
*Sess = e_malloc(sizeof(ait_sess_t)); | *Sess = e_malloc(sizeof(sess_t)); |
if (!*Sess) { |
if (!*Sess) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} |
} |
} |
} |
memset(*Sess, 0, sizeof(ait_sess_t)); | memset(*Sess, 0, sizeof(sess_t)); |
strlcpy((*Sess)->name, csFName, sizeof (*Sess)->name); | strlcpy((*Sess)->sess_name, csFName, sizeof (*Sess)->sess_name); |
|
|
h = open((*Sess)->name, O_WRONLY | O_CREAT | O_EXCL, SESS_MEM_MODE); | h = open((*Sess)->sess_name, O_WRONLY | O_CREAT | O_EXCL, SESS_MEM_MODE); |
if (h == -1) { |
if (h == -1) { |
if (errno != EEXIST) { |
if (errno != EEXIST) { |
LOGERR; |
LOGERR; |
Line 88 sess_initSession(int id, const char *csFName, ait_sess
|
Line 88 sess_initSession(int id, const char *csFName, ait_sess
|
return -1; |
return -1; |
} |
} |
/* If key file exist, session already connected */ |
/* If key file exist, session already connected */ |
h = open((*Sess)->name, O_RDONLY); | h = open((*Sess)->sess_name, O_RDONLY); |
if (h == -1) { |
if (h == -1) { |
LOGERR; |
LOGERR; |
e_free(*Sess); |
e_free(*Sess); |
Line 170 sess_initSession(int id, const char *csFName, ait_sess
|
Line 170 sess_initSession(int id, const char *csFName, ait_sess
|
} |
} |
close(h); |
close(h); |
|
|
(*Sess)->type = id; | (*Sess)->sess_type = id; |
(*Sess)->zcpy = (char) ret; | (*Sess)->sess_zcpy = (char) ret; |
return ret; |
return ret; |
} |
} |
|
|
Line 182 sess_initSession(int id, const char *csFName, ait_sess
|
Line 182 sess_initSession(int id, const char *csFName, ait_sess
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
sess_freeSession(ait_sess_t ** __restrict Sess) | sess_freeSession(sess_t ** __restrict Sess) |
{ |
{ |
if (!Sess || !(*Sess)) |
if (!Sess || !(*Sess)) |
return; |
return; |
|
|
if ((*Sess)->addr) | if ((*Sess)->sess_addr) |
DETACH_MEMORY(*Sess); |
DETACH_MEMORY(*Sess); |
|
|
/* |
/* |
Line 204 sess_freeSession(ait_sess_t ** __restrict Sess)
|
Line 204 sess_freeSession(ait_sess_t ** __restrict Sess)
|
/* |
/* |
* map_createSession() - MMAP Created session and allocated resources |
* map_createSession() - MMAP Created session and allocated resources |
* |
* |
* @nSeed = Seed for securing key, if =-1 must add ready for use key | * @nSeed = Seed for securing key, if =SESS_OPT_SEED must add ready for use key |
* @nSize = Allocated shared memory size in bytes |
* @nSize = Allocated shared memory size in bytes |
* @Sess = Session item |
* @Sess = Session item |
* @... = If nSeed == -1 add ready for use key value |
* @... = If nSeed == -1 add ready for use key value |
* return: 0 Ok successful, -1 error: not allocated resources |
* return: 0 Ok successful, -1 error: not allocated resources |
*/ |
*/ |
int |
int |
map_createSession(int nSeed, long nSize, ait_sess_t * __restrict Sess, ...) | map_createSession(int nSeed, long nSize, sess_t * __restrict Sess, ...) |
{ |
{ |
char szSName[2][FILENAME_MAX]; |
char szSName[2][FILENAME_MAX]; |
va_list lst; |
va_list lst; |
|
|
if (!Sess || !*Sess->name) | if (!Sess || !*Sess->sess_name) |
return -1; |
return -1; |
|
|
if (nSeed != -1) { | if (nSeed != SESS_OPT_SEED) { |
/* genkey */ |
/* genkey */ |
Sess->key = ftok(Sess->name, nSeed); | Sess->sess_key = ftok(Sess->sess_name, nSeed); |
if (Sess->key == -1) { | if (Sess->sess_key == -1) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} |
} |
} else { |
} else { |
/* get key from va_args */ |
/* get key from va_args */ |
va_start(lst, Sess); |
va_start(lst, Sess); |
Sess->key = va_arg(lst, key_t); | Sess->sess_key = va_arg(lst, key_t); |
va_end(lst); |
va_end(lst); |
} |
} |
|
|
/* build semaphore & shared memory name */ |
/* build semaphore & shared memory name */ |
memset(szSName, 0, sizeof szSName); |
memset(szSName, 0, sizeof szSName); |
snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) Sess->key); | snprintf(szSName[0], SEMNAME_MAX, "/%X.ANS", (u_int) Sess->sess_key); |
#ifdef HAVE_SHM_OPEN |
#ifdef HAVE_SHM_OPEN |
snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->name, (u_int) Sess->key); | snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->sess_name, (u_int) Sess->sess_key); |
#else |
#else |
snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->name, (u_int) Sess->key); | snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->sess_name, (u_int) Sess->sess_key); |
#endif |
#endif |
|
|
/* create semaphore & add 1 */ |
/* create semaphore & add 1 */ |
Sess->id.sid = sem_open(szSName[0], O_CREAT, SESS_MEM_MODE); | Sess->sess_id.sid = sem_open(szSName[0], O_CREAT, SESS_MEM_MODE); |
if (Sess->id.sid == SEM_FAILED) { | if (Sess->sess_id.sid == SEM_FAILED) { |
LOGERR; |
LOGERR; |
map_destroySession(Sess); |
map_destroySession(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 (!Sess->zcpy) | if (!Sess->sess_zcpy) |
sem_post(Sess->id.sid); | sem_post(Sess->sess_id.sid); |
|
|
/* create file for shared memory storage */ |
/* create file for shared memory storage */ |
#ifdef HAVE_SHM_OPEN |
#ifdef HAVE_SHM_OPEN |
Sess->mem.fd = shm_open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE); | Sess->sess_mem.fd = shm_open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE); |
#else |
#else |
Sess->mem.fd = open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE); | Sess->sess_mem.fd = open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE); |
#endif |
#endif |
if (Sess->mem.fd == -1) { | if (Sess->sess_mem.fd == -1) { |
LOGERR; |
LOGERR; |
map_destroySession(Sess); |
map_destroySession(Sess); |
return -1; |
return -1; |
} |
} |
if (!Sess->zcpy) { | if (!Sess->sess_zcpy) { |
#ifdef HAVE_SHM_OPEN | /* #ifdef HAVE_SHM_OPEN */ |
if (ftruncate(Sess->mem.fd, nSize) == -1) { | if (ftruncate(Sess->sess_mem.fd, nSize) == -1) { |
LOGERR; |
LOGERR; |
map_destroySession(Sess); |
map_destroySession(Sess); |
return -1; |
return -1; |
} |
} |
#else | /* #else */ |
/* if is new shared memory session, fill file with zeros */ |
/* if is new shared memory session, fill file with zeros */ |
if (lseek(Sess->mem.fd, nSize - 1, SEEK_SET) == -1) { | /* |
| if (lseek(Sess->sess_mem.fd, nSize - 1, SEEK_SET) == -1) { |
LOGERR; |
LOGERR; |
map_destroySession(Sess); |
map_destroySession(Sess); |
return -1; |
return -1; |
} else |
} else |
write(Sess->mem.fd, "", 1); | write(Sess->sess_mem.fd, "", 1); |
lseek(Sess->mem.fd, 0, SEEK_SET); | lseek(Sess->sess_mem.fd, 0, SEEK_SET); |
#endif |
#endif |
|
*/ |
} |
} |
Sess->eom = nSize; | Sess->sess_size = nSize; |
|
|
return (int) Sess->zcpy; | return (int) Sess->sess_zcpy; |
} |
} |
|
|
/* |
/* |
Line 294 map_createSession(int nSeed, long nSize, ait_sess_t *
|
Line 296 map_createSession(int nSeed, long nSize, ait_sess_t *
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
map_destroySession(ait_sess_t * __restrict Sess) | map_destroySession(sess_t * __restrict Sess) |
{ |
{ |
char szSName[2][FILENAME_MAX]; |
char szSName[2][FILENAME_MAX]; |
|
|
if (!Sess || sess_isAttached(Sess) || !*Sess->name) | if (!Sess || sess_isAttached(Sess) || !*Sess->sess_name) |
return; |
return; |
|
|
memset(szSName, 0, sizeof szSName); |
memset(szSName, 0, sizeof szSName); |
snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) Sess->key); | snprintf(szSName[0], SEMNAME_MAX, "/%X.ANS", (u_int) Sess->sess_key); |
#ifdef HAVE_SHM_UNLINK |
#ifdef HAVE_SHM_UNLINK |
snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->name, (u_int) Sess->key); | snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->sess_name, (u_int) Sess->sess_key); |
#else |
#else |
snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->name, (u_int) Sess->key); | snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->sess_name, (u_int) Sess->sess_key); |
#endif |
#endif |
|
|
if (Sess->id.sid != SEM_FAILED) { | if (Sess->sess_id.sid != SEM_FAILED) { |
sem_close(Sess->id.sid); | sem_close(Sess->sess_id.sid); |
sem_unlink(szSName[0]); |
sem_unlink(szSName[0]); |
} |
} |
if (Sess->mem.fd > 2) { | if (Sess->sess_mem.fd > 2) { |
close(Sess->mem.fd); | close(Sess->sess_mem.fd); |
#ifdef HAVE_SHM_UNLINK |
#ifdef HAVE_SHM_UNLINK |
shm_unlink(szSName[1]); |
shm_unlink(szSName[1]); |
#else |
#else |
unlink(szSName[1]); |
unlink(szSName[1]); |
#endif |
#endif |
} |
} |
unlink(Sess->name); | unlink(Sess->sess_name); |
memset(Sess->name, 0, sizeof Sess->name); | memset(Sess->sess_name, 0, sizeof Sess->sess_name); |
Sess->eom ^= Sess->eom; | Sess->sess_size ^= Sess->sess_size; |
Sess->key ^= Sess->key; | Sess->sess_key ^= Sess->sess_key; |
} |
} |
|
|
/* |
/* |
* ipc_createSession() - IPC Created session and allocated resources |
* ipc_createSession() - IPC Created session and allocated resources |
* |
* |
* @nSeed = Seed for securing key, if =-1 must add ready for use key | * @nSeed = Seed for securing key, if =SESS_OPT_SEED must add ready for use key |
* @nSize = Allocated shared memory size in bytes |
* @nSize = Allocated shared memory size in bytes |
* @Sess = Session item |
* @Sess = Session item |
* @... = If nSeed == -1 add ready for use key value |
* @... = If nSeed == -1 add ready for use key value |
* return: 0 Ok successful, -1 error: not allocated resources |
* return: 0 Ok successful, -1 error: not allocated resources |
*/ |
*/ |
int |
int |
ipc_createSession(int nSeed, long nSize, ait_sess_t * __restrict Sess, ...) | ipc_createSession(int nSeed, long nSize, sess_t * __restrict Sess, ...) |
{ |
{ |
union semun sems; |
union semun sems; |
va_list lst; |
va_list lst; |
|
|
if (!Sess || !*Sess->name) | if (!Sess || !*Sess->sess_name) |
return -1; |
return -1; |
|
|
if (nSeed != -1) { |
if (nSeed != -1) { |
/* genkey */ |
/* genkey */ |
Sess->key = ftok(Sess->name, nSeed); | Sess->sess_key = ftok(Sess->sess_name, nSeed); |
if (Sess->key == -1) { | if (Sess->sess_key == -1) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} |
} |
} else { |
} else { |
/* get key from va_args */ |
/* get key from va_args */ |
va_start(lst, Sess); |
va_start(lst, Sess); |
Sess->key = va_arg(lst, key_t); | Sess->sess_key = va_arg(lst, key_t); |
va_end(lst); |
va_end(lst); |
} |
} |
|
|
/* create semaphore */ |
/* create semaphore */ |
Sess->id.semid = semget(Sess->key, 1, SESS_MEM_MODE | IPC_CREAT); | Sess->sess_id.semid = semget(Sess->sess_key, 1, SESS_MEM_MODE | IPC_CREAT); |
if (Sess->id.semid == -1) { | if (Sess->sess_id.semid == -1) { |
LOGERR; |
LOGERR; |
ipc_destroySession(Sess); |
ipc_destroySession(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 (!Sess->zcpy) { | if (!Sess->sess_zcpy) { |
sems.val = 1; |
sems.val = 1; |
if (semctl(Sess->id.semid, 0, SETVAL, sems) == -1) { | if (semctl(Sess->sess_id.semid, 0, SETVAL, sems) == -1) { |
LOGERR; |
LOGERR; |
ipc_destroySession(Sess); |
ipc_destroySession(Sess); |
return -1; |
return -1; |
Line 377 ipc_createSession(int nSeed, long nSize, ait_sess_t *
|
Line 379 ipc_createSession(int nSeed, long nSize, ait_sess_t *
|
} |
} |
|
|
/* create shared memory object */ |
/* create shared memory object */ |
Sess->mem.shmid = shmget(Sess->key, nSize, SESS_MEM_MODE | IPC_CREAT); | Sess->sess_mem.shmid = shmget(Sess->sess_key, nSize, SESS_MEM_MODE | IPC_CREAT); |
if (Sess->mem.shmid == -1) { | if (Sess->sess_mem.shmid == -1) { |
LOGERR; |
LOGERR; |
ipc_destroySession(Sess); |
ipc_destroySession(Sess); |
return -1; |
return -1; |
} else |
} else |
Sess->eom = nSize; | Sess->sess_size = nSize; |
|
|
return (int) Sess->zcpy; | return (int) Sess->sess_zcpy; |
} |
} |
|
|
/* |
/* |
Line 395 ipc_createSession(int nSeed, long nSize, ait_sess_t *
|
Line 397 ipc_createSession(int nSeed, long nSize, ait_sess_t *
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
ipc_destroySession(ait_sess_t * __restrict Sess) | ipc_destroySession(sess_t * __restrict Sess) |
{ |
{ |
union semun sems; |
union semun sems; |
struct shmid_ds ds; |
struct shmid_ds ds; |
Line 403 ipc_destroySession(ait_sess_t * __restrict Sess)
|
Line 405 ipc_destroySession(ait_sess_t * __restrict Sess)
|
if (!Sess || sess_isAttached(Sess)) |
if (!Sess || sess_isAttached(Sess)) |
return; |
return; |
|
|
if (Sess->id.semid != -1) | if (Sess->sess_id.semid != -1) |
semctl(Sess->id.semid, 0, IPC_RMID, &sems); | semctl(Sess->sess_id.semid, 0, IPC_RMID, &sems); |
if (Sess->mem.shmid != -1) | if (Sess->sess_mem.shmid != -1) |
shmctl(Sess->mem.shmid, IPC_RMID, &ds); | shmctl(Sess->sess_mem.shmid, IPC_RMID, &ds); |
unlink(Sess->name); | unlink(Sess->sess_name); |
memset(Sess->name, 0, sizeof Sess->name); | memset(Sess->sess_name, 0, sizeof Sess->sess_name); |
Sess->eom ^= Sess->eom; | Sess->sess_size ^= Sess->sess_size; |
Sess->key ^= Sess->key; | Sess->sess_key ^= Sess->sess_key; |
} |
} |
|
|
|
|
Line 422 ipc_destroySession(ait_sess_t * __restrict Sess)
|
Line 424 ipc_destroySession(ait_sess_t * __restrict Sess)
|
* return: NULL failed attach, !=NULL begin address of memory |
* return: NULL failed attach, !=NULL begin address of memory |
*/ |
*/ |
void * |
void * |
map_attachSession(ait_sess_t * __restrict s, void *procMem) | map_attachSession(sess_t * __restrict s, void *procMem) |
{ |
{ |
if (!s) |
if (!s) |
return NULL; |
return NULL; |
Line 430 map_attachSession(ait_sess_t * __restrict s, void *pro
|
Line 432 map_attachSession(ait_sess_t * __restrict s, void *pro
|
sync(); |
sync(); |
|
|
/* attach to memory */ |
/* attach to memory */ |
s->addr = mmap(procMem, s->eom, PROT_READ | PROT_WRITE, MAP_SHARED, s->mem.fd, 0); | s->sess_addr = mmap(procMem, s->sess_size, PROT_READ | PROT_WRITE, MAP_SHARED, s->sess_mem.fd, 0); |
if (s->addr == MAP_FAILED) { | if (s->sess_addr == MAP_FAILED) { |
LOGERR; |
LOGERR; |
s->addr = NULL; | s->sess_addr = NULL; |
} |
} |
|
|
return s->addr; | return s->sess_addr; |
} |
} |
|
|
/* |
/* |
Line 446 map_attachSession(ait_sess_t * __restrict s, void *pro
|
Line 448 map_attachSession(ait_sess_t * __restrict s, void *pro
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
map_detachSession(ait_sess_t * __restrict s) | map_detachSession(sess_t * __restrict s) |
{ |
{ |
if (!s) |
if (!s) |
return; |
return; |
|
|
msync(s->addr, 0, MS_SYNC | MS_INVALIDATE); | msync(s->sess_addr, 0, MS_SYNC | MS_INVALIDATE); |
|
|
if (s->addr && s->eom) { | if (s->sess_size) { |
munmap(s->addr, s->eom); | munmap(s->sess_addr, s->sess_size); |
s->addr = NULL; | s->sess_addr = NULL; |
} |
} |
} |
} |
|
|
Line 467 map_detachSession(ait_sess_t * __restrict s)
|
Line 469 map_detachSession(ait_sess_t * __restrict s)
|
* return: NULL failed attach, !=NULL begin address of memory |
* return: NULL failed attach, !=NULL begin address of memory |
*/ |
*/ |
void * |
void * |
ipc_attachSession(ait_sess_t * __restrict s, void *procMem) | ipc_attachSession(sess_t * __restrict s, void *procMem) |
{ |
{ |
if (!s) |
if (!s) |
return NULL; |
return NULL; |
|
|
s->addr = shmat(s->mem.shmid, procMem, 0); | s->sess_addr = shmat(s->sess_mem.shmid, procMem, 0); |
if (s->addr == (void*) -1) { | if (s->sess_addr == (void*) -1) { |
LOGERR; |
LOGERR; |
s->addr = NULL; | s->sess_addr = NULL; |
} |
} |
|
|
return s->addr; | return s->sess_addr; |
} |
} |
|
|
/* |
/* |
Line 488 ipc_attachSession(ait_sess_t * __restrict s, void *pro
|
Line 490 ipc_attachSession(ait_sess_t * __restrict s, void *pro
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
ipc_detachSession(ait_sess_t * __restrict s) | ipc_detachSession(sess_t * __restrict s) |
{ |
{ |
if (!s) |
if (!s) |
return; |
return; |
|
|
if (s->addr) { | if (s->sess_size) { |
shmdt(s->addr); | shmdt(s->sess_addr); |
s->addr = NULL; | s->sess_addr = NULL; |
} |
} |
} |
} |
|
|
Line 506 ipc_detachSession(ait_sess_t * __restrict s)
|
Line 508 ipc_detachSession(ait_sess_t * __restrict s)
|
* return: -1 null session item, 0 not attached, 1 attached memory |
* return: -1 null session item, 0 not attached, 1 attached memory |
*/ |
*/ |
inline int |
inline int |
sess_isAttached(ait_sess_t * __restrict s) | sess_isAttached(sess_t * __restrict s) |
{ |
{ |
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return (s->addr ? 1 : 0); | return !!s->sess_addr; |
} |
} |
|
|
|
|
Line 522 sess_isAttached(ait_sess_t * __restrict s)
|
Line 524 sess_isAttached(ait_sess_t * __restrict s)
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
map_notSemaphore(ait_sess_t * __restrict s) | map_notSemaphore(sess_t * __restrict s) |
{ |
{ |
int i = -1; |
int i = -1; |
|
|
if (!s) |
if (!s) |
return; |
return; |
|
|
sem_getvalue(s->id.sid, &i); | sem_getvalue(s->sess_id.sid, &i); |
while (i > 0) { | for (; i; i--) |
sem_wait(s->id.sid); | sem_wait(s->sess_id.sid); |
i--; | |
} | |
} |
} |
|
|
/* |
/* |
Line 543 map_notSemaphore(ait_sess_t * __restrict s)
|
Line 543 map_notSemaphore(ait_sess_t * __restrict s)
|
* return: -1 error: can`t return semaphore, 0 = false, 1 = true |
* return: -1 error: can`t return semaphore, 0 = false, 1 = true |
*/ |
*/ |
int |
int |
map_isSemaphoreOK(ait_sess_t * __restrict s) | map_isSemaphoreOK(sess_t * __restrict s) |
{ |
{ |
int val = -1; |
int val = -1; |
|
|
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
sem_getvalue(s->id.sid, &val); | return sem_getvalue(s->sess_id.sid, &val) + 1; |
return (val ? 0 : 1); | |
} |
} |
|
|
/* |
/* |
Line 561 map_isSemaphoreOK(ait_sess_t * __restrict s)
|
Line 560 map_isSemaphoreOK(ait_sess_t * __restrict s)
|
* return: 0 Ok, -1 error: can`t increment |
* return: 0 Ok, -1 error: can`t increment |
*/ |
*/ |
int |
int |
map_incSemaphore(ait_sess_t * __restrict s) | map_incSemaphore(sess_t * __restrict s) |
{ |
{ |
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return sem_post(s->id.sid); | return sem_post(s->sess_id.sid); |
} |
} |
|
|
/* |
/* |
Line 576 map_incSemaphore(ait_sess_t * __restrict s)
|
Line 575 map_incSemaphore(ait_sess_t * __restrict s)
|
* return: 0 Ok, -1 error: can`t decrement |
* return: 0 Ok, -1 error: can`t decrement |
*/ |
*/ |
int |
int |
map_decSemaphore(ait_sess_t * __restrict s) | map_decSemaphore(sess_t * __restrict s) |
{ |
{ |
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return sem_wait(s->id.sid); | return sem_wait(s->sess_id.sid); |
} |
} |
|
|
/* |
/* |
Line 591 map_decSemaphore(ait_sess_t * __restrict s)
|
Line 590 map_decSemaphore(ait_sess_t * __restrict s)
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
ipc_notSemaphore(ait_sess_t * __restrict s) | ipc_notSemaphore(sess_t * __restrict s) |
{ |
{ |
struct sembuf sb = { 0, 0, 0 }; |
struct sembuf sb = { 0, 0, 0 }; |
|
|
if (s) |
if (s) |
semop(s->id.semid, &sb, 1); | semop(s->sess_id.semid, &sb, 1); |
} |
} |
|
|
/* |
/* |
Line 606 ipc_notSemaphore(ait_sess_t * __restrict s)
|
Line 605 ipc_notSemaphore(ait_sess_t * __restrict s)
|
* return: -1 error: can`t return semaphore, 0 = false, 1 = true |
* return: -1 error: can`t return semaphore, 0 = false, 1 = true |
*/ |
*/ |
int |
int |
ipc_isSemaphoreOK(ait_sess_t * __restrict s) | ipc_isSemaphoreOK(sess_t * __restrict s) |
{ |
{ |
struct sembuf sb = { 0, 0, IPC_NOWAIT }; |
struct sembuf sb = { 0, 0, IPC_NOWAIT }; |
|
|
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return semop(s->id.semid, &sb, 1) + 1; | return semop(s->sess_id.semid, &sb, 1) + 1; |
} |
} |
|
|
/* |
/* |
Line 623 ipc_isSemaphoreOK(ait_sess_t * __restrict s)
|
Line 622 ipc_isSemaphoreOK(ait_sess_t * __restrict s)
|
* return: 0 Ok, -1 error: can`t increment |
* return: 0 Ok, -1 error: can`t increment |
*/ |
*/ |
int |
int |
ipc_incSemaphore(ait_sess_t * __restrict s) | ipc_incSemaphore(sess_t * __restrict s) |
{ |
{ |
struct sembuf sb = { 0, 1, 0 }; |
struct sembuf sb = { 0, 1, 0 }; |
|
|
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return semop(s->id.semid, &sb, 1); | return semop(s->sess_id.semid, &sb, 1); |
} |
} |
|
|
/* |
/* |
Line 640 ipc_incSemaphore(ait_sess_t * __restrict s)
|
Line 639 ipc_incSemaphore(ait_sess_t * __restrict s)
|
* return: 0 Ok, -1 error: can`t decrement |
* return: 0 Ok, -1 error: can`t decrement |
*/ |
*/ |
int |
int |
ipc_decSemaphore(ait_sess_t * __restrict s) | ipc_decSemaphore(sess_t * __restrict s) |
{ |
{ |
struct sembuf sb = { 0, -1, 0 }; |
struct sembuf sb = { 0, -1, 0 }; |
|
|
if (!s) |
if (!s) |
return -1; |
return -1; |
|
|
return semop(s->id.semid, &sb, 1); | return semop(s->sess_id.semid, &sb, 1); |
} |
} |
|
|
/* --- A/V management --- */ |
/* --- A/V management --- */ |
|
|
/* |
/* |
* sess_FreeValues() - Free all values from value array allocated from sess_GetValues() |
|
* |
|
* @ppsVals = Array strings |
|
* return: none |
|
*/ |
|
inline void |
|
sess_FreeValues(char *** __restrict ppsVals) |
|
{ |
|
str_FreeNullTerm(ppsVals); |
|
} |
|
|
|
/* |
|
* 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 | * @Vals = Return array strings |
* return: -1 error: in parameter, !=-1 count of returned strings in ppsVals | * return: -1 error: in parameter, !=-1 count of returned strings in Vals |
* (must be sess_FreeValues after use!) | * (must call ait_freeVars() after use!) |
*/ |
*/ |
int |
int |
sess_GetValues(ait_sess_t * __restrict s, char ***ppsVals) | sess_GetValues(sess_t * __restrict s, array_t ** __restrict Vals) |
{ |
{ |
register int i; |
register int i; |
char **valz, *Shared = NULL; | char *Shared = NULL; |
char *peer, *p_brk; |
char *peer, *p_brk; |
|
ait_val_t *v; |
|
|
if (!s || !ppsVals) | if (!s || !Vals) |
return -1; |
return -1; |
valz = e_malloc(sizeof(caddr_t)); | *Vals = ait_allocVars(0); |
if (!valz) { | if (!*Vals) { |
LOGERR; | io_SetErr(elwix_GetErrno(), "%s", elwix_GetError()); |
return -1; |
return -1; |
} else | } |
*valz = NULL; | |
|
|
/* allocated memory & mirrored shared memory into this */ |
/* allocated memory & mirrored shared memory into this */ |
Shared = e_malloc(s->eom); | Shared = e_malloc(s->sess_size); |
if (!Shared) { |
if (!Shared) { |
LOGERR; |
LOGERR; |
e_free(valz); | ait_freeVars(Vals); |
return -1; |
return -1; |
} else | } |
memcpy(Shared, s->addr, s->eom); | |
|
|
|
DEC_SEM(s); |
|
memcpy(Shared, s->sess_addr, s->sess_size); |
|
INC_SEM(s); |
|
|
for (i = 0, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
for (i = 0, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { |
peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { |
if (!strchr(peer, '=')) |
if (!strchr(peer, '=')) |
Line 704 sess_GetValues(ait_sess_t * __restrict s, char ***ppsV
|
Line 694 sess_GetValues(ait_sess_t * __restrict s, char ***ppsV
|
else |
else |
i++; |
i++; |
|
|
valz = e_realloc(valz, (i + 1) * sizeof(caddr_t)); | if (!(v = ait_allocVar())) { |
if (!valz) { | io_SetErr(elwix_GetErrno(), "%s", elwix_GetError()); |
LOGERR; | |
e_free(Shared); |
e_free(Shared); |
|
ait_freeVars(Vals); |
return -1; |
return -1; |
} else |
} else |
valz[i] = NULL; | AIT_SET_STR(v, peer); |
|
|
valz[i - 1] = e_strdup(peer); | array_Push(*Vals, v, 0); |
} |
} |
|
|
e_free(Shared); |
e_free(Shared); |
*ppsVals = valz; | ait_hashKeyVars(*Vals); |
return i; |
return i; |
} |
} |
|
|
Line 725 sess_GetValues(ait_sess_t * __restrict s, char ***ppsV
|
Line 715 sess_GetValues(ait_sess_t * __restrict s, char ***ppsV
|
* |
* |
* @s = Session item |
* @s = Session item |
* @csAttr = Attribute for search |
* @csAttr = Attribute for search |
* @psVal = Return string buffer | * @v = Return string value and after use must call ait_freeVar(), also may be =NULL |
* @pnLen = Length of return string buffer, | |
// *{pnLen} input is max_size of buffer & output is really taken bytes | |
* return: 0 not found, -1 error: in parameter, >0 get position, |
* return: 0 not found, -1 error: in parameter, >0 get position, |
* if define item merged with IS_DEF |
* if define item merged with IS_DEF |
*/ |
*/ |
int |
int |
sess_GetValue(ait_sess_t * __restrict s, const char *csAttr, char *psVal, int *pnLen) | sess_GetValue(sess_t * __restrict s, const char *csAttr, ait_val_t ** __restrict v) |
{ |
{ |
register int i; |
register int i; |
int def = IS_VAL; | int def = 0; |
char *Shared = NULL; |
char *Shared = NULL; |
char *peer, *p_brk, *a_brk, *attr, *val; |
char *peer, *p_brk, *a_brk, *attr, *val; |
|
|
if (!s || !csAttr || !*csAttr) |
if (!s || !csAttr || !*csAttr) |
return -1; |
return -1; |
if (psVal) { | if (v) { |
if (pnLen && *pnLen > 0) | if (!(*v = ait_allocVar())) { |
memset(psVal, 0, *pnLen); | io_SetErr(elwix_GetErrno(), "%s", elwix_GetError()); |
else | |
return -1; |
return -1; |
|
} else |
|
AIT_INIT_VAL2(*v, string); |
} |
} |
|
|
/* allocated memory & mirrored shared memory into this */ |
/* allocated memory & mirrored shared memory into this */ |
Shared = e_malloc(s->eom); | Shared = e_malloc(s->sess_size); |
if (!Shared) { |
if (!Shared) { |
LOGERR; |
LOGERR; |
|
ait_freeVar(v); |
return -1; |
return -1; |
} else | } |
memcpy(Shared, s->addr, s->eom); | |
|
|
|
DEC_SEM(s); |
|
memcpy(Shared, s->sess_addr, s->sess_size); |
|
INC_SEM(s); |
|
|
for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { |
i++, peer = strtok_r(NULL, SESS_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 - 1)) { | if (attr && !strncmp(attr, csAttr, SESS_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) | AIT_SET_STR(*v, val); |
strlcpy(psVal, val, *pnLen); | else |
if (pnLen) | def = SESS_F_DEF; |
*pnLen = strlen(val); | |
} else | |
def = IS_DEF; | |
|
|
e_free(Shared); |
e_free(Shared); |
return i | def; |
return i | def; |
Line 783 sess_GetValue(ait_sess_t * __restrict s, const char *c
|
Line 773 sess_GetValue(ait_sess_t * __restrict s, const char *c
|
* |
* |
* @s = Session item |
* @s = Session item |
* @csAttr = Attribute for erasing |
* @csAttr = Attribute for erasing |
* return: 0 Ok, -1 error: in parameter | * return: -1 error: in parameter or !=-1 deleted items |
*/ |
*/ |
int |
int |
sess_DelValue(ait_sess_t * __restrict s, const char *csAttr) | sess_DelValue(sess_t * __restrict s, const char *csAttr) |
{ |
{ |
register int i; |
register int i; |
int attrlen; | int attrlen, d = 0; |
char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE]; | char *Buffer, *Shared, szAttr[SESS_MAX_ATTRIBUTE]; |
char *peer, *p_brk; |
char *peer, *p_brk; |
|
|
if (!s || !csAttr || !*csAttr) |
if (!s || !csAttr || !*csAttr) |
Line 801 sess_DelValue(ait_sess_t * __restrict s, const char *c
|
Line 791 sess_DelValue(ait_sess_t * __restrict s, const char *c
|
strlcpy(szAttr, csAttr, sizeof szAttr); |
strlcpy(szAttr, csAttr, sizeof szAttr); |
strlcat(szAttr, "=", sizeof szAttr); |
strlcat(szAttr, "=", sizeof szAttr); |
|
|
Buffer = e_malloc(s->eom); | Buffer = e_malloc(s->sess_size); |
if (!Buffer) { |
if (!Buffer) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} else |
} else |
memset(Buffer, 0, s->eom); | memset(Buffer, 0, s->sess_size); |
Shared = e_malloc(s->eom); | Shared = e_malloc(s->sess_size); |
if (!Shared) { |
if (!Shared) { |
LOGERR; |
LOGERR; |
e_free(Buffer); |
e_free(Buffer); |
return -1; |
return -1; |
} else { |
} else { |
DEC_SEM(s); |
DEC_SEM(s); |
memcpy(Shared, s->addr, s->eom); | memcpy(Shared, s->sess_addr, s->sess_size); |
} |
} |
|
|
for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { |
i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { |
if (!strncmp(peer, csAttr, attrlen)) |
if (!strncmp(peer, csAttr, attrlen)) |
if (peer[attrlen] == '=' || peer[attrlen] == *SESS_MEM_DELIM || !peer[attrlen] || | if (peer[attrlen] == '=' || !peer[attrlen]) { |
peer[attrlen] == '\r' || peer[attrlen] == '\n') | d++; |
continue; |
continue; |
|
} |
|
|
strlcat(Buffer, peer, s->eom); | strlcat(Buffer, peer, s->sess_size); |
strlcat(Buffer, SESS_MEM_DELIM, s->eom); | strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
} |
} |
|
|
memcpy(s->addr, Buffer, s->eom); | memcpy(s->sess_addr, Buffer, s->sess_size); |
|
|
if (s->type == SHARED_MAP) | if (s->sess_type == SHARED_MAP) |
msync(s->addr, 0, MS_SYNC | MS_INVALIDATE); | msync(s->sess_addr, 0, MS_SYNC | MS_INVALIDATE); |
|
|
INC_SEM(s); |
INC_SEM(s); |
e_free(Shared); |
e_free(Shared); |
e_free(Buffer); |
e_free(Buffer); |
return 0; | return d; |
} |
} |
|
|
/* |
/* |
Line 846 sess_DelValue(ait_sess_t * __restrict s, const char *c
|
Line 837 sess_DelValue(ait_sess_t * __restrict s, const char *c
|
* @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 added new item merged with SESS_F_ADD and |
| if just define item merged with SESS_F_DEF |
*/ |
*/ |
int |
int |
sess_SetValue(ait_sess_t * __restrict s, const char *csAttr, const char *psVal) | sess_SetValue(sess_t * __restrict s, const char *csAttr, const char *psVal) |
{ |
{ |
register int i; |
register int i; |
int upd, def = IS_VAL; | int upd = 0, def = 0; |
char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE]; | char *Buffer, *Shared, szAttr[SESS_MAX_ATTRIBUTE]; |
char *peer, *p_brk; |
char *peer, *p_brk; |
|
|
if (!s || !csAttr || !*csAttr) |
if (!s || !csAttr || !*csAttr) |
Line 863 sess_SetValue(ait_sess_t * __restrict s, const char *c
|
Line 855 sess_SetValue(ait_sess_t * __restrict s, const char *c
|
strlcpy(szAttr, csAttr, sizeof szAttr); |
strlcpy(szAttr, csAttr, sizeof szAttr); |
strlcat(szAttr, "=", sizeof szAttr); |
strlcat(szAttr, "=", sizeof szAttr); |
|
|
Buffer = e_malloc(s->eom); | Buffer = e_malloc(s->sess_size); |
if (!Buffer) { |
if (!Buffer) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} else |
} else |
memset(Buffer, 0, s->eom); | memset(Buffer, 0, s->sess_size); |
Shared = e_malloc(s->eom); | Shared = e_malloc(s->sess_size); |
if (!Shared) { |
if (!Shared) { |
LOGERR; |
LOGERR; |
e_free(Buffer); |
e_free(Buffer); |
return -1; |
return -1; |
} else { |
} else { |
DEC_SEM(s); |
DEC_SEM(s); |
memcpy(Shared, s->addr, s->eom); | memcpy(Shared, s->sess_addr, s->sess_size); |
} |
} |
|
|
for (i = 1, upd = 0, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; | for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer; |
i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) { | i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) |
if (!strncmp(peer, szAttr, strlen(szAttr))) { |
if (!strncmp(peer, szAttr, strlen(szAttr))) { |
upd++; |
upd++; |
if (psVal) { |
if (psVal) { |
strlcat(Buffer, szAttr, s->eom); | strlcat(Buffer, szAttr, s->sess_size); |
strlcat(Buffer, psVal, s->eom); | strlcat(Buffer, psVal, s->sess_size); |
strlcat(Buffer, SESS_MEM_DELIM, s->eom); | strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
} else { |
} else { |
strlcat(Buffer, csAttr, s->eom); | strlcat(Buffer, csAttr, s->sess_size); |
strlcat(Buffer, SESS_MEM_DELIM, s->eom); | strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
def = IS_DEF; | def = SESS_F_DEF; |
} |
} |
continue; | } else { |
| strlcat(Buffer, peer, s->sess_size); |
| strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
} |
} |
|
|
strlcat(Buffer, peer, s->eom); |
|
strlcat(Buffer, SESS_MEM_DELIM, s->eom); |
|
} |
|
|
|
if (!upd) { |
if (!upd) { |
if (psVal) { |
if (psVal) { |
strlcat(Buffer, szAttr, s->eom); | strlcat(Buffer, szAttr, s->sess_size); |
strlcat(Buffer, psVal, s->eom); | strlcat(Buffer, psVal, s->sess_size); |
strlcat(Buffer, SESS_MEM_DELIM, s->eom); | strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
} else { |
} else { |
strlcat(Buffer, csAttr, s->eom); | strlcat(Buffer, csAttr, s->sess_size); |
strlcat(Buffer, SESS_MEM_DELIM, s->eom); | strlcat(Buffer, SESS_MEM_DELIM, s->sess_size); |
def = IS_DEF; | def = SESS_F_DEF; |
} |
} |
def |= IS_ADD; | def |= SESS_F_ADD; |
} |
} |
|
|
memcpy(s->addr, Buffer, s->eom); | memcpy(s->sess_addr, Buffer, s->sess_size); |
|
|
if (s->type == SHARED_MAP) | if (s->sess_type == SHARED_MAP) |
msync(s->addr, 0, MS_SYNC | MS_INVALIDATE); | msync(s->sess_addr, 0, MS_SYNC | MS_INVALIDATE); |
|
|
INC_SEM(s); |
INC_SEM(s); |
e_free(Shared); |
e_free(Shared); |
Line 933 sess_SetValue(ait_sess_t * __restrict s, const char *c
|
Line 923 sess_SetValue(ait_sess_t * __restrict s, const char *c
|
* after use must free resources with sess_doneSession() |
* after use must free resources with sess_doneSession() |
*/ |
*/ |
array_t * |
array_t * |
sess_prepareSession(ait_sess_t * __restrict s, char useDirect) | sess_prepareSession(sess_t * __restrict s, char useDirect) |
{ |
{ |
array_t *arr = NULL; |
array_t *arr = NULL; |
sess_hdr_t *hdr; |
sess_hdr_t *hdr; |
|
|
assert(s); |
|
if (!s) { |
if (!s) { |
io_SetErr(EINVAL, "Invalid argument\n"); |
io_SetErr(EINVAL, "Invalid argument\n"); |
return NULL; |
return NULL; |
} |
} |
if (s->addr) { | if (s->sess_addr) { |
io_SetErr(EINVAL, "Already attached memory\n"); |
io_SetErr(EINVAL, "Already attached memory\n"); |
return NULL; |
return NULL; |
} |
} |
|
|
ATTACH_MEMORY(s); | if (!ATTACH_MEMORY(s)) |
if (!s->addr) | |
return NULL; |
return NULL; |
else |
else |
hdr = (sess_hdr_t*) s->addr; | hdr = (sess_hdr_t*) s->sess_addr; |
if (hdr->hdr_magic != SESS_AIT_MAGIC) { |
if (hdr->hdr_magic != SESS_AIT_MAGIC) { |
DETACH_MEMORY(s); |
DETACH_MEMORY(s); |
|
|
Line 961 sess_prepareSession(ait_sess_t * __restrict s, char us
|
Line 949 sess_prepareSession(ait_sess_t * __restrict s, char us
|
} |
} |
|
|
DEC_SEM(s); |
DEC_SEM(s); |
s->zcpy = useDirect; | s->sess_zcpy = useDirect; |
arr = ait_map2vars(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t), | arr = ait_map2vars(s->sess_addr + sizeof(sess_hdr_t), s->sess_size - sizeof(sess_hdr_t), |
hdr->hdr_argc, useDirect); | hdr->hdr_argc, s->sess_zcpy); |
INC_SEM(s); |
INC_SEM(s); |
|
|
if (!s->zcpy) | if (!s->sess_zcpy) |
DETACH_MEMORY(s); |
DETACH_MEMORY(s); |
return arr; |
return arr; |
} |
} |
Line 979 sess_prepareSession(ait_sess_t * __restrict s, char us
|
Line 967 sess_prepareSession(ait_sess_t * __restrict s, char us
|
* return: none |
* return: none |
*/ |
*/ |
void |
void |
sess_doneSession(ait_sess_t * __restrict s, array_t ** __restrict arr) | sess_doneSession(sess_t * __restrict s, array_t ** __restrict arr) |
{ |
{ |
assert(s); |
|
if (!s) { |
if (!s) { |
io_SetErr(EINVAL, "Invalid argument\n"); |
io_SetErr(EINVAL, "Invalid argument\n"); |
return; |
return; |
} |
} |
|
|
if (!s->zcpy) | if (!s->sess_zcpy) |
array_Free(*arr); |
array_Free(*arr); |
else |
else |
DETACH_MEMORY(s); |
DETACH_MEMORY(s); |
Line 1002 sess_doneSession(ait_sess_t * __restrict s, array_t **
|
Line 989 sess_doneSession(ait_sess_t * __restrict s, array_t **
|
* 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(ait_sess_t * __restrict s, array_t * __restrict arr) | sess_commitSession(sess_t * __restrict s, array_t * __restrict arr) |
{ |
{ |
sess_hdr_t *hdr; |
sess_hdr_t *hdr; |
int ret = 0; |
int ret = 0; |
|
|
assert(s && arr); |
|
if (!s || !arr) { |
if (!s || !arr) { |
io_SetErr(EINVAL, "Invalid argument\n"); |
io_SetErr(EINVAL, "Invalid argument\n"); |
return -1; |
return -1; |
} |
} |
|
|
ATTACH_MEMORY(s); | if (!ATTACH_MEMORY(s)) { |
if (!s->addr) { | |
DETACH_MEMORY(s); |
DETACH_MEMORY(s); |
return -1; |
return -1; |
} else |
} else |
hdr = (sess_hdr_t*) s->addr; | hdr = (sess_hdr_t*) s->sess_addr; |
|
|
DEC_SEM(s); |
DEC_SEM(s); |
if ((ret = ait_vars2map(s->addr + sizeof(sess_hdr_t), | if ((ret = ait_vars2map(s->sess_addr + sizeof(sess_hdr_t), |
s->eom - sizeof(sess_hdr_t), arr)) != -1) { | s->sess_size - sizeof(sess_hdr_t), arr)) != -1) { |
hdr->hdr_magic = SESS_AIT_MAGIC; |
hdr->hdr_magic = SESS_AIT_MAGIC; |
hdr->hdr_argc = array_Size(arr); |
hdr->hdr_argc = array_Size(arr); |
ret += sizeof(sess_hdr_t); |
ret += sizeof(sess_hdr_t); |