libaitio/src/sess.c - diff

Return to sess.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/sess.c between versions 1.2 and 1.3

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);

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

Removed from v.1.2
changed lines
	Added in v.1.3