1: /*************************************************************************
2: * (C) 2008 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
6: * $Id: sess.c,v 1.2 2013/03/13 14:54:39 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2013
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * sess_initSession() - Initializing session structure,
51: * if session file not exists creating with specified tech
52: *
53: * @id = Technology using in session. SHARED_IPC IPC tech or SHARED_MAP BSD MemoryMap tech
54: * @csFName = Session filename for build key and identified
55: * @Sess = Session item, if =NULL allocate memory for session after use must be free!
56: * return: 0 OK new key created, -1 error: no memory or file not created, 1 OK key finded
57: */
58: int
59: sess_initSession(int id, const char *csFName, ait_sess_t ** __restrict Sess)
60: {
61: int h, ret = 0;
62: char szStr[STRSIZ];
63:
64: if (!csFName) {
65: io_SetErr(EINVAL, "Filename is NULL");
66: return -1;
67: }
68: if (id < SHARED_UNKNOWN || id > SHARED_MAP) {
69: io_SetErr(EPROTONOSUPPORT, "Session type not supported");
70: return -1;
71: }
72:
73: if (!*Sess) {
74: *Sess = e_malloc(sizeof(ait_sess_t));
75: if (!*Sess) {
76: LOGERR;
77: return -1;
78: }
79: }
80: memset(*Sess, 0, sizeof(ait_sess_t));
81: strlcpy((*Sess)->name, csFName, sizeof (*Sess)->name);
82:
83: h = open((*Sess)->name, O_WRONLY | O_CREAT | O_EXCL, SESS_MEM_MODE);
84: if (h == -1) {
85: if (errno != EEXIST) {
86: LOGERR;
87: e_free(*Sess);
88: return -1;
89: }
90: /* If key file exist, session already connected */
91: h = open((*Sess)->name, O_RDONLY);
92: if (h == -1) {
93: LOGERR;
94: e_free(*Sess);
95: return -1;
96: }
97: ret = read(h, szStr, sizeof szStr);
98: if (ret == -1) {
99: LOGERR;
100: close(h);
101: e_free(*Sess);
102: return -1;
103: }
104: if (!strncmp(szStr, "IPC@", 4) && id == SHARED_IPC) {
105: ret = 1;
106:
107: (*Sess)->sess.create = (int (*)(int, long, void*, ...)) ipc_createSession;
108: (*Sess)->sess.destroy = (void (*)(void*)) ipc_destroySession;
109: (*Sess)->sess.attach = (void* (*)(void*, void*)) ipc_attachSession;
110: (*Sess)->sess.detach = (void (*)(void*)) ipc_detachSession;
111: (*Sess)->sess.notSem = (void (*)(void*)) ipc_notSemaphore;
112: (*Sess)->sess.isSemOK = (int (*)(void*)) ipc_isSemaphoreOK;
113: (*Sess)->sess.incSem = (int (*)(void*)) ipc_incSemaphore;
114: (*Sess)->sess.decSem = (int (*)(void*)) ipc_decSemaphore;
115: } else if (!strncmp(szStr, "MAP@", 4) && id == SHARED_MAP) {
116: ret = 1;
117:
118: (*Sess)->sess.create = (int (*)(int, long, void*, ...)) map_createSession;
119: (*Sess)->sess.destroy = (void (*)(void*)) map_destroySession;
120: (*Sess)->sess.attach = (void* (*)(void*, void*)) map_attachSession;
121: (*Sess)->sess.detach = (void (*)(void*)) map_detachSession;
122: (*Sess)->sess.notSem = (void (*)(void*)) map_notSemaphore;
123: (*Sess)->sess.isSemOK = (int (*)(void*)) map_isSemaphoreOK;
124: (*Sess)->sess.incSem = (int (*)(void*)) map_incSemaphore;
125: (*Sess)->sess.decSem = (int (*)(void*)) map_decSemaphore;
126: } else {
127: io_SetErr(EPROTONOSUPPORT,
128: "Session type not supported or wrong session type");
129: close(h);
130: e_free(*Sess);
131: return -1;
132: }
133: /* key found */
134: } else {
135: /* Build new key & new session */
136: if (id == SHARED_IPC) {
137: strlcpy(szStr, "IPC@", sizeof szStr);
138:
139: (*Sess)->sess.create = (int (*)(int, long, void*, ...)) ipc_createSession;
140: (*Sess)->sess.destroy = (void (*)(void*)) ipc_destroySession;
141: (*Sess)->sess.attach = (void* (*)(void*, void*)) ipc_attachSession;
142: (*Sess)->sess.detach = (void (*)(void*)) ipc_detachSession;
143: (*Sess)->sess.notSem = (void (*)(void*)) ipc_notSemaphore;
144: (*Sess)->sess.isSemOK = (int (*)(void*)) ipc_isSemaphoreOK;
145: (*Sess)->sess.incSem = (int (*)(void*)) ipc_incSemaphore;
146: (*Sess)->sess.decSem = (int (*)(void*)) ipc_decSemaphore;
147: } else if (id == SHARED_MAP) {
148: strlcpy(szStr, "MAP@", sizeof szStr);
149:
150: (*Sess)->sess.create = (int (*)(int, long, void*, ...)) map_createSession;
151: (*Sess)->sess.destroy = (void (*)(void*)) map_destroySession;
152: (*Sess)->sess.attach = (void* (*)(void*, void*)) map_attachSession;
153: (*Sess)->sess.detach = (void (*)(void*)) map_detachSession;
154: (*Sess)->sess.notSem = (void (*)(void*)) map_notSemaphore;
155: (*Sess)->sess.isSemOK = (int (*)(void*)) map_isSemaphoreOK;
156: (*Sess)->sess.incSem = (int (*)(void*)) map_incSemaphore;
157: (*Sess)->sess.decSem = (int (*)(void*)) map_decSemaphore;
158: } else {
159: io_SetErr(EINVAL, "Session type must be specified");
160: close(h);
161: unlink(csFName);
162: e_free(*Sess);
163: return -1;
164: }
165: strlcat(szStr, "ELWIX_Session ("PACKAGE_STRING")\n", sizeof szStr);
166: write(h, szStr, strlen(szStr));
167:
168: ret = 0;
169: /* new key created */
170: }
171: close(h);
172:
173: (*Sess)->type = id;
174: (*Sess)->zcpy = (char) ret;
175: return ret;
176: }
177:
178: /*
179: * sess_freeSession() - Free allocated memory for session item and delete session file if present name
180: *
181: * @Sess = Session item
182: * return: none
183: */
184: void
185: sess_freeSession(ait_sess_t ** __restrict Sess)
186: {
187: if (!Sess || !(*Sess))
188: return;
189:
190: if ((*Sess)->addr)
191: DETACH_MEMORY(*Sess);
192:
193: /*
194: memset(&(*Sess)->sess, 0, sizeof (*Sess)->sess);
195:
196: (*Sess)->type = SHARED_UNKNOWN;
197: */
198:
199: e_free(*Sess);
200: *Sess = NULL;
201: }
202:
203:
204: /*
205: * map_createSession() - MMAP Created session and allocated resources
206: *
207: * @nSeed = Seed for securing key, if =-1 must add ready for use key
208: * @nSize = Allocated shared memory size in bytes
209: * @Sess = Session item
210: * @... = If nSeed == -1 add ready for use key value
211: * return: 0 Ok successful, -1 error: not allocated resources
212: */
213: int
214: map_createSession(int nSeed, long nSize, ait_sess_t * __restrict Sess, ...)
215: {
216: char szSName[2][FILENAME_MAX];
217: va_list lst;
218:
219: if (!Sess || !*Sess->name)
220: return -1;
221:
222: if (nSeed != -1) {
223: /* genkey */
224: Sess->key = ftok(Sess->name, nSeed);
225: if (Sess->key == -1) {
226: LOGERR;
227: return -1;
228: }
229: } else {
230: /* get key from va_args */
231: va_start(lst, Sess);
232: Sess->key = va_arg(lst, key_t);
233: va_end(lst);
234: }
235:
236: /* build semaphore & shared memory name */
237: memset(szSName, 0, sizeof szSName);
238: snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) Sess->key);
239: #ifdef HAVE_SHM_OPEN
240: snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->name, (u_int) Sess->key);
241: #else
242: snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->name, (u_int) Sess->key);
243: #endif
244:
245: /* create semaphore & add 1 */
246: Sess->id.sid = sem_open(szSName[0], O_CREAT, SESS_MEM_MODE);
247: if (Sess->id.sid == SEM_FAILED) {
248: LOGERR;
249: map_destroySession(Sess);
250: return -1;
251: }
252: /* if is new shared memory session, init sempahore with 1 */
253: if (!Sess->zcpy)
254: sem_post(Sess->id.sid);
255:
256: /* create file for shared memory storage */
257: #ifdef HAVE_SHM_OPEN
258: Sess->mem.fd = shm_open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE);
259: #else
260: Sess->mem.fd = open(szSName[1], O_RDWR | O_CREAT, SESS_MEM_MODE);
261: #endif
262: if (Sess->mem.fd == -1) {
263: LOGERR;
264: map_destroySession(Sess);
265: return -1;
266: }
267: if (!Sess->zcpy) {
268: #ifdef HAVE_SHM_OPEN
269: if (ftruncate(Sess->mem.fd, nSize) == -1) {
270: LOGERR;
271: map_destroySession(Sess);
272: return -1;
273: }
274: #else
275: /* if is new shared memory session, fill file with zeros */
276: if (lseek(Sess->mem.fd, nSize - 1, SEEK_SET) == -1) {
277: LOGERR;
278: map_destroySession(Sess);
279: return -1;
280: } else
281: write(Sess->mem.fd, "", 1);
282: lseek(Sess->mem.fd, 0, SEEK_SET);
283: #endif
284: }
285: Sess->eom = nSize;
286:
287: return (int) Sess->zcpy;
288: }
289:
290: /*
291: * map_destroySession() - MMAP free shared resources
292: *
293: * @Sess = Session item
294: * return: none
295: */
296: void
297: map_destroySession(ait_sess_t * __restrict Sess)
298: {
299: char szSName[2][FILENAME_MAX];
300:
301: if (!Sess || sess_isAttached(Sess) || !*Sess->name)
302: return;
303:
304: memset(szSName, 0, sizeof szSName);
305: snprintf(szSName[0], MAX_SEMNAME, "/%X.ANS", (u_int) Sess->key);
306: #ifdef HAVE_SHM_UNLINK
307: snprintf(szSName[1], FILENAME_MAX, "/%s-%x.ANM", Sess->name, (u_int) Sess->key);
308: #else
309: snprintf(szSName[1], FILENAME_MAX, "%s-%x.ANM", Sess->name, (u_int) Sess->key);
310: #endif
311:
312: if (Sess->id.sid != SEM_FAILED) {
313: sem_close(Sess->id.sid);
314: sem_unlink(szSName[0]);
315: }
316: if (Sess->mem.fd > 2) {
317: close(Sess->mem.fd);
318: #ifdef HAVE_SHM_UNLINK
319: shm_unlink(szSName[1]);
320: #else
321: unlink(szSName[1]);
322: #endif
323: }
324: unlink(Sess->name);
325: memset(Sess->name, 0, sizeof Sess->name);
326: Sess->eom ^= Sess->eom;
327: Sess->key ^= Sess->key;
328: }
329:
330: /*
331: * ipc_createSession() - IPC Created session and allocated resources
332: *
333: * @nSeed = Seed for securing key, if =-1 must add ready for use key
334: * @nSize = Allocated shared memory size in bytes
335: * @Sess = Session item
336: * @... = If nSeed == -1 add ready for use key value
337: * return: 0 Ok successful, -1 error: not allocated resources
338: */
339: int
340: ipc_createSession(int nSeed, long nSize, ait_sess_t * __restrict Sess, ...)
341: {
342: union semun sems;
343: va_list lst;
344:
345: if (!Sess || !*Sess->name)
346: return -1;
347:
348: if (nSeed != -1) {
349: /* genkey */
350: Sess->key = ftok(Sess->name, nSeed);
351: if (Sess->key == -1) {
352: LOGERR;
353: return -1;
354: }
355: } else {
356: /* get key from va_args */
357: va_start(lst, Sess);
358: Sess->key = va_arg(lst, key_t);
359: va_end(lst);
360: }
361:
362: /* create semaphore */
363: Sess->id.semid = semget(Sess->key, 1, SESS_MEM_MODE | IPC_CREAT);
364: if (Sess->id.semid == -1) {
365: LOGERR;
366: ipc_destroySession(Sess);
367: return -1;
368: }
369: /* if is new shared memory session, init sempahore with 1 */
370: if (!Sess->zcpy) {
371: sems.val = 1;
372: if (semctl(Sess->id.semid, 0, SETVAL, sems) == -1) {
373: LOGERR;
374: ipc_destroySession(Sess);
375: return -1;
376: }
377: }
378:
379: /* create shared memory object */
380: Sess->mem.shmid = shmget(Sess->key, nSize, SESS_MEM_MODE | IPC_CREAT);
381: if (Sess->mem.shmid == -1) {
382: LOGERR;
383: ipc_destroySession(Sess);
384: return -1;
385: } else
386: Sess->eom = nSize;
387:
388: return (int) Sess->zcpy;
389: }
390:
391: /*
392: * ipc_destroySession() - IPC free shared resources
393: *
394: * @Sess = Session item
395: * return: none
396: */
397: void
398: ipc_destroySession(ait_sess_t * __restrict Sess)
399: {
400: union semun sems;
401: struct shmid_ds ds;
402:
403: if (!Sess || sess_isAttached(Sess))
404: return;
405:
406: if (Sess->id.semid != -1)
407: semctl(Sess->id.semid, 0, IPC_RMID, &sems);
408: if (Sess->mem.shmid != -1)
409: shmctl(Sess->mem.shmid, IPC_RMID, &ds);
410: unlink(Sess->name);
411: memset(Sess->name, 0, sizeof Sess->name);
412: Sess->eom ^= Sess->eom;
413: Sess->key ^= Sess->key;
414: }
415:
416:
417: /*
418: * map_attachSession() - MMAP Attach to shared memory & return begin address
419: *
420: * @s = Session item
421: * @procMem = Custom start address (optionl) *default must be 0*
422: * return: NULL failed attach, !=NULL begin address of memory
423: */
424: void *
425: map_attachSession(ait_sess_t * __restrict s, void *procMem)
426: {
427: if (!s)
428: return NULL;
429:
430: sync();
431:
432: /* attach to memory */
433: s->addr = mmap(procMem, s->eom, PROT_READ | PROT_WRITE, MAP_SHARED, s->mem.fd, 0);
434: if (s->addr == MAP_FAILED) {
435: LOGERR;
436: s->addr = NULL;
437: }
438:
439: return s->addr;
440: }
441:
442: /*
443: * map_detachSession() - MMAP Detach from shared memory
444: *
445: * @s = Session item
446: * return: none
447: */
448: void
449: map_detachSession(ait_sess_t * __restrict s)
450: {
451: if (!s)
452: return;
453:
454: msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
455:
456: if (s->addr && s->eom) {
457: munmap(s->addr, s->eom);
458: s->addr = NULL;
459: }
460: }
461:
462: /*
463: * ipc_attachSession() - IPC Attach to shared memory & return begin address
464: *
465: * @s = Session item
466: * @procMem = Custom start address (optionl) *default must be 0*
467: * return: NULL failed attach, !=NULL begin address of memory
468: */
469: void *
470: ipc_attachSession(ait_sess_t * __restrict s, void *procMem)
471: {
472: if (!s)
473: return NULL;
474:
475: s->addr = shmat(s->mem.shmid, procMem, 0);
476: if (s->addr == (void*) -1) {
477: LOGERR;
478: s->addr = NULL;
479: }
480:
481: return s->addr;
482: }
483:
484: /*
485: * ipc_detachSession() - IPC Detach from shared memory
486: *
487: * @s = Session item
488: * return: none
489: */
490: void
491: ipc_detachSession(ait_sess_t * __restrict s)
492: {
493: if (!s)
494: return;
495:
496: if (s->addr) {
497: shmdt(s->addr);
498: s->addr = NULL;
499: }
500: }
501:
502: /*
503: * sess_isAttached() - Check for attached shared memory
504: *
505: * @s = Session item
506: * return: -1 null session item, 0 not attached, 1 attached memory
507: */
508: inline int
509: sess_isAttached(ait_sess_t * __restrict s)
510: {
511: if (!s)
512: return -1;
513:
514: return (s->addr ? 1 : 0);
515: }
516:
517:
518: /*
519: * map_notSemaphore() - MMAP negative block if semaphore isn`t signaled
520: *
521: * @s = Session item
522: * return: none
523: */
524: void
525: map_notSemaphore(ait_sess_t * __restrict s)
526: {
527: int i = -1;
528:
529: if (!s)
530: return;
531:
532: sem_getvalue(s->id.sid, &i);
533: while (i > 0) {
534: sem_wait(s->id.sid);
535: i--;
536: }
537: }
538:
539: /*
540: * map_isSemaphoreOK() - MMAP Check semaphore
541: *
542: * @s = Session item
543: * return: -1 error: can`t return semaphore, 0 = false, 1 = true
544: */
545: int
546: map_isSemaphoreOK(ait_sess_t * __restrict s)
547: {
548: int val = -1;
549:
550: if (!s)
551: return -1;
552:
553: sem_getvalue(s->id.sid, &val);
554: return (val ? 0 : 1);
555: }
556:
557: /*
558: * map_incSemaphore() - MMAP unblock semaphore, increment semaphore
559: *
560: * @s = Session item
561: * return: 0 Ok, -1 error: can`t increment
562: */
563: int
564: map_incSemaphore(ait_sess_t * __restrict s)
565: {
566: if (!s)
567: return -1;
568:
569: return sem_post(s->id.sid);
570: }
571:
572: /*
573: * map_decSemaphore() - MMAP block semaphore, decrement semaphore
574: *
575: * @s = Session item
576: * return: 0 Ok, -1 error: can`t decrement
577: */
578: int
579: map_decSemaphore(ait_sess_t * __restrict s)
580: {
581: if (!s)
582: return -1;
583:
584: return sem_wait(s->id.sid);
585: }
586:
587: /*
588: * ipc_notSemaphore() - IPC negative block if semaphore isn`t signaled
589: *
590: * @s = Session item
591: * return: none
592: */
593: void
594: ipc_notSemaphore(ait_sess_t * __restrict s)
595: {
596: struct sembuf sb = { 0, 0, 0 };
597:
598: if (s)
599: semop(s->id.semid, &sb, 1);
600: }
601:
602: /*
603: * ipc_isSemaphoreOK() - IPC Check semaphore
604: *
605: * @s = Session item
606: * return: -1 error: can`t return semaphore, 0 = false, 1 = true
607: */
608: int
609: ipc_isSemaphoreOK(ait_sess_t * __restrict s)
610: {
611: struct sembuf sb = { 0, 0, IPC_NOWAIT };
612:
613: if (!s)
614: return -1;
615:
616: return semop(s->id.semid, &sb, 1) + 1;
617: }
618:
619: /*
620: * ipc_incSemaphore() - IPC unblock semaphore, increment semaphore
621: *
622: * @s = Session item
623: * return: 0 Ok, -1 error: can`t increment
624: */
625: int
626: ipc_incSemaphore(ait_sess_t * __restrict s)
627: {
628: struct sembuf sb = { 0, 1, 0 };
629:
630: if (!s)
631: return -1;
632:
633: return semop(s->id.semid, &sb, 1);
634: }
635:
636: /*
637: * ipc_decSemaphore() - IPC block semaphore, decrement semaphore
638: *
639: * @s = Session item
640: * return: 0 Ok, -1 error: can`t decrement
641: */
642: int
643: ipc_decSemaphore(ait_sess_t * __restrict s)
644: {
645: struct sembuf sb = { 0, -1, 0 };
646:
647: if (!s)
648: return -1;
649:
650: return semop(s->id.semid, &sb, 1);
651: }
652:
653: /* --- A/V management --- */
654:
655: /*
656: * sess_FreeValues() - Free all values from value array allocated from sess_GetValues()
657: *
658: * @ppsVals = Array strings
659: * return: none
660: */
661: inline void
662: sess_FreeValues(char *** __restrict ppsVals)
663: {
664: str_FreeNullTerm(ppsVals);
665: }
666:
667: /*
668: * sess_GetValues() - Get all values from session shared memory
669: *
670: * @s = Session item
671: * @ppsVals = Return array strings
672: * return: -1 error: in parameter, !=-1 count of returned strings in ppsVals
673: * (must be sess_FreeValues after use!)
674: */
675: int
676: sess_GetValues(ait_sess_t * __restrict s, char ***ppsVals)
677: {
678: register int i;
679: char **valz, *Shared = NULL;
680: char *peer, *p_brk;
681:
682: if (!s || !ppsVals)
683: return -1;
684: valz = e_malloc(sizeof(caddr_t));
685: if (!valz) {
686: LOGERR;
687: return -1;
688: } else
689: *valz = NULL;
690:
691: /* allocated memory & mirrored shared memory into this */
692: Shared = e_malloc(s->eom);
693: if (!Shared) {
694: LOGERR;
695: e_free(valz);
696: return -1;
697: } else
698: memcpy(Shared, s->addr, s->eom);
699:
700: for (i = 0, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer;
701: peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) {
702: if (!strchr(peer, '='))
703: continue;
704: else
705: i++;
706:
707: valz = e_realloc(valz, (i + 1) * sizeof(caddr_t));
708: if (!valz) {
709: LOGERR;
710: e_free(Shared);
711: return -1;
712: } else
713: valz[i] = NULL;
714:
715: valz[i - 1] = e_strdup(peer);
716: }
717:
718: e_free(Shared);
719: *ppsVals = valz;
720: return i;
721: }
722:
723: /*
724: * sess_GetValue() - Get value from session shared memory from attribute
725: *
726: * @s = Session item
727: * @csAttr = Attribute for search
728: * @psVal = Return string buffer
729: * @pnLen = Length of return string buffer,
730: // *{pnLen} input is max_size of buffer & output is really taken bytes
731: * return: 0 not found, -1 error: in parameter, >0 get position,
732: * if define item merged with IS_DEF
733: */
734: int
735: sess_GetValue(ait_sess_t * __restrict s, const char *csAttr, char *psVal, int *pnLen)
736: {
737: register int i;
738: int def = IS_VAL;
739: char *Shared = NULL;
740: char *peer, *p_brk, *a_brk, *attr, *val;
741:
742: if (!s || !csAttr || !*csAttr)
743: return -1;
744: if (psVal) {
745: if (pnLen && *pnLen > 0)
746: memset(psVal, 0, *pnLen);
747: else
748: return -1;
749: }
750:
751: /* allocated memory & mirrored shared memory into this */
752: Shared = e_malloc(s->eom);
753: if (!Shared) {
754: LOGERR;
755: return -1;
756: } else
757: memcpy(Shared, s->addr, s->eom);
758:
759: for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer;
760: i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) {
761: attr = strtok_r(peer, "=\r\n", &a_brk);
762: if (attr && !strncmp(attr, csAttr, MAX_ATTRIBUTE - 1)) {
763: val = strtok_r(NULL, "=\r\n", &a_brk);
764: if (val && strlen(val)) {
765: if (psVal)
766: strlcpy(psVal, val, *pnLen);
767: if (pnLen)
768: *pnLen = strlen(val);
769: } else
770: def = IS_DEF;
771:
772: e_free(Shared);
773: return i | def;
774: }
775: }
776:
777: e_free(Shared);
778: return 0;
779: }
780:
781: /*
782: * sess_DelValue() - Delete item from session shared memory
783: *
784: * @s = Session item
785: * @csAttr = Attribute for erasing
786: * return: 0 Ok, -1 error: in parameter
787: */
788: int
789: sess_DelValue(ait_sess_t * __restrict s, const char *csAttr)
790: {
791: register int i;
792: int attrlen;
793: char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
794: char *peer, *p_brk;
795:
796: if (!s || !csAttr || !*csAttr)
797: return -1;
798: else
799: attrlen = strlen(csAttr);
800: Buffer = Shared = NULL;
801: strlcpy(szAttr, csAttr, sizeof szAttr);
802: strlcat(szAttr, "=", sizeof szAttr);
803:
804: Buffer = e_malloc(s->eom);
805: if (!Buffer) {
806: LOGERR;
807: return -1;
808: } else
809: memset(Buffer, 0, s->eom);
810: Shared = e_malloc(s->eom);
811: if (!Shared) {
812: LOGERR;
813: e_free(Buffer);
814: return -1;
815: } else {
816: DEC_SEM(s);
817: memcpy(Shared, s->addr, s->eom);
818: }
819:
820: for (i = 1, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer;
821: i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) {
822: if (!strncmp(peer, csAttr, attrlen))
823: if (peer[attrlen] == '=' || peer[attrlen] == *SESS_MEM_DELIM || !peer[attrlen] ||
824: peer[attrlen] == '\r' || peer[attrlen] == '\n')
825: continue;
826:
827: strlcat(Buffer, peer, s->eom);
828: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
829: }
830:
831: memcpy(s->addr, Buffer, s->eom);
832:
833: if (s->type == SHARED_MAP)
834: msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
835:
836: INC_SEM(s);
837: e_free(Shared);
838: e_free(Buffer);
839: return 0;
840: }
841:
842: /*
843: * sess_SetValue() - Set item into session shared memory or update if exists
844: *
845: * @s = Session item
846: * @csAttr = Attribute
847: * @psVal = Value
848: * return: 0 nothing, -1 error: in parameter,
849: >0 set position, if add item merged with IS_ADD and if define item merged with IS_DEF
850: */
851: int
852: sess_SetValue(ait_sess_t * __restrict s, const char *csAttr, const char *psVal)
853: {
854: register int i;
855: int upd, def = IS_VAL;
856: char *Buffer, *Shared, szAttr[MAX_ATTRIBUTE];
857: char *peer, *p_brk;
858:
859: if (!s || !csAttr || !*csAttr)
860: return -1;
861: else
862: Buffer = Shared = NULL;
863: strlcpy(szAttr, csAttr, sizeof szAttr);
864: strlcat(szAttr, "=", sizeof szAttr);
865:
866: Buffer = e_malloc(s->eom);
867: if (!Buffer) {
868: LOGERR;
869: return -1;
870: } else
871: memset(Buffer, 0, s->eom);
872: Shared = e_malloc(s->eom);
873: if (!Shared) {
874: LOGERR;
875: e_free(Buffer);
876: return -1;
877: } else {
878: DEC_SEM(s);
879: memcpy(Shared, s->addr, s->eom);
880: }
881:
882: for (i = 1, upd = 0, peer = strtok_r(Shared, SESS_MEM_DELIM"\r\n", &p_brk); peer;
883: i++, peer = strtok_r(NULL, SESS_MEM_DELIM"\r\n", &p_brk)) {
884: if (!strncmp(peer, szAttr, strlen(szAttr))) {
885: upd++;
886: if (psVal) {
887: strlcat(Buffer, szAttr, s->eom);
888: strlcat(Buffer, psVal, s->eom);
889: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
890: } else {
891: strlcat(Buffer, csAttr, s->eom);
892: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
893: def = IS_DEF;
894: }
895: continue;
896: }
897:
898: strlcat(Buffer, peer, s->eom);
899: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
900: }
901:
902: if (!upd) {
903: if (psVal) {
904: strlcat(Buffer, szAttr, s->eom);
905: strlcat(Buffer, psVal, s->eom);
906: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
907: } else {
908: strlcat(Buffer, csAttr, s->eom);
909: strlcat(Buffer, SESS_MEM_DELIM, s->eom);
910: def = IS_DEF;
911: }
912: def |= IS_ADD;
913: }
914:
915: memcpy(s->addr, Buffer, s->eom);
916:
917: if (s->type == SHARED_MAP)
918: msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
919:
920: INC_SEM(s);
921: e_free(Shared);
922: e_free(Buffer);
923: return upd | def;
924: }
925:
926:
927: /*
928: * sess_prepareSession() - Attach to shared memory and de-marshaling data
929: *
930: * @s = Session
931: * @useDirect = Use direct shared memory if !=0 or snapshot of data to array
932: * return: NULL error or no data, !=NULL array with variables,
933: * after use must free resources with sess_doneSession()
934: */
935: array_t *
936: sess_prepareSession(ait_sess_t * __restrict s, char useDirect)
937: {
938: array_t *arr = NULL;
939: sess_hdr_t *hdr;
940:
941: assert(s);
942: if (!s) {
943: io_SetErr(EINVAL, "Invalid argument\n");
944: return NULL;
945: }
946: if (s->addr) {
947: io_SetErr(EINVAL, "Already attached memory\n");
948: return NULL;
949: }
950:
951: ATTACH_MEMORY(s);
952: if (!s->addr)
953: return NULL;
954: else
955: hdr = (sess_hdr_t*) s->addr;
956: if (hdr->hdr_magic != SESS_AIT_MAGIC) {
957: DETACH_MEMORY(s);
958:
959: io_SetErr(EINVAL, "Shared memory not contains values with proper format\n");
960: return NULL;
961: }
962:
963: DEC_SEM(s);
964: s->zcpy = useDirect;
965: arr = ait_map2vars(s->addr + sizeof(sess_hdr_t), s->eom - sizeof(sess_hdr_t),
966: hdr->hdr_argc, useDirect);
967: INC_SEM(s);
968:
969: if (!s->zcpy)
970: DETACH_MEMORY(s);
971: return arr;
972: }
973:
974: /*
975: * sess_doneSession() - Free resources allocated with sess_prepareSession()
976: *
977: * @s = Session
978: * @arr = Array with variables for free
979: * return: none
980: */
981: void
982: sess_doneSession(ait_sess_t * __restrict s, array_t ** __restrict arr)
983: {
984: assert(s);
985: if (!s) {
986: io_SetErr(EINVAL, "Invalid argument\n");
987: return;
988: }
989:
990: if (!s->zcpy)
991: array_Free(*arr);
992: else
993: DETACH_MEMORY(s);
994: array_Destroy(arr);
995: }
996:
997: /*
998: * sess_commitSession() - Commit data to shared memory
999: *
1000: * @s = Session
1001: * @arr = Array with variables for save
1002: * return -1 error or !=-1 size of stored variables into shared memory
1003: */
1004: int
1005: sess_commitSession(ait_sess_t * __restrict s, array_t * __restrict arr)
1006: {
1007: sess_hdr_t *hdr;
1008: int ret = 0;
1009:
1010: assert(s && arr);
1011: if (!s || !arr) {
1012: io_SetErr(EINVAL, "Invalid argument\n");
1013: return -1;
1014: }
1015:
1016: ATTACH_MEMORY(s);
1017: if (!s->addr) {
1018: DETACH_MEMORY(s);
1019: return -1;
1020: } else
1021: hdr = (sess_hdr_t*) s->addr;
1022:
1023: DEC_SEM(s);
1024: if ((ret = ait_vars2map(s->addr + sizeof(sess_hdr_t),
1025: s->eom - sizeof(sess_hdr_t), arr)) != -1) {
1026: hdr->hdr_magic = SESS_AIT_MAGIC;
1027: hdr->hdr_argc = array_Size(arr);
1028: ret += sizeof(sess_hdr_t);
1029: }
1030: INC_SEM(s);
1031:
1032: DETACH_MEMORY(s);
1033: return ret;
1034: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sess.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src