![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitsess.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitsess / src|
Return to aitsess.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / libaitsess / src |
1.1 misho 1: #include "global.h"
2: #include "aitsess.h"
3:
4:
5: #pragma GCC visibility push(hidden)
6:
7: int sessErrno;
8: char sessError[MAX_STR + 1];
9:
10: #pragma GCC visibility pop
11:
12: // -----------------------------------------------------------
13:
14: // Error maintenance functions ...
15:
16: // sess_GetErrno() Get error code of last operation
17: inline int sess_GetErrno()
18: {
19: return sessErrno;
20: }
21: // sess_GetError() Get error text of last operation
22: inline const char *sess_GetError()
23: {
24: return sessError;
25: }
26: // sessDbg() Debug/Logging operations
27: static inline int sessDbg(FILE *f, char *fmt, ...)
28: {
29: int ret = 0;
30: va_list lst;
31:
32: va_start(lst, fmt);
33: ret = vfprintf(f, fmt, lst);
34: va_end(lst);
35:
36: return ret;
37: }
38:
39: // -----------------------------------------------------------
40:
41: /*
42: * initSession() Initializing session structure, if session file not exists creating with specified tech
43: * @cnID = Technology using in session. SHARED_IPC IPC tech; SHARED_MAP BSD MemoryMap tech
44: * @csFName = Session filename for build key and identified
45: * @Sess = Session item
46: * return: 0 OK new key created, -1 error: no memory or file not created, 1 OK key finded
47: */
48: inline int initSession(const int cnID, const char *csFName, tagSess ** __restrict Sess)
49: {
50: int h, ret = 0;
51: char szStr[MAX_STR + 1];
52:
53: if (!*Sess) {
54: *Sess = malloc(sizeof(tagSess));
55: if (!*Sess) {
56: LOGERR;
57: return -1;
58: }
59: }
60: memset(*Sess, 0, sizeof(tagSess));
61:
62: // If key file exist, session already connected
63: if (!access(csFName, F_OK))
64: ret = 1;
65: // Build new key & new session
66: h = open(csFName, O_WRONLY | O_CREAT, 0640);
67: if (h == -1) {
68: LOGERR;
69: free(*Sess);
70: return -1;
71: }
72:
73: bzero(szStr, MAX_STR + 1);
74: switch (cnID) {
75: case SHARED_IPC:
76: strcpy(szStr, "IPC@");
77: break;
78: case SHARED_MAP:
79: strcpy(szStr, "MAP@");
80: break;
81: default:
82: errno = EPROTONOSUPPORT;
83: LOGERR;
84:
85: close(h);
86: unlink(csFName);
87: free(*Sess);
88: return -1;
89: }
90: strcat(szStr, "AN_Session ver");
91: strcat(szStr, "\n");
92: write(h, szStr, strlen(szStr));
93: close(h);
94:
95: (*Sess)->type = cnID;
96: return ret;
97: }
98:
99: /*
100: * freeSession() Free allocated memory for session item and delete session file if present name
101: * @csFName = Session filename for delete, if NULL nothing delete
102: * @Sess = Session item
103: */
104: inline void freeSession(const char *csFName, tagSess ** __restrict Sess)
105: {
106: (*Sess)->type ^= (*Sess)->type;
107: if (csFName)
108: unlink(csFName);
109: if (*Sess)
110: free(*Sess);
111: *Sess = NULL;
112: }
113:
114:
115: /*
116: * map_createSession() MMAP Created session and allocated resources
117: * @csFName = Session name for identified
118: * @cnSeed = Seed for securing key
119: * @cnSize = Allocated shared memory size in bytes
120: * @Sess = Session item
121: * return: 0 Ok successful, -1 error: not allocated resources
122: */
123: int map_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)
124: {
125: int ret = 0;
126: char szSName[2][FILENAME_MAX + 1];
127: void *mem;
128:
129: ret = initSession(SHARED_MAP, csFName, Sess);
130: if (ret == -1 || !*Sess)
131: return -1;
132:
133: // genkey
134: (*Sess)->key = ftok(csFName, cnSeed);
135: if ((*Sess)->key == -1) {
136: LOGERR;
137: freeSession(csFName, Sess);
138: return -1;
139: }
140:
141: // build semaphore & shared memory name
142: memset(szSName, 0, (FILENAME_MAX + 1) * 2);
143: snprintf(szSName[0], MAX_SEMNAME + 1, "/%X.ANS", (u_int) (*Sess)->key);
144: snprintf(szSName[1], FILENAME_MAX + 1, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);
145:
146: mem = malloc(cnSize);
147: if (!mem) {
148: LOGERR;
149: freeSession(csFName, Sess);
150: return -1;
151: } else
152: memset(mem, 0, cnSize);
153:
154: // create semaphore & add 1
155: (*Sess)->id.sid = sem_open(szSName[0], O_CREAT, 0644);
156: if ((*Sess)->id.sid == SEM_FAILED) {
157: LOGERR;
158: map_destroySession(csFName, Sess);
159: free(mem);
160: return -1;
161: } else
162: sem_post((*Sess)->id.sid);
163:
164: // create file for shared memory storage
165: (*Sess)->mem.fd = open(szSName[1], O_RDWR | O_CREAT, 0644);
166: if ((*Sess)->mem.fd == -1) {
167: LOGERR;
168: map_destroySession(csFName, Sess);
169: free(mem);
170: return -1;
171: }
172: // if is new shared memory session, fill file with zeros
173: if (!ret) {
174: if (write((*Sess)->mem.fd, mem, cnSize) != cnSize) {
175: LOGERR;
176: map_destroySession(csFName, Sess);
177: free(mem);
178: return -1;
179: }
180: if (lseek((*Sess)->mem.fd, 0, SEEK_SET)) {
181: LOGERR;
182: map_destroySession(csFName, Sess);
183: free(mem);
184: return -1;
185: }
186: }
187: (*Sess)->eom = cnSize;
188:
189: free(mem);
190: return ret;
191: }
192:
193: /*
194: * map_destroySession() MMAP free shared resources
195: * @csFName = Session name for delete
196: * @Sess = Session item
197: */
198: void map_destroySession(const char *csFName, tagSess ** __restrict Sess)
199: {
200: int flg = 1;
201: char szSName[2][FILENAME_MAX + 1];
202:
203: if (!*Sess)
204: return;
205:
206: bzero(szSName, (FILENAME_MAX + 1) * 2);
207: snprintf(szSName[0], MAX_SEMNAME + 1, "/%X.ANS", (u_int) (*Sess)->key);
208: snprintf(szSName[1], FILENAME_MAX + 1, "%s-%x.ANM", csFName, (u_int) (*Sess)->key);
209:
210: if ((*Sess)->id.sid != SEM_FAILED) {
211: if (sem_close((*Sess)->id.sid) == -1)
212: flg = 0;
213:
214: if (sem_unlink(szSName[0]) == -1)
215: /*flg = 0*/;
216: }
217: if ((*Sess)->mem.fd != -1) {
218: if (close((*Sess)->mem.fd) == -1)
219: flg = 0;
220:
221: if (unlink(szSName[1]) == -1)
222: /*flg = 0*/;
223: }
224: (*Sess)->eom ^= (*Sess)->eom;
225:
226: freeSession(flg ? csFName : NULL, Sess);
227: }
228:
229: /*
230: * ipc_createSession() IPC Created session and allocated resources
231: * @csFName = Session name for identified
232: * @cnSeed = Seed for securing key
233: * @cnSize = Allocated shared memory size in bytes
234: * @Sess = Session item
235: * return: 0 Ok successful, -1 error: not allocated resources
236: */
237: int ipc_createSession(const char *csFName, const int cnSeed, const u_int cnSize, tagSess ** __restrict Sess)
238: {
239: int ret = 0;
240: union semun sems;
241:
242: ret = initSession(SHARED_IPC, csFName, Sess);
243: if (ret == -1 || !*Sess)
244: return -1;
245:
246: // genkey
247: (*Sess)->key = ftok(csFName, cnSeed);
248: if ((*Sess)->key == -1) {
249: LOGERR;
250: freeSession(csFName, Sess);
251: return -1;
252: }
253:
254: // create semaphore
255: (*Sess)->id.semid = semget((*Sess)->key, 1, 0644 | IPC_CREAT);
256: if ((*Sess)->id.semid == -1) {
257: LOGERR;
258: ipc_destroySession(csFName, Sess);
259: return -1;
260: }
261: // if is new shared memory session, init sempahore with 1
262: if (!ret) {
263: sems.val = 1;
264: if (semctl((*Sess)->id.semid, 0, SETVAL, sems) == -1) {
265: LOGERR;
266: ipc_destroySession(csFName, Sess);
267: return -1;
268: }
269: }
270:
271: // create shared memory object
272: (*Sess)->mem.shmid = shmget((*Sess)->key, cnSize, 0644 | IPC_CREAT);
273: if ((*Sess)->mem.shmid == -1) {
274: LOGERR;
275: ipc_destroySession(csFName, Sess);
276: return -1;
277: }
278: (*Sess)->eom = cnSize;
279:
280: return ret;
281: }
282:
283: /*
284: * ipc_destroySession() IPC free shared resources
285: * @csFName = Session name for delete
286: * @Sess = Session item
287: */
288: void ipc_destroySession(const char *csFName, tagSess ** __restrict Sess)
289: {
290: int flg = 1;
291: union semun sems;
292: struct shmid_ds ds;
293:
294: if (!*Sess)
295: return;
296:
297: if ((*Sess)->id.semid != -1)
298: if (semctl((*Sess)->id.semid, 0, IPC_RMID, &sems) == -1)
299: flg = 0;
300: if ((*Sess)->mem.shmid != -1)
301: if (shmctl((*Sess)->mem.shmid, IPC_RMID, &ds) == -1)
302: flg = 0;
303: (*Sess)->eom ^= (*Sess)->eom;
304:
305: freeSession(flg ? csFName : NULL, Sess);
306: }
307:
308:
309: /*
310: * map_attachSession() MMAP Attach to shared memory & return begin address
311: * @s = Session item
312: * @procMem = Custom start address (optionl) *default must be 0*
313: * return: NULL failed attach, !=NULL begin address of memory
314: */
315: inline void *map_attachSession(tagSess * __restrict s, void *procMem)
316: {
317: struct stat sb;
318:
319: if (!s)
320: return NULL;
321:
322: // Learn size of shared memory block
323: sync();
324: if (fstat(s->mem.fd, &sb) == -1) {
325: LOGERR;
326: return NULL;
327: } else
328: s->eom = sb.st_size;
329:
330: // attach to memory
331: s->addr = mmap(procMem, s->eom, PROT_READ | PROT_WRITE, MAP_SHARED, s->mem.fd, 0);
332: if (s->addr == MAP_FAILED) {
333: LOGERR;
334: s->addr = NULL;
335: }
336:
337: return s->addr;
338: }
339:
340: /*
341: * map_detachSession() MMAP Detach from shared memory
342: * @s = Session item
343: */
344: inline void map_detachSession(tagSess * __restrict s)
345: {
346: if (!s)
347: return;
348:
349: msync(s->addr, 0, MS_SYNC | MS_INVALIDATE);
350:
351: if (s->addr && s->eom) {
352: munmap(s->addr, s->eom);
353: s->addr = NULL;
354: }
355: }
356:
357: /*
358: * ipc_attachSession() IPC Attach to shared memory & return begin address
359: * @s = Session item
360: * @procMem = Custom start address (optionl) *default must be 0*
361: * return: NULL failed attach, !=NULL begin address of memory
362: */
363: inline void *ipc_attachSession(tagSess * __restrict s, void *procMem)
364: {
365: if (!s)
366: return NULL;
367:
368: s->addr = shmat(s->mem.shmid, procMem, 0);
369: if (s->addr == (void*) -1) {
370: LOGERR;
371: s->addr = NULL;
372: }
373:
374: return s->addr;
375: }
376:
377: /*
378: * ipc_detachSession() IPC Detach from shared memory
379: * @s = Session item
380: */
381: inline void ipc_detachSession(tagSess * __restrict s)
382: {
383: if (!s)
384: return;
385:
386: if (s->addr) {
387: shmdt(s->addr);
388: s->addr = NULL;
389: }
390: }
391:
392:
393: /*
394: * map_notSemaphore() MMAP negative block if semaphore isn`t signaled
395: * @s = Session item
396: */
397: inline void map_notSemaphore(tagSess * __restrict s)
398: {
399: int i = -1;
400:
401: if (!s)
402: return;
403:
404: sem_getvalue(s->id.sid, &i);
405: for (;i > 0; i--)
406: sem_wait(s->id.sid);
407: }
408:
409: /*
410: * map_isSemaphored() MMAP Check semaphore
411: * @s = Session item
412: * return: -1 error: can`t return semaphore, 0 = false, 1 = true
413: */
414: inline int map_isSemaphored(tagSess * __restrict s)
415: {
416: int val = -1;
417:
418: if (!s)
419: return -1;
420:
421: sem_getvalue(s->id.sid, &val);
422: return val ? 0 : 1;
423: }
424:
425: /*
426: * map_addSemaphore() MMAP unblock semaphore, increment semaphore
427: * @s = Session item
428: * return: 0 Ok, -1 error: can`t increment
429: */
430: inline int map_addSemaphore(tagSess * __restrict s)
431: {
432: if (!s)
433: return -1;
434:
435: return sem_post(s->id.sid);
436: }
437:
438: /*
439: * map_decSemaphore() MMAP block semaphore, decrement semaphore
440: * @s = Session item
441: * return: 0 Ok, -1 error: can`t decrement
442: */
443: inline int map_decSemaphore(tagSess * __restrict s)
444: {
445: if (!s)
446: return -1;
447:
448: return sem_wait(s->id.sid);
449: }
450:
451: /*
452: * ipc_notSemaphore() IPC negative block if semaphore isn`t signaled
453: * @s = Session item
454: */
455: inline void ipc_notSemaphore(tagSess * __restrict s)
456: {
457: struct sembuf sb = { 0, 0, 0 };
458:
459: if (s)
460: semop(s->id.semid, &sb, 1);
461: }
462:
463: /*
464: * ipc_isSemaphored() IPC Check semaphore
465: * @s = Session item
466: * return: -1 error: can`t return semaphore, 0 = false, 1 = true
467: */
468: inline int ipc_isSemaphored(tagSess * __restrict s)
469: {
470: struct sembuf sb = { 0, 0, IPC_NOWAIT };
471:
472: if (!s)
473: return -1;
474:
475: return semop(s->id.semid, &sb, 1) + 1;
476: }
477:
478: /*
479: * ipc_addSemaphore() IPC unblock semaphore, increment semaphore
480: * @s = Session item
481: * return: 0 Ok, -1 error: can`t increment
482: */
483: inline int ipc_addSemaphore(tagSess * __restrict s)
484: {
485: struct sembuf sb = { 0, 1, 0 };
486:
487: if (!s)
488: return -1;
489:
490: return semop(s->id.semid, &sb, 1);
491: }
492:
493: /*
494: * ipc_decSemaphore() IPC block semaphore, decrement semaphore
495: * @s = Session item
496: * return: 0 Ok, -1 error: can`t decrement
497: */
498: inline int ipc_decSemaphore(tagSess * __restrict s)
499: {
500: struct sembuf sb = { 0, -1, 0 };
501:
502: if (!s)
503: return -1;
504:
505: return semop(s->id.semid, &sb, 1);
506: }