utils/faimtest/ft.c

   1
   2 #include "faimtest.h"
   3
   4 static int directim_incoming(aim_session_t *sess, aim_frame_t *fr, ...)
   5 {
   6         va_list ap;
   7         char *sn, *msg;
   8
   9         va_start(ap, fr);
  10         sn = va_arg(ap, char *);
  11         msg = va_arg(ap, char *);
  12         va_end(ap);
  13
  14         dvprintf("faimtest: Directim from %s: %s\n", sn, msg);
  15
  16         if (strstr(msg, "sendmsg")) {
  17                 int i;
  18
  19                 i = atoi(strstr(msg, "sendmsg")+8);
  20                 if (i < 10000) {
  21                         char *newbuf;
  22                         int z;
  23
  24                         newbuf = malloc(i+1);
  25                         for (z = 0; z < i; z++)
  26                                 newbuf[z] = (z % 10)+0x30;
  27                         newbuf[i] = '\0';
  28                         aim_send_im_direct(sess, fr->conn, newbuf);
  29                         free(newbuf);
  30                 }
  31
  32         } else if (strstr(msg, "goodday")) {
  33
  34                 aim_send_im_direct(sess, fr->conn, "Good day to you, too");
  35
  36         } else {
  37                 char newmsg[1024];
  38
  39                 snprintf(newmsg, sizeof(newmsg), "unknown (%s)\n", msg);
  40                 aim_send_im_direct(sess, fr->conn, newmsg);
  41         }
  42
  43         return 1;
  44 }
  45
  46 static int directim_typing(aim_session_t *sess, aim_frame_t *fr, ...)
  47 {
  48         va_list ap;
  49         char *sn;
  50
  51         va_start(ap, fr);
  52         sn = va_arg(ap, char *);
  53         va_end(ap);
  54
  55         dvprintf("faimtest: ohmigod! %s has started typing (DirectIM). He's going to send you a message! *squeal*\n", sn);
  56
  57         return 1;
  58 }
  59
  60 static int faimtest_directim_initiate(aim_session_t *sess, aim_frame_t *fr, ...)
  61 {
  62         va_list ap;
  63         aim_conn_t *newconn, *listenerconn;
  64
  65         va_start(ap, fr);
  66         newconn = va_arg(ap, aim_conn_t *);
  67         listenerconn = va_arg(ap, aim_conn_t *);
  68         va_end(ap);
  69
  70         aim_conn_close(listenerconn);
  71         aim_conn_kill(sess, &listenerconn);
  72
  73         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING, directim_incoming, 0);
  74         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING, directim_typing, 0);
  75
  76         aim_send_im_direct(sess, newconn, "goodday");
  77
  78         dvprintf("faimtest: OFT: DirectIM: connected to %s\n", aim_directim_getsn(newconn));
  79
  80         return 1;
  81 }
  82
  83 static int faimtest_getfile_filereq(aim_session_t *ses, aim_frame_t *fr, ...)
  84 {
  85         va_list ap;
  86         aim_conn_t *oftconn;
  87         struct aim_fileheader_t *fh;
  88         fu8_t *cookie;
  89
  90         va_start(ap, fr);
  91         oftconn = va_arg(ap, aim_conn_t *);
  92         fh = va_arg(ap, struct aim_fileheader_t *);
  93         cookie = va_arg(ap, fu8_t *);
  94         va_end(ap);
  95
  96         dvprintf("faimtest: request for file %s.\n", fh->name);
  97
  98         return 1;
  99 }
 100
 101 static int faimtest_getfile_filesend(aim_session_t *sess, aim_frame_t *fr, ...)
 102 {
 103         struct faimtest_priv *priv = (struct faimtest_priv *)sess->aux_data;
 104         va_list ap;
 105         aim_conn_t *oftconn;
 106         struct aim_fileheader_t *fh;
 107         char *path;
 108         fu8_t *cookie;
 109         int pos, bufpos = 0, bufsize = 2048, i;
 110         char *buf;
 111         FILE *file;
 112
 113         va_start(ap, fr);
 114         oftconn = va_arg(ap, aim_conn_t *);
 115         fh = va_arg(ap, struct aim_fileheader_t *);
 116         cookie = va_arg(ap, fu8_t *);
 117         va_end(ap);
 118
 119         dvprintf("faimtest: sending file %s(%ld).\n", fh->name, fh->size);
 120
 121         if (!(buf = malloc(2048)))
 122                 return -1;
 123
 124         if (!(path = (char *)calloc(1, strlen(priv->listingpath) +strlen(fh->name)+2))) {
 125                 dperror("calloc");
 126                 dprintf("faimtest: error in calloc of path\n");
 127
 128                 return 0; /* XXX: no idea what winaim expects here =) */
 129         }
 130
 131         snprintf(path, strlen(priv->listingpath)+strlen(fh->name)+2, "%s/%s", priv->listingpath, fh->name);
 132
 133         if (!(file = fopen(path, "r"))) {
 134                 dvprintf("faimtest: getfile_send fopen failed for %s. damn.\n", path);
 135                 return 0;
 136         }
 137
 138         /*
 139          * This is a mess. Remember that faimtest is demonstration code
 140          * only and for the sake of the gods, don't use this code in any
 141          * of your clients. --mid
 142          */
 143         for(pos = 0; pos < fh->size; pos++) {
 144
 145                 bufpos = pos % bufsize;
 146
 147                 if (bufpos == 0 && pos > 0) { /* filled our buffer. spit it across the wire */
 148                         if ( (i = send(oftconn->fd, buf, bufsize, 0)) != bufsize ) {
 149                                 dperror("faim: getfile_send: write1");
 150                                 dprintf("faim: getfile_send: whoopsy, didn't write it all...\n");
 151                                 free(buf);
 152                                 return 0;
 153                         }
 154                 }
 155
 156                 if( (buf[bufpos] = fgetc(file)) == EOF) {
 157                         if(pos != fh->size) {
 158                                 dvprintf("faim: getfile_send: hrm... apparent early EOF at pos 0x%x of 0x%lx\n", pos, fh->size);
 159                                 free(buf);
 160                                 return 0;
 161                         }
 162                 }
 163                 dvprintf("%c(0x%02x) ", buf[pos], buf[pos]);
 164         }
 165
 166         if( (i = send(oftconn->fd, buf, bufpos+1, 0)) != (bufpos+1)) {
 167                 dperror("faim: getfile_send: write2");
 168                 dprintf("faim: getfile_send cleanup: whoopsy, didn't write it all...\n");
 169                 free(buf);
 170                 return 0;
 171         }
 172
 173         free(buf);
 174         free(fh);
 175
 176         return 1;
 177 }
 178
 179 static int faimtest_getfile_complete(aim_session_t *sess, aim_frame_t *fr, ...)
 180 {
 181         va_list ap;
 182         aim_conn_t *conn;
 183         struct aim_fileheader_t *fh;
 184
 185         va_start(ap, fr);
 186         conn = va_arg(ap, aim_conn_t *);
 187         fh = va_arg(ap, struct aim_fileheader_t *);
 188         va_end(ap);
 189
 190         dvprintf("faimtest: completed file transfer for %s.\n", fh->name);
 191
 192         aim_conn_close(conn);
 193         aim_conn_kill(sess, &conn);
 194
 195         return 1;
 196 }
 197
 198 static int faimtest_getfile_disconnect(aim_session_t *sess, aim_frame_t *fr, ...)
 199 {
 200         va_list ap;
 201         aim_conn_t *conn;
 202         char *sn;
 203
 204         va_start(ap, fr);
 205         conn = va_arg(ap, aim_conn_t *);
 206         sn = va_arg(ap, char *);
 207         va_end(ap);
 208
 209         aim_conn_kill(sess, &conn);
 210
 211         dvprintf("faimtest: getfile: disconnected from %s\n", sn);
 212
 213         return 1;
 214 }
 215
 216 static int faimtest_getfile_listing(aim_session_t *sess, aim_frame_t *fr, ...)
 217 {
 218         va_list ap;
 219         aim_conn_t *conn;
 220         char *listing;
 221         struct aim_filetransfer_priv *ft;
 222         char *filename, *nameend, *sizec;
 223         int filesize, namelen;
 224
 225         va_start(ap, fr);
 226         conn = va_arg(ap, aim_conn_t *);
 227         ft = va_arg(ap, struct aim_filetransfer_priv *);
 228         listing = va_arg(ap, char *);
 229         va_end(ap);
 230
 231         dvprintf("listing on %d==================\n%s\n===========\n", conn->fd, listing);
 232
 233         nameend = strstr(listing+0x1a, "\r");
 234
 235         namelen = nameend - (listing + 0x1a);
 236
 237         filename = malloc(namelen + 1);
 238         strncpy(filename, listing+0x1a, namelen);
 239         filename[namelen] = 0x00;
 240
 241         sizec = malloc(8+1);
 242         memcpy(sizec, listing + 0x11, 8);
 243         sizec[8] = 0x00;
 244
 245         filesize =  strtol(sizec, (char **)NULL, 10);
 246
 247         dvprintf("faimtest: requesting %d %s(%d long)\n", namelen, filename, filesize);
 248
 249         aim_oft_getfile_request(sess, conn, filename, filesize);
 250
 251         free(filename);
 252         free(sizec);
 253
 254         return 0;
 255 }
 256
 257 static int faimtest_getfile_listingreq(aim_session_t *sess, aim_frame_t *fr, ...)
 258 {
 259         struct faimtest_priv *priv = (struct faimtest_priv *)sess->aux_data;
 260         va_list ap;
 261         aim_conn_t *oftconn;
 262         struct aim_fileheader_t *fh;
 263         int pos, bufpos = 0, bufsize = 2048, i;
 264         char *buf;
 265
 266         va_start(ap, fr);
 267         oftconn = va_arg(ap, aim_conn_t *);
 268         fh = va_arg(ap, struct aim_fileheader_t *);
 269         va_end(ap);
 270
 271         dvprintf("faimtest: sending listing of size %ld\n", fh->size);
 272
 273         if(!(buf = malloc(2048)))
 274                 return -1;
 275
 276         for(pos = 0; pos < fh->size; pos++) {
 277
 278                 bufpos = pos % bufsize;
 279
 280                 if(bufpos == 0 && pos > 0) { /* filled our buffer. spit it across the wire */
 281                         if ( (i = send(oftconn->fd, buf, bufsize, 0)) != bufsize ) {
 282                                 dperror("faim: getfile_send: write1");
 283                                 dprintf("faim: getfile_send: whoopsy, didn't write it all...\n");
 284                                 free(buf);
 285                                 return 0;
 286                         }
 287                 }
 288                 if( (buf[bufpos] = fgetc(priv->listingfile)) == EOF) {
 289                         if(pos != fh->size) {
 290                                 dvprintf("faim: getfile_send: hrm... apparent early EOF at pos 0x%x of 0x%lx\n", pos, fh->size);
 291                                 free(buf);
 292                                 return 0;
 293                         }
 294                 }
 295         }
 296
 297         if( (i = send(oftconn->fd, buf, bufpos+1, 0)) != (bufpos+1)) {
 298                 dperror("faim: getfile_send: write2");
 299                 dprintf("faim: getfile_send cleanup: whoopsy, didn't write it all...\n");
 300                 free(buf);
 301                 return 0;
 302         }
 303
 304         dprintf("faimtest: sent listing\n");
 305         free(buf);
 306
 307         return 0;
 308 }
 309
 310 static int faimtest_getfile_receive(aim_session_t *sess, aim_frame_t *fr, ...)
 311 {
 312         va_list ap;
 313         aim_conn_t *conn;
 314         struct aim_filetransfer_priv *ft;
 315         unsigned char data;
 316         int pos;
 317
 318         va_start(ap, fr);
 319         conn = va_arg(ap, aim_conn_t *);
 320         ft = va_arg(ap, struct aim_filetransfer_priv *);
 321         va_end(ap);
 322
 323         dvprintf("faimtest: receiving %ld bytes of file data for %s:\n\t", ft->fh.size, ft->fh.name);
 324
 325         for(pos = 0; pos < ft->fh.size; pos++) {
 326                 read(conn->fd, &data, 1);
 327                 printf("%c(%02x) ", data, data);
 328         }
 329
 330         printf("\n");
 331
 332         aim_oft_getfile_end(sess, conn);
 333
 334         return 0;
 335 }
 336
 337 static int faimtest_getfile_state4(aim_session_t *sess, aim_frame_t *fr, ...)
 338 {
 339         va_list ap;
 340         aim_conn_t *conn;
 341
 342         va_start(ap, fr);
 343         conn = va_arg(ap, aim_conn_t *);
 344         va_end(ap);
 345
 346         aim_conn_close(conn);
 347         aim_conn_kill(sess, &conn);
 348
 349         return 0;
 350 }
 351
 352 static int faimtest_getfile_initiate(aim_session_t *sess, aim_frame_t *fr, ...)
 353 {
 354         va_list ap;
 355         aim_conn_t *conn, *listenerconn;
 356         struct aim_filetransfer_priv *priv;
 357
 358         va_start(ap, fr);
 359         conn = va_arg(ap, aim_conn_t *);
 360         listenerconn = va_arg(ap, aim_conn_t *);
 361         va_end(ap);
 362
 363         aim_conn_close(listenerconn);
 364         aim_conn_kill(sess, &listenerconn);
 365
 366         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ,  faimtest_getfile_filereq, 0);
 367         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILESEND, faimtest_getfile_filesend, 0);
 368         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILECOMPLETE, faimtest_getfile_complete, 0);
 369         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEDISCONNECT, faimtest_getfile_disconnect, 0);
 370         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTING, faimtest_getfile_listing, 0);
 371         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTINGREQ, faimtest_getfile_listingreq, 0);
 372         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILERECEIVE, faimtest_getfile_receive, 0);
 373         aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILESTATE4, faimtest_getfile_state4, 0);
 374
 375         priv = (struct aim_filetransfer_priv *)conn->priv;
 376
 377         dvprintf("faimtest: getfile: %s (%s) connected to us on %d\n", priv->sn, priv->ip, conn->fd);
 378
 379         return 1;
 380 }
 381
 382 void getfile_start(aim_session_t *sess, aim_conn_t *conn, const char *sn)
 383 {
 384         aim_conn_t *newconn;
 385
 386         newconn = aim_getfile_initiate(sess, conn, sn);
 387         dvprintf("faimtest: getting file listing from %s\n", sn);
 388         aim_conn_addhandler(sess, newconn,  AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEINITIATE, faimtest_getfile_initiate,0);
 389
 390         return;
 391 }
 392
 393 void getfile_requested(aim_session_t *sess, aim_conn_t *conn, struct aim_userinfo_s *userinfo, struct aim_incomingim_ch2_args *args)
 394 {
 395         struct faimtest_priv *priv = (struct faimtest_priv *)sess->aux_data;
 396         aim_conn_t *newconn;
 397         struct aim_fileheader_t *fh;
 398
 399         dvprintf("faimtest: get file request from %s (at %s) %x\n", userinfo->sn, args->info.getfile.ip, args->reqclass);
 400
 401         fh = aim_getlisting(sess, priv->listingfile);
 402
 403         newconn = aim_accepttransfer(sess, conn, userinfo->sn, args->info.getfile.cookie, args->info.getfile.ip, fh->totfiles, fh->totsize, fh->size, fh->checksum, args->reqclass);
 404
 405         free(fh);
 406
 407         if ( (!newconn) || (newconn->fd == -1) ) {
 408
 409                 dprintf("faimtest: getfile: requestconn: apparent error in accepttransfer\n");
 410
 411                 if (newconn)
 412                         aim_conn_kill(sess, &newconn);
 413
 414                 return;
 415         }
 416
 417
 418         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTINGREQ, faimtest_getfile_listingreq, 0);
 419         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ,  faimtest_getfile_filereq, 0);
 420         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILESEND, faimtest_getfile_filesend, 0);
 421         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILECOMPLETE, faimtest_getfile_complete, 0);
 422
 423         aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEDISCONNECT, faimtest_getfile_disconnect, 0);
 424
 425         dprintf("faimtest: getfile connect succeeded, handlers added.\n");
 426
 427         return;
 428 }
 429
 430 void directim_start(aim_session_t *sess, aim_conn_t *conn, const char *sn)
 431 {
 432         aim_conn_t *newconn;
 433
 434         printf("faimtest: opening directim to %s\n", sn);
 435
 436         newconn = aim_directim_initiate(sess, conn, sn);
 437
 438         if (!newconn || (newconn->fd == -1)) {
 439
 440                 printf("connection failed!\n");
 441
 442                 if (newconn)
 443                         aim_conn_kill(sess, &newconn);
 444
 445         } else
 446                 aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINITIATE, faimtest_directim_initiate, 0);
 447
 448         return;
 449 }
 450
 451 void directim_requested(aim_session_t *sess, aim_conn_t *conn, struct aim_userinfo_s *userinfo, struct aim_incomingim_ch2_args *args)
 452 {
 453         aim_conn_t *newconn;
 454
 455         dvprintf("faimtest: OFT: DirectIM: request from %s (%s)\n", userinfo->sn, args->info.imimage.ip);
 456
 457         newconn = aim_directim_connect(sess, userinfo->sn, args->info.imimage.ip, args->cookie);
 458
 459         if (!newconn || (newconn->fd == -1)) {
 460
 461                 dprintf("faimtest: icbm: imimage: could not connect\n");
 462
 463                 if (newconn)
 464                         aim_conn_kill(sess, &newconn);
 465
 466         } else {
 467
 468                 aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING, directim_incoming, 0);
 469                 aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING, directim_typing, 0);
 470
 471                 dvprintf("faimtest: OFT: DirectIM: connected to %s\n", userinfo->sn);
 472
 473                 aim_send_im_direct(sess, newconn, "goodday");
 474         }
 475
 476 }
 477