Annotation of libaitio/src/sess.c, revision 1.2
1.2 ! misho 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.1.2.4 2013/03/13 14:42:28 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