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)
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.sin_zero, 0, 8);
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);
353 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
362 * aim_newconn - Open a new connection
363 * @sess: Session to create connection in
364 * @type: Type of connection to create
365 * @dest: Host to connect to (in "host:port" syntax)
367 * Opens a new connection to the specified dest host of specified
368 * type, using the proxy settings if available. If @host is %NULL,
369 * the connection is allocated and returned, but no connection
372 * FIXME: Return errors in a more sane way.
375 faim_export struct aim_conn_t *aim_newconn(struct aim_session_t *sess,
376 int type, char *dest)
378 struct aim_conn_t *connstruct;
380 u_short port = FAIM_LOGIN_PORT;
384 if ((connstruct=aim_conn_getnext(sess))==NULL)
387 faim_mutex_lock(&connstruct->active);
389 connstruct->type = type;
391 if (!dest) { /* just allocate a struct */
393 connstruct->status = 0;
394 faim_mutex_unlock(&connstruct->active);
399 * As of 23 Jul 1999, AOL now sends the port number, preceded by a
400 * colon, in the BOS redirect. This fatally breaks all previous
401 * libfaims. Bad, bad AOL.
403 * We put this here to catch every case.
407 for(i=0;i<(int)strlen(dest);i++) {
408 if (dest[i] == ':') {
409 port = atoi(&(dest[i+1]));
413 host = (char *)malloc(i+1);
414 strncpy(host, dest, i);
417 if ((ret = aim_proxyconnect(sess, host, port, &connstruct->status)) < 0) {
419 connstruct->status = (errno | AIM_CONN_STATUS_CONNERR);
421 faim_mutex_unlock(&connstruct->active);
424 connstruct->fd = ret;
426 faim_mutex_unlock(&connstruct->active);
434 * aim_conngetmaxfd - Return the highest valued file discriptor in session
435 * @sess: Session to search
437 * Returns the highest valued filed descriptor of all open
438 * connections in @sess.
441 faim_export int aim_conngetmaxfd(struct aim_session_t *sess)
444 struct aim_conn_t *cur;
446 faim_mutex_lock(&sess->connlistlock);
447 for (cur = sess->connlist; cur; cur = cur->next) {
451 faim_mutex_unlock(&sess->connlistlock);
457 * aim_countconn - Return the number of open connections in the session
458 * @sess: Session to look at
460 * Returns the number of number connections in @sess.
463 static int aim_countconn(struct aim_session_t *sess)
466 struct aim_conn_t *cur;
468 faim_mutex_lock(&sess->connlistlock);
469 for (cur = sess->connlist; cur; cur = cur->next)
471 faim_mutex_unlock(&sess->connlistlock);
477 * aim_conn_in_sess - Predicate to test the precense of a connection in a sess
478 * @sess: Session to look in
479 * @conn: Connection to look for
481 * Searches @sess for the passed connection. Returns 1 if its present,
485 faim_export int aim_conn_in_sess(struct aim_session_t *sess, struct aim_conn_t *conn)
487 struct aim_conn_t *cur;
489 faim_mutex_lock(&sess->connlistlock);
490 for(cur = sess->connlist; cur; cur = cur->next)
492 faim_mutex_unlock(&sess->connlistlock);
495 faim_mutex_unlock(&sess->connlistlock);
500 * aim_select - Wait for a socket with data or timeout
501 * @sess: Session to wait on
502 * @timeout: How long to wait
503 * @status: Return status
505 * Waits for a socket with data or for timeout, whichever comes first.
508 * Return codes in *status:
509 * -1 error in select() (%NULL returned)
510 * 0 no events pending (%NULL returned)
511 * 1 outgoing data pending (%NULL returned)
512 * 2 incoming data pending (connection with pending data returned)
514 * XXX: we could probably stand to do a little courser locking here.
517 faim_export struct aim_conn_t *aim_select(struct aim_session_t *sess,
518 struct timeval *timeout, int *status)
520 struct aim_conn_t *cur;
525 faim_mutex_lock(&sess->connlistlock);
526 if (sess->connlist == NULL) {
527 faim_mutex_unlock(&sess->connlistlock);
531 faim_mutex_unlock(&sess->connlistlock);
534 * If we have data waiting to be sent, return immediatly
536 if (sess->queue_outgoing != NULL) {
544 faim_mutex_lock(&sess->connlistlock);
545 for (cur = sess->connlist; cur; cur = cur->next) {
546 FD_SET(cur->fd, &fds);
550 faim_mutex_unlock(&sess->connlistlock);
552 if ((i = select(maxfd+1, &fds, NULL, NULL, timeout))>=1) {
553 faim_mutex_lock(&sess->connlistlock);
554 for (cur = sess->connlist; cur; cur = cur->next) {
555 if (FD_ISSET(cur->fd, &fds)) {
557 faim_mutex_unlock(&sess->connlistlock);
561 *status = 0; /* shouldn't happen */
562 } else if ((i == -1) && (errno == EINTR)) /* treat interrupts as a timeout */
565 *status = i; /* can be 0 or -1 */
567 faim_mutex_unlock(&sess->connlistlock);
568 return NULL; /* no waiting or error, return */
572 * aim_conn_isready - Test if a connection is marked ready
573 * @conn: Connection to test
575 * Returns true if the connection is ready, false otherwise.
576 * Returns -1 if the connection is invalid.
578 * XXX: This is deprecated.
581 faim_export int aim_conn_isready(struct aim_conn_t *conn)
584 return (conn->status & 0x0001);
589 * aim_conn_setstatus - Set the status of a connection
591 * @status: New status
593 * @newstatus is %XOR'd with the previous value of the connection
594 * status and returned. Returns -1 if the connection is invalid.
597 faim_export int aim_conn_setstatus(struct aim_conn_t *conn, int status)
604 faim_mutex_lock(&conn->active);
605 val = conn->status ^= status;
606 faim_mutex_unlock(&conn->active);
611 * aim_conn_setlatency - Set a forced latency value for connection
612 * @conn: Conn to set latency for
613 * @newval: Number of seconds to force between transmits
615 * Causes @newval seconds to be spent between transmits on a connection.
617 * This is my lame attempt at overcoming not understanding the rate
620 * XXX: This should really be replaced with something that scales and
621 * backs off like the real rate limiting does.
624 faim_export int aim_conn_setlatency(struct aim_conn_t *conn, int newval)
629 faim_mutex_lock(&conn->active);
630 conn->forcedlatency = newval;
631 conn->lastactivity = 0; /* reset this just to make sure */
632 faim_mutex_unlock(&conn->active);
638 * aim_setupproxy - Configure a proxy for this session
639 * @sess: Session to set proxy for
640 * @server: SOCKS server
641 * @username: SOCKS username
642 * @password: SOCKS password
644 * Call this with your SOCKS5 proxy server parameters before
645 * the first call to aim_newconn(). If called with all %NULL
646 * args, it will clear out a previously set proxy.
648 * Set username and password to %NULL if not applicable.
651 faim_export void aim_setupproxy(struct aim_session_t *sess, char *server, char *username, char *password)
653 /* clear out the proxy info */
654 if (!server || !strlen(server)) {
655 memset(sess->socksproxy.server, 0, sizeof(sess->socksproxy.server));
656 memset(sess->socksproxy.username, 0, sizeof(sess->socksproxy.username));
657 memset(sess->socksproxy.password, 0, sizeof(sess->socksproxy.password));
661 strncpy(sess->socksproxy.server, server, sizeof(sess->socksproxy.server));
662 if (username && strlen(username))
663 strncpy(sess->socksproxy.username, username, sizeof(sess->socksproxy.username));
664 if (password && strlen(password))
665 strncpy(sess->socksproxy.password, password, sizeof(sess->socksproxy.password));
670 * aim_session_init - Initializes a session structure
671 * @sess: Session to initialize
673 * Sets up the initial values for a session.
676 faim_export void aim_session_init(struct aim_session_t *sess)
681 memset(sess, 0, sizeof(struct aim_session_t));
683 sess->queue_outgoing = NULL;
684 sess->queue_incoming = NULL;
685 sess->pendingjoin = NULL;
686 aim_initsnachash(sess);
687 sess->snac_nextid = 0x00000001;
688 sess->snaclogin = 1; /* default to yes, oh gods yes. */
691 * This must always be set. Default to the queue-based
692 * version for back-compatibility.
694 sess->tx_enqueue = &aim_tx_enqueue__queuebased;