]>
Commit | Line | Data |
---|---|---|
9de3ca7e | 1 | |
2 | /* | |
3 | * aim_conn.c | |
4 | * | |
5 | * Does all this gloriously nifty connection handling stuff... | |
6 | * | |
7 | */ | |
8 | ||
37ee990e | 9 | #define FAIM_INTERNAL |
dd60ff8b | 10 | #include <aim.h> |
9de3ca7e | 11 | |
67a264ef | 12 | #ifndef _WIN32 |
78b3fb13 | 13 | #include <netdb.h> |
14 | #include <sys/socket.h> | |
15 | #include <netinet/in.h> | |
67a264ef | 16 | #endif |
78b3fb13 | 17 | |
be67fdd0 | 18 | /** |
19 | * aim_connrst - Clears out connection list, killing remaining connections. | |
20 | * @sess: Session to be cleared | |
21 | * | |
22 | * Clears out the connection list and kills any connections left. | |
23 | * | |
040457cc | 24 | */ |
5f47d4a9 | 25 | static void aim_connrst(struct aim_session_t *sess) |
9de3ca7e | 26 | { |
b13c9e13 | 27 | faim_mutex_init(&sess->connlistlock); |
040457cc | 28 | if (sess->connlist) { |
29 | struct aim_conn_t *cur = sess->connlist, *tmp; | |
30 | ||
31 | while(cur) { | |
32 | tmp = cur->next; | |
33 | aim_conn_close(cur); | |
34 | free(cur); | |
35 | cur = tmp; | |
36 | } | |
e88ba395 | 37 | } |
040457cc | 38 | sess->connlist = NULL; |
39 | return; | |
9de3ca7e | 40 | } |
41 | ||
9d2a3582 | 42 | /** |
43 | * aim_conn_init - Reset a connection to default values. | |
44 | * @deadconn: Connection to be reset | |
45 | * | |
46 | * Initializes and/or resets a connection structure. | |
47 | * | |
48 | */ | |
49 | static void aim_conn_init(struct aim_conn_t *deadconn) | |
50 | { | |
51 | if (!deadconn) | |
52 | return; | |
53 | ||
54 | deadconn->fd = -1; | |
55 | deadconn->subtype = -1; | |
56 | deadconn->type = -1; | |
57 | deadconn->seqnum = 0; | |
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); | |
64 | ||
65 | return; | |
66 | } | |
67 | ||
be67fdd0 | 68 | /** |
69 | * aim_conn_getnext - Gets a new connection structure. | |
70 | * @sess: Session | |
71 | * | |
72 | * Allocate a new empty connection structure. | |
73 | * | |
040457cc | 74 | */ |
5f47d4a9 | 75 | static struct aim_conn_t *aim_conn_getnext(struct aim_session_t *sess) |
9de3ca7e | 76 | { |
040457cc | 77 | struct aim_conn_t *newconn, *cur; |
78 | ||
79 | if (!(newconn = malloc(sizeof(struct aim_conn_t)))) | |
80 | return NULL; | |
81 | ||
82 | memset(newconn, 0, sizeof(struct aim_conn_t)); | |
9d2a3582 | 83 | aim_conn_init(newconn); |
040457cc | 84 | newconn->next = NULL; |
85 | ||
86 | faim_mutex_lock(&sess->connlistlock); | |
87 | if (sess->connlist == NULL) | |
88 | sess->connlist = newconn; | |
89 | else { | |
90 | for (cur = sess->connlist; cur->next; cur = cur->next) | |
91 | ; | |
92 | cur->next = newconn; | |
93 | } | |
94 | faim_mutex_unlock(&sess->connlistlock); | |
95 | ||
96 | return newconn; | |
97 | } | |
98 | ||
be67fdd0 | 99 | /** |
100 | * aim_conn_kill - Close and free a connection. | |
101 | * @sess: Session for the connection | |
102 | * @deadconn: Connection to be freed | |
103 | * | |
646c6b52 | 104 | * Close, clear, and free a connection structure. Should never be |
105 | * called from within libfaim. | |
be67fdd0 | 106 | * |
107 | */ | |
78b3fb13 | 108 | faim_export void aim_conn_kill(struct aim_session_t *sess, struct aim_conn_t **deadconn) |
040457cc | 109 | { |
110 | struct aim_conn_t *cur; | |
111 | ||
112 | if (!deadconn || !*deadconn) | |
113 | return; | |
114 | ||
9e8c4225 | 115 | aim_tx_cleanqueue(sess, *deadconn); |
116 | ||
040457cc | 117 | faim_mutex_lock(&sess->connlistlock); |
118 | if (sess->connlist == NULL) | |
119 | ; | |
120 | else if (sess->connlist->next == NULL) { | |
121 | if (sess->connlist == *deadconn) | |
122 | sess->connlist = NULL; | |
123 | } else { | |
124 | cur = sess->connlist; | |
125 | while (cur->next) { | |
126 | if (cur->next == *deadconn) { | |
127 | cur->next = cur->next->next; | |
128 | break; | |
129 | } | |
130 | cur = cur->next; | |
131 | } | |
132 | } | |
133 | faim_mutex_unlock(&sess->connlistlock); | |
134 | ||
68ac63c2 | 135 | /* XXX: do we need this for txqueue too? */ |
136 | aim_rxqueue_cleanbyconn(sess, *deadconn); | |
137 | ||
9d2a3582 | 138 | if ((*deadconn)->fd != -1) |
139 | aim_conn_close(*deadconn); | |
f8ac5020 | 140 | if ((*deadconn)->priv) |
141 | free((*deadconn)->priv); | |
040457cc | 142 | free(*deadconn); |
143 | deadconn = NULL; | |
144 | ||
145 | return; | |
9de3ca7e | 146 | } |
147 | ||
be67fdd0 | 148 | /** |
149 | * aim_conn_close - Close a connection | |
150 | * @deadconn: Connection to close | |
151 | * | |
152 | * Close (but not free) a connection. | |
153 | * | |
9d2a3582 | 154 | * This leaves everything untouched except for clearing the |
155 | * handler list and setting the fd to -1 (used to recognize | |
156 | * dead connections). | |
157 | * | |
be67fdd0 | 158 | */ |
78b3fb13 | 159 | faim_export void aim_conn_close(struct aim_conn_t *deadconn) |
9de3ca7e | 160 | { |
4d7c1bfb | 161 | |
162 | faim_mutex_destroy(&deadconn->active); | |
163 | faim_mutex_destroy(&deadconn->seqnum_lock); | |
9de3ca7e | 164 | if (deadconn->fd >= 3) |
165 | close(deadconn->fd); | |
9d2a3582 | 166 | deadconn->fd = -1; |
0252e8c0 | 167 | if (deadconn->handlerlist) |
168 | aim_clearhandlers(deadconn); | |
3369f8d4 | 169 | |
4d7c1bfb | 170 | return; |
9de3ca7e | 171 | } |
172 | ||
be67fdd0 | 173 | /** |
174 | * aim_getconn_type - Find a connection of a specific type | |
175 | * @sess: Session to search | |
176 | * @type: Type of connection to look for | |
177 | * | |
178 | * Searches for a connection of the specified type in the | |
179 | * specified session. Returns the first connection of that | |
180 | * type found. | |
181 | * | |
182 | */ | |
37ee990e | 183 | faim_export struct aim_conn_t *aim_getconn_type(struct aim_session_t *sess, |
184 | int type) | |
9de3ca7e | 185 | { |
040457cc | 186 | struct aim_conn_t *cur; |
187 | ||
188 | faim_mutex_lock(&sess->connlistlock); | |
189 | for (cur = sess->connlist; cur; cur = cur->next) { | |
22517493 | 190 | if ((cur->type == type) && !(cur->status & AIM_CONN_STATUS_INPROGRESS)) |
040457cc | 191 | break; |
192 | } | |
193 | faim_mutex_unlock(&sess->connlistlock); | |
5f47d4a9 | 194 | |
195 | return cur; | |
196 | } | |
197 | ||
198 | faim_export struct aim_conn_t *aim_getconn_type_all(struct aim_session_t *sess, | |
199 | int type) | |
200 | { | |
201 | struct aim_conn_t *cur; | |
202 | ||
203 | faim_mutex_lock(&sess->connlistlock); | |
204 | for (cur = sess->connlist; cur; cur = cur->next) { | |
205 | if (cur->type == type) | |
206 | break; | |
207 | } | |
208 | faim_mutex_unlock(&sess->connlistlock); | |
209 | ||
210 | return cur; | |
211 | } | |
212 | ||
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, | |
215 | int fd) | |
216 | { | |
217 | struct aim_conn_t *cur; | |
218 | ||
219 | faim_mutex_lock(&sess->connlistlock); | |
220 | for (cur = sess->connlist; cur; cur = cur->next) { | |
221 | if (cur->fd == fd) | |
222 | break; | |
223 | } | |
224 | faim_mutex_unlock(&sess->connlistlock); | |
225 | ||
040457cc | 226 | return cur; |
9de3ca7e | 227 | } |
228 | ||
be67fdd0 | 229 | /** |
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 | |
235 | * | |
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. | |
239 | * | |
bb0dc593 | 240 | */ |
241 | static int aim_proxyconnect(struct aim_session_t *sess, | |
242 | char *host, unsigned short port, | |
243 | int *statusret) | |
244 | { | |
245 | int fd = -1; | |
246 | ||
247 | if (strlen(sess->socksproxy.server)) { /* connecting via proxy */ | |
248 | int i; | |
249 | unsigned char buf[512]; | |
250 | struct sockaddr_in sa; | |
251 | struct hostent *hp; | |
252 | char *proxy; | |
253 | unsigned short proxyport = 1080; | |
254 | ||
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])); | |
258 | break; | |
259 | } | |
260 | } | |
261 | proxy = (char *)malloc(i+1); | |
262 | strncpy(proxy, sess->socksproxy.server, i); | |
263 | proxy[i] = '\0'; | |
264 | ||
265 | if (!(hp = gethostbyname(proxy))) { | |
646c6b52 | 266 | faimdprintf(sess, 0, "proxyconnect: unable to resolve proxy name\n"); |
bb0dc593 | 267 | *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR); |
268 | return -1; | |
269 | } | |
270 | free(proxy); | |
271 | ||
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; | |
276 | ||
277 | fd = socket(hp->h_addrtype, SOCK_STREAM, 0); | |
278 | if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) { | |
646c6b52 | 279 | faimdprintf(sess, 0, "proxyconnect: unable to connect to proxy\n"); |
bb0dc593 | 280 | close(fd); |
281 | return -1; | |
282 | } | |
283 | ||
284 | i = 0; | |
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 */ | |
290 | i = 4; | |
291 | } else { | |
292 | buf[1] = 0x01; | |
293 | buf[2] = 0x00; | |
294 | i = 3; | |
295 | } | |
296 | ||
297 | if (write(fd, buf, i) < i) { | |
298 | *statusret = errno; | |
299 | close(fd); | |
300 | return -1; | |
301 | } | |
302 | ||
303 | if (read(fd, buf, 2) < 2) { | |
304 | *statusret = errno; | |
305 | close(fd); | |
306 | return -1; | |
307 | } | |
308 | ||
309 | if ((buf[0] != 0x05) || (buf[1] == 0xff)) { | |
310 | *statusret = EINVAL; | |
311 | close(fd); | |
312 | return -1; | |
313 | } | |
314 | ||
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) { | |
323 | *statusret = errno; | |
324 | close(fd); | |
325 | return -1; | |
326 | } | |
327 | if (read(fd, buf, 2) < 2) { | |
328 | *statusret = errno; | |
329 | close(fd); | |
330 | return -1; | |
331 | } | |
332 | if ((buf[0] != 0x01) || (buf[1] != 0x00)) { | |
333 | *statusret = EINVAL; | |
334 | close(fd); | |
335 | return -1; | |
336 | } | |
337 | } | |
338 | ||
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); | |
346 | ||
347 | if (write(fd, buf, i) < i) { | |
348 | *statusret = errno; | |
349 | close(fd); | |
350 | return -1; | |
351 | } | |
352 | if (read(fd, buf, 10) < 10) { | |
353 | *statusret = errno; | |
354 | close(fd); | |
355 | return -1; | |
356 | } | |
357 | if ((buf[0] != 0x05) || (buf[1] != 0x00)) { | |
358 | *statusret = EINVAL; | |
359 | close(fd); | |
360 | return -1; | |
361 | } | |
362 | ||
363 | } else { /* connecting directly */ | |
364 | struct sockaddr_in sa; | |
365 | struct hostent *hp; | |
366 | ||
367 | if (!(hp = gethostbyname(host))) { | |
368 | *statusret = (h_errno | AIM_CONN_STATUS_RESOLVERR); | |
369 | return -1; | |
370 | } | |
371 | ||
22517493 | 372 | memset(&sa, 0, sizeof(struct sockaddr_in)); |
bb0dc593 | 373 | sa.sin_port = htons(port); |
374 | memcpy(&sa.sin_addr, hp->h_addr, hp->h_length); | |
375 | sa.sin_family = hp->h_addrtype; | |
376 | ||
377 | fd = socket(hp->h_addrtype, SOCK_STREAM, 0); | |
22517493 | 378 | |
379 | if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT) | |
380 | fcntl(fd, F_SETFL, O_NONBLOCK); /* XXX save flags */ | |
381 | ||
bb0dc593 | 382 | if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) { |
22517493 | 383 | if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT) { |
384 | if ((errno == EINPROGRESS) || (errno == EINTR)) { | |
385 | if (statusret) | |
386 | *statusret |= AIM_CONN_STATUS_INPROGRESS; | |
387 | return fd; | |
388 | } | |
389 | } | |
bb0dc593 | 390 | close(fd); |
391 | fd = -1; | |
392 | } | |
393 | } | |
394 | return fd; | |
395 | } | |
396 | ||
646c6b52 | 397 | /** |
398 | * aim_cloneconn - clone an aim_conn_t | |
399 | * @sess: session containing parent | |
400 | * @src: connection to clone | |
401 | * | |
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. | |
406 | * | |
407 | * This function returns a pointer to the new aim_conn_t, or %NULL on | |
408 | * error | |
409 | */ | |
37ee990e | 410 | faim_internal struct aim_conn_t *aim_cloneconn(struct aim_session_t *sess, |
411 | struct aim_conn_t *src) | |
412 | { | |
413 | struct aim_conn_t *conn; | |
414 | struct aim_rxcblist_t *cur; | |
415 | ||
416 | if (!(conn = aim_conn_getnext(sess))) | |
417 | return NULL; | |
37ee990e | 418 | |
419 | faim_mutex_lock(&conn->active); | |
420 | ||
421 | conn->fd = src->fd; | |
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; | |
5f47d4a9 | 428 | conn->sessv = src->sessv; |
37ee990e | 429 | |
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); | |
434 | } | |
435 | ||
436 | faim_mutex_unlock(&conn->active); | |
437 | ||
438 | return conn; | |
439 | } | |
440 | ||
be67fdd0 | 441 | /** |
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) | |
9de3ca7e | 446 | * |
be67fdd0 | 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 | |
450 | * is made. | |
9de3ca7e | 451 | * |
9de3ca7e | 452 | * FIXME: Return errors in a more sane way. |
453 | * | |
454 | */ | |
78b3fb13 | 455 | faim_export struct aim_conn_t *aim_newconn(struct aim_session_t *sess, |
456 | int type, char *dest) | |
9de3ca7e | 457 | { |
458 | struct aim_conn_t *connstruct; | |
459 | int ret; | |
9de3ca7e | 460 | u_short port = FAIM_LOGIN_PORT; |
a25832e6 | 461 | char *host = NULL; |
9de3ca7e | 462 | int i=0; |
040457cc | 463 | |
e6b05d80 | 464 | if ((connstruct=aim_conn_getnext(sess))==NULL) |
9de3ca7e | 465 | return NULL; |
466 | ||
040457cc | 467 | faim_mutex_lock(&connstruct->active); |
5f47d4a9 | 468 | |
469 | connstruct->sessv = (void *)sess; | |
9de3ca7e | 470 | connstruct->type = type; |
471 | ||
e6b05d80 | 472 | if (!dest) { /* just allocate a struct */ |
473 | connstruct->fd = -1; | |
474 | connstruct->status = 0; | |
040457cc | 475 | faim_mutex_unlock(&connstruct->active); |
e6b05d80 | 476 | return connstruct; |
477 | } | |
478 | ||
9de3ca7e | 479 | /* |
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. | |
483 | * | |
484 | * We put this here to catch every case. | |
485 | * | |
486 | */ | |
487 | ||
5ac21963 | 488 | for(i=0;i<(int)strlen(dest);i++) { |
e88ba395 | 489 | if (dest[i] == ':') { |
490 | port = atoi(&(dest[i+1])); | |
491 | break; | |
9de3ca7e | 492 | } |
e88ba395 | 493 | } |
a25832e6 | 494 | host = (char *)malloc(i+1); |
495 | strncpy(host, dest, i); | |
9ba272ca | 496 | host[i] = '\0'; |
497 | ||
bb0dc593 | 498 | if ((ret = aim_proxyconnect(sess, host, port, &connstruct->status)) < 0) { |
e88ba395 | 499 | connstruct->fd = -1; |
500 | connstruct->status = (errno | AIM_CONN_STATUS_CONNERR); | |
bb0dc593 | 501 | free(host); |
040457cc | 502 | faim_mutex_unlock(&connstruct->active); |
e88ba395 | 503 | return connstruct; |
bb0dc593 | 504 | } else |
505 | connstruct->fd = ret; | |
a25832e6 | 506 | |
040457cc | 507 | faim_mutex_unlock(&connstruct->active); |
508 | ||
bb0dc593 | 509 | free(host); |
510 | ||
9de3ca7e | 511 | return connstruct; |
512 | } | |
513 | ||
be67fdd0 | 514 | /** |
515 | * aim_conngetmaxfd - Return the highest valued file discriptor in session | |
516 | * @sess: Session to search | |
517 | * | |
518 | * Returns the highest valued filed descriptor of all open | |
519 | * connections in @sess. | |
520 | * | |
521 | */ | |
78b3fb13 | 522 | faim_export int aim_conngetmaxfd(struct aim_session_t *sess) |
9de3ca7e | 523 | { |
040457cc | 524 | int j = 0; |
525 | struct aim_conn_t *cur; | |
526 | ||
527 | faim_mutex_lock(&sess->connlistlock); | |
528 | for (cur = sess->connlist; cur; cur = cur->next) { | |
529 | if (cur->fd > j) | |
530 | j = cur->fd; | |
531 | } | |
532 | faim_mutex_unlock(&sess->connlistlock); | |
e88ba395 | 533 | |
9de3ca7e | 534 | return j; |
535 | } | |
536 | ||
be67fdd0 | 537 | /** |
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 | |
541 | * | |
542 | * Searches @sess for the passed connection. Returns 1 if its present, | |
543 | * zero otherwise. | |
544 | * | |
545 | */ | |
3b101546 | 546 | faim_export int aim_conn_in_sess(struct aim_session_t *sess, struct aim_conn_t *conn) |
547 | { | |
548 | struct aim_conn_t *cur; | |
549 | ||
550 | faim_mutex_lock(&sess->connlistlock); | |
551 | for(cur = sess->connlist; cur; cur = cur->next) | |
552 | if(cur == conn) { | |
553 | faim_mutex_unlock(&sess->connlistlock); | |
554 | return 1; | |
555 | } | |
556 | faim_mutex_unlock(&sess->connlistlock); | |
557 | return 0; | |
558 | } | |
559 | ||
be67fdd0 | 560 | /** |
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 | |
9de3ca7e | 565 | * |
566 | * Waits for a socket with data or for timeout, whichever comes first. | |
646c6b52 | 567 | * See select(2). |
9de3ca7e | 568 | * |
b8d0da45 | 569 | * Return codes in *status: |
be67fdd0 | 570 | * -1 error in select() (%NULL returned) |
571 | * 0 no events pending (%NULL returned) | |
572 | * 1 outgoing data pending (%NULL returned) | |
b8d0da45 | 573 | * 2 incoming data pending (connection with pending data returned) |
574 | * | |
040457cc | 575 | * XXX: we could probably stand to do a little courser locking here. |
576 | * | |
9de3ca7e | 577 | */ |
78b3fb13 | 578 | faim_export struct aim_conn_t *aim_select(struct aim_session_t *sess, |
9e8c4225 | 579 | struct timeval *timeout, |
580 | int *status) | |
9de3ca7e | 581 | { |
040457cc | 582 | struct aim_conn_t *cur; |
22517493 | 583 | fd_set fds, wfds; |
040457cc | 584 | int maxfd = 0; |
22517493 | 585 | int i, haveconnecting = 0; |
9de3ca7e | 586 | |
040457cc | 587 | faim_mutex_lock(&sess->connlistlock); |
588 | if (sess->connlist == NULL) { | |
589 | faim_mutex_unlock(&sess->connlistlock); | |
68ac63c2 | 590 | *status = -1; |
591 | return NULL; | |
040457cc | 592 | } |
593 | faim_mutex_unlock(&sess->connlistlock); | |
f1a5efe0 | 594 | |
9de3ca7e | 595 | FD_ZERO(&fds); |
22517493 | 596 | FD_ZERO(&wfds); |
040457cc | 597 | maxfd = 0; |
598 | ||
599 | faim_mutex_lock(&sess->connlistlock); | |
600 | for (cur = sess->connlist; cur; cur = cur->next) { | |
9d2a3582 | 601 | if (cur->fd == -1) { |
602 | /* don't let invalid/dead connections sit around */ | |
603 | *status = 2; | |
604 | faim_mutex_unlock(&sess->connlistlock); | |
605 | return cur; | |
606 | } else if (cur->status & AIM_CONN_STATUS_INPROGRESS) { | |
22517493 | 607 | FD_SET(cur->fd, &wfds); |
9e8c4225 | 608 | |
22517493 | 609 | haveconnecting++; |
610 | } | |
040457cc | 611 | FD_SET(cur->fd, &fds); |
612 | if (cur->fd > maxfd) | |
613 | maxfd = cur->fd; | |
614 | } | |
615 | faim_mutex_unlock(&sess->connlistlock); | |
616 | ||
22517493 | 617 | /* |
618 | * If we have data waiting to be sent, return | |
619 | * | |
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 | |
626 | * sockets. Evil. | |
627 | * | |
628 | * But its still better than having blocking connects. | |
629 | * | |
630 | */ | |
631 | if (!haveconnecting && (sess->queue_outgoing != NULL)) { | |
632 | *status = 1; | |
633 | return NULL; | |
634 | } | |
635 | ||
636 | if ((i = select(maxfd+1, &fds, &wfds, NULL, timeout))>=1) { | |
040457cc | 637 | faim_mutex_lock(&sess->connlistlock); |
638 | for (cur = sess->connlist; cur; cur = cur->next) { | |
22517493 | 639 | if ((FD_ISSET(cur->fd, &fds)) || |
640 | ((cur->status & AIM_CONN_STATUS_INPROGRESS) && | |
641 | FD_ISSET(cur->fd, &wfds))) { | |
040457cc | 642 | *status = 2; |
643 | faim_mutex_unlock(&sess->connlistlock); | |
22517493 | 644 | return cur; /* XXX race condition here -- shouldnt unlock connlist */ |
040457cc | 645 | } |
646 | } | |
9797852c | 647 | *status = 0; /* shouldn't happen */ |
648 | } else if ((i == -1) && (errno == EINTR)) /* treat interrupts as a timeout */ | |
649 | *status = 0; | |
650 | else | |
651 | *status = i; /* can be 0 or -1 */ | |
b8d0da45 | 652 | |
040457cc | 653 | faim_mutex_unlock(&sess->connlistlock); |
646c6b52 | 654 | |
b8d0da45 | 655 | return NULL; /* no waiting or error, return */ |
9de3ca7e | 656 | } |
657 | ||
be67fdd0 | 658 | /** |
659 | * aim_conn_isready - Test if a connection is marked ready | |
660 | * @conn: Connection to test | |
661 | * | |
662 | * Returns true if the connection is ready, false otherwise. | |
663 | * Returns -1 if the connection is invalid. | |
664 | * | |
665 | * XXX: This is deprecated. | |
666 | * | |
667 | */ | |
78b3fb13 | 668 | faim_export int aim_conn_isready(struct aim_conn_t *conn) |
9de3ca7e | 669 | { |
670 | if (conn) | |
671 | return (conn->status & 0x0001); | |
040457cc | 672 | return -1; |
9de3ca7e | 673 | } |
674 | ||
be67fdd0 | 675 | /** |
676 | * aim_conn_setstatus - Set the status of a connection | |
677 | * @conn: Connection | |
678 | * @status: New status | |
679 | * | |
680 | * @newstatus is %XOR'd with the previous value of the connection | |
681 | * status and returned. Returns -1 if the connection is invalid. | |
682 | * | |
22517493 | 683 | * This isn't real useful. |
684 | * | |
be67fdd0 | 685 | */ |
78b3fb13 | 686 | faim_export int aim_conn_setstatus(struct aim_conn_t *conn, int status) |
9de3ca7e | 687 | { |
040457cc | 688 | int val; |
689 | ||
690 | if (!conn) | |
9de3ca7e | 691 | return -1; |
040457cc | 692 | |
693 | faim_mutex_lock(&conn->active); | |
694 | val = conn->status ^= status; | |
695 | faim_mutex_unlock(&conn->active); | |
646c6b52 | 696 | |
040457cc | 697 | return val; |
9de3ca7e | 698 | } |
699 | ||
be67fdd0 | 700 | /** |
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 | |
704 | * | |
705 | * Causes @newval seconds to be spent between transmits on a connection. | |
706 | * | |
707 | * This is my lame attempt at overcoming not understanding the rate | |
708 | * limiting. | |
709 | * | |
710 | * XXX: This should really be replaced with something that scales and | |
711 | * backs off like the real rate limiting does. | |
712 | * | |
713 | */ | |
78b3fb13 | 714 | faim_export int aim_conn_setlatency(struct aim_conn_t *conn, int newval) |
9de3ca7e | 715 | { |
716 | if (!conn) | |
717 | return -1; | |
040457cc | 718 | |
719 | faim_mutex_lock(&conn->active); | |
9de3ca7e | 720 | conn->forcedlatency = newval; |
721 | conn->lastactivity = 0; /* reset this just to make sure */ | |
040457cc | 722 | faim_mutex_unlock(&conn->active); |
9de3ca7e | 723 | |
724 | return 0; | |
725 | } | |
a25832e6 | 726 | |
be67fdd0 | 727 | /** |
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 | |
733 | * | |
bb0dc593 | 734 | * Call this with your SOCKS5 proxy server parameters before |
be67fdd0 | 735 | * the first call to aim_newconn(). If called with all %NULL |
bb0dc593 | 736 | * args, it will clear out a previously set proxy. |
737 | * | |
be67fdd0 | 738 | * Set username and password to %NULL if not applicable. |
bb0dc593 | 739 | * |
740 | */ | |
741 | faim_export void aim_setupproxy(struct aim_session_t *sess, char *server, char *username, char *password) | |
742 | { | |
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)); | |
748 | return; | |
749 | } | |
750 | ||
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)); | |
756 | return; | |
757 | } | |
758 | ||
9f1a4013 | 759 | static void defaultdebugcb(struct aim_session_t *sess, int level, const char *format, va_list va) |
760 | { | |
761 | vfprintf(stderr, format, va); | |
762 | } | |
763 | ||
be67fdd0 | 764 | /** |
765 | * aim_session_init - Initializes a session structure | |
766 | * @sess: Session to initialize | |
22517493 | 767 | * @flags: Flags to use. Any of %AIM_SESS_FLAGS %OR'd together. |
646c6b52 | 768 | * @debuglevel: Level of debugging output (zero is least) |
be67fdd0 | 769 | * |
770 | * Sets up the initial values for a session. | |
771 | * | |
772 | */ | |
646c6b52 | 773 | faim_export void aim_session_init(struct aim_session_t *sess, unsigned long flags, int debuglevel) |
a25832e6 | 774 | { |
a25832e6 | 775 | if (!sess) |
776 | return; | |
777 | ||
040457cc | 778 | memset(sess, 0, sizeof(struct aim_session_t)); |
e88ba395 | 779 | aim_connrst(sess); |
a25832e6 | 780 | sess->queue_outgoing = NULL; |
781 | sess->queue_incoming = NULL; | |
0c20631f | 782 | sess->pendingjoin = NULL; |
9f20a4e3 | 783 | sess->pendingjoinexchange = 0; |
b13c9e13 | 784 | aim_initsnachash(sess); |
9f20a4e3 | 785 | sess->msgcookies = NULL; |
a25832e6 | 786 | sess->snac_nextid = 0x00000001; |
22517493 | 787 | |
788 | sess->flags = 0; | |
e80a0fa9 | 789 | sess->debug = debuglevel; |
9f1a4013 | 790 | sess->debugcb = defaultdebugcb; |
791 | ||
792 | sess->modlistv = NULL; | |
22517493 | 793 | |
794 | /* | |
795 | * Default to SNAC login unless XORLOGIN is explicitly set. | |
796 | */ | |
797 | if (!(flags & AIM_SESS_FLAGS_XORLOGIN)) | |
798 | sess->flags |= AIM_SESS_FLAGS_SNACLOGIN; | |
799 | sess->flags |= flags; | |
a25832e6 | 800 | |
e88ba395 | 801 | /* |
802 | * This must always be set. Default to the queue-based | |
803 | * version for back-compatibility. | |
804 | */ | |
b8c79ca7 | 805 | aim_tx_setenqueue(sess, AIM_TX_QUEUED, NULL); |
e88ba395 | 806 | |
9f1a4013 | 807 | |
808 | /* | |
809 | * Register all the modules for this session... | |
810 | */ | |
00ef5271 | 811 | aim__registermodule(sess, misc_modfirst); /* load the catch-all first */ |
9f1a4013 | 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); | |
00ef5271 | 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); | |
9f1a4013 | 823 | |
824 | return; | |
825 | } | |
826 | ||
827 | /** | |
828 | * aim_session_kill - Deallocate a session | |
829 | * @sess: Session to kill | |
830 | * | |
831 | * | |
832 | */ | |
833 | faim_export void aim_session_kill(struct aim_session_t *sess) | |
834 | { | |
835 | ||
836 | aim_logoff(sess); | |
837 | ||
838 | aim__shutdownmodules(sess); | |
839 | ||
a25832e6 | 840 | return; |
841 | } | |
22517493 | 842 | |
646c6b52 | 843 | /** |
844 | * aim_setdebuggingcb - Set the function to call when outputting debugging info | |
845 | * @sess: Session to change | |
846 | * @cb: Function to call | |
847 | * | |
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. | |
851 | * | |
852 | */ | |
853 | faim_export int aim_setdebuggingcb(struct aim_session_t *sess, faim_debugging_callback_t cb) | |
854 | { | |
855 | ||
856 | if (!sess) | |
857 | return -1; | |
858 | ||
859 | sess->debugcb = cb; | |
860 | ||
861 | return 0; | |
862 | } | |
863 | ||
22517493 | 864 | /** |
865 | * aim_conn_isconnecting - Determine if a connection is connecting | |
866 | * @conn: Connection to examine | |
867 | * | |
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). | |
871 | * | |
872 | */ | |
873 | faim_export int aim_conn_isconnecting(struct aim_conn_t *conn) | |
874 | { | |
875 | if (!conn) | |
876 | return 0; | |
877 | return (conn->status & AIM_CONN_STATUS_INPROGRESS)?1:0; | |
878 | } | |
879 | ||
880 | faim_export int aim_conn_completeconnect(struct aim_session_t *sess, struct aim_conn_t *conn) | |
881 | { | |
882 | fd_set fds, wfds; | |
883 | struct timeval tv; | |
884 | int res, error = ETIMEDOUT; | |
e677fc43 | 885 | aim_rxcallback_t userfunc; |
22517493 | 886 | |
887 | if (!conn || (conn->fd == -1)) | |
888 | return -1; | |
889 | ||
890 | if (!(conn->status & AIM_CONN_STATUS_INPROGRESS)) | |
891 | return -1; | |
892 | ||
893 | FD_ZERO(&fds); | |
894 | FD_SET(conn->fd, &fds); | |
895 | FD_ZERO(&wfds); | |
896 | FD_SET(conn->fd, &wfds); | |
897 | tv.tv_sec = 0; | |
898 | tv.tv_usec = 0; | |
899 | ||
900 | if ((res = select(conn->fd+1, &fds, &wfds, NULL, &tv)) == -1) { | |
901 | error = errno; | |
902 | aim_conn_close(conn); | |
903 | errno = error; | |
904 | return -1; | |
905 | } else if (res == 0) { | |
646c6b52 | 906 | faimdprintf(sess, 0, "aim_conn_completeconnect: false alarm on %d\n", conn->fd); |
22517493 | 907 | return 0; /* hasn't really completed yet... */ |
908 | } | |
909 | ||
910 | if (FD_ISSET(conn->fd, &fds) || FD_ISSET(conn->fd, &wfds)) { | |
911 | int len = sizeof(error); | |
912 | ||
913 | if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) | |
914 | error = errno; | |
915 | } | |
916 | ||
917 | if (error) { | |
918 | aim_conn_close(conn); | |
919 | errno = error; | |
920 | return -1; | |
921 | } | |
922 | ||
923 | fcntl(conn->fd, F_SETFL, 0); /* XXX should restore original flags */ | |
924 | ||
925 | conn->status &= ~AIM_CONN_STATUS_INPROGRESS; | |
926 | ||
646c6b52 | 927 | if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE))) |
22517493 | 928 | userfunc(sess, NULL, conn); |
929 | ||
930 | /* Flush out the queues if there was something waiting for this conn */ | |
931 | aim_tx_flushqueue(sess); | |
932 | ||
933 | return 0; | |
934 | } | |
dd60ff8b | 935 | |
5f47d4a9 | 936 | faim_export struct aim_session_t *aim_conn_getsess(struct aim_conn_t *conn) |
937 | { | |
938 | ||
939 | if (!conn) | |
940 | return NULL; | |
941 | ||
942 | return (struct aim_session_t *)conn->sessv; | |
943 | } | |
944 | ||
dd60ff8b | 945 | /* |
946 | * aim_logoff() | |
947 | * | |
948 | * Closes -ALL- open connections. | |
949 | * | |
950 | */ | |
951 | faim_export int aim_logoff(struct aim_session_t *sess) | |
952 | { | |
646c6b52 | 953 | |
dd60ff8b | 954 | aim_connrst(sess); /* in case we want to connect again */ |
955 | ||
956 | return 0; | |
957 | ||
958 | } | |
959 |