utils/faimtest/ft.c

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