![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to session.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow|
Return to session.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow |
1.1 misho 1: /*
2: * Copyright (c) 1999-2003 Rinet Corp., Novosibirsk, Russia
3: *
4: * Redistribution and use in source forms, with and without modification,
5: * are permitted provided that this entire comment appears intact.
6: *
7: * THIS SOURCE CODE IS PROVIDED ``AS IS'' WITHOUT ANY WARRANTIES OF ANY KIND.
8: */
9:
10: #ifdef HAVE_CONFIG_H
11: #include <config.h>
12: #endif
13:
14: #include <sys/types.h>
15: #include <sys/socket.h>
16: #include <netinet/in.h>
17: #include <fcntl.h>
18: #include <stdlib.h>
19: #include <string.h>
20: #include <unistd.h>
21: #include <errno.h>
22:
23: #include "session.h"
24: #include "events.h" /* just for tv_sub() */
25:
26: #define dprintf(x) /* nope */
27:
28: #ifndef BUF_SIZE
29: #define BUF_SIZE 8192
30: #endif
31: #ifndef MAX_STR_LEN
32: #define MAX_STR_LEN 1500 /* must be vastly smaller then BUF_SIZE */
33: #endif
34:
35: #ifdef O_NONBLOCK
36: #define ASYNC_MODE O_NONBLOCK
37: #elif O_NDELAY
38: #define ASYNC_MODE O_NDELAY
39: #elif FNDELAY
40: #define ASYNC_MODE FNDELAY
41: #elif O_ASYNC
42: #define ASYNC_MODE O_ASYNC
43: #elif
44: #error the fcntl argument to turn ON/OFF non-blocking I/O is unknown
45: #endif
46:
47: static int session_read(SESSION *sd);
48:
49: static SESSION *first_session = 0; /* first network session in table */
50:
51: typedef struct session_binder_ent {
52: void (*notify)(void *arg); /* call it before free */
53: void *arg;
54: struct session_binder_ent *next;
55: } SESSION_BINDER;
56:
57:
58: SESSION *
59: session_open(sock, peer, type)
60: int sock;
61: const struct sockaddr *peer;
62: SessionType type;
63: {
64: SESSION *sd, *prev = 0, *next = 0;
65: static u_long sid = 0;
66:
67: /*
68: * Search for first empty or last session slot.
69: */
70: for (sd = first_session; sd; sd = sd->next) {
71: if (!sd->sid) {
72: next = sd->next;
73: break;
74: }
75: prev = sd;
76: }
77: if (!sd && (sd = (SESSION *)malloc(sizeof(SESSION))) == 0)
78: return 0;
79: memset(sd, 0, sizeof(SESSION));
80:
81: if (++sid == 0) sid++; /* prevent 0 sid */
82: sd->sid = sid;
83: sd->sock = sock;
84: if (peer)
85: memcpy(&sd->peer, peer, sizeof(struct sockaddr));
86: else memset(&sd->peer, 0, sizeof(sd->peer));
87: memset(&sd->from, 0, sizeof(sd->from));
88:
89: sd->type = type;
90:
91: /* make chain */
92: if (next) sd->next = next;
93: else if (prev) prev->next = sd;
94: if (!first_session) first_session = sd;
95:
96: if (session_start(sd) < 0) {
97: sd->sid = 0; /* this slot may be recycled later */
98: sd = 0;
99: }
100: return sd;
101: }
102:
103: int
104: session_start(sd)
105: SESSION *sd;
106: {
107: int af;
108:
109: /* sanity check */
110: if (!sd) {
111: errno = EINVAL;
112: return -1;
113: }
114: errno = EBADF;
115: if (sd->sock != -1 &&
116: (sd->type == PlainFile || socket_peer((struct sockaddr *)&sd->peer, sd->sock) != -1)) {
117: /* already connected for example by accept() */
118:
119: socket_nonblock(sd->sock, 0);
120: if (sd->type == TextStream)
121: socket_keepalive(sd->sock, 1);
122: return 0;
123: }
124:
125: af = sd->peer.ss_family;
126: if (!af) af = AF_INET; /* by default */
127:
128: if (errno == EBADF || errno == ENOTSOCK) {
129: switch (sd->type) {
130: case PlainFile:
131: sd->sock = -1;
132: errno = EINVAL;
133: break;
134: case TextStream:
135: sd->sock = socket(af, SOCK_STREAM, 0);
136: break;
137: case DataSequence:
138: sd->sock = socket(af, SOCK_DGRAM, 0);
139: break;
140: /* XXX other session types would be added here */
141: }
142: if (sd->sock == -1)
143: return -1;
144:
145: errno = ENOTCONN;
146: }
147: if (errno == ENOTCONN) {
148: /*
149: * Make socket `connected' for any type, so error on this
150: * socket will be returned asynchronously without timing out.
151: */
152: socket_nonblock(sd->sock, 1);
153:
154: if (!sd->peer.ss_family) {
155: errno = 0;
156: return 0;
157: }
158:
159: if (connect(sd->sock, (struct sockaddr *)&sd->peer, sizeof(struct sockaddr)) != -1 ||
160: errno == EINPROGRESS)
161: return 0;
162: }
163: /* prevent lost of unused socket */
164: session_stop(sd);
165:
166: return -1;
167: }
168:
169: int
170: session_sock(sd)
171: SESSION *sd;
172: {
173: return (sd ? sd->sock : -1);
174: }
175:
176: unsigned
177: session_settimeout(sd, timeout)
178: SESSION *sd;
179: unsigned timeout;
180: {
181: unsigned prev;
182:
183: if (!sd || !sd->sid) return 0;
184:
185: prev = sd->timeout;
186: sd->timeout = timeout;
187:
188: if (sd->timeout < 1)
189: timerclear(&sd->expire);
190:
191: return prev;
192: }
193:
194: void
195: session_setcallback(sd, connected, read_error, read_data)
196: SESSION *sd;
197: void (*connected)(SESSION *sd);
198: void (*read_error)(SESSION *sd, int error);
199: void (*read_data)(SESSION *sd, const unsigned char *data, int len);
200: {
201: if (sd && sd->sid) {
202: if (connected && sd->type == TextStream) {
203: sd->connected = connected;
204: }
205: if (read_error)
206: sd->read_error = read_error;
207: if (read_data)
208: sd->read_data = read_data;
209: }
210: }
211:
212: void
213: session_setcookie(sd, cookie)
214: SESSION *sd;
215: const void *cookie;
216: {
217: if (sd && sd->sid) sd->cookie = cookie;
218: }
219:
220: const void *
221: session_cookie(sd)
222: SESSION *sd;
223: {
224: return ((sd && sd->sid) ? sd->cookie : 0);
225: }
226:
227: void
228: session_stop(sd)
229: SESSION *sd;
230: {
231: if (!sd) return;
232:
233: if (sd->sock != -1) {
234: close(sd->sock);
235: sd->sock = -1;
236: }
237: if (sd->buf) {
238: free(sd->buf);
239: sd->buf = 0;
240: }
241: timerclear(&sd->expire);
242: }
243:
244: int
245: session_idle(sd)
246: SESSION *sd;
247: {
248: if (!sd || !sd->sid) return -1;
249: return (sd->sock != -1 ? 0 : 1);
250: }
251:
252: int
253: session_bind(sd, notify, arg)
254: SESSION *sd;
255: void (*notify)(void *arg);
256: void *arg;
257: {
258: SESSION_BINDER *curr, *last = 0;
259:
260: if (!sd || !notify || !arg) {
261: errno = EINVAL;
262: return -1;
263: }
264: /* prevent dups and find last */
265: for (curr = sd->sb; curr; curr = curr->next) {
266: if (curr->notify == notify && curr->arg == arg)
267: return 0;
268: last = curr;
269: }
270: if ((curr = (SESSION_BINDER *)malloc(sizeof(SESSION_BINDER))) == 0)
271: return -1;
272: curr->notify = notify;
273: curr->arg = arg;
274: curr->next = 0;
275: if (last)
276: last->next = curr;
277: else sd->sb = curr;
278: return 0;
279: }
280:
281: void
282: session_unbind(sd, notify, arg)
283: SESSION *sd;
284: void (*notify)(void *arg);
285: void *arg;
286: {
287: SESSION_BINDER *curr, *prev, *next;
288:
289: curr = (sd ? sd->sb : 0);
290: prev = 0;
291: while (curr) {
292: if ((!notify && !arg) ||
293: (curr->notify == notify && curr->arg == arg)) {
294: next = curr->next;
295: if (prev)
296: prev->next = next;
297: else sd->sb = next;
298: free(curr);
299: curr = next;
300: } else {
301: prev = curr;
302: curr = curr->next;
303: }
304: }
305: }
306:
307: /*
308: * This function free all memory only when free_sd = 0 else it just reset
309: * session id and does not free memory. The mean of this behaving is to
310: * reuse/recycle session slots without new malloc (avoiding it overhead).
311: */
312: void
313: session_free(free_sd)
314: SESSION *free_sd;
315: {
316: SESSION *sd, *prev, *next;
317: SESSION_BINDER *sb;
318:
319: sd = first_session;
320: prev = next = 0;
321: while (sd) {
322: if (!free_sd || sd == free_sd) {
323: if (!free_sd) {
324: next = sd->next;
325: if (prev)
326: prev->next = next;
327: else first_session = next;
328: }
329:
330: for (sb = sd->sb; sb; sb = sb->next) {
331: if (sb->notify && sb->arg)
332: (*sb->notify)(sb->arg);
333: }
334: session_stop(sd);
335: session_unbind(sd, 0, 0); /* to free all */
336:
337: if (!free_sd) {
338: free(sd);
339: sd = next;
340: continue;
341: }
342: sd->sid = 0; /* this slot may be recycled later */
343: }
344: prev = sd;
345: sd = sd->next;
346: }
347: }
348:
349: SESSION *
350: session_find(peer, type)
351: const struct sockaddr *peer;
352: SessionType type;
353: {
354: SESSION *sd;
355:
356: /* sanity check */
357: if (!peer) return 0;
358:
359: for (sd = first_session; sd; sd = sd->next) {
360: if (!sd->sid || sd->type != type ||
361: sd->peer.ss_family != peer->sa_family)
362: continue;
363:
364: if (peer->sa_family == AF_INET) {
365: struct sockaddr_in *sin = (struct sockaddr_in *)&sd->peer;
366: if (sin->sin_port == ((struct sockaddr_in *)peer)->sin_port &&
367: !memcmp(&sin->sin_addr,
368: &((struct sockaddr_in *)peer)->sin_addr,
369: sizeof(sin->sin_addr)))
370: return sd;
371: }
372: #ifdef INET6
373: else if (peer->sa_family == AF_INET6) {
374: struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&sd->peer;
375: if (sin->sin6_port == ((struct sockaddr_in6 *)peer)->sin6_port &&
376: !memcmp(&sin->sin6_addr,
377: &((struct sockaddr_in6 *)peer)->sin6_addr,
378: sizeof(sin->sin6_addr)))
379: return sd;
380: }
381: #endif
382: }
383: return 0;
384: }
385:
386: int
387: session_send(sd, data, len)
388: SESSION *sd;
389: const unsigned char *data;
390: int len;
391: {
392: int wlen = 0;
393:
394: if (!sd || len < 0) {
395: errno = EINVAL;
396: return -1;
397: }
398: if (!sd->sid || sd->sock == -1) {
399: errno = ENOTCONN;
400: return -1;
401: }
402: if (data) {
403: if (sd->type == PlainFile) {
404: if (len) wlen = write(sd->sock, data, len);
405:
406: } else if (sd->type == TextStream) {
407: char buf[BUF_SIZE];
408:
409: if (!sd->peer.ss_family) {
410: errno = ENOTCONN;
411: return -1;
412: }
413: if (len > sizeof(buf)-2) len = sizeof(buf)-2;
414: if (len) memcpy(buf, data, len);
415: if (!len || buf[len-1] != '\n') {
416: buf[len++] = '\r';
417: buf[len++] = '\n';
418: }
419: wlen = write(sd->sock, buf, len);
420:
421: } else if (sd->type == DataSequence) {
422:
423: if (!sd->peer.ss_family) {
424: errno = ENOTCONN;
425: return -1;
426: }
427: if (len) wlen = send(sd->sock, data, len, 0);
428:
429: } else { /* XXX other session types must be added here */
430: wlen = -1;
431: errno = ESOCKTNOSUPPORT;
432: }
433: }
434: if (wlen == -1) {
435: if (errno == EAGAIN || errno == EINPROGRESS) {
436: errno = 0;
437: wlen = 0;
438: } else if (sd->read_error) {
439: (*sd->read_error)(sd, errno);
440: return wlen;
441: }
442: }
443: if (sd->timeout > 0) {
444: gettimeofday(&sd->expire, 0);
445: sd->expire.tv_sec += sd->timeout;
446: }
447: return wlen;
448: }
449:
450: static int
451: session_read(sd)
452: SESSION *sd;
453: {
454: int rlen = 0, rest = 0;
455: char *cp, *line, buf[BUF_SIZE];
456:
457: if (!sd) {
458: errno = EINVAL;
459: return -1;
460: }
461: if (!sd->sid || sd->sock == -1) {
462: errno = ENOTCONN;
463: return -1;
464: }
465: buf[0] = '\0';
466:
467: if (sd->type == PlainFile) {
468: rlen = read(sd->sock, buf, sizeof(buf));
469:
470: } else if (sd->type == TextStream) {
471: if (sd->buf) { /* previous line was truncated */
472: rest = strlen(strcpy(buf, sd->buf));
473: free(sd->buf);
474: sd->buf = 0;
475: }
476: rlen = read(sd->sock, &buf[rest], (sizeof(buf)-1) - rest);
477:
478: } else if (sd->type == DataSequence) {
479: struct sockaddr from;
480: socklen_t slen = sizeof(from);
481:
482: rlen = recvfrom(sd->sock, buf, sizeof(buf), 0, &from, &slen);
483: if (rlen != -1) {
484: /* just for sanity */
485: if (slen < sizeof(struct sockaddr_in) ||
486: slen > sizeof(struct sockaddr))
487: return 0; /* should not happen */
488:
489: if (sd->peer.ss_family &&
490: sd->peer.ss_family != from.sa_family)
491: return 0; /* bad family */
492:
493: /* save packet from */
494: memcpy(&sd->from, &from, slen);
495: } else memset(&sd->from, 0, sizeof(sd->from));
496:
497: } else { /* XXX other session types must be added here */
498: errno = ESOCKTNOSUPPORT;
499: return -1;
500: }
501:
502: if (rlen < 1) {
503: if (!rlen || !errno)
504: errno = ECONNRESET;
505: return -1;
506: }
507:
508: if (sd->type == PlainFile || sd->type == DataSequence) {
509: if (!sd->sid || sd->sock == -1)
510: return 0;
511: if (sd->read_data)
512: (*sd->read_data)(sd, (u_char *)buf, rlen);
513:
514: } else { /* TextStream */
515: buf[rest + rlen] = '\0';
516: for (cp = buf; (line = strchr(cp, '\n')) != 0; cp = line) {
517: if (line > cp && line[-1] == '\r') line[-1] = '\0';
518: *line++ = '\0';
519: if (!sd->sid || sd->sock == -1)
520: return 0;
521: if (sd->read_data) {
522: rest = strlen(cp);
523: if (rest > MAX_STR_LEN) {
524: errno = EMSGSIZE;
525: return -1;
526: }
527: (*sd->read_data)(sd, (u_char *)cp, rest);
528: }
529: }
530: if (cp && *cp) { /* truncated line, save it for next read */
531: if (strlen(cp) > MAX_STR_LEN) {
532: errno = EMSGSIZE;
533: return -1;
534: }
535: sd->buf = strdup(cp);
536: }
537: }
538: return rlen;
539: }
540:
541: int
542: session_select(nfds, readfds, writefds, timeout, block)
543: int *nfds;
544: fd_set *readfds, *writefds;
545: struct timeval *timeout;
546: int *block;
547: {
548: SESSION *sd;
549: struct timeval earliest, now;
550: int active = 0, pending = 0;
551:
552: timerclear(&earliest);
553:
554: /*
555: * For each request outstanding, add it's socket to the readfds,
556: * and if it is the earliest timeout to expire, mark it as lowest.
557: */
558: for (sd = first_session; sd; sd = sd->next) {
559: if (!sd->sid || sd->sock == -1) {
560: if (sd->sock != -1) /* lost session? free socket */
561: session_stop(sd);
562: continue;
563: }
564:
565: active++;
566: if (sd->sock + 1 > *nfds)
567: *nfds = sd->sock + 1;
568:
569: if (!sd->connected) {
570: FD_SET(sd->sock, readfds);
571:
572: dprintf(("session_select: sock %d set for read", sd->sock));
573: } else {
574: FD_SET(sd->sock, writefds);
575:
576: dprintf(("session_select: sock %d set for write", sd->sock));
577: }
578:
579: if (timerisset(&sd->expire)) {
580: pending++;
581: if (!timerisset(&earliest) ||
582: timercmp(&sd->expire, &earliest, <))
583: earliest = sd->expire;
584: }
585: }
586:
587: /*dprintf(("session_select: active=%d pending=%d", active, pending));*/
588:
589: if (!pending)
590: return active;
591:
592: /*
593: * Transforms earliest from an absolute time into a delta time, the
594: * time left until the select should timeout.
595: */
596: gettimeofday(&now, 0);
597: tv_sub(&earliest, &now);
598:
599: /* if it was blocking before or our delta time is less, reset timeout */
600: if (*block || timercmp(&earliest, timeout, <)) {
601: *timeout = earliest;
602: *block = 0;
603: }
604: return active;
605: }
606:
607: /*
608: * Checks to see if any of the fd's set in the readfds belong to a session.
609: */
610: void
611: session_operate(readfds, writefds)
612: fd_set *readfds, *writefds;
613: {
614: SESSION *sd;
615: int try_conn, error;
616:
617: for (sd = first_session; sd; sd = sd->next) {
618: if (!sd->sid || sd->sock == -1)
619: continue;
620:
621: try_conn = (sd->connected != 0);
622:
623: if (!try_conn && FD_ISSET(sd->sock, readfds)) {
624:
625: dprintf(("session_operate: sock %d ready to read", sd->sock));
626:
627: if (sd->type == PlainFile)
628: error = 0;
629: else error = socket_error(sd->sock);
630:
631: if (!error && session_read(sd) < 0)
632: error = errno;
633: if (error && sd->sid && sd->read_error)
634: (*sd->read_error)(sd, error);
635: }
636:
637: if (try_conn && FD_ISSET(sd->sock, writefds)) {
638:
639: dprintf(("session_operate: sock %d ready to write", sd->sock));
640:
641: error = socket_error(sd->sock);
642: if (!error) {
643: socket_peer((struct sockaddr *)&sd->peer, sd->sock);
644: socket_nonblock(sd->sock, 0);
645: if (sd->type == TextStream)
646: socket_keepalive(sd->sock, 1);
647: if (sd->sid && sd->connected)
648: (*sd->connected)(sd);
649: sd->connected = 0; /* fire a shot only once! */
650: } else if (sd->sid && sd->read_error)
651: (*sd->read_error)(sd, error);
652: }
653: }
654: }
655:
656: /*
657: * Checks to see if any of the sessions have an outstanding request
658: * that has timed out.
659: */
660: void
661: session_timeout()
662: {
663: SESSION *sd;
664: struct timeval now;
665:
666: gettimeofday(&now, 0);
667:
668: for (sd = first_session; sd; sd = sd->next) {
669: if (!sd->sid || sd->sock == -1)
670: continue;
671:
672: if (timerisset(&sd->expire) && timercmp(&sd->expire, &now, <)) {
673: if (sd->read_error) (*sd->read_error)(sd, ETIMEDOUT);
674: }
675: }
676: }
677:
678: /*
679: * Return session peer pointer.
680: */
681: const struct sockaddr *
682: session_peer(sd)
683: SESSION *sd;
684: {
685: return ((sd && sd->peer.ss_family) ? (struct sockaddr *)&sd->peer : 0);
686: }
687:
688: /*
689: * Return session from pointer.
690: */
691: const struct sockaddr *
692: session_from(sd)
693: SESSION *sd;
694: {
695: return ((sd && sd->from.ss_family) ? (struct sockaddr *)&sd->from : 0);
696: }
697:
698: /*
699: * Return connected socket peer ip address and port.
700: */
701: int
702: socket_peer(peer, sock)
703: struct sockaddr *peer;
704: int sock;
705: {
706: socklen_t arglen;
707:
708: if (!peer) {
709: errno = EINVAL;
710: return -1;
711: }
712: arglen = sizeof(struct sockaddr);
713: return getpeername(sock, peer, &arglen);
714: }
715:
716: /*
717: * Return socket name ip address and port.
718: */
719: int
720: socket_name(name, sock)
721: struct sockaddr *name;
722: int sock;
723: {
724: socklen_t arglen;
725:
726: if (!name) {
727: errno = EINVAL;
728: return -1;
729: }
730: arglen = sizeof(*name);
731: return getsockname(sock, name, &arglen);
732: }
733:
734: /*
735: * Return socket error (like errno) in the session or 0 if no errors.
736: */
737: int
738: socket_error(sock)
739: int sock;
740: {
741: int argbuf;
742: socklen_t arglen;
743: struct sockaddr peer;
744:
745: arglen = sizeof(argbuf);
746: if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &argbuf, &arglen) < 0)
747: return errno;
748: if (argbuf)
749: return argbuf;
750:
751: arglen = sizeof(argbuf);
752: if (getsockopt(sock, SOL_SOCKET, SO_TYPE, &argbuf, &arglen) < 0)
753: return errno;
754: if (argbuf == SOCK_STREAM) {
755: arglen = sizeof(peer);
756: if (getpeername(sock, &peer, &arglen) < 0)
757: return errno;
758: }
759: return 0;
760: }
761:
762: /*
763: * Make socket blocked or non-blocked for sync/async I/O.
764: */
765: int
766: socket_nonblock(sock, on)
767: int sock;
768: int on; /* boolean */
769: {
770: int mode;
771: int prev; /* boolean */
772:
773: /* get current value of I/O mode */
774: if ((mode = fcntl(sock, F_GETFL, 0)) < 0)
775: return -1;
776:
777: prev = (mode & ASYNC_MODE) != 0;
778: if (on != prev) {
779: if (on) mode |= ASYNC_MODE;
780: else mode &= ~ASYNC_MODE;
781: if (fcntl(sock, F_SETFL, mode))
782: return -1;
783: }
784: return prev;
785: }
786:
787: int
788: socket_keepalive(sock, on)
789: int sock, on;
790: {
791: #ifdef SO_KEEPALIVE
792: int curr = 0;
793: socklen_t slen = sizeof(curr);
794: if (getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &curr, &slen) < 0)
795: return -1;
796:
797: curr = (curr != 0);
798: if (on != curr) {
799: if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)) < 0)
800: return -1;
801: }
802: return 0;
803: #else
804: errno = ESOCKTNOSUPPORT;
805: return -1;
806: #endif
807: }
808: