5 #include <sys/socket.h>
6 #include <netinet/in.h>
7 #include <sys/utsname.h> /* for aim_directim_initiate */
8 #include <arpa/inet.h> /* for inet_ntoa */
11 /* aim_msgcookies.c is mostly new. just look at the diff and replace yours, easiest. */
14 function name where i had it
15 aim_send_im_direct aim_im.c
16 aim_directim_initiate aim_im.c
17 aim_filetransfer_accept aim_im.c
18 aim_getlisting aim_misc.c (?!) -- prototype function. can be ignored.
20 aim_get_command_rendezvous aim_r
21 oft_getfh aim_rxqueue.c
24 faim_export int aim_handlerendconnect(struct aim_session_t *sess, struct aim_conn_t *cur)
27 rxcallback_t userfunc;
28 struct sockaddr cliaddr;
29 socklen_t clilen = sizeof(cliaddr);
33 * Listener sockets only have incoming connections. No data.
35 if( (acceptfd = accept(cur->fd, &cliaddr, &clilen)) == -1)
38 if (cliaddr.sa_family != AF_INET) /* just in case IPv6 really is happening */
41 switch(cur->subtype) {
42 case AIM_CONN_SUBTYPE_OFT_DIRECTIM: {
43 struct aim_directim_priv *priv;
45 priv = (struct aim_directim_priv *)calloc(1, sizeof(struct aim_directim_priv));
47 snprintf(priv->ip, sizeof(priv->ip), "%s:%u", inet_ntoa(((struct sockaddr_in *)&cliaddr)->sin_addr), ntohs(((struct sockaddr_in *)&cliaddr)->sin_port));
50 cur->priv = priv; /* what happens if there is one?! -- mid */
52 cur->type = AIM_CONN_TYPE_RENDEZVOUS;
53 close(cur->fd); /* should we really do this? seems like the client should decide. maybe clone the connection and keep the listener open. -- mid */
56 if ( (userfunc = aim_callhandler(cur, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINITIATE)))
57 ret = userfunc(sess, NULL, cur);
61 case AIM_CONN_SUBTYPE_OFT_GETFILE: {
62 struct aim_filetransfer_priv *priv;
64 priv = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv));
66 snprintf(priv->ip, sizeof(priv->ip), "%s:%u", inet_ntoa(((struct sockaddr_in *)&cliaddr)->sin_addr), ntohs(((struct sockaddr_in *)&cliaddr)->sin_port));
71 if ( (userfunc = aim_callhandler(cur, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEINITIATE)))
72 ret = userfunc(sess, NULL, cur);
86 * conn - directim connection
87 * msg - null-terminated string to send
90 faim_export int aim_send_im_direct(struct aim_session_t *sess,
91 struct aim_conn_t *conn,
94 struct command_tx_struct *newpacket , *newpacket2;
96 /* newpacket contains a real header with data, newpacket2 is just a
97 null packet, with a cookie and a lot of 0x00s. newpacket is the
98 "i'm sending", newpacket2 is the "i'm typing".*/
100 /* uhm. the client should send those as two seperate things -- mid */
102 struct aim_directim_priv *priv = NULL;
105 if (!sess || !conn || !(conn->type) || (conn->type != AIM_CONN_TYPE_RENDEZVOUS) || !conn->priv || !msg) {
106 printf("faim: directim: invalid arguments\n");
110 if (strlen(msg) >= MAXMSGLEN)
113 priv = (struct aim_directim_priv *)conn->priv;
117 if (!(newpacket2 = aim_tx_new(AIM_FRAMETYPE_OFT, 0x0001, conn, 0))) {
118 printf("faim: directim: tx_new2 failed\n");
122 newpacket2->lock = 1; /* lock struct */
124 memcpy(newpacket2->hdr.oft.magic, "ODC2", 4);
125 newpacket2->hdr.oft.hdr2len = 0x44;
127 if (!(newpacket2->hdr.oft.hdr2 = calloc(1,newpacket2->hdr.oft.hdr2len))) {
133 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0006);
134 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
136 i += aimutil_putstr(newpacket2->hdr.oft.hdr2+i, (char *)priv->cookie, 8);
138 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
139 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
140 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
141 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
143 i += aimutil_put32(newpacket2->hdr.oft.hdr2+i, 0x00000000);
145 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
146 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
147 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
149 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x000e);
151 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
152 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
154 i += aimutil_putstr(newpacket2->hdr.oft.hdr2+i, sess->sn, strlen(sess->sn));
157 i += aimutil_put8(newpacket2->hdr.oft.hdr2+i, 0x00); /* 53 */
158 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000); /* 55 */
159 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
160 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
161 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);/* 61 */
162 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);
163 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);/* 65 */
164 i += aimutil_put16(newpacket2->hdr.oft.hdr2+i, 0x0000);/* end of hdr2 */
166 newpacket2->lock = 0;
167 newpacket2->data = NULL;
169 aim_tx_enqueue(sess, newpacket2);
173 if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OFT, 0x0001, conn, strlen(msg)))) {
174 printf("faim: directim: tx_new failed\n");
178 newpacket->lock = 1; /* lock struct */
180 memcpy(newpacket->hdr.oft.magic, "ODC2", 4);
181 newpacket->hdr.oft.hdr2len = 0x54;
183 if (!(newpacket->hdr.oft.hdr2 = calloc(1,newpacket->hdr.oft.hdr2len))) {
189 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0006);
190 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
192 i += aimutil_putstr(newpacket->hdr.oft.hdr2+i, (char *)priv->cookie, 8);
194 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
195 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
196 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
197 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
199 i += aimutil_put32(newpacket->hdr.oft.hdr2+i, strlen(msg));
201 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
202 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
203 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
204 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
205 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
206 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
208 i += aimutil_putstr(newpacket->hdr.oft.hdr2+i, sess->sn, strlen(sess->sn));
211 i += aimutil_put8(newpacket->hdr.oft.hdr2+i, 0x00); /* 53 */
212 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000); /* 55 */
213 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
214 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
215 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);/* 61 */
216 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);
217 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);/* 65 */
218 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);/* end of hdr2 */
220 /* values grabbed from a dump */
221 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0008); /* 69 */
222 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x000c);
223 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0000);/* 71 */
224 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x1466);/* 73 */
225 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x0001);/* 73 */
226 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x2e0f);
227 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0x393e);
228 i += aimutil_put16(newpacket->hdr.oft.hdr2+i, 0xcac8);
230 memcpy(newpacket->data, msg, strlen(msg));
234 aim_tx_enqueue(sess, newpacket);
240 * aim_directim_intitiate:
241 * For those times when we want to open up the directim channel ourselves.
242 * sess is your session,
243 * conn is the BOS conn,
244 * priv is a dummy priv value (we'll let it get filled in later) (if
245 * you pass a NULL, we alloc one)
246 * destsn is the SN to connect to.
250 faim_export struct aim_conn_t *aim_directim_initiate(struct aim_session_t *sess,
251 struct aim_conn_t *conn,
252 struct aim_directim_priv *priv,
255 struct command_tx_struct *newpacket;
256 struct aim_conn_t *newconn;
258 struct aim_msgcookie_t *cookie;
260 int curbyte, i, listenfd;
263 struct hostent *hptr;
266 unsigned char cap[16];
267 char d[4]; /* XXX: IPv6. *cough* */
273 if( (listenfd = aim_listenestablish(port)) == -1)
280 if(gethostname(localhost, 128) < 0)
283 if( (hptr = gethostbyname(localhost)) == NULL)
286 memcpy(&d, hptr->h_addr_list[0], 4); /* XXX: this probably isn't quite kosher, but it works */
288 aim_putcap(cap, 16, AIM_CAPS_IMIMAGE);
291 * create the OSCAR packet
294 if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+8+2+1+strlen(destsn)+4+4+0x32)))
297 newpacket->lock = 1; /* lock struct */
300 curbyte += aim_putsnac(newpacket->data+curbyte,
301 0x0004, 0x0006, 0x0000, sess->snac_nextid);
304 * Generate a random message cookie
305 * This cookie needs to be alphanumeric and NULL-terminated to be TOC-compatible.
308 curbyte += aimutil_put8(newpacket->data+curbyte, 0x30 + ((u_char) rand() % 20));
309 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
312 * grab all the data for cookie caching.
314 cookie = (struct aim_msgcookie_t *)calloc(1, sizeof(struct aim_msgcookie_t));
316 memcpy(cookie->cookie, newpacket->data+curbyte-8, 8);
317 cookie->type = AIM_COOKIETYPE_OFTIM;
320 priv = (struct aim_directim_priv *)calloc(1, sizeof(struct aim_directim_priv));
322 memcpy(priv->cookie, cookie, 8);
323 memcpy(priv->sn, destsn, sizeof(priv->sn));
327 aim_cachecookie(sess, cookie); /* cache da cookie */
332 curbyte += aimutil_put16(newpacket->data+curbyte,0x0002);
335 * Destination SN (prepended with byte length)
337 curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
338 curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
340 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0003);
341 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
346 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
347 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0032);
350 * Flag data / ICBM Parameters?
352 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
353 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
358 curbyte += aimutil_putstr(newpacket->data+curbyte, (char *)cookie, 8);
363 curbyte += aimutil_putstr(newpacket->data+curbyte, (char *)cap, 0x10);
368 curbyte += aimutil_put16(newpacket->data+curbyte, 0x000a);
369 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
370 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
373 * 0003/0004: IP address
376 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0003);
377 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0004);
379 for(i = 0; i < 4; i++)
380 curbyte += aimutil_put8(newpacket->data+curbyte, d[i]); /* already in network byte order */
386 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
387 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
388 curbyte += aimutil_put16(newpacket->data+curbyte, port);
391 * 000f/0000: umm.. dunno. Zigamorph[1]?
392 * [1]: see esr's TNHD.
395 curbyte += aimutil_put16(newpacket->data+curbyte, 0x000f);
396 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
398 printf("curbyte: 0x%x\n",curbyte);
400 newpacket->commandlen = curbyte;
403 aim_tx_enqueue(sess, newpacket);
406 * allocate and set up our connection
409 newconn = aim_newconn(sess, AIM_CONN_TYPE_RENDEZVOUS_OUT, NULL);
411 perror("aim_newconn");
412 aim_conn_kill(sess, &newconn);
416 newconn->fd = listenfd;
417 newconn->subtype = AIM_CONN_SUBTYPE_OFT_DIRECTIM;
418 newconn->priv = priv;
419 printf("faim: listening (fd = %d, unconnected)\n", newconn->fd);
422 * XXX We need some way of closing the listener socket after
423 * n seconds of no connection. -- mid
430 * struct aim_conn_t *aim_directim_connect(struct aim_session_t *sess, struct aim_conn_t *conn, struct aim_directim_priv *priv)
431 * sess is the session to append the conn to,
432 * conn is the BOS connection,
433 * priv is the filled-in priv data structure for the connection
434 * returns conn if connected, NULL on error
438 faim_export struct aim_conn_t *aim_directim_connect(struct aim_session_t *sess,
439 struct aim_conn_t *conn,
440 struct aim_directim_priv *priv )
442 struct aim_conn_t *newconn = NULL;;
444 newconn = aim_newconn(sess, AIM_CONN_TYPE_RENDEZVOUS, priv->ip);
445 if (!newconn || (newconn->fd == -1)) {
446 printf("could not connect to %s\n", priv->ip);
447 perror("aim_newconn");
448 aim_conn_kill(sess, &newconn);
451 newconn->subtype = AIM_CONN_SUBTYPE_OFT_DIRECTIM;
452 newconn->priv = priv;
453 printf("faim: connected to peer (fd = %d)\n", newconn->fd);
460 * struct aim_conn_t *aim_directim_getconn(struct aim_session_t *sess, const char *name)
461 * sess is your session,
462 * name is the name to get,
463 * returns conn for directim with name, NULL if none found.
466 faim_export struct aim_conn_t *aim_directim_getconn(struct aim_session_t *sess, const char *name)
468 struct aim_conn_t *cur;
469 struct aim_directim_priv *priv;
471 faim_mutex_lock(&sess->connlistlock);
472 for (cur = sess->connlist; cur; cur = cur->next) {
473 if (cur->type != AIM_CONN_TYPE_RENDEZVOUS || cur->subtype != AIM_CONN_SUBTYPE_OFT_DIRECTIM)
477 if (aim_sncmp(priv->sn, name) == 0)
480 faim_mutex_unlock(&sess->connlistlock);
486 * aim_accepttransfer:
487 * accept a file transfer request.
488 * sess is the session,
489 * conn is the BOS conn for the CAP reply
490 * sn is the screenname to send it to,
491 * cookie is the cookie used
492 * ip is the ip to connect to
493 * file is the listing file to use
499 faim_export struct aim_conn_t *aim_accepttransfer(struct aim_session_t *sess,
500 struct aim_conn_t *conn,
505 unsigned short rendid)
507 struct command_tx_struct *newpacket, *newoft;
509 struct aim_conn_t *newconn;
510 struct aim_fileheader_t *listingfh;
511 struct aim_filetransfer_priv *priv;
512 struct aim_msgcookie_t *cachedcook;
516 if(rendid == AIM_CAPS_GETFILE) {
518 newconn = aim_newconn(sess, AIM_CONN_TYPE_RENDEZVOUS, ip);
520 newconn->subtype = AIM_CONN_SUBTYPE_OFT_GETFILE;
522 if (!newconn || (newconn->fd == -1)) {
523 perror("aim_newconn");
524 faimdprintf(2, "could not connect to %s (fd: %i)\n", ip, newconn?newconn->fd:0);
525 aim_conn_kill(sess, &newconn);
528 priv = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv));
529 memcpy(priv->cookie, cookie, 8);
530 strncpy(priv->sn, sn, MAXSNLEN);
531 strncpy(priv->ip, ip, sizeof(priv->ip));
532 newconn->priv = (void *)priv;
533 faimdprintf(2, "faim: connected to peer (fd = %d)\n", newconn->fd);
536 /* cache da cookie. COOOOOKIES! */
538 if(!(cachedcook = (struct aim_msgcookie_t *)calloc(1, sizeof(struct aim_msgcookie_t)))) {
539 faimdprintf(1, "faim: accepttransfer: couldn't calloc cachedcook. yeep!\n");
540 /* XXX die here, or go on? search for cachedcook for future references */
544 memcpy(cachedcook->cookie, cookie, 8);
546 /* strncpy(ft->fh.name, miscinfo->value+8, sizeof(ft->fh.name)); */
548 if(cachedcook) { /* see above calloc of cachedcook */
549 cachedcook->type = AIM_COOKIETYPE_OFTGET;
550 cachedcook->data = (void *)priv;
552 if (aim_cachecookie(sess, cachedcook) != 0)
553 faimdprintf(1, "faim: ERROR caching message cookie\n");
556 if(rendid == AIM_CAPS_GETFILE) {
557 faimdprintf(2, "faim: getfile request accept\n");
558 if(!(newoft = aim_tx_new(AIM_FRAMETYPE_OFT, 0x1108, newconn, 0))) {
559 faimdprintf(2, "faim: aim_accepttransfer: tx_new OFT failed\n");
560 /* XXX: what else do we need to clean up here? */
566 memcpy(newoft->hdr.oft.magic, "OFT2", 4);
567 newoft->hdr.oft.hdr2len = 0xf8; /* 0x100 - 8 */
569 if(!(listingfh = aim_getlisting(file))) {
573 if (!(newoft->hdr.oft.hdr2 = (char *)calloc(1,newoft->hdr.oft.hdr2len))) {
578 memcpy(listingfh->bcookie, cookie, 8);
580 aim_oft_buildheader((void *)newoft->hdr.oft.hdr2, listingfh);
585 aim_tx_enqueue(sess, newoft);
586 printf("faim: getfile: OFT listing enqueued.\n");
590 /* OSCAR CAP accept packet */
592 if(!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+8+2+1+strlen(sn)+4+2+8+16)))
597 curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0006, 0x0000, sess->snac_nextid);
598 for (i = 0; i < 8; i++)
599 curbyte += aimutil_put8(newpacket->data+curbyte, cookie[i]);
600 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
601 curbyte += aimutil_put8(newpacket->data+curbyte, strlen(sn));
602 curbyte += aimutil_putstr(newpacket->data+curbyte, sn, strlen(sn));
603 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
604 curbyte += aimutil_put16(newpacket->data+curbyte, 0x001a);
605 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002 /* accept */);
606 for (i = 0; i < 8; i++)
607 curbyte += aimutil_put8(newpacket->data+curbyte, cookie[i]);
608 curbyte += aim_putcap(newpacket->data+curbyte, 0x10, rendid);
611 aim_tx_enqueue(sess, newpacket);
619 * aim_getlisting(FILE *file)
621 * file is an opened listing file
622 * returns a pointer to the filled-in fileheader_t
624 * currently omits checksum. we'll fix this when AOL breaks us, i
629 faim_internal struct aim_fileheader_t *aim_getlisting(FILE *file)
631 struct aim_fileheader_t *fh;
632 u_long totsize = 0, size = 0, checksum = 0xffff0000;
634 char *linebuf, sizebuf[9];
636 int linelength = 1024;
638 /* XXX: if we have a line longer than 1024chars, God help us. */
639 if( (linebuf = (char *)calloc(1, linelength)) == NULL ) {
640 faimdprintf(2, "linebuf calloc failed\n");
644 if(fseek(file, 0, SEEK_END) == -1) { /* use this for sanity check */
645 perror("getlisting END1 fseek:");
646 faimdprintf(2, "getlising fseek END1 error\n");
649 if(fgetpos(file, &size) == -1) {
650 perror("getlisting END1 getpos:");
651 faimdprintf(2, "getlising getpos END1 error\n");
654 if(fseek(file, 0, SEEK_SET) != 0) {
655 perror("getlesting fseek(SET):");
656 faimdprintf(2, "faim: getlisting: couldn't seek to beginning of listing file\n");
659 bzero(linebuf, linelength);
663 while(fgets(linebuf, linelength, file)) {
667 size += strlen(linebuf);
669 if(strlen(linebuf) < 23) {
670 faimdprintf(2, "line \"%s\" too short. skipping\n", linebuf);
673 if(linebuf[strlen(linebuf)-1] != '\n') {
674 faimdprintf(2, "faim: OFT: getlisting -- hit EOF or line too long!\n");
677 memcpy(sizebuf, linebuf+17, 8);
679 totsize += strtol(sizebuf, NULL, 10);
680 bzero(linebuf, linelength);
684 faimdprintf(2, "faim: getlisting: size != 0 after while.. %i\n", size);
687 if(fseek(file, 0, SEEK_SET) == -1) {
688 perror("getlisting END2 fseek:");
689 faimdprintf(2, "getlising fseek END2 error\n");
694 /* we're going to ignore checksumming the data for now -- that
695 * requires walking the whole listing.txt. it should probably be
696 * done at register time and cached, but, eh. */
698 if(!(fh = (struct aim_fileheader_t*)calloc(1, sizeof(struct aim_fileheader_t))))
701 printf( "faim: OFT: getlisting: totfiles: %u, totsize: %lu, size: %lu\n", totfiles, totsize, size);
703 fh->encrypt = 0x0000;
704 fh->compress = 0x0000;
705 fh->totfiles = totfiles;
706 fh->filesleft = totfiles; /* is this right ?*/
707 fh->totparts = 0x0001;
708 fh->partsleft = 0x0001;
709 fh->totsize = totsize;
710 fh->size = size; /* ls -l listing.txt */
711 fh->modtime = (int)time(NULL); /* we'll go with current time for now */
712 fh->checksum = checksum; /* XXX: checksum ! */
713 fh->rfcsum = 0x00000000;
714 fh->rfsize = 0x00000000;
715 fh->cretime = 0x00000000;
716 fh->rfcsum = 0x00000000;
717 fh->nrecvd = 0x00000000;
718 fh->recvcsum = 0x00000000;
720 /* memset(fh->idstring, 0, sizeof(fh->idstring)); */
721 memcpy(fh->idstring, "OFT_Windows ICBMFT V1.1 32", sizeof(fh->idstring));
722 memset(fh->idstring+strlen(fh->idstring), 0, sizeof(fh->idstring)-strlen(fh->idstring));
725 fh->lnameoffset = 0x1a;
726 fh->lsizeoffset = 0x10;
728 /* memset(fh->dummy, 0, sizeof(fh->dummy)); */
729 memset(fh->macfileinfo, 0, sizeof(fh->macfileinfo));
731 fh->nencode = 0x0000; /* we need to figure out these encodings for filenames */
732 fh->nlanguage = 0x0000;
734 /* memset(fh->name, 0, sizeof(fh->name)); */
735 memcpy(fh->name, "listing.txt", sizeof(fh->name));
736 memset(fh->name+strlen(fh->name), 0, 64-strlen(fh->name));
738 faimdprintf(2, "faim: OFT: listing fh name %s / %s\n", fh->name, (fh->name+(strlen(fh->name))));
743 * establish: create a listening socket on a port. you need to call
744 * accept() when it's connected.
745 * portnum is the port number to bind to.
749 faim_internal int aim_listenestablish(u_short portnum)
751 #if defined(__linux__) /* XXX what other OS's support getaddrinfo? */
754 struct addrinfo hints, *res, *ressave;
756 sprintf(serv, "%d", portnum);
757 memset(&hints, 0, sizeof(struct addrinfo));
758 hints.ai_flags = AI_PASSIVE;
759 hints.ai_family = AF_UNSPEC;
760 hints.ai_socktype = SOCK_STREAM;
761 if (getaddrinfo(NULL/*any IP*/, serv, &hints, &res) != 0) {
762 perror("getaddrinfo");
767 listenfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
770 setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
771 if (bind(listenfd, res->ai_addr, res->ai_addrlen) == 0)
774 } while ( (res = res->ai_next) );
777 if (listen(listenfd, 1024)!=0) {
781 freeaddrinfo(ressave);
786 struct sockaddr_in sockin;
788 if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
789 perror("socket(listenfd)");
792 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on) != 0)) {
793 perror("setsockopt(listenfd)");
797 memset(&sockin, 0, sizeof(struct sockaddr_in));
798 sockin.sin_family = AF_INET;
799 sockin.sin_port = htons(portnum);
800 if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) {
801 perror("bind(listenfd)");
805 if (listen(listenfd, 4) != 0) {
806 perror("listen(listenfd)");
815 faim_internal int aim_get_command_rendezvous(struct aim_session_t *sess, struct aim_conn_t *conn)
817 unsigned char hdrbuf1[6];
818 unsigned char *hdr = NULL;
821 rxcallback_t userfunc = NULL;
824 memset(hdrbuf1, 0, sizeof(hdrbuf1));
826 faim_mutex_lock(&conn->active); /* gets locked down for the entirety */
828 if ( (hdrlen = aim_recv(conn->fd, hdrbuf1, 6)) < 6) {
830 faimdprintf(2, "faim: rend: read error (fd: %i) %02x%02x%02x%02x%02x%02x (%i)\n", conn->fd, hdrbuf1[0],hdrbuf1[1],hdrbuf1[0],hdrbuf1[0],hdrbuf1[0],hdrbuf1[0],hdrlen);
831 faim_mutex_unlock(&conn->active);
835 else { /* disconnected */
836 switch(conn->subtype) {
837 case AIM_CONN_SUBTYPE_OFT_DIRECTIM: { /* XXX: clean up cookies here ? */
838 struct aim_directim_priv *priv = NULL;
839 if(!(priv = (struct aim_directim_priv *)conn->priv) )
840 return -1; /* not much we can do */
841 aim_uncachecookie(sess, priv->cookie, AIM_COOKIETYPE_OFTIM);
844 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMDISCONNECT)) ) {
845 aim_conn_close(conn);
846 return userfunc(sess, NULL, conn, priv->sn);
852 case AIM_CONN_SUBTYPE_OFT_GETFILE: {
853 struct aim_filetransfer_priv *priv;
854 if(!(priv = (struct aim_filetransfer_priv *)conn->priv))
857 aim_uncachecookie(sess, priv->cookie, AIM_COOKIETYPE_OFTGET);
859 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEDISCONNECT)) ) {
860 aim_conn_close(conn);
861 return userfunc(sess, NULL, conn, priv->sn);
867 case AIM_CONN_SUBTYPE_OFT_SENDFILE: {
868 struct aim_filetransfer_priv *priv;
869 if(!(priv = (struct aim_filetransfer_priv *)conn->priv))
872 aim_uncachecookie(sess, priv->cookie, AIM_COOKIETYPE_OFTSEND);
874 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_SENDFILEDISCONNECT)) ) {
875 aim_conn_close(conn);
876 return userfunc(sess, NULL, conn, priv->sn);
883 aim_conn_close(conn);
884 aim_conn_kill(sess, &conn);
890 hdrlen = aimutil_get16(hdrbuf1+4);
893 if (!(hdr = malloc(hdrlen))) {
894 faim_mutex_unlock(&conn->active);
898 if (aim_recv(conn->fd, hdr, hdrlen) < hdrlen) {
900 faimdprintf(2,"faim: rend: read2 error\n");
902 faim_mutex_unlock(&conn->active);
903 aim_conn_close(conn);
907 hdrtype = aimutil_get16(hdr);
910 case 0x0001: { /* directim */
911 int payloadlength = 0;
913 struct aim_directim_priv *priv;
916 priv = (struct aim_directim_priv *)calloc(1, sizeof(struct aim_directim_priv));
918 payloadlength = aimutil_get32(hdr+22);
919 flags = aimutil_get16(hdr+32);
920 snptr = (char *)hdr+38;
922 strncpy(priv->sn, snptr, MAXSNLEN);
924 faimdprintf(2, "faim: OFT frame: %04x / %04x / %04x / %s\n", hdrtype, payloadlength, flags, snptr);
926 if (flags == 0x000e) {
927 faim_mutex_unlock(&conn->active);
928 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING)) )
929 return userfunc(sess, NULL, snptr);
930 } else if ((flags == 0x0000) && payloadlength) {
933 if(! (msg = calloc(1, payloadlength+1)) ) {
934 faim_mutex_unlock(&conn->active);
938 if (aim_recv(conn->fd, msg, payloadlength) < payloadlength) {
940 printf("faim: rend: read3 error\n");
942 faim_mutex_unlock(&conn->active);
943 aim_conn_close(conn);
946 faim_mutex_unlock(&conn->active);
947 msg[payloadlength] = '\0';
948 faimdprintf(2, "faim: directim: %s/%04x/%04x/%s\n", snptr, payloadlength, flags, msg);
951 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING)) )
952 i = userfunc(sess, NULL, conn, snptr, msg);
960 /* currently experimental to a non-compiling degree */
961 case 0x1108: { /* getfile listing.txt incoming tx->rx */
962 struct aim_filetransfer_priv *ft;
963 struct aim_fileheader_t *fh;
964 struct aim_msgcookie_t *cook;
965 struct aim_conn_type *newoft;
970 faimdprintf(2,"faim: rend: fileget 0x1108\n");
972 if(!(ft = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv)))) {
973 faimdprintf(2, "faim: couldn't malloc ft. um. bad. bad bad. file transfer will likely fail, sorry.\n");
974 faim_mutex_unlock(&conn->active);
978 ft->state = 1; /* we're waaaaiiiting.. */
980 fh = aim_oft_getfh(hdr);
982 memcpy(&(ft->fh), fh, sizeof(struct aim_fileheader_t));
984 if(!(cook = aim_checkcookie(sess, ft->fh.bcookie, AIM_COOKIETYPE_OFTGET))) {
985 faim_mutex_unlock(&conn->active);
994 aim_cachecookie(sess, cook);
996 if(!(newoft = aim_tx_new(AIM_FRAMETYPE_OFT, 0x1209, conn, 0))) {
997 /* XXX: what else do we need to clean up here? */
998 faim_mutex_unlock(&conn->active);
1003 aim_oft_buildheader((void *)newoft->hdr.oft.hdr2, ft->fh); /* no change */
1005 aim_tx_enqueue(sess, newoft);
1009 case 0x1209: { /* get file listing ack rx->tx */
1010 struct aim_filetransfer_priv *ft;
1011 struct aim_fileheader_t *fh;
1012 struct aim_msgcookie_t *cook;
1017 faimdprintf(2,"faim: rend: fileget 0x1209\n");
1019 if(!(ft = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv)))) {
1020 faimdprintf(2, "faim: couldn't malloc ft. um. bad. bad bad. file transfer will likely fail, sorry.\n");
1021 faim_mutex_unlock(&conn->active);
1025 fh = aim_oft_getfh(hdr);
1027 memcpy(&(ft->fh), fh, sizeof(struct aim_fileheader_t));
1029 cook = aim_checkcookie(sess, ft->fh.bcookie, AIM_COOKIETYPE_OFTGET);
1031 /* we currently trust the other client to be giving us Valid
1032 * Enough input, else this gets to be a messy function (and we
1033 * won't break like winaim does when it gets bad input =) */
1036 free(cook->data); /* XXX */
1040 aim_cachecookie(sess, cook);
1042 /* XXX: have this send chunks of the file instead of the whole
1043 * file. requires rethinking some code. */
1045 if(fseek(sess->oft.listing, 0, SEEK_SET) != 0) {
1046 perror("get_command_rendezvous 1209 fseek(SET):");
1047 faimdprintf(2, "faim: getlisting: couldn't seek to beginning of listing file\n");
1049 commandlen = ft->fh.size;
1051 if((data = (char *)calloc(1, commandlen)) == NULL) {
1052 faimdprintf(2, "faim: get_command_rendezvous 1209: couldn't malloc data.\n");
1053 faim_mutex_unlock(&conn->active);
1058 for(commandlen = 0; commandlen < ft->fh.size; commandlen++)
1059 if( (data[commandlen] = (unsigned char)fgetc(sess->oft.listing)) == EOF)
1060 faimdprintf(2, "faim: get_command_rendezvous 1209: got early EOF (error?)\n");
1062 commandlen = ft->fh.size;
1064 if (write(conn->fd, data, commandlen) != commandlen) {
1065 perror("listing write error");
1067 faim_mutex_unlock(&conn->active);
1069 faimdprintf(2, "faim: get_command_rendezvous: hit end of 1209\n");
1075 case 0x120b: { /* get file second */
1076 struct aim_filetransfer_priv *ft;
1077 struct aim_msgcookie_t *cook;
1079 struct aim_fileheader_t *fh;
1081 faimdprintf(2, "faim: rend: fileget 120b\n");
1083 if(!(ft = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv)))) {
1084 faimdprintf(2, "faim: couldn't malloc ft. um. bad. bad bad. file transfer will likely fail, sorry.\n");
1085 faim_mutex_unlock(&conn->active);
1089 fh = aim_oft_getfh(hdr);
1091 memcpy(&(ft->fh), fh, sizeof(struct aim_fileheader_t));
1093 if(!(cook = aim_checkcookie(sess, ft->fh.bcookie, AIM_COOKIETYPE_OFTGET))) {
1094 faim_mutex_unlock(&conn->active);
1099 free(cook->data); /* XXX: integrate cookie caching */
1103 aim_cachecookie(sess, cook);
1105 faim_mutex_unlock(&conn->active);
1107 /* call listing.txt rx confirm */
1111 case 0x120c: { /* yet more get file */
1112 struct aim_filetransfer_priv *ft;
1113 struct aim_msgcookie_t *cook;
1114 struct aim_fileheader_t *listingfh;
1115 struct command_tx_struct *newoft;
1119 rxcallback_t userfunc;
1121 printf("faim: rend: fileget 120c\n");
1123 if(!(ft = (struct aim_filetransfer_priv *)calloc(1, sizeof(struct aim_filetransfer_priv)))) {
1124 printf("faim: couldn't malloc ft. um. bad. bad bad. file transfer will likely fail, sorry.\n");
1125 faim_mutex_unlock(&conn->active);
1130 printf("faim: fileget_command(120c): um. hdrlen != 0x100..\n");
1132 listingfh = aim_oft_getfh((char *)hdr);
1134 memcpy(&(ft->fh), listingfh, sizeof(struct aim_fileheader_t));
1136 if(!(cook = aim_checkcookie(sess, ft->fh.bcookie, AIM_COOKIETYPE_OFTGET))) {
1137 faim_mutex_unlock(&conn->active);
1142 free(cook->data); /* XXX */
1146 aim_cachecookie(sess, cook);
1148 faim_mutex_unlock(&conn->active);
1150 faimdprintf(2, "faim: fileget: %s seems to want %s\n", ft->sn, ft->fh.name);
1152 if( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ)) )
1153 i = userfunc(sess, NULL, conn, &ft->fh, cook->cookie);
1158 if(!(newoft = aim_tx_new(AIM_FRAMETYPE_OFT, 0x0101, conn, 0))) {
1159 faimdprintf(2, "faim: send_final_transfer: tx_new OFT failed\n");
1165 memcpy(newoft->hdr.oft.magic, "OFT2", 4);
1166 newoft->hdr.oft.hdr2len = 0xf8; /* 0x100 - 8 */
1168 if (!(newoft->hdr.oft.hdr2 = calloc(1,newoft->hdr.oft.hdr2len))) {
1170 aim_tx_destroy(newoft);
1174 /* memcpy(listingfh->bcookie, ft->fh.bcookie, 8); */
1176 listingfh->nrecvd = 0; /* these need reset for protocol-correctness */
1177 listingfh->recvcsum = 0;
1179 aim_oft_buildheader((void *)newoft->hdr.oft.hdr2, listingfh);
1182 aim_tx_enqueue(sess, newoft);
1183 faimdprintf(2, "faim: OFT: OFT file enqueued.\n");
1185 if( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ)) == NULL)
1188 i = userfunc(sess, NULL, conn, listingfh, listingfh->bcookie);
1196 case 0x0202: { /* get file: ready to recieve data */
1197 struct aim_fileheader_t *fh;
1198 fh = aim_oft_getfh((char *)hdr);
1200 faimdprintf(2, "faim: get_rend: looks like we're ready to send data.(oft 0x0202)\n");
1202 faim_mutex_unlock(&conn->active);
1204 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILESEND)) == NULL)
1207 return userfunc(sess, NULL, conn, fh);
1213 case 0x0204: { /* get file: finished. close it up */
1216 struct aim_fileheader_t *fh;
1217 fh = aim_oft_getfh((char *)hdr);
1219 faimdprintf(2, "faim: get_rend: looks like we're done with a transfer (oft 0x0204)\n");
1221 faim_mutex_unlock(&conn->active);
1223 if ( (userfunc = aim_callhandler(conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILECOMPLETE)) )
1224 i = userfunc(sess, NULL, conn, fh);
1230 /* not sure where to do this yet, as we need to keep it to allow multiple file sends... bleh */
1236 printf("OFT frame: type %04x\n", hdrtype);
1237 /* data connection may be unreliable here */
1238 faim_mutex_unlock(&conn->active);
1249 * aim_oft_registerlisting()
1251 * file: opened FILE *
1252 * listingdir: the path to listing.txt
1253 * returns -1 on error, 0 on success.
1255 * it's not my problem if the listing fd is already set.
1258 faim_export int aim_oft_registerlisting(struct aim_session_t *sess, FILE *file, char* listingdir)
1263 /* XXX: checksum each file in the listing */
1266 if(sess->oft.listing) {
1267 faimdprintf(1, "We already have a file pointer. Closing and overwriting.\n");
1268 fclose(sess->oft.listing);
1271 sess->oft.listing = file;
1273 if(sess->oft.listingdir) {
1274 faimdprintf(1, "We already have a directory string. Freeing and overwriting\n");
1275 free(sess->oft.listingdir);
1279 if( (sess->oft.listingdir = (char *)calloc(1, strlen(listingdir)+1)) )
1280 memcpy(sess->oft.listingdir, listingdir, strlen(listingdir));
1286 faim_internal struct aim_fileheader_t *aim_oft_getfh(unsigned char *hdr)
1288 struct aim_fileheader_t *fh;
1291 if(!(fh = calloc(1, sizeof(struct aim_fileheader_t))))
1294 /* [0] and [1] are the type. we can ignore those here. */
1298 for(j = 0; j < 8; j++, i++)
1299 fh->bcookie[j] = hdr[i];
1300 fh->encrypt = aimutil_get16(hdr+i);
1302 fh->compress = aimutil_get16(hdr+i);
1304 fh->totfiles = aimutil_get16(hdr+i);
1306 fh->filesleft = aimutil_get16(hdr+i);
1308 fh->totparts = aimutil_get16(hdr+i);
1310 fh->partsleft = aimutil_get16(hdr+i);
1312 fh->totsize = aimutil_get32(hdr+i);
1314 fh->size = aimutil_get32(hdr+i);
1316 fh->modtime = aimutil_get32(hdr+i);
1318 fh->checksum = aimutil_get32(hdr+i);
1320 fh->rfrcsum = aimutil_get32(hdr+i);
1322 fh->rfsize = aimutil_get32(hdr+i);
1324 fh->cretime = aimutil_get32(hdr+i);
1326 fh->rfcsum = aimutil_get32(hdr+i);
1328 fh->nrecvd = aimutil_get32(hdr+i);
1330 fh->recvcsum = aimutil_get32(hdr+i);
1333 memcpy(fh->idstring, hdr+i, 32);
1336 fh->flags = aimutil_get8(hdr+i);
1338 fh->lnameoffset = aimutil_get8(hdr+i);
1340 fh->lsizeoffset = aimutil_get8(hdr+i);
1343 memcpy(fh->dummy, hdr+i, 69);
1346 memcpy(fh->macfileinfo, hdr+i, 16);
1349 fh->nencode = aimutil_get16(hdr+i);
1351 fh->nlanguage = aimutil_get16(hdr+i);
1354 memcpy(fh->name, hdr+i, 64);
1360 faim_export int aim_oft_checksum(char *buffer, int bufsize, int *checksum)
1362 short check0, check1;
1365 check0 = ((*checksum & 0xFF000000) >> 16);
1366 check1 = ((*checksum & 0x00ff0000) >> 16);
1368 for(i = 0; i < bufsize; i++) {
1370 if(i % 2) { /* use check1 -- second byte */
1371 if ( (short)buffer[i] > check1 ) { /* wrapping */
1373 check1 += 0x100; /* this is a cheap way to wrap */
1375 /* if we're wrapping, decrement the other one */
1376 if(check0 == 0) /* XXX: check this corner case */
1382 check1 -= buffer[i];
1383 } else { /* use check0 -- first byte */
1384 if ( (short)buffer[i] > check0 ) { /* wrapping */
1386 check0 += 0x100; /* this is a cheap way to wrap */
1388 /* if we're wrapping, decrement the other one */
1389 if(check1 == 0) /* XXX: check this corner case */
1395 check0 -= buffer[i];
1399 if(check0 > 0xff || check1 > 0xff) { /* they shouldn't be able to do this. error! */
1400 faimdprintf(2, "check0 or check1 is too high: 0x%04x, 0x%04x\n", check0, check1);
1404 check0 &= 0xff; /* grab just the lowest byte */
1405 check1 &= 0xff; /* this should be clean, but just in case */
1407 *checksum = ((check0 * 0x1000000) + (check1 * 0x10000));
1414 * aim_oft_buildheader:
1415 * fills a buffer with network-order fh data.
1416 * returns length written; -1 on error.
1417 * dest: buffer to fill -- pre-alloced
1418 * listingfh: fh to get data from
1420 * DOES NOT DO BOUNDS CHECKING!
1424 faim_internal int aim_oft_buildheader(char *dest,struct aim_fileheader_t *listingfh)
1428 if(!dest || !listingfh)
1432 for(i = 0; i < 8; i++)
1433 curbyte += aimutil_put8(dest+curbyte, listingfh->bcookie[i]);
1434 curbyte += aimutil_put16(dest+curbyte, listingfh->encrypt);
1435 curbyte += aimutil_put16(dest+curbyte, listingfh->compress);
1436 curbyte += aimutil_put16(dest+curbyte, listingfh->totfiles);
1437 curbyte += aimutil_put16(dest+curbyte, listingfh->filesleft);
1438 curbyte += aimutil_put16(dest+curbyte, listingfh->totparts);
1439 curbyte += aimutil_put16(dest+curbyte, listingfh->partsleft);
1440 curbyte += aimutil_put32(dest+curbyte, listingfh->totsize);
1441 curbyte += aimutil_put32(dest+curbyte, listingfh->size);
1442 curbyte += aimutil_put32(dest+curbyte, listingfh->modtime);
1443 curbyte += aimutil_put32(dest+curbyte, listingfh->checksum);
1444 curbyte += aimutil_put32(dest+curbyte, listingfh->rfrcsum);
1445 curbyte += aimutil_put32(dest+curbyte, listingfh->rfsize);
1446 curbyte += aimutil_put32(dest+curbyte, listingfh->cretime);
1447 curbyte += aimutil_put32(dest+curbyte, listingfh->rfcsum);
1448 curbyte += aimutil_put32(dest+curbyte, listingfh->nrecvd);
1449 curbyte += aimutil_put32(dest+curbyte, listingfh->recvcsum);
1451 memcpy(dest+curbyte, listingfh->idstring, 32);
1454 curbyte += aimutil_put8(dest+curbyte, listingfh->flags);
1455 curbyte += aimutil_put8(dest+curbyte, listingfh->lnameoffset);
1456 curbyte += aimutil_put8(dest+curbyte, listingfh->lsizeoffset);
1458 memcpy(dest+curbyte, listingfh->dummy, 69);
1461 memcpy(dest+curbyte, listingfh->macfileinfo, 16);
1464 curbyte += aimutil_put16(dest+curbyte, listingfh->nencode);
1465 curbyte += aimutil_put16(dest+curbyte, listingfh->nlanguage);
1467 memcpy(dest+curbyte, listingfh->name, 64); /* XXX: Filenames longer than 64B */
1474 * int aim_getfile_send(struct aim_conn_t *conn, FILE *tosend, struct aim_fileheader_t *fh)
1475 * conn is the OFT connection to shove the data down,
1476 * tosend is the FILE * for the file to send
1477 * fh is the filled-in fh value
1478 * returns -1 on error, 1 on success.
1481 faim_export int aim_getfile_send(struct aim_conn_t *conn, FILE *tosend, struct aim_fileheader_t *fh)
1484 const int bufsize = 4096;
1488 if(conn->type != AIM_CONN_TYPE_RENDEZVOUS || conn->subtype != AIM_CONN_SUBTYPE_OFT_GETFILE) {
1489 faimdprintf(1, "getfile_send: conn->type(0x%04x) != RENDEZVOUS or conn->subtype(0x%04x) != GETFILE\n", conn->type, conn->subtype);
1494 faimdprintf(1, "getfile_send: file pointer isn't valid\n");
1499 faimdprintf(1, "getfile_send: fh isn't valid\n");
1505 if(!(buf = (char *)calloc(1, bufsize))) {
1506 perror("faim: getfile_send: calloc:");
1507 faimdprintf(2, "getfile_send calloc error\n");
1513 if( fseek(tosend, 0, SEEK_SET) == -1) {
1514 perror("faim: getfile_send: fseek:");
1515 faimdprintf(2, "getfile_send fseek error\n");
1518 faimdprintf(2, "faim: getfile_send: using %i byte blocks\n", bufsize);
1520 for(pos = 0; pos < fh->size; pos++) {
1521 bufpos = pos % bufsize;
1523 if(bufpos == 0 && pos > 0) { /* filled our buffer. spit it across the wire */
1524 if ( (i = write(conn->fd, buf, bufsize)) != bufsize ) {
1525 perror("faim: getfile_send: write1: ");
1526 faimdprintf(1, "faim: getfile_send: whoopsy, didn't write it all...\n");
1531 if( (buf[bufpos] = fgetc(tosend)) == EOF) {
1532 if(pos != fh->size) {
1533 printf("faim: getfile_send: hrm... apparent early EOF at pos 0x%x of 0x%lx\n", pos, fh->size);
1534 faimdprintf(1, "faim: getfile_send: hrm... apparent early EOF at pos 0x%lx of 0x%lx\n", pos, fh->size);
1543 if( (i = write(conn->fd, buf, bufpos+1)) != (bufpos+1)) {
1544 perror("faim: getfile_send: write2: ");
1545 faimdprintf(1, "faim: getfile_send cleanup: whoopsy, didn't write it all...\n");
1557 * int aim_getfile_send_chunk(struct aim_conn_t *conn, FILE *tosend, struct aim_fileheader_t *fh, int pos, int bufsize)
1558 * conn is the OFT connection to shove the data down,
1559 * tosend is the FILE * for the file to send
1560 * fh is the filled-in fh value
1561 * pos is the position to start at (at beginning should be 0, after 5
1562 * bytes are sent should be 5); -1 for "don't seek"
1563 * bufsize is the size of the chunk to send
1565 * returns -1 on error, new pos on success.
1569 * You don't really have to keep track of pos if you don't want
1570 * to. just always call with -1 for pos, and it'll use the one
1571 * contained within the FILE *.
1573 * if (pos + chunksize > fh->size), we only send as much data as we
1574 * can get (ie: up to fh->size.
1576 faim_export int aim_getfile_send_chunk(struct aim_conn_t *conn, FILE *tosend, struct aim_fileheader_t *fh, int pos, int bufsize)
1582 if(conn->type != AIM_CONN_TYPE_RENDEZVOUS || conn->type != AIM_CONN_SUBTYPE_OFT_GETFILE) {
1583 faimdprintf(1, "faim: getfile_send_chunk: conn->type(0x%04x) != RENDEZVOUS or conn->subtype(0x%04x) != GETFILE\n", conn->type, conn->subtype);
1588 faimdprintf(1, "faim: getfile_send_chunk: file pointer isn't valid\n");
1593 faimdprintf(1, "faim: getfile_send_chunk: fh isn't valid\n");
1599 if(!(buf = (char *)calloc(1, bufsize))) {
1600 perror("faim: getfile_send_chunk: calloc:");
1601 faimdprintf(2, "faim: getfile_send_chunk calloc error\n");
1606 if( fseek(tosend, pos, SEEK_SET) == -1) {
1607 perror("faim: getfile_send_chunk: fseek:");
1608 faimdprintf(2, "faim: getfile_send_chunk fseek error\n");
1612 faimdprintf(2, "faim: getfile_send_chunk: using %i byte blocks\n", bufsize);
1614 for(bufpos = 0; pos < fh->size; bufpos++, pos++) {
1615 if( (buf[bufpos] = fgetc(tosend)) == EOF) {
1616 if(pos != fh->size) {
1617 faimdprintf(1, "faim: getfile_send_chunk: hrm... apparent early EOF at pos 0x%x of 0x%x\n", pos, fh->size);
1624 if( write(conn->fd, buf, bufpos+1) != (bufpos+1)) {
1625 faimdprintf(1, "faim: getfile_send_chunk cleanup: whoopsy, didn't write it all...\n");
1632 return (pos + bufpos);
1637 * free's tx_command_t's. if command is locked, doesn't free.
1638 * returns -1 on error (locked struct); 0 on success.
1639 * command is the command to free
1642 faim_internal int aim_tx_destroy(struct command_tx_struct *command)
1647 free(command->data);
1655 * aim_getfile_intitiate:
1656 * For those times when we want to open up the directim channel ourselves.
1657 * sess is your session,
1658 * conn is the BOS conn,
1659 * priv is a dummy priv value (we'll let it get filled in later) (if
1660 * you pass a NULL, we alloc one)
1661 * destsn is the SN to connect to.
1665 faim_export struct aim_conn_t *aim_getfile_initiate(struct aim_session_t *sess,
1666 struct aim_conn_t *conn,
1667 struct aim_getfile_priv *priv,
1670 struct command_tx_struct *newpacket;
1671 struct aim_conn_t *newconn;
1673 struct aim_msgcookie_t *cookie;
1675 int curbyte, i, listenfd;
1678 struct hostent *hptr;
1679 struct utsname myname;
1682 char d[4]; /* XXX: IPv6. *cough* */
1688 if( (listenfd = aim_listenestablish(port)) == -1)
1695 if(uname(&myname) < 0)
1698 if( (hptr = gethostbyname(myname.nodename)) == NULL)
1701 memcpy(&d, hptr->h_addr_list[0], 4); /* XXX: this probably isn't quite kosher, but it works */
1703 aim_putcap(cap, 16, AIM_CAPS_IMIMAGE);
1706 * create the OSCAR packet
1709 if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+8+2+1+strlen(destsn)+4+4+0x32)))
1712 newpacket->lock = 1; /* lock struct */
1715 curbyte += aim_putsnac(newpacket->data+curbyte,
1716 0x0004, 0x0006, 0x0000, sess->snac_nextid);
1719 * Generate a random message cookie
1720 * This cookie needs to be alphanumeric and NULL-terminated to be TOC-compatible.
1723 curbyte += aimutil_put8(newpacket->data+curbyte, 0x30 + ((u_char) random() % 20));
1724 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
1727 * grab all the data for cookie caching.
1729 cookie = (struct aim_msgcookie_t *)calloc(1, sizeof(struct aim_msgcookie_t));
1731 memcpy(cookie->cookie, newpacket->data+curbyte-8, 8);
1732 cookie->type = AIM_COOKIETYPE_OFTIM;
1735 priv = (struct aim_directim_priv *)calloc(1, sizeof(struct aim_directim_priv));
1737 memcpy(priv->cookie, cookie, 8);
1738 memcpy(priv->sn, destsn, sizeof(priv->sn));
1740 cookie->data = priv;
1742 aim_cachecookie(sess, cookie); /* cache da cookie */
1747 curbyte += aimutil_put16(newpacket->data+curbyte,0x0002);
1750 * Destination SN (prepended with byte length)
1752 curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
1753 curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
1755 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0003);
1756 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
1761 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
1762 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0032);
1765 * Flag data / ICBM Parameters?
1767 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
1768 curbyte += aimutil_put8(newpacket->data+curbyte, 0x00);
1773 curbyte += aimutil_putstr(newpacket->data+curbyte, (char *)cookie, 8);
1778 curbyte += aimutil_putstr(newpacket->data+curbyte, (char *)cap, 0x10);
1783 curbyte += aimutil_put16(newpacket->data+curbyte, 0x000a);
1784 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
1785 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
1788 * 0003/0004: IP address
1791 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0003);
1792 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0004);
1794 for(i = 0; i < 4; i++)
1795 curbyte += aimutil_put8(newpacket->data+curbyte, d[i]); /* already in network byte order */
1801 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
1802 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
1803 curbyte += aimutil_put16(newpacket->data+curbyte, port);
1806 * 000f/0000: umm.. dunno. Zigamorph[1]?
1807 * [1]: see esr's TNHD.
1810 curbyte += aimutil_put16(newpacket->data+curbyte, 0x000f);
1811 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
1813 printf("curbyte: 0x%x\n",curbyte);
1815 newpacket->commandlen = curbyte;
1816 newpacket->lock = 0;
1818 aim_tx_enqueue(sess, newpacket);
1821 * allocate and set up our connection
1824 i = fcntl(listenfd, F_GETFL, 0);
1825 fcntl(listenfd, F_SETFL, i | O_NONBLOCK);
1827 newconn = aim_newconn(sess, AIM_CONN_TYPE_RENDEZVOUS_OUT, NULL);
1829 perror("aim_newconn");
1830 aim_conn_kill(sess, &newconn);
1834 newconn->fd = listenfd;
1835 newconn->subtype = AIM_CONN_SUBTYPE_OFT_DIRECTIM;
1836 newconn->priv = priv;
1837 printf("faim: listening (fd = %d, unconnected)\n", newconn->fd);
1840 * XXX We need some way of closing the listener socket after
1841 * n seconds of no connection. -- mid