utils/faimtest/ft.c

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