5 * Does all this gloriously nifty connection handling stuff...
13 #include <sys/socket.h>
14 #include <netinet/in.h>
18 * aim_connrst - Clears out connection list, killing remaining connections.
19 * @sess: Session to be cleared
21 * Clears out the connection list and kills any connections left.
24 faim_internal void aim_connrst(struct aim_session_t *sess)
26 faim_mutex_init(&sess->connlistlock);
28 struct aim_conn_t *cur = sess->connlist, *tmp;
37 sess->connlist = NULL;
42 * aim_conn_getnext - Gets a new connection structure.
45 * Allocate a new empty connection structure.
48 faim_internal struct aim_conn_t *aim_conn_getnext(struct aim_session_t *sess)
50 struct aim_conn_t *newconn, *cur;
52 if (!(newconn = malloc(sizeof(struct aim_conn_t))))
55 memset(newconn, 0, sizeof(struct aim_conn_t));
56 aim_conn_close(newconn);
59 faim_mutex_lock(&sess->connlistlock);
60 if (sess->connlist == NULL)
61 sess->connlist = newconn;
63 for (cur = sess->connlist; cur->next; cur = cur->next)
67 faim_mutex_unlock(&sess->connlistlock);
73 * aim_conn_init - Reset a connection to default values.
74 * @deadconn: Connection to be reset
76 * Initializes and/or resets a connection structure.
79 static void aim_conn_init(struct aim_conn_t *deadconn)
85 deadconn->subtype = -1;
88 deadconn->lastactivity = 0;
89 deadconn->forcedlatency = 0;
90 deadconn->handlerlist = NULL;
91 deadconn->priv = NULL;
92 faim_mutex_init(&deadconn->active);
93 faim_mutex_init(&deadconn->seqnum_lock);
99 * aim_conn_kill - Close and free a connection.
100 * @sess: Session for the connection
101 * @deadconn: Connection to be freed
103 * Close, clear, and free a connection structure.
106 faim_export void aim_conn_kill(struct aim_session_t *sess, struct aim_conn_t **deadconn)
108 struct aim_conn_t *cur;
110 if (!deadconn || !*deadconn)
113 faim_mutex_lock(&sess->connlistlock);
114 if (sess->connlist == NULL)
116 else if (sess->connlist->next == NULL) {
117 if (sess->connlist == *deadconn)
118 sess->connlist = NULL;
120 cur = sess->connlist;
122 if (cur->next == *deadconn) {
123 cur->next = cur->next->next;
129 faim_mutex_unlock(&sess->connlistlock);
131 /* XXX: do we need this for txqueue too? */
132 aim_rxqueue_cleanbyconn(sess, *deadconn);
134 aim_conn_close(*deadconn);
135 if ((*deadconn)->priv)
136 free((*deadconn)->priv);
144 * aim_conn_close - Close a connection
145 * @deadconn: Connection to close
147 * Close (but not free) a connection.
150 faim_export void aim_conn_close(struct aim_conn_t *deadconn)
152 int typesav = -1, subtypesav = -1;
153 void *privsav = NULL;
155 faim_mutex_destroy(&deadconn->active);
156 faim_mutex_destroy(&deadconn->seqnum_lock);
157 if (deadconn->fd >= 3)
159 if (deadconn->handlerlist)
160 aim_clearhandlers(deadconn);
162 typesav = deadconn->type;
163 subtypesav = deadconn->subtype;
165 if (deadconn->priv && (deadconn->type != AIM_CONN_TYPE_RENDEZVOUS)) {
166 free(deadconn->priv);
167 deadconn->priv = NULL;
169 privsav = deadconn->priv;
171 aim_conn_init(deadconn);
173 deadconn->type = typesav;
174 deadconn->subtype = subtypesav;
175 deadconn->priv = privsav;
181 * aim_getconn_type - Find a connection of a specific type
182 * @sess: Session to search
183 * @type: Type of connection to look for
185 * Searches for a connection of the specified type in the
186 * specified session. Returns the first connection of that
190 faim_internal struct aim_conn_t *aim_getconn_type(struct aim_session_t *sess,
193 struct aim_conn_t *cur;
195 faim_mutex_lock(&sess->connlistlock);
196 for (cur = sess->connlist; cur; cur = cur->next) {
197 if ((cur->type == type) && !(cur->status & AIM_CONN_STATUS_INPROGRESS))
200 faim_mutex_unlock(&sess->connlistlock);
205 * aim_proxyconnect - An extrememly quick and dirty SOCKS5 interface.
206 * @sess: Session to connect
207 * @host: Host to connect to
208 * @port: Port to connect to
209 * @statusret: Return value of the connection
211 * Attempts to connect to the specified host via the configured
212 * proxy settings, if present. If no proxy is configured for
213 * this session, the connection is done directly.
216 static int aim_proxyconnect(struct aim_session_t *sess,
217 char *host, unsigned short port,
222 if (strlen(sess->socksproxy.server)) { /* connecting via proxy */
224 unsigned char buf[512];
225 struct sockaddr_in sa;
228 unsigned short proxyport = 1080;
230 for(i=0;i<(int)strlen(sess->socksproxy.server);i++) {
231 if (sess->socksproxy.server[i] == ':') {
232 proxyport = atoi(&(sess->socksproxy.server[i+1]));
236 proxy = (char *)malloc(i+1);
237 strncpy(proxy, sess->socksproxy.server, i);
240 if (!(hp = gethostbyname(proxy))) {
241 printf("proxyconnect: unable to resolve proxy name\n");
242 *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR);
247 memset(&sa.sin_zero, 0, 8);
248 sa.sin_port = htons(proxyport);
249 memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
250 sa.sin_family = hp->h_addrtype;
252 fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
253 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
254 printf("proxyconnect: unable to connect to proxy\n");
260 buf[0] = 0x05; /* SOCKS version 5 */
261 if (strlen(sess->socksproxy.username)) {
262 buf[1] = 0x02; /* two methods */
263 buf[2] = 0x00; /* no authentication */
264 buf[3] = 0x02; /* username/password authentication */
272 if (write(fd, buf, i) < i) {
278 if (read(fd, buf, 2) < 2) {
284 if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
290 /* check if we're doing username authentication */
291 if (buf[1] == 0x02) {
292 i = aimutil_put8(buf, 0x01); /* version 1 */
293 i += aimutil_put8(buf+i, strlen(sess->socksproxy.username));
294 i += aimutil_putstr(buf+i, sess->socksproxy.username, strlen(sess->socksproxy.username));
295 i += aimutil_put8(buf+i, strlen(sess->socksproxy.password));
296 i += aimutil_putstr(buf+i, sess->socksproxy.password, strlen(sess->socksproxy.password));
297 if (write(fd, buf, i) < i) {
302 if (read(fd, buf, 2) < 2) {
307 if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
314 i = aimutil_put8(buf, 0x05);
315 i += aimutil_put8(buf+i, 0x01); /* CONNECT */
316 i += aimutil_put8(buf+i, 0x00); /* reserved */
317 i += aimutil_put8(buf+i, 0x03); /* address type: host name */
318 i += aimutil_put8(buf+i, strlen(host));
319 i += aimutil_putstr(buf+i, host, strlen(host));
320 i += aimutil_put16(buf+i, port);
322 if (write(fd, buf, i) < i) {
327 if (read(fd, buf, 10) < 10) {
332 if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
338 } else { /* connecting directly */
339 struct sockaddr_in sa;
342 if (!(hp = gethostbyname(host))) {
343 *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR);
347 memset(&sa, 0, sizeof(struct sockaddr_in));
348 sa.sin_port = htons(port);
349 memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
350 sa.sin_family = hp->h_addrtype;
352 fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
354 if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT)
355 fcntl(fd, F_SETFL, O_NONBLOCK); /* XXX save flags */
357 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
358 if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT) {
359 if ((errno == EINPROGRESS) || (errno == EINTR)) {
361 *statusret |= AIM_CONN_STATUS_INPROGRESS;
373 * aim_newconn - Open a new connection
374 * @sess: Session to create connection in
375 * @type: Type of connection to create
376 * @dest: Host to connect to (in "host:port" syntax)
378 * Opens a new connection to the specified dest host of specified
379 * type, using the proxy settings if available. If @host is %NULL,
380 * the connection is allocated and returned, but no connection
383 * FIXME: Return errors in a more sane way.
386 faim_export struct aim_conn_t *aim_newconn(struct aim_session_t *sess,
387 int type, char *dest)
389 struct aim_conn_t *connstruct;
391 u_short port = FAIM_LOGIN_PORT;
395 if ((connstruct=aim_conn_getnext(sess))==NULL)
398 faim_mutex_lock(&connstruct->active);
400 connstruct->type = type;
402 if (!dest) { /* just allocate a struct */
404 connstruct->status = 0;
405 faim_mutex_unlock(&connstruct->active);
410 * As of 23 Jul 1999, AOL now sends the port number, preceded by a
411 * colon, in the BOS redirect. This fatally breaks all previous
412 * libfaims. Bad, bad AOL.
414 * We put this here to catch every case.
418 for(i=0;i<(int)strlen(dest);i++) {
419 if (dest[i] == ':') {
420 port = atoi(&(dest[i+1]));
424 host = (char *)malloc(i+1);
425 strncpy(host, dest, i);
428 if ((ret = aim_proxyconnect(sess, host, port, &connstruct->status)) < 0) {
430 connstruct->status = (errno | AIM_CONN_STATUS_CONNERR);
432 faim_mutex_unlock(&connstruct->active);
435 connstruct->fd = ret;
437 faim_mutex_unlock(&connstruct->active);
445 * aim_conngetmaxfd - Return the highest valued file discriptor in session
446 * @sess: Session to search
448 * Returns the highest valued filed descriptor of all open
449 * connections in @sess.
452 faim_export int aim_conngetmaxfd(struct aim_session_t *sess)
455 struct aim_conn_t *cur;
457 faim_mutex_lock(&sess->connlistlock);
458 for (cur = sess->connlist; cur; cur = cur->next) {
462 faim_mutex_unlock(&sess->connlistlock);
468 * aim_countconn - Return the number of open connections in the session
469 * @sess: Session to look at
471 * Returns the number of number connections in @sess.
474 static int aim_countconn(struct aim_session_t *sess)
477 struct aim_conn_t *cur;
479 faim_mutex_lock(&sess->connlistlock);
480 for (cur = sess->connlist; cur; cur = cur->next)
482 faim_mutex_unlock(&sess->connlistlock);
488 * aim_conn_in_sess - Predicate to test the precense of a connection in a sess
489 * @sess: Session to look in
490 * @conn: Connection to look for
492 * Searches @sess for the passed connection. Returns 1 if its present,
496 faim_export int aim_conn_in_sess(struct aim_session_t *sess, struct aim_conn_t *conn)
498 struct aim_conn_t *cur;
500 faim_mutex_lock(&sess->connlistlock);
501 for(cur = sess->connlist; cur; cur = cur->next)
503 faim_mutex_unlock(&sess->connlistlock);
506 faim_mutex_unlock(&sess->connlistlock);
511 * aim_select - Wait for a socket with data or timeout
512 * @sess: Session to wait on
513 * @timeout: How long to wait
514 * @status: Return status
516 * Waits for a socket with data or for timeout, whichever comes first.
519 * Return codes in *status:
520 * -1 error in select() (%NULL returned)
521 * 0 no events pending (%NULL returned)
522 * 1 outgoing data pending (%NULL returned)
523 * 2 incoming data pending (connection with pending data returned)
525 * XXX: we could probably stand to do a little courser locking here.
528 faim_export struct aim_conn_t *aim_select(struct aim_session_t *sess,
529 struct timeval *timeout, int *status)
531 struct aim_conn_t *cur;
534 int i, haveconnecting = 0;
536 faim_mutex_lock(&sess->connlistlock);
537 if (sess->connlist == NULL) {
538 faim_mutex_unlock(&sess->connlistlock);
542 faim_mutex_unlock(&sess->connlistlock);
548 faim_mutex_lock(&sess->connlistlock);
549 for (cur = sess->connlist; cur; cur = cur->next) {
550 if (cur->status & AIM_CONN_STATUS_INPROGRESS) {
551 FD_SET(cur->fd, &wfds);
554 FD_SET(cur->fd, &fds);
558 faim_mutex_unlock(&sess->connlistlock);
561 * If we have data waiting to be sent, return
563 * We have to not do this if theres at least one
564 * connection thats still connecting, since that connection
565 * may have queued data and this return would prevent
566 * the connection from ever completing! This is a major
567 * inadequacy of the libfaim way of doing things. It means
568 * that nothing can transmit as long as there's connecting
571 * But its still better than having blocking connects.
574 if (!haveconnecting && (sess->queue_outgoing != NULL)) {
579 if ((i = select(maxfd+1, &fds, &wfds, NULL, timeout))>=1) {
580 faim_mutex_lock(&sess->connlistlock);
581 for (cur = sess->connlist; cur; cur = cur->next) {
582 if ((FD_ISSET(cur->fd, &fds)) ||
583 ((cur->status & AIM_CONN_STATUS_INPROGRESS) &&
584 FD_ISSET(cur->fd, &wfds))) {
586 faim_mutex_unlock(&sess->connlistlock);
587 return cur; /* XXX race condition here -- shouldnt unlock connlist */
590 *status = 0; /* shouldn't happen */
591 } else if ((i == -1) && (errno == EINTR)) /* treat interrupts as a timeout */
594 *status = i; /* can be 0 or -1 */
596 faim_mutex_unlock(&sess->connlistlock);
597 return NULL; /* no waiting or error, return */
601 * aim_conn_isready - Test if a connection is marked ready
602 * @conn: Connection to test
604 * Returns true if the connection is ready, false otherwise.
605 * Returns -1 if the connection is invalid.
607 * XXX: This is deprecated.
610 faim_export int aim_conn_isready(struct aim_conn_t *conn)
613 return (conn->status & 0x0001);
618 * aim_conn_setstatus - Set the status of a connection
620 * @status: New status
622 * @newstatus is %XOR'd with the previous value of the connection
623 * status and returned. Returns -1 if the connection is invalid.
625 * This isn't real useful.
628 faim_export int aim_conn_setstatus(struct aim_conn_t *conn, int status)
635 faim_mutex_lock(&conn->active);
636 val = conn->status ^= status;
637 faim_mutex_unlock(&conn->active);
642 * aim_conn_setlatency - Set a forced latency value for connection
643 * @conn: Conn to set latency for
644 * @newval: Number of seconds to force between transmits
646 * Causes @newval seconds to be spent between transmits on a connection.
648 * This is my lame attempt at overcoming not understanding the rate
651 * XXX: This should really be replaced with something that scales and
652 * backs off like the real rate limiting does.
655 faim_export int aim_conn_setlatency(struct aim_conn_t *conn, int newval)
660 faim_mutex_lock(&conn->active);
661 conn->forcedlatency = newval;
662 conn->lastactivity = 0; /* reset this just to make sure */
663 faim_mutex_unlock(&conn->active);
669 * aim_setupproxy - Configure a proxy for this session
670 * @sess: Session to set proxy for
671 * @server: SOCKS server
672 * @username: SOCKS username
673 * @password: SOCKS password
675 * Call this with your SOCKS5 proxy server parameters before
676 * the first call to aim_newconn(). If called with all %NULL
677 * args, it will clear out a previously set proxy.
679 * Set username and password to %NULL if not applicable.
682 faim_export void aim_setupproxy(struct aim_session_t *sess, char *server, char *username, char *password)
684 /* clear out the proxy info */
685 if (!server || !strlen(server)) {
686 memset(sess->socksproxy.server, 0, sizeof(sess->socksproxy.server));
687 memset(sess->socksproxy.username, 0, sizeof(sess->socksproxy.username));
688 memset(sess->socksproxy.password, 0, sizeof(sess->socksproxy.password));
692 strncpy(sess->socksproxy.server, server, sizeof(sess->socksproxy.server));
693 if (username && strlen(username))
694 strncpy(sess->socksproxy.username, username, sizeof(sess->socksproxy.username));
695 if (password && strlen(password))
696 strncpy(sess->socksproxy.password, password, sizeof(sess->socksproxy.password));
701 * aim_session_init - Initializes a session structure
702 * @sess: Session to initialize
703 * @flags: Flags to use. Any of %AIM_SESS_FLAGS %OR'd together.
705 * Sets up the initial values for a session.
708 faim_export void aim_session_init(struct aim_session_t *sess, unsigned long flags)
713 memset(sess, 0, sizeof(struct aim_session_t));
715 sess->queue_outgoing = NULL;
716 sess->queue_incoming = NULL;
717 sess->pendingjoin = NULL;
718 aim_initsnachash(sess);
719 sess->snac_nextid = 0x00000001;
724 * Default to SNAC login unless XORLOGIN is explicitly set.
726 if (!(flags & AIM_SESS_FLAGS_XORLOGIN))
727 sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
728 sess->flags |= flags;
731 * This must always be set. Default to the queue-based
732 * version for back-compatibility.
734 sess->tx_enqueue = &aim_tx_enqueue__queuebased;
740 * aim_conn_isconnecting - Determine if a connection is connecting
741 * @conn: Connection to examine
743 * Returns nonzero if the connection is in the process of
744 * connecting (or if it just completed and aim_conn_completeconnect()
745 * has yet to be called on it).
748 faim_export int aim_conn_isconnecting(struct aim_conn_t *conn)
752 return (conn->status & AIM_CONN_STATUS_INPROGRESS)?1:0;
755 faim_export int aim_conn_completeconnect(struct aim_session_t *sess, struct aim_conn_t *conn)
759 int res, error = ETIMEDOUT;
760 rxcallback_t userfunc;
762 if (!conn || (conn->fd == -1))
765 if (!(conn->status & AIM_CONN_STATUS_INPROGRESS))
769 FD_SET(conn->fd, &fds);
771 FD_SET(conn->fd, &wfds);
775 if ((res = select(conn->fd+1, &fds, &wfds, NULL, &tv)) == -1) {
777 aim_conn_close(conn);
780 } else if (res == 0) {
781 printf("faim: aim_conn_completeconnect: false alarm on %d\n", conn->fd);
782 return 0; /* hasn't really completed yet... */
785 if (FD_ISSET(conn->fd, &fds) || FD_ISSET(conn->fd, &wfds)) {
786 int len = sizeof(error);
788 if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
793 aim_conn_close(conn);
798 fcntl(conn->fd, F_SETFL, 0); /* XXX should restore original flags */
800 conn->status &= ~AIM_CONN_STATUS_INPROGRESS;
802 if ((userfunc = aim_callhandler(conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE)))
803 userfunc(sess, NULL, conn);
805 /* Flush out the queues if there was something waiting for this conn */
806 aim_tx_flushqueue(sess);