aim_conn.c

   1
   2 /*
   3  *  aim_conn.c
   4  *
   5  * Does all this gloriously nifty connection handling stuff...
   6  *
   7  */
   8
   9 #include <faim/aim.h>
  10
  11 void aim_connrst(struct aim_session_t *sess)
  12 {
  13   int i;
  14   for (i = 0; i < AIM_CONN_MAX; i++)
  15     {
  16       sess->conns[i].fd = -1;
  17       sess->conns[i].type = -1;
  18       sess->conns[i].status = 0;
  19       sess->conns[i].seqnum = 0;
  20       sess->conns[i].lastactivity = 0;
  21       sess->conns[i].forcedlatency = 0;
  22       aim_clearhandlers(&(sess->conns[i]));
  23       sess->conns[i].handlerlist = NULL;
  24     }
  25
  26 }
  27
  28 struct aim_conn_t *aim_conn_getnext(struct aim_session_t *sess)
  29 {
  30   int i;
  31   for (i=0;i<AIM_CONN_MAX;i++)
  32     if (sess->conns[i].fd == -1)
  33       return &(sess->conns[i]);
  34   return NULL;
  35 }
  36
  37 void aim_conn_close(struct aim_conn_t *deadconn)
  38 {
  39   if (deadconn->fd >= 3)
  40     close(deadconn->fd);
  41   deadconn->fd = -1;
  42   deadconn->type = -1;
  43   deadconn->seqnum = 0;
  44   deadconn->lastactivity = 0;
  45   deadconn->forcedlatency = 0;
  46   aim_clearhandlers(deadconn);
  47   deadconn->handlerlist = NULL;
  48   if (deadconn->priv)
  49     free(deadconn->priv);
  50   deadconn->priv = NULL;
  51 }
  52
  53 struct aim_conn_t *aim_getconn_type(struct aim_session_t *sess,
  54                                     int type)
  55 {
  56   int i;
  57   for (i=0; i<AIM_CONN_MAX; i++)
  58     if (sess->conns[i].type == type)
  59       return &(sess->conns[i]);
  60   return NULL;
  61 }
  62
  63 /*
  64  * aim_newconn(type, dest)
  65  *
  66  * Opens a new connection to the specified dest host of type type.
  67  *
  68  * TODO: fix for proxies
  69  * FIXME: Return errors in a more sane way.
  70  *
  71  */
  72 struct aim_conn_t *aim_newconn(struct aim_session_t *sess,
  73                                int type, char *dest)
  74 {
  75   struct aim_conn_t *connstruct;
  76   int ret;
  77   struct sockaddr_in sa;
  78   struct hostent *hp;
  79   u_short port = FAIM_LOGIN_PORT;
  80   char *host = NULL;
  81   int i=0;
  82
  83   if (!dest || ((connstruct=aim_conn_getnext(sess))==NULL))
  84     return NULL;
  85
  86   connstruct->type = type;
  87
  88   /*
  89    * As of 23 Jul 1999, AOL now sends the port number, preceded by a
  90    * colon, in the BOS redirect.  This fatally breaks all previous
  91    * libfaims.  Bad, bad AOL.
  92    *
  93    * We put this here to catch every case.
  94    *
  95    */
  96
  97   for(i=0;i<strlen(dest);i++)
  98     {
  99       if (dest[i] == ':') {
 100         port = atoi(&(dest[i+1]));
 101         break;
 102       }
 103     }
 104   host = (char *)malloc(i+1);
 105   strncpy(host, dest, i);
 106   host[i] = '\0';
 107
 108   hp = gethostbyname2(host, AF_INET);
 109   free(host);
 110
 111   if (hp == NULL)
 112     {
 113       connstruct->status = (h_errno | AIM_CONN_STATUS_RESOLVERR);
 114       return connstruct;
 115     }
 116
 117   memset(&sa.sin_zero, 0, 8);
 118   sa.sin_port = htons(port);
 119   memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
 120   sa.sin_family = hp->h_addrtype;
 121
 122   connstruct->fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
 123   ret = connect(connstruct->fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in));
 124   if( ret < 0)
 125     {
 126       connstruct->fd = -1;
 127       connstruct->status = (errno | AIM_CONN_STATUS_CONNERR);
 128       return connstruct;
 129     }
 130
 131   return connstruct;
 132 }
 133
 134 int aim_conngetmaxfd(struct aim_session_t *sess)
 135 {
 136   int i,j;
 137   j=0;
 138   for (i=0;i<AIM_CONN_MAX;i++)
 139     if(sess->conns[i].fd > j)
 140       j = sess->conns[i].fd;
 141   return j;
 142 }
 143
 144 int aim_countconn(struct aim_session_t *sess)
 145 {
 146   int i,cnt;
 147   cnt = 0;
 148   for (i=0;i<AIM_CONN_MAX;i++)
 149     if (sess->conns[i].fd > -1)
 150       cnt++;
 151   return cnt;
 152 }
 153
 154 /*
 155  * aim_select(timeout)
 156  *
 157  * Waits for a socket with data or for timeout, whichever comes first.
 158  * See select(2).
 159  *
 160  */
 161 struct aim_conn_t *aim_select(struct aim_session_t *sess,
 162                               struct timeval *timeout)
 163 {
 164   fd_set fds;
 165   fd_set errfds;
 166   int i;
 167
 168   if (aim_countconn(sess) <= 0)
 169     return 0;
 170
 171   /*
 172    * If we have data waiting to be sent, return immediatly
 173    */
 174   if (sess->queue_outgoing)
 175     return (struct aim_conn_t *)1;
 176
 177   FD_ZERO(&fds);
 178   FD_ZERO(&errfds);
 179
 180   for(i=0;i<AIM_CONN_MAX;i++)
 181     if (sess->conns[i].fd>-1)
 182       {
 183         FD_SET(sess->conns[i].fd, &fds);
 184         FD_SET(sess->conns[i].fd, &errfds);
 185       }
 186
 187   i = select(aim_conngetmaxfd(sess)+1, &fds, NULL, &errfds, timeout);
 188   if (i>=1)
 189     {
 190       int j;
 191       for (j=0;j<AIM_CONN_MAX;j++)
 192         {
 193           if (sess->conns[j].fd > -1)
 194             {
 195               if ((FD_ISSET(sess->conns[j].fd, &errfds)))
 196                 {
 197                   /* got an exception; close whats left of it up */
 198                   aim_conn_close(&(sess->conns[j]));
 199                   return (struct aim_conn_t *)-1;
 200                 }
 201               else if ((FD_ISSET(sess->conns[j].fd, &fds)))
 202                 return &(sess->conns[j]);  /* return the first waiting struct */
 203             }
 204         }
 205       /* should never get here */
 206     }
 207   else
 208     return (struct aim_conn_t *)i;  /* no waiting or error, return -- FIXME: return type funnies */
 209   return NULL; /* NO REACH */
 210 }
 211
 212 int aim_conn_isready(struct aim_conn_t *conn)
 213 {
 214   if (conn)
 215     return (conn->status & 0x0001);
 216   else
 217     return -1;
 218 }
 219
 220 int aim_conn_setstatus(struct aim_conn_t *conn, int status)
 221 {
 222   if (conn)
 223     return (conn->status ^= status);
 224   else
 225     return -1;
 226 }
 227
 228 int aim_conn_setlatency(struct aim_conn_t *conn, int newval)
 229 {
 230   if (!conn)
 231     return -1;
 232
 233   conn->forcedlatency = newval;
 234   conn->lastactivity = 0; /* reset this just to make sure */
 235
 236   return 0;
 237 }
 238
 239 void aim_session_init(struct aim_session_t *sess)
 240 {
 241   int i;
 242
 243   if (!sess)
 244     return;
 245
 246   memset(sess->logininfo.screen_name, 0x00, MAXSNLEN);
 247   sess->logininfo.BOSIP = NULL;
 248   memset(sess->logininfo.cookie, 0x00, AIM_COOKIELEN);
 249   sess->logininfo.email = NULL;
 250   sess->logininfo.regstatus = 0x00;
 251
 252   for (i = 0; i < AIM_CONN_MAX; i++)
 253     {
 254       sess->conns[i].fd = -1;
 255       sess->conns[i].type = -1;
 256       sess->conns[i].status = 0;
 257       sess->conns[i].seqnum = 0;
 258       sess->conns[i].lastactivity = 0;
 259       sess->conns[i].forcedlatency = 0;
 260       sess->conns[i].handlerlist = NULL;
 261       sess->conns[i].priv = NULL;
 262     }
 263
 264   sess->queue_outgoing = NULL;
 265   sess->queue_incoming = NULL;
 266   sess->pendingjoin = NULL;
 267   sess->outstanding_snacs = NULL;
 268   sess->snac_nextid = 0x00000001;
 269
 270   return;
 271 }