5 * Does all this gloriously nifty connection handling stuff...
14 #include <sys/socket.h>
15 #include <netinet/in.h>
19 * aim_connrst - Clears out connection list, killing remaining connections.
20 * @sess: Session to be cleared
22 * Clears out the connection list and kills any connections left.
25 static void aim_connrst(struct aim_session_t *sess)
27 faim_mutex_init(&sess->connlistlock);
29 struct aim_conn_t *cur = sess->connlist, *tmp;
38 sess->connlist = NULL;
43 * aim_conn_init - Reset a connection to default values.
44 * @deadconn: Connection to be reset
46 * Initializes and/or resets a connection structure.
49 static void aim_conn_init(struct aim_conn_t *deadconn)
55 deadconn->subtype = -1;
58 deadconn->lastactivity = 0;
59 deadconn->forcedlatency = 0;
60 deadconn->handlerlist = NULL;
61 deadconn->priv = NULL;
62 faim_mutex_init(&deadconn->active);
63 faim_mutex_init(&deadconn->seqnum_lock);
69 * aim_conn_getnext - Gets a new connection structure.
72 * Allocate a new empty connection structure.
75 static struct aim_conn_t *aim_conn_getnext(struct aim_session_t *sess)
77 struct aim_conn_t *newconn, *cur;
79 if (!(newconn = malloc(sizeof(struct aim_conn_t))))
82 memset(newconn, 0, sizeof(struct aim_conn_t));
83 aim_conn_init(newconn);
86 faim_mutex_lock(&sess->connlistlock);
87 if (sess->connlist == NULL)
88 sess->connlist = newconn;
90 for (cur = sess->connlist; cur->next; cur = cur->next)
94 faim_mutex_unlock(&sess->connlistlock);
100 * aim_conn_kill - Close and free a connection.
101 * @sess: Session for the connection
102 * @deadconn: Connection to be freed
104 * Close, clear, and free a connection structure. Should never be
105 * called from within libfaim.
108 faim_export void aim_conn_kill(struct aim_session_t *sess, struct aim_conn_t **deadconn)
110 struct aim_conn_t *cur;
112 if (!deadconn || !*deadconn)
115 aim_tx_cleanqueue(sess, *deadconn);
117 faim_mutex_lock(&sess->connlistlock);
118 if (sess->connlist == NULL)
120 else if (sess->connlist->next == NULL) {
121 if (sess->connlist == *deadconn)
122 sess->connlist = NULL;
124 cur = sess->connlist;
126 if (cur->next == *deadconn) {
127 cur->next = cur->next->next;
133 faim_mutex_unlock(&sess->connlistlock);
135 /* XXX: do we need this for txqueue too? */
136 aim_rxqueue_cleanbyconn(sess, *deadconn);
138 if ((*deadconn)->fd != -1)
139 aim_conn_close(*deadconn);
140 if ((*deadconn)->priv)
141 free((*deadconn)->priv);
149 * aim_conn_close - Close a connection
150 * @deadconn: Connection to close
152 * Close (but not free) a connection.
154 * This leaves everything untouched except for clearing the
155 * handler list and setting the fd to -1 (used to recognize
159 faim_export void aim_conn_close(struct aim_conn_t *deadconn)
162 faim_mutex_destroy(&deadconn->active);
163 faim_mutex_destroy(&deadconn->seqnum_lock);
164 if (deadconn->fd >= 3)
167 if (deadconn->handlerlist)
168 aim_clearhandlers(deadconn);
174 * aim_getconn_type - Find a connection of a specific type
175 * @sess: Session to search
176 * @type: Type of connection to look for
178 * Searches for a connection of the specified type in the
179 * specified session. Returns the first connection of that
183 faim_export struct aim_conn_t *aim_getconn_type(struct aim_session_t *sess,
186 struct aim_conn_t *cur;
188 faim_mutex_lock(&sess->connlistlock);
189 for (cur = sess->connlist; cur; cur = cur->next) {
190 if ((cur->type == type) && !(cur->status & AIM_CONN_STATUS_INPROGRESS))
193 faim_mutex_unlock(&sess->connlistlock);
198 faim_export struct aim_conn_t *aim_getconn_type_all(struct aim_session_t *sess,
201 struct aim_conn_t *cur;
203 faim_mutex_lock(&sess->connlistlock);
204 for (cur = sess->connlist; cur; cur = cur->next) {
205 if (cur->type == type)
208 faim_mutex_unlock(&sess->connlistlock);
213 /* If you pass -1 for the fd, you'll get what you ask for. Gibberish. */
214 faim_export struct aim_conn_t *aim_getconn_fd(struct aim_session_t *sess,
217 struct aim_conn_t *cur;
219 faim_mutex_lock(&sess->connlistlock);
220 for (cur = sess->connlist; cur; cur = cur->next) {
224 faim_mutex_unlock(&sess->connlistlock);
230 * aim_proxyconnect - An extrememly quick and dirty SOCKS5 interface.
231 * @sess: Session to connect
232 * @host: Host to connect to
233 * @port: Port to connect to
234 * @statusret: Return value of the connection
236 * Attempts to connect to the specified host via the configured
237 * proxy settings, if present. If no proxy is configured for
238 * this session, the connection is done directly.
241 static int aim_proxyconnect(struct aim_session_t *sess,
242 char *host, unsigned short port,
247 if (strlen(sess->socksproxy.server)) { /* connecting via proxy */
249 unsigned char buf[512];
250 struct sockaddr_in sa;
253 unsigned short proxyport = 1080;
255 for(i=0;i<(int)strlen(sess->socksproxy.server);i++) {
256 if (sess->socksproxy.server[i] == ':') {
257 proxyport = atoi(&(sess->socksproxy.server[i+1]));
261 proxy = (char *)malloc(i+1);
262 strncpy(proxy, sess->socksproxy.server, i);
265 if (!(hp = gethostbyname(proxy))) {
266 faimdprintf(sess, 0, "proxyconnect: unable to resolve proxy name\n");
267 *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR);
272 memset(&sa.sin_zero, 0, 8);
273 sa.sin_port = htons(proxyport);
274 memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
275 sa.sin_family = hp->h_addrtype;
277 fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
278 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
279 faimdprintf(sess, 0, "proxyconnect: unable to connect to proxy\n");
285 buf[0] = 0x05; /* SOCKS version 5 */
286 if (strlen(sess->socksproxy.username)) {
287 buf[1] = 0x02; /* two methods */
288 buf[2] = 0x00; /* no authentication */
289 buf[3] = 0x02; /* username/password authentication */
297 if (write(fd, buf, i) < i) {
303 if (read(fd, buf, 2) < 2) {
309 if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
315 /* check if we're doing username authentication */
316 if (buf[1] == 0x02) {
317 i = aimutil_put8(buf, 0x01); /* version 1 */
318 i += aimutil_put8(buf+i, strlen(sess->socksproxy.username));
319 i += aimutil_putstr(buf+i, sess->socksproxy.username, strlen(sess->socksproxy.username));
320 i += aimutil_put8(buf+i, strlen(sess->socksproxy.password));
321 i += aimutil_putstr(buf+i, sess->socksproxy.password, strlen(sess->socksproxy.password));
322 if (write(fd, buf, i) < i) {
327 if (read(fd, buf, 2) < 2) {
332 if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
339 i = aimutil_put8(buf, 0x05);
340 i += aimutil_put8(buf+i, 0x01); /* CONNECT */
341 i += aimutil_put8(buf+i, 0x00); /* reserved */
342 i += aimutil_put8(buf+i, 0x03); /* address type: host name */
343 i += aimutil_put8(buf+i, strlen(host));
344 i += aimutil_putstr(buf+i, host, strlen(host));
345 i += aimutil_put16(buf+i, port);
347 if (write(fd, buf, i) < i) {
352 if (read(fd, buf, 10) < 10) {
357 if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
363 } else { /* connecting directly */
364 struct sockaddr_in sa;
367 if (!(hp = gethostbyname(host))) {
368 *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR);
372 memset(&sa, 0, sizeof(struct sockaddr_in));
373 sa.sin_port = htons(port);
374 memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
375 sa.sin_family = hp->h_addrtype;
377 fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
379 if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT)
380 fcntl(fd, F_SETFL, O_NONBLOCK); /* XXX save flags */
382 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
383 if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT) {
384 if ((errno == EINPROGRESS) || (errno == EINTR)) {
386 *statusret |= AIM_CONN_STATUS_INPROGRESS;
398 * aim_cloneconn - clone an aim_conn_t
399 * @sess: session containing parent
400 * @src: connection to clone
402 * A new connection is allocated, and the values are filled in
403 * appropriately. Note that this function sets the new connnection's
404 * ->priv pointer to be equal to that of its parent: only the pointer
405 * is copied, not the data it points to.
407 * This function returns a pointer to the new aim_conn_t, or %NULL on
410 faim_internal struct aim_conn_t *aim_cloneconn(struct aim_session_t *sess,
411 struct aim_conn_t *src)
413 struct aim_conn_t *conn;
414 struct aim_rxcblist_t *cur;
416 if (!(conn = aim_conn_getnext(sess)))
419 faim_mutex_lock(&conn->active);
422 conn->type = src->type;
423 conn->subtype = src->subtype;
424 conn->seqnum = src->seqnum;
425 conn->priv = src->priv;
426 conn->lastactivity = src->lastactivity;
427 conn->forcedlatency = src->forcedlatency;
428 conn->sessv = src->sessv;
430 /* clone handler list */
431 for (cur = src->handlerlist; cur; cur = cur->next) {
432 aim_conn_addhandler(sess, conn, cur->family, cur->type,
433 cur->handler, cur->flags);
436 faim_mutex_unlock(&conn->active);
442 * aim_newconn - Open a new connection
443 * @sess: Session to create connection in
444 * @type: Type of connection to create
445 * @dest: Host to connect to (in "host:port" syntax)
447 * Opens a new connection to the specified dest host of specified
448 * type, using the proxy settings if available. If @host is %NULL,
449 * the connection is allocated and returned, but no connection
452 * FIXME: Return errors in a more sane way.
455 faim_export struct aim_conn_t *aim_newconn(struct aim_session_t *sess,
456 int type, char *dest)
458 struct aim_conn_t *connstruct;
460 u_short port = FAIM_LOGIN_PORT;
464 if ((connstruct=aim_conn_getnext(sess))==NULL)
467 faim_mutex_lock(&connstruct->active);
469 connstruct->sessv = (void *)sess;
470 connstruct->type = type;
472 if (!dest) { /* just allocate a struct */
474 connstruct->status = 0;
475 faim_mutex_unlock(&connstruct->active);
480 * As of 23 Jul 1999, AOL now sends the port number, preceded by a
481 * colon, in the BOS redirect. This fatally breaks all previous
482 * libfaims. Bad, bad AOL.
484 * We put this here to catch every case.
488 for(i=0;i<(int)strlen(dest);i++) {
489 if (dest[i] == ':') {
490 port = atoi(&(dest[i+1]));
494 host = (char *)malloc(i+1);
495 strncpy(host, dest, i);
498 if ((ret = aim_proxyconnect(sess, host, port, &connstruct->status)) < 0) {
500 connstruct->status = (errno | AIM_CONN_STATUS_CONNERR);
502 faim_mutex_unlock(&connstruct->active);
505 connstruct->fd = ret;
507 faim_mutex_unlock(&connstruct->active);
515 * aim_conngetmaxfd - Return the highest valued file discriptor in session
516 * @sess: Session to search
518 * Returns the highest valued filed descriptor of all open
519 * connections in @sess.
522 faim_export int aim_conngetmaxfd(struct aim_session_t *sess)
525 struct aim_conn_t *cur;
527 faim_mutex_lock(&sess->connlistlock);
528 for (cur = sess->connlist; cur; cur = cur->next) {
532 faim_mutex_unlock(&sess->connlistlock);
538 * aim_conn_in_sess - Predicate to test the precense of a connection in a sess
539 * @sess: Session to look in
540 * @conn: Connection to look for
542 * Searches @sess for the passed connection. Returns 1 if its present,
546 faim_export int aim_conn_in_sess(struct aim_session_t *sess, struct aim_conn_t *conn)
548 struct aim_conn_t *cur;
550 faim_mutex_lock(&sess->connlistlock);
551 for(cur = sess->connlist; cur; cur = cur->next)
553 faim_mutex_unlock(&sess->connlistlock);
556 faim_mutex_unlock(&sess->connlistlock);
561 * aim_select - Wait for a socket with data or timeout
562 * @sess: Session to wait on
563 * @timeout: How long to wait
564 * @status: Return status
566 * Waits for a socket with data or for timeout, whichever comes first.
569 * Return codes in *status:
570 * -1 error in select() (%NULL returned)
571 * 0 no events pending (%NULL returned)
572 * 1 outgoing data pending (%NULL returned)
573 * 2 incoming data pending (connection with pending data returned)
575 * XXX: we could probably stand to do a little courser locking here.
578 faim_export struct aim_conn_t *aim_select(struct aim_session_t *sess,
579 struct timeval *timeout,
582 struct aim_conn_t *cur;
585 int i, haveconnecting = 0;
587 faim_mutex_lock(&sess->connlistlock);
588 if (sess->connlist == NULL) {
589 faim_mutex_unlock(&sess->connlistlock);
593 faim_mutex_unlock(&sess->connlistlock);
599 faim_mutex_lock(&sess->connlistlock);
600 for (cur = sess->connlist; cur; cur = cur->next) {
602 /* don't let invalid/dead connections sit around */
604 faim_mutex_unlock(&sess->connlistlock);
606 } else if (cur->status & AIM_CONN_STATUS_INPROGRESS) {
607 FD_SET(cur->fd, &wfds);
611 FD_SET(cur->fd, &fds);
615 faim_mutex_unlock(&sess->connlistlock);
618 * If we have data waiting to be sent, return
620 * We have to not do this if theres at least one
621 * connection thats still connecting, since that connection
622 * may have queued data and this return would prevent
623 * the connection from ever completing! This is a major
624 * inadequacy of the libfaim way of doing things. It means
625 * that nothing can transmit as long as there's connecting
628 * But its still better than having blocking connects.
631 if (!haveconnecting && (sess->queue_outgoing != NULL)) {
636 if ((i = select(maxfd+1, &fds, &wfds, NULL, timeout))>=1) {
637 faim_mutex_lock(&sess->connlistlock);
638 for (cur = sess->connlist; cur; cur = cur->next) {
639 if ((FD_ISSET(cur->fd, &fds)) ||
640 ((cur->status & AIM_CONN_STATUS_INPROGRESS) &&
641 FD_ISSET(cur->fd, &wfds))) {
643 faim_mutex_unlock(&sess->connlistlock);
644 return cur; /* XXX race condition here -- shouldnt unlock connlist */
647 *status = 0; /* shouldn't happen */
648 } else if ((i == -1) && (errno == EINTR)) /* treat interrupts as a timeout */
651 *status = i; /* can be 0 or -1 */
653 faim_mutex_unlock(&sess->connlistlock);
655 return NULL; /* no waiting or error, return */
659 * aim_conn_isready - Test if a connection is marked ready
660 * @conn: Connection to test
662 * Returns true if the connection is ready, false otherwise.
663 * Returns -1 if the connection is invalid.
665 * XXX: This is deprecated.
668 faim_export int aim_conn_isready(struct aim_conn_t *conn)
671 return (conn->status & 0x0001);
676 * aim_conn_setstatus - Set the status of a connection
678 * @status: New status
680 * @newstatus is %XOR'd with the previous value of the connection
681 * status and returned. Returns -1 if the connection is invalid.
683 * This isn't real useful.
686 faim_export int aim_conn_setstatus(struct aim_conn_t *conn, int status)
693 faim_mutex_lock(&conn->active);
694 val = conn->status ^= status;
695 faim_mutex_unlock(&conn->active);
701 * aim_conn_setlatency - Set a forced latency value for connection
702 * @conn: Conn to set latency for
703 * @newval: Number of seconds to force between transmits
705 * Causes @newval seconds to be spent between transmits on a connection.
707 * This is my lame attempt at overcoming not understanding the rate
710 * XXX: This should really be replaced with something that scales and
711 * backs off like the real rate limiting does.
714 faim_export int aim_conn_setlatency(struct aim_conn_t *conn, int newval)
719 faim_mutex_lock(&conn->active);
720 conn->forcedlatency = newval;
721 conn->lastactivity = 0; /* reset this just to make sure */
722 faim_mutex_unlock(&conn->active);
728 * aim_setupproxy - Configure a proxy for this session
729 * @sess: Session to set proxy for
730 * @server: SOCKS server
731 * @username: SOCKS username
732 * @password: SOCKS password
734 * Call this with your SOCKS5 proxy server parameters before
735 * the first call to aim_newconn(). If called with all %NULL
736 * args, it will clear out a previously set proxy.
738 * Set username and password to %NULL if not applicable.
741 faim_export void aim_setupproxy(struct aim_session_t *sess, char *server, char *username, char *password)
743 /* clear out the proxy info */
744 if (!server || !strlen(server)) {
745 memset(sess->socksproxy.server, 0, sizeof(sess->socksproxy.server));
746 memset(sess->socksproxy.username, 0, sizeof(sess->socksproxy.username));
747 memset(sess->socksproxy.password, 0, sizeof(sess->socksproxy.password));
751 strncpy(sess->socksproxy.server, server, sizeof(sess->socksproxy.server));
752 if (username && strlen(username))
753 strncpy(sess->socksproxy.username, username, sizeof(sess->socksproxy.username));
754 if (password && strlen(password))
755 strncpy(sess->socksproxy.password, password, sizeof(sess->socksproxy.password));
759 static void defaultdebugcb(struct aim_session_t *sess, int level, const char *format, va_list va)
761 vfprintf(stderr, format, va);
765 * aim_session_init - Initializes a session structure
766 * @sess: Session to initialize
767 * @flags: Flags to use. Any of %AIM_SESS_FLAGS %OR'd together.
768 * @debuglevel: Level of debugging output (zero is least)
770 * Sets up the initial values for a session.
773 faim_export void aim_session_init(struct aim_session_t *sess, unsigned long flags, int debuglevel)
778 memset(sess, 0, sizeof(struct aim_session_t));
780 sess->queue_outgoing = NULL;
781 sess->queue_incoming = NULL;
782 sess->pendingjoin = NULL;
783 sess->pendingjoinexchange = 0;
784 aim_initsnachash(sess);
785 sess->msgcookies = NULL;
786 sess->snac_nextid = 0x00000001;
789 sess->debug = debuglevel;
790 sess->debugcb = defaultdebugcb;
792 sess->modlistv = NULL;
795 * Default to SNAC login unless XORLOGIN is explicitly set.
797 if (!(flags & AIM_SESS_FLAGS_XORLOGIN))
798 sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
799 sess->flags |= flags;
802 * This must always be set. Default to the queue-based
803 * version for back-compatibility.
805 aim_tx_setenqueue(sess, AIM_TX_QUEUED, NULL);
809 * Register all the modules for this session...
811 aim__registermodule(sess, misc_modfirst); /* load the catch-all first */
812 aim__registermodule(sess, buddylist_modfirst);
813 aim__registermodule(sess, admin_modfirst);
814 aim__registermodule(sess, bos_modfirst);
815 aim__registermodule(sess, search_modfirst);
816 aim__registermodule(sess, stats_modfirst);
817 aim__registermodule(sess, auth_modfirst);
818 aim__registermodule(sess, msg_modfirst);
819 aim__registermodule(sess, chatnav_modfirst);
820 aim__registermodule(sess, chat_modfirst);
821 aim__registermodule(sess, locate_modfirst);
822 aim__registermodule(sess, general_modfirst);
828 * aim_session_kill - Deallocate a session
829 * @sess: Session to kill
833 faim_export void aim_session_kill(struct aim_session_t *sess)
838 aim__shutdownmodules(sess);
844 * aim_setdebuggingcb - Set the function to call when outputting debugging info
845 * @sess: Session to change
846 * @cb: Function to call
848 * The function specified is called whenever faimdprintf() is used within
849 * libfaim, and the session's debugging level is greater tha nor equal to
850 * the value faimdprintf was called with.
853 faim_export int aim_setdebuggingcb(struct aim_session_t *sess, faim_debugging_callback_t cb)
865 * aim_conn_isconnecting - Determine if a connection is connecting
866 * @conn: Connection to examine
868 * Returns nonzero if the connection is in the process of
869 * connecting (or if it just completed and aim_conn_completeconnect()
870 * has yet to be called on it).
873 faim_export int aim_conn_isconnecting(struct aim_conn_t *conn)
877 return (conn->status & AIM_CONN_STATUS_INPROGRESS)?1:0;
880 faim_export int aim_conn_completeconnect(struct aim_session_t *sess, struct aim_conn_t *conn)
884 int res, error = ETIMEDOUT;
885 aim_rxcallback_t userfunc;
887 if (!conn || (conn->fd == -1))
890 if (!(conn->status & AIM_CONN_STATUS_INPROGRESS))
894 FD_SET(conn->fd, &fds);
896 FD_SET(conn->fd, &wfds);
900 if ((res = select(conn->fd+1, &fds, &wfds, NULL, &tv)) == -1) {
902 aim_conn_close(conn);
905 } else if (res == 0) {
906 faimdprintf(sess, 0, "aim_conn_completeconnect: false alarm on %d\n", conn->fd);
907 return 0; /* hasn't really completed yet... */
910 if (FD_ISSET(conn->fd, &fds) || FD_ISSET(conn->fd, &wfds)) {
911 int len = sizeof(error);
913 if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
918 aim_conn_close(conn);
923 fcntl(conn->fd, F_SETFL, 0); /* XXX should restore original flags */
925 conn->status &= ~AIM_CONN_STATUS_INPROGRESS;
927 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE)))
928 userfunc(sess, NULL, conn);
930 /* Flush out the queues if there was something waiting for this conn */
931 aim_tx_flushqueue(sess);
936 faim_export struct aim_session_t *aim_conn_getsess(struct aim_conn_t *conn)
942 return (struct aim_session_t *)conn->sessv;
948 * Closes -ALL- open connections.
951 faim_export int aim_logoff(struct aim_session_t *sess)
954 aim_connrst(sess); /* in case we want to connect again */