Changeset f4d0975 for aim.c


Ignore:
Timestamp:
Oct 10, 2003, 5:12:19 PM (17 years ago)
Author:
James M. Kretchmar <kretch@mit.edu>
Branches:
master, barnowl_perlaim, debian, owl, release-1.4, release-1.5, release-1.6, release-1.7, release-1.8, release-1.9
Children:
e374dee
Parents:
12582d3
Message:
Fixed bug with idle times causing broken pipes.
New libfaim
File:
1 edited

Legend:

Unmodified
Added
Removed
  • aim.c

    ra352335c rf4d0975  
    7777static int faimtest_locrights(aim_session_t *sess, aim_frame_t *fr, ...);
    7878static int faimtest_reportinterval(aim_session_t *sess, aim_frame_t *fr, ...);
     79/* static int reportinterval(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs); */
    7980static int faimtest_parse_motd(aim_session_t *sess, aim_frame_t *fr, ...);
    8081static int getaimdata(aim_session_t *sess, unsigned char **bufret, int *buflenret, unsigned long offset, unsigned long len, const char *modname);
     
    106107static int offlinemsgdone(aim_session_t *sess, aim_frame_t *fr, ...);
    107108
    108 static int directim_incoming(aim_session_t *sess, aim_frame_t *fr, ...);
    109 static int directim_typing(aim_session_t *sess, aim_frame_t *fr, ...);
    110 static int faimtest_directim_initiate(aim_session_t *sess, aim_frame_t *fr, ...);
    111 static int faimtest_getfile_filereq(aim_session_t *ses, aim_frame_t *fr, ...);
    112 static int faimtest_getfile_filesend(aim_session_t *sess, aim_frame_t *fr, ...);
    113 static int faimtest_getfile_complete(aim_session_t *sess, aim_frame_t *fr, ...);
    114 static int faimtest_getfile_disconnect(aim_session_t *sess, aim_frame_t *fr, ...);
    115 static int faimtest_getfile_listing(aim_session_t *sess, aim_frame_t *fr, ...);
    116 static int faimtest_getfile_listingreq(aim_session_t *sess, aim_frame_t *fr, ...);
    117 static int faimtest_getfile_receive(aim_session_t *sess, aim_frame_t *fr, ...);
    118 static int faimtest_getfile_state4(aim_session_t *sess, aim_frame_t *fr, ...);
    119 static int faimtest_getfile_initiate(aim_session_t *sess, aim_frame_t *fr, ...);
    120 void getfile_start(aim_session_t *sess, aim_conn_t *conn, const char *sn);
    121 void getfile_requested(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args);
    122 void directim_start(aim_session_t *sess, const char *sn);
    123 void directim_requested(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args);
    124 
    125109void chatnav_redirect(aim_session_t *sess, struct aim_redirect_data *redir);
    126110void chat_redirect(aim_session_t *sess, struct aim_redirect_data *redir);
     
    130114void owl_aim_init(void)
    131115{
    132   aim_session_init(owl_global_get_aimsess(&g), AIM_SESS_FLAGS_NONBLOCKCONNECT, 1);
     116  aim_session_init(owl_global_get_aimsess(&g), AIM_SESS_FLAGS_NONBLOCKCONNECT, 0);
    133117  aim_setdebuggingcb(owl_global_get_aimsess(&g), faimtest_debugcb);
    134118}
     119
    135120
    136121int owl_aim_login(char *screenname, char *password)
     
    147132  priv->server = "login.oscar.aol.com";
    148133  owl_global_get_aimsess(&g)->aux_data = priv;
     134
     135  aim_tx_setenqueue(owl_global_get_aimsess(&g), AIM_TX_IMMEDIATE, NULL);
    149136 
    150137  /* login */
     
    159146}
    160147
     148#if 0
     149static void oscar_login(GaimAccount *account) {
     150  aim_session_t *sess;
     151  aim_conn_t *conn;
     152  char buf[256];
     153  GaimConnection *gc = gaim_account_get_connection(account);
     154  struct oscar_data *od = gc->proto_data = g_new0(struct oscar_data, 1);
     155
     156  gaim_debug(GAIM_DEBUG_MISC, "oscar", "oscar_login: gc = %p\n", gc);
     157
     158  if (isdigit(*(gaim_account_get_username(account)))) {
     159    od->icq = TRUE;
     160  } else {
     161    gc->flags |= GAIM_CONNECTION_HTML;
     162    gc->flags |= GAIM_CONNECTION_AUTO_RESP;
     163  }
     164  od->buddyinfo = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, oscar_free_buddyinfo);
     165
     166  sess = g_new0(aim_session_t, 1);
     167
     168  aim_session_init(sess, AIM_SESS_FLAGS_NONBLOCKCONNECT, 0);
     169  aim_setdebuggingcb(sess, oscar_debug);
     170
     171  /* we need an immediate queue because we don't use a while-loop to
     172   * see if things need to be sent. */
     173  aim_tx_setenqueue(sess, AIM_TX_IMMEDIATE, NULL);
     174  od->sess = sess;
     175  sess->aux_data = gc;
     176
     177  conn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, NULL);
     178  if (conn == NULL) {
     179    gaim_debug(GAIM_DEBUG_ERROR, "oscar",
     180               "internal connection error\n");
     181    gaim_connection_error(gc, _("Unable to login to AIM"));
     182    return;
     183  }
     184
     185  g_snprintf(buf, sizeof(buf), _("Signon: %s"), gaim_account_get_username(account));
     186  gaim_connection_update_progress(gc, buf, 2, 5);
     187
     188  aim_conn_addhandler(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR, gaim_connerr, 0);
     189  aim_conn_addhandler(sess, conn, 0x0017, 0x0007, gaim_parse_login, 0);
     190  aim_conn_addhandler(sess, conn, 0x0017, 0x0003, gaim_parse_auth_resp, 0);
     191
     192  conn->status |= AIM_CONN_STATUS_INPROGRESS;
     193  if (gaim_proxy_connect(account, gaim_account_get_string(account, "server", FAIM_LOGIN_SERVER),
     194                         gaim_account_get_int(account, "port", FAIM_LOGIN_PORT),
     195                         oscar_login_connect, gc) < 0) {
     196    gaim_connection_error(gc, _("Couldn't connect to host"));
     197    return;
     198  }
     199  aim_request_login(sess, conn, gaim_account_get_username(account));
     200}
     201#endif
     202
     203
    161204/* stuff to run once login has been successful */
    162205void owl_aim_successful_login(char *screenname)
     
    171214  owl_timer_reset_newstart(owl_global_get_aim_login_timer(&g),
    172215                           owl_global_get_aim_ignorelogin_timer(&g));
    173 
    174216}
    175217
     
    196238int owl_aim_send_im(char *to, char *msg)
    197239{
    198   aim_send_im(owl_global_get_aimsess(&g), to, AIM_IMFLAGS_ACK, msg);
     240  int ret;
     241
     242  ret=aim_im_sendch1(owl_global_get_aimsess(&g), to, NULL, msg);
     243   
     244  /* aim_send_im(owl_global_get_aimsess(&g), to, AIM_IMFLAGS_ACK, msg); */
    199245
    200246  /* I don't know how to check for an error yet */
     
    204250void owl_aim_addbuddy(char *screenname)
    205251{
    206   const char **foo;
    207  
    208   /*
    209   aim_bos_setbuddylist(owl_global_get_aimsess(&g),
    210                        aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    211                        foo);
    212   */
    213 
    214   /*
    215   aim_add_buddy(owl_global_get_aimsess(&g),
    216                 aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    217                 screenname);
    218   */
    219 
    220   foo=(char *) owl_malloc(30);
    221   foo[0]=screenname;
    222   aim_ssi_addbuddies(owl_global_get_aimsess(&g),
    223                      aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    224                      "Buddies", foo, 1);
    225   owl_free(foo);
    226 
     252  aim_ssi_addbuddy(owl_global_get_aimsess(&g), screenname, "Buddies", NULL, NULL, NULL, 0);
    227253}
    228254
    229255void owl_aim_delbuddy(char *screenname)
    230256{
    231   /*
    232   aim_remove_buddy(owl_global_get_aimsess(&g),
    233                    aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    234                    screenname);
    235   */
    236 
    237   aim_ssi_delbuddies(owl_global_get_aimsess(&g),
    238                      aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    239                      "Buddies", &screenname, 1);
    240 
    241   /* for some reason we don't get an offgoing notice, so we'll remove
    242    * manually
    243    */
    244 
     257  aim_ssi_delbuddy(owl_global_get_aimsess(&g), screenname, "Buddies");
    245258  owl_buddylist_offgoing(owl_global_get_buddylist(&g), screenname);
    246 
    247 
    248 }
    249 
     259}
     260
     261#if 0
    250262void owl_aim_get_idle(char *screenname)
    251263{
     264  /*
    252265  aim_getinfo(owl_global_get_aimsess(&g),
    253266              aim_getconn_type(owl_global_get_aimsess(&g), AIM_CONN_TYPE_BOS),
    254267              screenname,
    255268              AIM_GETINFO_GENERALINFO);
    256 }
     269  */
     270}
     271#endif
    257272
    258273
     
    308323  }
    309324
    310   if (selstat == -1) { /* error */
    311     /* keepgoing = 0; */ /* fall through */
    312   } else if (selstat == 0) { /* no events pending */
    313     /* printf("selstat == 0\n"); */
     325  if (selstat == -1) {
     326    owl_function_debugmsg("Error in select");
     327    /* error */
     328  } else if (selstat == 0) {
     329    /* no events pending */
    314330  } else if (selstat == 1) { /* outgoing data pending */
    315     /* printf("selstat == 1\n"); */
    316331    aim_tx_flushqueue(aimsess);
    317332  } else if (selstat == 2) { /* incoming data pending */
    318333    /* printf("selstat == 2\n"); */
    319     if (waitingconn->type == AIM_CONN_TYPE_RENDEZVOUS_OUT) {
    320       if (aim_handlerendconnect(aimsess, waitingconn) < 0) {
    321         /* printf("connection error (rend out)\n"); */
     334   
     335    if (aim_get_command(aimsess, waitingconn) >= 0) {
     336      aim_rxdispatch(aimsess);
     337    } else {
     338      /* printf("connection error (type 0x%04x:0x%04x)\n", waitingconn->type, waitingconn->subtype); */
     339      /* we should have callbacks for all these, else the library will do the conn_kill for us. */
     340      if (waitingconn->type == AIM_CONN_TYPE_RENDEZVOUS) {
     341        if (waitingconn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM) {
     342          /* printf("disconnected from %s\n", aim_directim_getsn(waitingconn)); */
     343          aim_conn_kill(aimsess, &waitingconn);
     344        }
     345      } else {
    322346        aim_conn_kill(aimsess, &waitingconn);
    323347      }
    324     } else {
    325       if (aim_get_command(aimsess, waitingconn) >= 0) {
    326         aim_rxdispatch(aimsess);
    327       } else {
    328         /* printf("connection error (type 0x%04x:0x%04x)\n", waitingconn->type, waitingconn->subtype); */
    329         /* we should have callbacks for all these, else the library will do the conn_kill for us. */
    330         if (waitingconn->type == AIM_CONN_TYPE_RENDEZVOUS) {
    331           if (waitingconn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM) {
    332             /* printf("disconnected from %s\n", aim_directim_getsn(waitingconn)); */
    333             aim_conn_kill(aimsess, &waitingconn);
    334           }
    335         } else {
    336           aim_conn_kill(aimsess, &waitingconn);
    337         }
    338         if (!aim_getconn_type(aimsess, AIM_CONN_TYPE_BOS)) {
    339           /* printf("major connection error\n"); */
    340           /* break; */
    341           /* we should probably kill the session */
    342         }
     348      if (!aim_getconn_type(aimsess, AIM_CONN_TYPE_BOS)) {
     349        /* printf("major connection error\n"); */
     350        /* break; */
     351        /* we should probably kill the session */
    343352      }
    344353    }
     
    354363}
    355364
    356 
    357365static int faimtest_parse_login(aim_session_t *sess, aim_frame_t *fr, ...)
    358366{
     
    384392
    385393  /* printf("Screen name: %s\n", info->sn); */
    386   owl_function_debugmsg("Here with %s", info->sn);
     394  owl_function_debugmsg("faimtest_parse_authresp: %s", info->sn);
    387395
    388396  /*
     
    434442  owl_aim_successful_login(info->sn);
    435443  addcb_bos(sess, bosconn);
    436   aim_sendcookie(sess, bosconn, info->cookie);
     444  aim_sendcookie(sess, bosconn, info->cookielen, info->cookie);
    437445  return 1;
    438446}
     
    513521}
    514522
    515 static int conninitdone_bos(aim_session_t *sess, aim_frame_t *fr, ...)
    516 {
    517   char buddies[128]; /* this is the new buddy list */
    518   char profile[256]; /* this is the new profile */
    519   /* char awaymsg[] = {"blah blah blah Ole! blah blah blah"}; */
    520 
    521   /* Caution: Buddy1 and Buddy2 are real people! (who I don't know) */
    522   /*  snprintf(buddies, sizeof(buddies), "Buddy1&Buddy2&%s&", priv->ohcaptainmycaptain ? priv->ohcaptainmycaptain : "blah");
    523   snprintf(profile, sizeof(profile), "Hello.<br>My captain is %s.  They were dumb enough to leave this message in their client, or they are using faimtest.  Shame
    524 on them.", priv->ohcaptainmycaptain);
    525   */
    526 
    527   /*
    528   snprintf(buddies, sizeof(buddies), "Buddy1&Buddy2&");
    529   snprintf(profile, sizeof(profile), "Hello.<br>This is a test");
    530   */
    531   strcpy(profile, "");
    532 
     523
     524static int conninitdone_bos(aim_session_t *sess, aim_frame_t *fr, ...) {
    533525  aim_reqpersonalinfo(sess, fr->conn);
     526
     527  #ifndef NOSSI
     528  aim_ssi_reqrights(sess);
     529  aim_ssi_reqdata(sess);
     530  #endif
     531
    534532  aim_bos_reqlocaterights(sess, fr->conn);
    535 
    536   /* aim_bos_setprofile(sess, fr->conn, profile, awaymsg, AIM_CAPS_BUDDYICON | AIM_CAPS_CHAT | AIM_CAPS_GETFILE | AIM_CAPS_SENDFILE | AIM_CAPS_IMIMAGE | AIM_CAPS_GAMES | AIM_CAPS_SAVESTOCKS | AIM_CAPS_SENDBUDDYLIST | AIM_CAPS_ICQ | AIM_CAPS_ICQUNKNOWN | AIM_CAPS_ICQRTF | AIM_CAPS_ICQSERVERRELAY | AIM_CAPS_TRILLIANCRYPT); */
    537   aim_bos_setprofile(sess, fr->conn, "", "", AIM_CAPS_SENDBUDDYLIST );
    538533  aim_bos_reqbuddyrights(sess, fr->conn);
    539 
    540   /* send the buddy list and profile (required, even if empty) */
    541   aim_bos_setbuddylist(sess, fr->conn, buddies);
    542 
    543   aim_reqicbmparams(sess);
    544 
    545   aim_bos_reqrights(sess, fr->conn);
    546   /* set group permissions -- all user classes */
     534  aim_im_reqparams(sess);
     535  aim_bos_reqrights(sess, fr->conn); /* XXX - Don't call this with ssi? */
     536
     537  #ifdef NOSSI
    547538  aim_bos_setgroupperm(sess, fr->conn, AIM_FLAG_ALLUSERS);
    548   aim_bos_setprivacyflags(sess, fr->conn, AIM_PRIVFLAGS_ALLOWIDLE);
     539  aim_bos_setprivacyflags(sess, fr->conn, AIM_PRIVFLAGS_ALLOWIDLE | AIM_PRIVFLAGS_ALLOWMEMBERSINCE);
     540  #endif
    549541
    550542  return 1;
     
    693685      aim_conn_addhandler(sess, tstconn, 0x0007, 0x0005, faimtest_infochange, 0);
    694686      /* Send the cookie to the Auth */
    695       aim_sendcookie(sess, tstconn, redir->cookie);
     687      aim_sendcookie(sess, tstconn, redir->cookielen, redir->cookie);
    696688      /* printf("sent cookie to authorizer host\n"); */
    697689    }
     
    726718  params->maxmsglen = 8000;
    727719  params->minmsginterval = 0; /* in milliseconds */
    728   aim_seticbmparam(sess, params);
     720  /* aim_seticbmparam(sess, params); */
     721  aim_im_setparams(sess, params);
    729722 
    730723  return 1;
     
    743736  /* printf("buddy list rights: Max buddies = %d / Max watchers = %d\n", maxbuddies, maxwatchers); */
    744737 
    745   aim_ssi_reqrights(sess, fr->conn);
     738  /* aim_ssi_reqrights(sess, fr->conn); */
     739  aim_ssi_reqrights(sess);
    746740 
    747741  return 1;
     
    784778  va_list ap;
    785779  fu16_t interval;
    786  
     780
    787781  va_start(ap, fr);
    788782  interval = va_arg(ap, int);
    789783  va_end(ap);
    790  
     784
    791785  /* printf("minimum report interval: %d (seconds?)\n", interval); */
    792  
     786
    793787  if (!priv->connected) {
    794788    priv->connected++;
    795789  }
    796   aim_reqicbmparams(sess);
     790  /* aim_reqicbmparams(sess); */
     791  aim_im_reqparams(sess);
     792  /* kretch */
    797793  return 1;
    798794}
     
    10261022  char *prof = NULL;
    10271023  fu16_t inforeq = 0;
    1028 
     1024  owl_buddy *b;
    10291025  va_list ap;
    10301026  va_start(ap, fr);
     
    10361032
    10371033  /* right now the only reason we call this is for idle times */
    1038   owl_buddylist_set_idletime(owl_global_get_buddylist(&g), userinfo->sn, userinfo->idletime);
     1034  owl_function_debugmsg("parse_userinfo sn: %s idle: %i", userinfo->sn, userinfo->idletime);
     1035  b=owl_buddylist_get_aim_buddy(owl_global_get_buddylist(&g),
     1036                                userinfo->sn);
     1037  if (!b) return(1);
     1038  owl_buddy_set_idle_since(b, userinfo->idletime);
    10391039  return(1);
    10401040
     
    10441044  printuserflags(userinfo->flags);
    10451045  printf("\n");
    1046  
     1046
     1047  /*
    10471048  printf("userinfo: membersince: %lu\n", userinfo->membersince);
    10481049  printf("userinfo: onlinesince: %lu\n", userinfo->onlinesince);
    10491050  printf("userinfo: idletime: 0x%04x\n", userinfo->idletime);
    10501051  printf("userinfo: capabilities = %s = 0x%08lx\n", (userinfo->present & AIM_USERINFO_PRESENT_CAPABILITIES) ? "present" : "not present", userinfo->capabilities);
    1051  
     1052  */
    10521053 
    10531054  if (inforeq == AIM_GETINFO_GENERALINFO) {
     
    10661067}
    10671068
     1069#if 0
    10681070static int faimtest_handlecmd(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, const char *tmpstr)
    10691071{
     
    10731075    logout(sess);
    10741076  } else if (strstr(tmpstr, "goodday")) {
    1075     aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_ACK, "Good day to you too.");
     1077    /* aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_ACK, "Good day to you too."); */
    10761078  } else if (strstr(tmpstr, "haveicon") && priv->buddyicon) {
    10771079    struct aim_sendimext_args args;
     
    11181120     */
    11191121    args.destsn = userinfo->sn;
    1120     args.flags = AIM_IMFLAGS_CUSTOMCHARSET;
     1122    /* args.flags = AIM_IMFLAGS_CUSTOMCHARSET; */
    11211123    args.charset = args.charsubset = 0x4242;
    11221124    args.msg = data;
    11231125    args.msglen = sizeof(data);
    1124     aim_send_im_ext(sess, &args);
     1126    /* aim_send_im_ext(sess, &args); */
    11251127   } else if (strstr(tmpstr, "sendmulti")) {
    11261128    struct aim_sendimext_args args;
     
    11481150    args.mpmsg = &mpm;
    11491151   
    1150     aim_send_im_ext(sess, &args);
     1152    /* aim_send_im_ext(sess, &args); */
    11511153   
    11521154    aim_mpmsg_free(sess, &mpm);
     
    11821184    args.mpmsg = &mpm;
    11831185   
    1184     aim_send_im_ext(sess, &args);
     1186    /* aim_send_im_ext(sess, &args); */
    11851187    aim_mpmsg_free(sess, &mpm);
    11861188   
     
    11971199    args.featureslen = sizeof(features);
    11981200   
    1199     aim_send_im_ext(sess, &args);
     1201    /* aim_send_im_ext(sess, &args); */
    12001202  } else if (strstr(tmpstr, "sendicon") && priv->buddyicon) {
    1201     aim_send_icon(sess, userinfo->sn, priv->buddyicon, priv->buddyiconlen, priv->buddyiconstamp, priv->buddyiconsum);
     1203    /* aim_send_icon(sess, userinfo->sn, priv->buddyicon, priv->buddyiconlen, priv->buddyiconstamp, priv->buddyiconsum); */
    12021204  } else if (strstr(tmpstr, "warnme")) {
    12031205    /* printf("icbm: sending non-anon warning\n"); */
    1204     aim_send_warning(sess, conn, userinfo->sn, 0);
     1206    /* aim_send_warning(sess, conn, userinfo->sn, 0); */
    12051207  } else if (strstr(tmpstr, "anonwarn")) {
    12061208    /* printf("icbm: sending anon warning\n"); */
    1207     aim_send_warning(sess, conn, userinfo->sn, AIM_WARN_ANON);
     1209    /* aim_send_warning(sess, conn, userinfo->sn, AIM_WARN_ANON); */
    12081210  } else if (strstr(tmpstr, "setdirectoryinfo")) {
    12091211    /* printf("icbm: sending backwards profile data\n"); */
     
    12121214    /* printf("icbm: setting fun interests\n"); */
    12131215    aim_setuserinterests(sess, conn, "interest1", "interest2", "interest3", "interest4", "interest5", 1);
    1214   } else if (!strncmp(tmpstr, "getfile", 7)) {
    1215     if (!priv->ohcaptainmycaptain) {
    1216       aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_ACK, "I have no owner!");
    1217     } else {
    1218       getfile_start(sess, conn, (strlen(tmpstr) < 8)?priv->ohcaptainmycaptain:tmpstr+8);
    1219     }
    12201216  } else if (!strncmp(tmpstr, "open chatnav", 12)) {
    12211217    aim_reqservice(sess, conn, AIM_CONN_TYPE_CHATNAV);
     
    12341230    aim_getinfo(sess, conn, "midendian", AIM_GETINFO_AWAYMESSAGE);
    12351231    aim_getinfo(sess, conn, "midendian", AIM_GETINFO_CAPABILITIES);
    1236   } else if (strstr(tmpstr, "open directim")) {
    1237     directim_start(sess, userinfo->sn);
    12381232  } else if(strstr(tmpstr, "lookup")) {
    1239     aim_usersearch_address(sess, conn, "mid@auk.cx");
     1233    /* aim_usersearch_address(sess, conn, "mid@auk.cx"); */
    12401234  } else if (!strncmp(tmpstr, "reqsendmsg", 10)) {
    1241     aim_send_im(sess, priv->ohcaptainmycaptain, 0, "sendmsg 7900");
     1235    /* aim_send_im(sess, priv->ohcaptainmycaptain, 0, "sendmsg 7900"); */
    12421236  } else if (!strncmp(tmpstr, "reqadmin", 8)) {
    12431237    aim_reqservice(sess, conn, AIM_CONN_TYPE_AUTH);
     
    12641258        newbuf[z] = (z % 10)+0x30;
    12651259      newbuf[i] = '\0';
    1266       aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_ACK | AIM_IMFLAGS_AWAY, newbuf);
     1260      /* aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_ACK | AIM_IMFLAGS_AWAY, newbuf); */
    12671261      free(newbuf);
    12681262    }
    12691263  } else if (strstr(tmpstr, "seticqstatus")) {
    1270     aim_setextstatus(sess, conn, AIM_ICQ_STATE_DND);
     1264    aim_setextstatus(sess, AIM_ICQ_STATE_DND);
    12711265  } else if (strstr(tmpstr, "rtfmsg")) {
    12721266    static const char rtfmsg[] = {"{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1033{\\fonttbl{\\f0\\fswiss\\fcharset0 Arial;}{\\f1\\froman\\fprq2\\fcharset0 Georgia;}{\\f2\\fmodern\\fprq1\\fcharset0 MS Mincho;}{\\f3\\froman\\fprq2\\fcharset2 Symbol;}}\\viewkind4\\uc1\\pard\\f0\\fs20 Test\\f1 test\\f2\fs44 test\\f3\\fs20 test\\f0\\par}"};
     
    12781272    rtfargs.bgcolor = 0x00000000;
    12791273    rtfargs.rtfmsg = rtfmsg;
    1280     aim_send_rtfmsg(sess, &rtfargs);
     1274    /* aim_send_rtfmsg(sess, &rtfargs); */
    12811275  } else {
    12821276    /* printf("unknown command.\n"); */
     
    12861280  return 0;
    12871281}
     1282#endif
    12881283
    12891284/*
     
    12931288{
    12941289  struct owlfaim_priv *priv = (struct owlfaim_priv *)sess->aux_data;
    1295   int clienttype = AIM_CLIENTTYPE_UNKNOWN;
    12961290  owl_message *m;
    12971291  char *stripmsg, *nz_screenname, *wrapmsg;
    12981292  char realmsg[8192+1] = {""};
    1299   clienttype = aim_fingerprintclient(args->features, args->featureslen);
     1293  /* int clienttype = AIM_CLIENTTYPE_UNKNOWN; */
     1294
     1295  /* clienttype = aim_fingerprintclient(args->features, args->featureslen); */
    13001296
    13011297  /*
     
    13251321  */
    13261322
     1323  /*
    13271324  if (args->icbmflags & AIM_IMFLAGS_CUSTOMCHARSET) {
    1328     /* printf("icbm: encoding flags = {%04x, %04x}\n", args->charset, args->charsubset); */
    1329   }
     1325  printf("icbm: encoding flags = {%04x, %04x}\n", args->charset, args->charsubset);
     1326  }
     1327  */
    13301328 
    13311329  /*
     
    14251423 
    14261424  if (priv->buddyicon && (args->icbmflags & AIM_IMFLAGS_BUDDYREQ)) {
    1427     aim_send_icon(sess, userinfo->sn, priv->buddyicon, priv->buddyiconlen, priv->buddyiconstamp, priv->buddyiconsum);
     1425    /* aim_send_icon(sess, userinfo->sn, priv->buddyicon, priv->buddyiconlen, priv->buddyiconstamp, priv->buddyiconsum); */
    14281426  }
    14291427 
     
    14511449  */
    14521450 
    1453   if (args->reqclass == AIM_CAPS_GETFILE) {
    1454     getfile_requested(sess, conn, userinfo, args);
    1455   } else if (args->reqclass == AIM_CAPS_SENDFILE) {
     1451  if (args->reqclass == AIM_CAPS_SENDFILE) {
    14561452    /* printf("send file!\n"); */
    14571453  } else if (args->reqclass == AIM_CAPS_CHAT) {
     
    14651461
    14661462    /* aim_chat_join(sess, conn, args->info.chat.roominfo.exchange, args->info.chat.roominfo.name, args->info.chat.roominfo.instance); */
    1467   } else if (args->reqclass == AIM_CAPS_IMIMAGE) {
    1468     directim_requested(sess, conn, userinfo, args);
    14691463  } else if (args->reqclass == AIM_CAPS_BUDDYICON) {
    14701464    /* printf("Buddy Icon from %s, length = %lu\n", userinfo->sn, args->info.icon.length); */
     
    15081502  aim_userinfo_t *userinfo;
    15091503  char *nz_screenname;
    1510 
     1504  owl_buddy *b;
     1505  owl_buddylist *bl;
    15111506  va_list ap;
    15121507  va_start(ap, fr);
     
    15151510
    15161511  nz_screenname=owl_aim_normalize_screenname(userinfo->sn);
     1512  bl=owl_global_get_buddylist(&g);
     1513 
    15171514  owl_buddylist_oncoming(owl_global_get_buddylist(&g), nz_screenname);
     1515
     1516  if (userinfo->present & AIM_USERINFO_PRESENT_IDLE) {
     1517    /*  */
     1518  }
     1519
     1520  b=owl_buddylist_get_aim_buddy(owl_global_get_buddylist(&g), nz_screenname);
     1521  if (!b) {
     1522    owl_function_debugmsg("Error: parse_oncoming setting idle time with no buddy present.");
     1523    return(1);
     1524  }
     1525  if (userinfo->idletime==0) {
     1526    owl_buddy_set_unidle(b);
     1527  } else {
     1528    owl_buddy_set_idle(b);
     1529    owl_buddy_set_idle_since(b, userinfo->idletime);
     1530  }
     1531  owl_function_debugmsg("parse_oncoming sn: %s idle: %i", userinfo->sn, userinfo->idletime);
     1532   
    15181533  owl_free(nz_screenname);
    15191534 
     
    15501565  owl_free(nz_screenname);
    15511566
     1567  if (userinfo->present & AIM_USERINFO_PRESENT_IDLE) {
     1568    owl_function_debugmsg("parse_offgoing sn: %s idle time %i", userinfo->sn, userinfo->idletime);
     1569  }
     1570
    15521571  /*
    15531572  printf("%ld  %s is now offline (flags: %04x = %s%s%s%s%s%s%s%s) (caps = %s = 0x%08lx)\n",
     
    18301849  /* Login will happen all over again. */
    18311850  addcb_bos(sess, bosconn);
    1832   aim_sendcookie(sess, bosconn, cookie);
     1851  /* aim_sendcookie(sess, bosconn, cookie); */
    18331852  return 1;
    18341853}
     
    18381857 
    18391858  /* printf("got SSI rights, requesting data\n"); */
    1840   aim_ssi_reqdata(sess, fr->conn, 0, 0x0000);
     1859  /* aim_ssi_reqdata(sess, fr->conn, 0, 0x0000); */
     1860  aim_ssi_reqdata(sess);
    18411861 
    18421862  return 1;
     
    18491869  fu16_t itemcount;
    18501870  fu32_t stamp;
    1851   struct aim_ssi_item *list, *l;
     1871  struct aim_ssi_item *list;
     1872  struct aim_ssi_item *curitem;
     1873  /* struct aim_ssi_item *l; */
    18521874 
    18531875  va_start(ap, fr);
     
    18591881 
    18601882  /* printf("got SSI data: (0x%02x, %d items, %ld)\n", fmtver, itemcount, stamp); */
    1861   for (l = list; l; l = l->next) {
     1883  for (curitem=sess->ssi.local; curitem; curitem=curitem->next) {
     1884    /* for (l = list; l; l = l->next) { */
    18621885    /* printf("\t0x%04x (%s) - 0x%04x/0x%04x\n", l->type, l->name, l->gid, l->bid); */
    18631886    /* printf("I would have printed data here!\n"); */
    18641887  }
    18651888 
    1866   aim_ssi_enable(sess, fr->conn);
     1889  aim_ssi_enable(sess);
    18671890 
    18681891  return 1;
     
    18721895{
    18731896  /* printf("server says we have the latest SSI data already\n"); */
    1874   aim_ssi_enable(sess, fr->conn);
     1897  /* aim_ssi_enable(sess, fr->conn); */
     1898  aim_ssi_enable(sess);
    18751899  return 1;
    18761900}
     
    21282152  aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE, faimtest_conncomplete, 0);
    21292153  aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chat, 0);
    2130   aim_sendcookie(sess, tstconn, redir->cookie);
     2154  aim_sendcookie(sess, tstconn, redir->cookielen, redir->cookie);
    21312155  /* printf("chatnav: connected\n"); */
    21322156  return;
     
    21522176  aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE, faimtest_conncomplete, 0);
    21532177  aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chat, 0);
    2154   aim_sendcookie(sess, tstconn, redir->cookie);
     2178  aim_sendcookie(sess, tstconn, redir->cookielen, redir->cookie);
    21552179  return;       
    2156 }
    2157 
    2158 
    2159 
    2160 
    2161 /******************************************* ft.c ******************************************/
    2162 
    2163 
    2164 static int directim_incoming(aim_session_t *sess, aim_frame_t *fr, ...)
    2165 {
    2166   va_list ap;
    2167   char *sn, *msg;
    2168  
    2169   va_start(ap, fr);
    2170   sn = va_arg(ap, char *);
    2171   msg = va_arg(ap, char *);
    2172   va_end(ap);
    2173  
    2174   /* printf("Directim from %s: %s\n", sn, msg); */
    2175   if (strstr(msg, "sendmsg")) {
    2176     int i;
    2177    
    2178     i = atoi(strstr(msg, "sendmsg")+8);
    2179     if (i < 10000) {
    2180       char *newbuf;
    2181       int z;
    2182      
    2183       newbuf = malloc(i+1);
    2184       for (z = 0; z < i; z++)
    2185         newbuf[z] = (z % 10)+0x30;
    2186       newbuf[i] = '\0';
    2187       aim_send_im_direct(sess, fr->conn, newbuf, strlen(newbuf), 0);
    2188       free(newbuf);
    2189     }
    2190   } else if (strstr(msg, "goodday")) {
    2191     aim_send_im_direct(sess, fr->conn, "Good day to you, too", 18, 0);
    2192   } else {
    2193     char newmsg[1024];
    2194     snprintf(newmsg, sizeof(newmsg), "unknown (%s)\n", msg);
    2195     aim_send_im_direct(sess, fr->conn, newmsg, strlen(newmsg), 0);
    2196   }
    2197 
    2198   return 1;
    2199 }
    2200 
    2201 static int directim_typing(aim_session_t *sess, aim_frame_t *fr, ...)
    2202 {
    2203   va_list ap;
    2204   char *sn;
    2205  
    2206   va_start(ap, fr);
    2207   sn = va_arg(ap, char *);
    2208   va_end(ap);
    2209   /* printf("ohmigod! %s has started typing (DirectIM). He's going to send you a message! *squeal*\n", sn); */
    2210   return 1;
    2211 }
    2212 
    2213 static int faimtest_directim_initiate(aim_session_t *sess, aim_frame_t *fr, ...)
    2214 {
    2215   va_list ap;
    2216   aim_conn_t *newconn, *listenerconn;
    2217  
    2218   va_start(ap, fr);
    2219   newconn = va_arg(ap, aim_conn_t *);
    2220   listenerconn = va_arg(ap, aim_conn_t *);
    2221   va_end(ap);
    2222  
    2223   aim_conn_close(listenerconn);
    2224   aim_conn_kill(sess, &listenerconn);
    2225  
    2226   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING, directim_incoming, 0);
    2227   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING, directim_typing, 0);
    2228  
    2229   aim_send_im_direct(sess, newconn, "goodday", 8, 0);
    2230  
    2231   /* printf("OFT: DirectIM: connected to %s\n", aim_directim_getsn(newconn)); */
    2232  
    2233   return 1;
    2234 }
    2235 
    2236 static int faimtest_getfile_filereq(aim_session_t *ses, aim_frame_t *fr, ...)
    2237 {
    2238   va_list ap;
    2239   aim_conn_t *oftconn;
    2240   struct aim_fileheader_t *fh;
    2241   fu8_t *cookie;
    2242  
    2243   va_start(ap, fr);
    2244   oftconn = va_arg(ap, aim_conn_t *);
    2245   fh = va_arg(ap, struct aim_fileheader_t *);
    2246   cookie = va_arg(ap, fu8_t *);
    2247   va_end(ap);
    2248  
    2249   /* printf("request for file %s.\n", fh->name); */
    2250  
    2251   return 1;
    2252 }
    2253 
    2254 static int faimtest_getfile_filesend(aim_session_t *sess, aim_frame_t *fr, ...)
    2255 {
    2256   struct owlfaim_priv *priv = (struct owlfaim_priv *)sess->aux_data;
    2257   va_list ap;
    2258   aim_conn_t *oftconn;
    2259   struct aim_fileheader_t *fh;
    2260   char *path;
    2261   fu8_t *cookie;
    2262   int pos, bufpos = 0, bufsize = 2048, i;
    2263   char *buf;
    2264   FILE *file;
    2265  
    2266   va_start(ap, fr);
    2267   oftconn = va_arg(ap, aim_conn_t *);
    2268   fh = va_arg(ap, struct aim_fileheader_t *);
    2269   cookie = va_arg(ap, fu8_t *);
    2270   va_end(ap);
    2271  
    2272   /* printf("sending file %s(%ld).\n", fh->name, fh->size); */
    2273 
    2274   if (!(buf = malloc(2048)))
    2275     return -1;
    2276  
    2277   if (!(path = (char *)calloc(1, strlen(priv->listingpath) +strlen(fh->name)+2))) {
    2278     /* perror("calloc"); */
    2279     /* printf("error in calloc of path\n"); */
    2280    
    2281     return 0; /* XXX: no idea what winaim expects here =) */
    2282   }
    2283 
    2284   snprintf(path, strlen(priv->listingpath)+strlen(fh->name)+2, "%s/%s", priv->listingpath, fh->name);
    2285  
    2286   if (!(file = fopen(path, "r"))) {
    2287     /* printf("getfile_send fopen failed for %s. damn.\n", path); */
    2288     return 0;
    2289   }
    2290  
    2291   /*
    2292    * This is a mess. Remember that faimtest is demonstration code
    2293    * only and for the sake of the gods, don't use this code in any
    2294    * of your clients. --mid
    2295    */
    2296   for(pos = 0; pos < fh->size; pos++) {
    2297    
    2298     bufpos = pos % bufsize;
    2299    
    2300     if (bufpos == 0 && pos > 0) { /* filled our buffer. spit it across the wire */
    2301       if ( (i = send(oftconn->fd, buf, bufsize, 0)) != bufsize ) {
    2302         /* perror("faim: getfile_send: write1"); */
    2303         /* printf("faim: getfile_send: whoopsy, didn't write it all...\n"); */
    2304         free(buf);   
    2305         return 0;
    2306       }
    2307     }
    2308    
    2309     if( (buf[bufpos] = fgetc(file)) == EOF) {
    2310       if(pos != fh->size) {
    2311         /* printf("faim: getfile_send: hrm... apparent early EOF at pos 0x%x of 0x%lx\n", pos, fh->size); */
    2312         free(buf);   
    2313         return 0;
    2314       }
    2315     }     
    2316     /* printf("%c(0x%02x) ", buf[pos], buf[pos]); */
    2317   }
    2318  
    2319   if( (i = send(oftconn->fd, buf, bufpos+1, 0)) != (bufpos+1)) {
    2320     /* perror("faim: getfile_send: write2"); */
    2321     /* printf("faim: getfile_send cleanup: whoopsy, didn't write it all...\n"); */
    2322     free(buf);   
    2323     return 0;
    2324   }
    2325  
    2326   free(buf);
    2327   free(fh);
    2328  
    2329   return 1;
    2330 }
    2331 
    2332 static int faimtest_getfile_complete(aim_session_t *sess, aim_frame_t *fr, ...)
    2333 {
    2334   va_list ap;
    2335   aim_conn_t *conn;
    2336   struct aim_fileheader_t *fh;
    2337  
    2338   va_start(ap, fr);
    2339   conn = va_arg(ap, aim_conn_t *);
    2340   fh = va_arg(ap, struct aim_fileheader_t *);
    2341   va_end(ap);
    2342  
    2343   /* printf("completed file transfer for %s.\n", fh->name); */
    2344  
    2345   aim_conn_close(conn);
    2346   aim_conn_kill(sess, &conn);
    2347  
    2348   return 1;
    2349 }
    2350 
    2351 static int faimtest_getfile_disconnect(aim_session_t *sess, aim_frame_t *fr, ...)
    2352 {
    2353   va_list ap;
    2354   aim_conn_t *conn;
    2355   char *sn;
    2356  
    2357   va_start(ap, fr);
    2358   conn = va_arg(ap, aim_conn_t *);
    2359   sn = va_arg(ap, char *);
    2360   va_end(ap);
    2361  
    2362   aim_conn_kill(sess, &conn);
    2363  
    2364   /* printf("getfile: disconnected from %s\n", sn); */
    2365  
    2366   return 1;
    2367 }
    2368 
    2369 static int faimtest_getfile_listing(aim_session_t *sess, aim_frame_t *fr, ...)
    2370 {
    2371   va_list ap;
    2372   aim_conn_t *conn;
    2373   char *listing;
    2374   struct aim_filetransfer_priv *ft;
    2375   char *filename, *nameend, *sizec;
    2376   int filesize, namelen;
    2377  
    2378   va_start(ap, fr);
    2379   conn = va_arg(ap, aim_conn_t *);
    2380   ft = va_arg(ap, struct aim_filetransfer_priv *);
    2381   listing = va_arg(ap, char *);
    2382   va_end(ap);
    2383  
    2384   /* printf("listing on %d==================\n%s\n===========\n", conn->fd, listing); */
    2385  
    2386   nameend = strstr(listing+0x1a, "\r");
    2387   namelen = nameend - (listing + 0x1a);
    2388  
    2389   filename = malloc(namelen + 1);
    2390   strncpy(filename, listing+0x1a, namelen);
    2391   filename[namelen] = 0x00;
    2392  
    2393   sizec = malloc(8+1);
    2394   memcpy(sizec, listing + 0x11, 8);
    2395   sizec[8] = 0x00;
    2396  
    2397   filesize =  strtol(sizec, (char **)NULL, 10);
    2398  
    2399   /* printf("requesting %d %s(%d long)\n", namelen, filename, filesize); */
    2400  
    2401   /* aim_oft_getfile_request(sess, conn, filename, filesize); */
    2402  
    2403   free(filename);
    2404   free(sizec);
    2405  
    2406   return 0;
    2407 }
    2408 
    2409 static int faimtest_getfile_listingreq(aim_session_t *sess, aim_frame_t *fr, ...)
    2410 {
    2411   struct owlfaim_priv *priv = (struct owlfaim_priv *)sess->aux_data;
    2412   va_list ap;
    2413   aim_conn_t *oftconn;
    2414   struct aim_fileheader_t *fh;
    2415   int pos, bufpos = 0, bufsize = 2048, i;
    2416   char *buf;
    2417  
    2418   va_start(ap, fr);
    2419   oftconn = va_arg(ap, aim_conn_t *);
    2420   fh = va_arg(ap, struct aim_fileheader_t *);
    2421   va_end(ap);
    2422  
    2423   /* printf("sending listing of size %ld\n", fh->size); */
    2424 
    2425   if(!(buf = malloc(2048))) return -1;
    2426  
    2427   for(pos = 0; pos < fh->size; pos++) {
    2428     bufpos = pos % bufsize;
    2429     if(bufpos == 0 && pos > 0) { /* filled our buffer. spit it across the wire */
    2430       if ( (i = send(oftconn->fd, buf, bufsize, 0)) != bufsize ) {
    2431         /* perror("faim: getfile_send: write1"); */
    2432         /* printf("faim: getfile_send: whoopsy, didn't write it all...\n"); */
    2433         free(buf);   
    2434         return 0;
    2435       }
    2436     }
    2437     if( (buf[bufpos] = fgetc(priv->listingfile)) == EOF) {
    2438       if(pos != fh->size) {
    2439         /* printf("faim: getfile_send: hrm... apparent early EOF at pos 0x%x of 0x%lx\n", pos, fh->size); */
    2440         free(buf);   
    2441         return 0;
    2442       }
    2443     }     
    2444   }
    2445  
    2446   if( (i = send(oftconn->fd, buf, bufpos+1, 0)) != (bufpos+1)) {
    2447     /* perror("faim: getfile_send: write2"); */
    2448     /* printf("faim: getfile_send cleanup: whoopsy, didn't write it all...\n"); */
    2449     free(buf);   
    2450     return 0;
    2451   }
    2452  
    2453   /* printf("sent listing\n"); */
    2454   free(buf);
    2455  
    2456   return 0;
    2457 }
    2458 
    2459 static int faimtest_getfile_receive(aim_session_t *sess, aim_frame_t *fr, ...)
    2460 {
    2461   /* needs ot be fixed --kretch */
    2462 #if 0
    2463   va_list ap;
    2464   aim_conn_t *conn;
    2465   struct aim_filetransfer_priv *ft;
    2466   unsigned char data;
    2467   int pos;
    2468 
    2469 
    2470   va_start(ap, fr);
    2471   conn = va_arg(ap, aim_conn_t *);
    2472   ft = va_arg(ap, struct aim_filetransfer_priv *);
    2473   va_end(ap);
    2474 
    2475   /* printf("receiving %ld bytes of file data for %s:\n\t", ft->fh.size, ft->fh.name); */
    2476 
    2477   for(pos = 0; pos < ft->fh.size; pos++) {
    2478     read(conn->fd, &data, 1);
    2479     /* printf("%c(%02x) ", data, data); */
    2480   }
    2481 
    2482   /* printf("\n"); */
    2483 
    2484   aim_oft_getfile_end(sess, conn);
    2485 #endif
    2486   return 0;
    2487 }
    2488 
    2489 static int faimtest_getfile_state4(aim_session_t *sess, aim_frame_t *fr, ...)
    2490 {
    2491   va_list ap;
    2492   aim_conn_t *conn;
    2493  
    2494   va_start(ap, fr);
    2495   conn = va_arg(ap, aim_conn_t *);
    2496   va_end(ap);
    2497  
    2498   aim_conn_close(conn);
    2499   aim_conn_kill(sess, &conn);
    2500  
    2501   return 0;
    2502 }
    2503 
    2504 static int faimtest_getfile_initiate(aim_session_t *sess, aim_frame_t *fr, ...)
    2505 {
    2506   va_list ap;
    2507   aim_conn_t *conn, *listenerconn;
    2508   struct aim_filetransfer_priv *priv;
    2509  
    2510   va_start(ap, fr);
    2511   conn = va_arg(ap, aim_conn_t *);
    2512   listenerconn = va_arg(ap, aim_conn_t *);
    2513   va_end(ap);
    2514  
    2515   aim_conn_close(listenerconn);
    2516   aim_conn_kill(sess, &listenerconn);
    2517 
    2518   /*   This doesn't work with the new libfaim */
    2519   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ,  faimtest_getfile_filereq, 0);
    2520   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILESEND, faimtest_getfile_filesend, 0);
    2521   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILECOMPLETE, faimtest_getfile_complete, 0);     
    2522   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEDISCONNECT, faimtest_getfile_disconnect, 0);     
    2523   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTING, faimtest_getfile_listing, 0);
    2524   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTINGREQ, faimtest_getfile_listingreq, 0);
    2525   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILERECEIVE, faimtest_getfile_receive, 0);
    2526   aim_conn_addhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILESTATE4, faimtest_getfile_state4, 0);
    2527  
    2528   priv = (struct aim_filetransfer_priv *)conn->priv;
    2529  
    2530   /* printf("getfile: %s (%s) connected to us on %d\n", priv->sn, priv->ip, conn->fd); */
    2531  
    2532   return 1;
    2533 }
    2534 
    2535 void getfile_start(aim_session_t *sess, aim_conn_t *conn, const char *sn)
    2536 {
    2537   aim_conn_t *newconn;
    2538  
    2539   newconn = aim_getfile_initiate(sess, conn, sn);
    2540   /* printf("getting file listing from %s\n", sn); */
    2541   aim_conn_addhandler(sess, newconn,  AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEINITIATE, faimtest_getfile_initiate,0);
    2542  
    2543   return;
    2544 }
    2545 
    2546 void getfile_requested(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args)
    2547 {
    2548   struct owlfaim_priv *priv = (struct owlfaim_priv *)sess->aux_data;
    2549   aim_conn_t *newconn;
    2550   struct aim_fileheader_t *fh;
    2551  
    2552   printf("get file request from %s (at %s/%s/%s) %x\n", userinfo->sn, args->clientip, args->clientip2, args->verifiedip, args->reqclass);
    2553   fh = aim_getlisting(sess, priv->listingfile);
    2554   newconn = aim_accepttransfer(sess, conn, userinfo->sn, args->cookie, args->clientip, fh->totfiles, fh->totsize, fh->size, fh->checksum, args->reqclass);
    2555   free(fh);
    2556 
    2557   if ( (!newconn) || (newconn->fd == -1) ) {
    2558     printf("getfile: requestconn: apparent error in accepttransfer\n");
    2559     if (newconn) aim_conn_kill(sess, &newconn);
    2560     return;
    2561   }
    2562  
    2563   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILELISTINGREQ, faimtest_getfile_listingreq, 0);
    2564   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILEREQ,  faimtest_getfile_filereq, 0);
    2565   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEFILESEND, faimtest_getfile_filesend, 0);
    2566   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILECOMPLETE, faimtest_getfile_complete, 0);     
    2567   aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_GETFILEDISCONNECT, faimtest_getfile_disconnect, 0);     
    2568  
    2569   /* printf("getfile connect succeeded, handlers added.\n"); */
    2570  
    2571   return;
    2572 }
    2573 
    2574 void directim_start(aim_session_t *sess, const char *sn)
    2575 {
    2576   aim_conn_t *newconn;
    2577  
    2578   /* printf("opening directim to %s\n", sn); */
    2579   newconn = aim_directim_initiate(sess, sn);
    2580   if (!newconn || (newconn->fd == -1)) {
    2581     /* printf("connection failed!\n"); */
    2582     if (newconn) aim_conn_kill(sess, &newconn);
    2583   } else {
    2584     aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINITIATE, faimtest_directim_initiate, 0);
    2585   }
    2586   return;
    2587 }
    2588 
    2589 void directim_requested(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args)
    2590 {
    2591   aim_conn_t *newconn;
    2592  
    2593   /* printf("OFT: DirectIM: request from %s (%s/%s/%s)\n", userinfo->sn, args->clientip, args->clientip2, args->verifiedip); */
    2594  
    2595   newconn = aim_directim_connect(sess, userinfo->sn, args->clientip, args->cookie);
    2596   if (!newconn || (newconn->fd == -1)) {
    2597     /* printf("icbm: imimage: could not connect\n"); */
    2598     if (newconn) aim_conn_kill(sess, &newconn);
    2599   } else {
    2600     aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING, directim_incoming, 0);
    2601     aim_conn_addhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING, directim_typing, 0);
    2602     /* printf("OFT: DirectIM: connected to %s\n", userinfo->sn); */
    2603     aim_send_im_direct(sess, newconn, "goodday", 7, 0);
    2604   }
    26052180}
    26062181
Note: See TracChangeset for help on using the changeset viewer.