开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > ICQ/即时通讯 > 查看源码
sendmsg.c
资源名称：micq.tgz　[点击查看]
上传用户：ai20ln
上传日期：2007-01-05
资源大小：79k
文件大小：26k
源码类别：

ICQ/即时通讯

开发平台：

Unix_Linux

sendmsg.c：源码内容
  1. /*
  2. Send Message Function for ICQ... 
  3. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. Author : zed@mentasm.com
  5. */
  6. #include "datatype.h"
  7. #include "micq.h"
  8. #include "msg_queue.h"
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <time.h>
  12. #ifdef _WIN32
  13.   #include <winsock2.h>
  14. #else
  15.   #include <unistd.h>
  16.   #include <sys/types.h>
  17.   #include <sys/socket.h>
  18. #endif
  19. #include <string.h>
  20. #include <assert.h>
  21. #include <limits.h>
  23. /*unsigned int next_resend;*/
  25. static size_t SOCKWRITE_LOW( SOK_T sok, void * ptr, size_t len );
  27. /* Historical */
  28. void Initialize_Msg_Queue()
  29. {
  30.     msg_queue_init();
  31. }
  33. /****************************************************************
  34. Checks if packets are waiting to be resent and sends them.
  35. *****************************************************************/
  36. void Do_Resend( SOK_T sok )
  37. {
  38.     struct msg *queued_msg;
  39.     SIMPLE_MESSAGE_PTR s_mesg;
  40.     DWORD type; 
  41.     char *data;
  42.     char *tmp;
  43.     char *temp;
  44.     char url_desc[1024], url_data[1024];
  45.     net_icq_pak pak;
  47.     if ((queued_msg = msg_queue_pop()) != NULL)
  48.     {
  49.         queued_msg->attempts++;
  50.         if (queued_msg->attempts <= 6)
  51.         {
  52.             if ( Verbose )
  53.             {
  54.                 M_print( "nResending message with SEQ num %04x.tCMD ", queued_msg->seq );
  55. Print_CMD( Chars_2_Word( &queued_msg->body[6] ) );
  56. M_print( "(Attempt #%d.)n", queued_msg->attempts);
  57.                 Prompt();
  58.             }
  59.             if ( 0x1000 < Chars_2_Word( &queued_msg->body[6] ) ) {
  60. Dump_Queue();
  61.             }
  62.     temp = malloc( queued_msg->len );
  63.     memcpy( temp, queued_msg->body, queued_msg->len);
  64.             SOCKWRITE_LOW(sok, temp, queued_msg->len);
  65.     free(temp);
  66.             queued_msg->exp_time = time(NULL) + 10; 
  67.             msg_queue_push( queued_msg );
  68.         }
  69.         else
  70.         {
  71.             memcpy(&pak.head.ver, queued_msg->body, queued_msg->len); 
  72.     if ( CMD_SENDM  == Chars_2_Word( pak.head.cmd ) ) {
  73.                s_mesg = ( SIMPLE_MESSAGE_PTR ) pak.data;
  74.                M_print("nDiscarding message to ");
  75.                Print_UIN_Name( Chars_2_DW( s_mesg->uin ) );
  76.                M_print(" after %d send attempts.  Message content:n",
  77.                        queued_msg->attempts - 1);
  79.                type = Chars_2_Word(s_mesg->type);
  80.                data = s_mesg->len + 2; 
  81.                if (type == URL_MESS || type == MRURL_MESS)
  82.                {
  83.                    tmp = strchr( data, 'xFE' );
  84.                    if ( tmp != NULL )
  85.                    {
  86.                        *tmp = 0;
  87.                        rus_conv("wk", data);
  88.                        strcpy(url_desc, data);
  89.                        tmp++;
  90.                        data = tmp;
  91.                        rus_conv("wk", data);
  92.                        strcpy(url_data, data);
  94.                        M_print( " Description: " MESSCOL "%s" 
  95.                                NOCOL "n", url_desc );
  96.                        M_print( " URL        : " MESSCOL "%s" NOCOL "n", 
  97.                                url_data );
  98.                    }
  99.                }
  100.                else if (type == NORM_MESS || type == MRNORM_MESS)
  101.                {
  102.                    rus_conv("wk", data); 
  103.                    M_print( MESSCOL "%s", data );
  104.                    M_print( NOCOL "n" );
  105.                }
  106.             } else {
  107.        M_print( "nDiscarded a " );
  108.        Print_CMD( Chars_2_Word( pak.head.cmd ) );
  109.        M_print( " packet.n" );
  110.        if ( ( CMD_LOGIN == Chars_2_Word( pak.head.cmd ) ) ||
  111.             ( CMD_KEEP_ALIVE == Chars_2_Word( pak.head.cmd ) ) ) {
  112.                   M_print( "aConnection unstable exiting....n" );
  113.   Quit = TRUE;
  114.        }
  115.     }
  116.             Prompt();
  118.             free(queued_msg->body);
  119.             free(queued_msg);
  120.         }
  122.         if ( (queued_msg = msg_queue_peek() ) != NULL )
  123.         {
  124.             next_resend = queued_msg->exp_time; 
  125.         }
  126.         else
  127.         {
  128.             next_resend = INT_MAX;
  129.         }
  130.     }
  131.     else
  132.     {
  133.         next_resend = INT_MAX;
  134.     }
  135. }
  137. /*********************************
  138. This must be called to remove messages
  139. from the server
  140. **********************************/
  141. void snd_got_messages( int sok )
  142. {
  143.    net_icq_pak pak;
  144.    
  145.    Word_2_Chars( pak.head.ver, ICQ_VER );
  146.    Word_2_Chars( pak.head.cmd, CMD_ACK_MESSAGES );
  147.    Word_2_Chars( pak.head.seq, seq_num++ );
  148.    DW_2_Chars( pak.head.UIN, UIN );
  149.    
  150.    last_cmd[ (seq_num - 1) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  151.    SOCKWRITE( sok, &(pak.head.ver), sizeof( pak.head ) - 2 );
  152. }
  154. /*************************************
  155. this sends over the contact list
  156. **************************************/
  157. void snd_contact_list( int sok )
  158. {
  159.    net_icq_pak pak;
  160.    int num_used;
  161.    int i, size;
  162.    char *tmp;
  163.    
  164.    Word_2_Chars( pak.head.ver, ICQ_VER );
  165.    Word_2_Chars( pak.head.cmd, CMD_CONT_LIST );
  166.    Word_2_Chars( pak.head.seq, seq_num++ );
  167.    DW_2_Chars( pak.head.UIN, UIN );
  168.    
  169.    tmp = pak.data;
  170.    tmp++;
  171.    for ( i=0, num_used=0; i < Num_Contacts ; i++ )
  172.    {
  173.       if ( (S_DWORD) Contacts[ i ].uin >  0 )
  174.       {
  175.          DW_2_Chars( tmp, Contacts[i].uin );
  176.          tmp+=4;
  177.          num_used++;
  178.       }
  179.    }
  180.    pak.data[0] = num_used;
  181. /*   Word_2_Chars( pak.data, num_used ); */
  182.    size = sizeof( DWORD ) * num_used + 1;
  183.    size += sizeof( pak.head ) - 2;
  184.    last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  185.    SOCKWRITE( sok, &(pak.head.ver), size );
  186. }
  188. /*************************************
  189. this sends over the Invisible list
  190. that allows certain users to see you
  191. if you're invisible.
  192. **************************************/
  193. void snd_invis_list( int sok )
  194. {
  195.    net_icq_pak pak;
  196.    int num_used;
  197.    int i, size;
  198.    char *tmp;
  199.    
  200.    Word_2_Chars( pak.head.ver, ICQ_VER );
  201.    Word_2_Chars( pak.head.cmd, CMD_INVIS_LIST );
  202.    Word_2_Chars( pak.head.seq, seq_num );
  203.    DW_2_Chars( pak.head.UIN, UIN );
  204.    
  205.    tmp = pak.data;
  206.    tmp++;
  207.    for ( i=0, num_used=0; i < Num_Contacts ; i++ )
  208.    {
  209.       if ( (S_DWORD) Contacts[ i ].uin >  0 )
  210.       {
  211.          if ( Contacts[i].invis_list )
  212.          {
  213.             DW_2_Chars( tmp, Contacts[i].uin );
  214.             tmp+=4;
  215.             num_used++;
  216.          }
  217.       }
  218.    }
  219.    if ( num_used != 0 )
  220.    {
  221.       pak.data[0] = num_used;
  222.       size = ( ( int ) tmp - ( int ) pak.data );
  223.       size += sizeof( pak.head ) - 2;
  224.       last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  225.       SOCKWRITE( sok, &(pak.head.ver), size );
  226.       seq_num++;
  227.    }
  228. }
  230. /*************************************
  231. this sends over the Visible list
  232. that allows certain users to see you
  233. if you're invisible.
  234. **************************************/
  235. void snd_vis_list( int sok )
  236. {
  237.    net_icq_pak pak;
  238.    int num_used;
  239.    int i, size;
  240.    char *tmp;
  241.    
  242.    Word_2_Chars( pak.head.ver, ICQ_VER );
  243.    Word_2_Chars( pak.head.cmd, CMD_VIS_LIST );
  244.    Word_2_Chars( pak.head.seq, seq_num );
  245.    DW_2_Chars( pak.head.UIN, UIN );
  246.    
  247.    tmp = pak.data;
  248.    tmp++;
  249.    for ( i=0, num_used=0; i < Num_Contacts ; i++ )
  250.    {
  251.       if ( (S_DWORD) Contacts[ i ].uin >  0 )
  252.       {
  253.          if ( Contacts[i].vis_list )
  254.          {
  255.             DW_2_Chars( tmp, Contacts[i].uin );
  256.             tmp+=4;
  257.             num_used++;
  258.          }
  259.       }
  260.    }
  261.    if ( num_used != 0 )
  262.    {
  263.       pak.data[0] = num_used;
  264.       size = ( ( int ) tmp - ( int ) pak.data );
  265.       size += sizeof( pak.head ) - 2;
  266.       last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  267.       SOCKWRITE( sok, &(pak.head.ver), size );
  268.       seq_num++;
  269.    }
  270. }
  272. /**************************************
  273. This sends the second login command
  274. this is necessary to finish logging in.
  275. ***************************************/
  276. void snd_login_1( int sok )
  277. {
  278.    net_icq_pak pak;
  279.    
  280.    Word_2_Chars( pak.head.ver, ICQ_VER );
  281.    Word_2_Chars( pak.head.cmd, CMD_LOGIN_1 );
  282.    Word_2_Chars( pak.head.seq, seq_num++ );
  283.    DW_2_Chars( pak.head.UIN, UIN );
  284.    
  285.    last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  286.    SOCKWRITE( sok, &(pak.head.ver), sizeof( pak.head ) - 2 );
  287. }
  289. /*********************************
  290. This must be called every 2 min.
  291. so the server knows we're still alive.
  292. JAVA client sends two different commands
  293. so we do also :)
  294. **********************************/
  295. void Keep_Alive( int sok )
  296. {
  297.    net_icq_pak pak;
  298.    
  299.    Word_2_Chars( pak.head.ver, ICQ_VER );
  300.    Word_2_Chars( pak.head.cmd, CMD_KEEP_ALIVE );
  301.    Word_2_Chars( pak.head.seq, seq_num++ );
  302.    DW_2_Chars( pak.head.UIN, UIN );
  303.    
  304.    last_cmd[(seq_num - 1) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  305.    SOCKWRITE( sok, &(pak.head.ver), sizeof( pak.head ) - 2 );
  307.    Word_2_Chars( pak.head.ver, ICQ_VER );
  308.    Word_2_Chars( pak.head.cmd, CMD_KEEP_ALIVE2 );
  309.    Word_2_Chars( pak.head.seq, seq_num++ );
  310.    DW_2_Chars( pak.head.UIN, UIN );
  311.    
  312.    last_cmd[(seq_num - 1) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  313.    SOCKWRITE( sok, &(pak.head.ver), sizeof( pak.head ) - 2 );
  314.    if ( Verbose )
  315.    {
  316. #ifdef FUNNY_MSGS
  317.    M_print( "nIf you go to" MESSCOL " Z'Ha'Dum " NOCOL "you will die!!!!n" ); 
  318.    /* or if you don't send this packet */
  319. #else
  320.    M_print( "nSend Keep_Alive packet to the servern" );
  321. #endif
  322.    }
  323. }
  325. /********************************************************
  326. The following data constitutes fair use for compatibility.
  327. *********************************************************/
  328. unsigned char icq_check_data[257] = {
  329. 0x0a, 0x5b, 0x31, 0x5d, 0x20, 0x59, 0x6f, 0x75, 
  330. 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6d, 0x6f, 0x64, 
  331. 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 
  332. 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x20, 0x49,
  333. 0x43, 0x51, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 
  334. 0x2e, 0x20, 0x4a, 0x75, 0x73, 0x74, 0x20, 0x73, 
  335. 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x22, 0x53, 
  336. 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x22, 0x20, 0x66, 
  337. 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20,
  338. 0x22, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65,
  339. 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x6d, 0x69, 0x73,
  340. 0x63, 0x22, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x43,
  341. 0x51, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x72, 0x6f,
  342. 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x22, 0x53,
  343. 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x22, 0x20, 0x69,
  344. 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f,
  345. 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x70, 0x61,
  346. 0x6e, 0x65, 0x6c, 0x2e, 0x20, 0x43, 0x72, 0x65,
  347. 0x64, 0x69, 0x74, 0x3a, 0x20, 0x45, 0x72, 0x61,
  348. 0x6e, 0x0a, 0x5b, 0x32, 0x5d, 0x20, 0x43, 0x61,
  349. 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x6d, 0x65,
  350. 0x6d, 0x62, 0x65, 0x72, 0x20, 0x77, 0x68, 0x61,
  351. 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x73, 0x61,
  352. 0x69, 0x64, 0x3f, 0x20, 0x20, 0x44, 0x6f, 0x75,
  353. 0x62, 0x6c, 0x65, 0x2d, 0x63, 0x6c, 0x69, 0x63,
  354. 0x6b, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x75,
  355. 0x73, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x67,
  356. 0x65, 0x74, 0x20, 0x61, 0x20, 0x64, 0x69, 0x61,
  357. 0x6c, 0x6f, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x61,
  358. 0x6c, 0x6c, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61,
  359. 0x67, 0x65, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x74,
  360. 0x20, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0
  361. };
  363. /***************************************************
  364. Sends a message thru the server to uin.  Text is the
  365. message to send.
  366. ****************************************************/
  367. void icq_sendmsg( SOK_T sok, DWORD uin, char *text, DWORD msg_type)
  368. {
  369. SIMPLE_MESSAGE msg;
  370. net_icq_pak pak;
  371. int size, len; 
  373. log_event("You sent instant message",text,uin);
  374. rus_conv ("kw",text);
  377. len = strlen(text);
  378. Word_2_Chars( pak.head.ver, ICQ_VER );
  379. Word_2_Chars( pak.head.cmd, CMD_SENDM );
  380. Word_2_Chars( pak.head.seq, seq_num++ );
  381. DW_2_Chars( pak.head.UIN, UIN );
  383. DW_2_Chars( msg.uin, uin );
  384. Word_2_Chars(msg.type, msg_type);
  385. Word_2_Chars( msg.len, len + 1 ); /* length + the NULL */
  387. memcpy(&pak.data, &msg, sizeof( msg ) );
  388. memcpy(&pak.data[8], text, len + 1);
  390. size = sizeof( msg ) + len + 1;
  392. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  393. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  394. }
  396. /**************************************************
  397. Sends a authorixation to the server so the Mirabilis
  398. client can add the user.
  399. ***************************************************/
  400. void icq_sendauthmsg( SOK_T sok, DWORD uin)
  401. {
  402. SIMPLE_MESSAGE msg;
  403. net_icq_pak pak;
  404. int size; 
  406. Word_2_Chars( pak.head.ver, ICQ_VER );
  407. Word_2_Chars( pak.head.cmd, CMD_SENDM );
  408. Word_2_Chars( pak.head.seq, seq_num++ );
  409. DW_2_Chars( pak.head.UIN, UIN );
  411. DW_2_Chars( msg.uin, uin );
  412. DW_2_Chars( msg.type, AUTH_MESSAGE ); /* A type authorization msg*/
  413. Word_2_Chars( msg.len, 2 );
  415. memcpy(&pak.data, &msg, sizeof( msg ) );
  417.    pak.data[ sizeof(msg) ]=0x03;
  418.    pak.data[ sizeof(msg) + 1]=0x00;
  420. size = sizeof( msg ) + 2;
  422. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  423. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  424. }
  426. /***************************************************
  427. Requests a random user from the specified group.
  428. ****************************************************/
  429. void icq_rand_user_req( SOK_T sok, DWORD group )
  430. {
  431.    net_icq_pak pak;
  432.    int size ;
  435.    Word_2_Chars( pak.head.ver, ICQ_VER );
  436.    Word_2_Chars( pak.head.cmd, CMD_RAND_SEARCH );
  437.    Word_2_Chars( pak.head.seq, seq_num++ );
  438.    DW_2_Chars( pak.head.UIN, UIN );
  440.    DW_2_Chars( pak.data, group);
  442.    size = 4;
  444.    last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  445.    SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  446. }
  448. /***************************************************
  449. Sets our Random chat group
  450. ****************************************************/
  451. void icq_rand_set( SOK_T sok, DWORD group )
  452. {
  453.    net_icq_pak pak;
  454.    int size ;
  457.    Word_2_Chars( pak.head.ver, ICQ_VER );
  458.    Word_2_Chars( pak.head.cmd, CMD_RAND_SET );
  459.    Word_2_Chars( pak.head.seq, seq_num++ );
  460.    DW_2_Chars( pak.head.UIN, UIN );
  462.    DW_2_Chars( pak.data, group);
  464.    size = 4;
  466.    last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  467.    SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  468. }
  471. /***************************************************
  472. Changes the users status on the server
  473. ****************************************************/
  474. void icq_change_status( SOK_T sok, DWORD status )
  475. {
  476. net_icq_pak pak;
  477. int size ;
  480. Word_2_Chars( pak.head.ver, ICQ_VER );
  481. Word_2_Chars( pak.head.cmd, CMD_STATUS_CHANGE );
  482. Word_2_Chars( pak.head.seq, seq_num++ );
  483. DW_2_Chars( pak.head.UIN, UIN );
  485.    DW_2_Chars( pak.data, status);
  486.    Current_Status = status;
  488. size = 4;
  490. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  491. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  492. }
  494. /******************************************************************
  495. Logs off ICQ should handle other cleanup as well
  496. ********************************************************************/
  497. void Quit_ICQ( int sok )
  498. {
  499. net_icq_pak pak;
  500. int size, len;
  501.    
  502. Word_2_Chars( pak.head.ver, ICQ_VER );
  503. Word_2_Chars( pak.head.cmd, CMD_SEND_TEXT_CODE );
  504. Word_2_Chars( pak.head.seq, seq_num++ );
  505. DW_2_Chars( pak.head.UIN, UIN );
  506.    
  507.    len = strlen( "B_USER_DISCONNECTED" ) + 1;
  508.    *(short * ) pak.data = len;
  509.    size = len + 4;
  510.    
  511.    memcpy( &pak.data[2], "B_USER_DISCONNECTED", len );
  512.    pak.data[ 2 + len ] = 05;
  513.    pak.data[ 3 + len ] = 00;
  515.    last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  516.    SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  518.    SOCKCLOSE(sok);
  519.    SOCKCLOSE( sok );
  520. }
  522. void info_req_99( SOK_T sok, DWORD uin )
  523. {
  524. net_icq_pak pak;
  525. int size ;
  527. Word_2_Chars( pak.head.ver, ICQ_VER );
  528. Word_2_Chars( pak.head.cmd, CMD_META_USER );
  529. Word_2_Chars( pak.head.seq, seq_num++ );
  530. DW_2_Chars( pak.head.UIN, UIN );
  531. #if ICQ_VER == 0x0002
  532.    Word_2_Chars( pak.data , seq_num );
  533.    DW_2_Chars( pak.data + 2, uin );
  535. size = 6;
  536. #else
  537.    Word_2_Chars( pak.data , META_INFO_REQ );
  538.    DW_2_Chars( pak.data + 2, uin );
  540. size = 6;
  541. #endif
  543. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  544. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  546. }
  548. /*********************************************************
  549. Sends a request to the server for info on a specific user
  550. **********************************************************/
  551. void send_info_req( SOK_T sok, DWORD uin )
  552. {
  553. net_icq_pak pak;
  554. int size ;
  556. #if 1
  557. Word_2_Chars( pak.head.ver, ICQ_VER );
  558. Word_2_Chars( pak.head.cmd, CMD_INFO_REQ );
  559. Word_2_Chars( pak.head.seq, seq_num++ );
  560. DW_2_Chars( pak.head.UIN, UIN );
  561. #if ICQ_VER == 0x0002
  562.    Word_2_Chars( pak.data , seq_num );
  563.    DW_2_Chars( pak.data + 2, uin );
  565. size = 6;
  566. #else
  567.    DW_2_Chars( pak.data, uin );
  569. size = 4;
  570. #endif
  572. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  573. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  574. #endif
  575. }
  577. /*********************************************************
  578. Sends a request to the server for info on a specific user
  579. **********************************************************/
  580. void send_ext_info_req( SOK_T sok, DWORD uin )
  581. {
  582. net_icq_pak pak;
  583. int size ;
  586. Word_2_Chars( pak.head.ver, ICQ_VER );
  587. Word_2_Chars( pak.head.cmd, CMD_EXT_INFO_REQ );
  588. Word_2_Chars( pak.head.seq, seq_num++ );
  589. DW_2_Chars( pak.head.UIN, UIN );
  591. #if ICQ_VER == 0x0002
  592.    Word_2_Chars( pak.data , seq_num );
  593.    DW_2_Chars( pak.data + 2, uin );
  594. size = 6;
  595. #else
  596.    DW_2_Chars( pak.data , uin );
  597. size = 4;
  598. #endif
  601. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  602. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  603. }
  605. /***************************************************************
  606. Initializes a server search for the information specified
  607. ****************************************************************/
  608. void start_search( SOK_T sok, char *email, char *nick, char* first, char* last )
  609. {
  610. net_icq_pak pak;
  611. int size ;
  613. Word_2_Chars( pak.head.ver, ICQ_VER );
  614. Word_2_Chars( pak.head.cmd, CMD_SEARCH_USER );
  615. Word_2_Chars( pak.head.seq, seq_num++ );
  616. DW_2_Chars( pak.head.UIN, UIN );
  617. /*
  618.    Word_2_Chars( pak.data , seq_num++ );
  619.    size = 2;
  620. */
  621.    size = 0;
  622.    Word_2_Chars( pak.data + size, strlen( nick ) + 1 );
  623.    size += 2;
  624.    strcpy( pak.data + size , nick );
  625.    size += strlen( nick ) + 1;
  626.    Word_2_Chars( pak.data + size, strlen( first ) + 1 );
  627.    size += 2;
  628.    strcpy( pak.data + size , first );
  629.    size += strlen( first ) + 1;
  630.    Word_2_Chars( pak.data + size, strlen( last ) + 1);
  631.    size += 2;
  632.    strcpy( pak.data + size , last );
  633.    size += strlen( last ) +1 ;
  634.    Word_2_Chars( pak.data + size, strlen( email ) + 1  );
  635.    size += 2;
  636.    strcpy( pak.data + size , email );
  637.    size += strlen( email ) + 1;
  638. last_cmd[seq_num - 2 ] = Chars_2_Word( pak.head.cmd );
  639. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  640. }
  642. /***************************************************
  643. Registers a new UIN in the ICQ network
  644. ****************************************************/
  645. void reg_new_user( SOK_T sok, char *pass)
  646. {
  647. #if ICQ_VER == 0x0002
  648. srv_net_icq_pak pak;
  649. #else
  650. net_icq_pak pak;
  651. #endif
  652.    char len_buf[2];
  653. int size, len; 
  655. len = strlen(pass);
  656. Word_2_Chars( pak.head.ver, ICQ_VER );
  657. Word_2_Chars( pak.head.cmd, CMD_REG_NEW_USER );
  658. Word_2_Chars( pak.head.seq, seq_num++ );
  659. #if ICQ_VER != 0x0002
  660. Word_2_Chars( pak.head.seq2, seq_num-1 );
  661. #endif
  662.    Word_2_Chars( len_buf, len );
  663. #if ICQ_VER == 0x0002
  664. memcpy(&pak.data, "x02x00", 2 );
  665.    memcpy(&pak.data[2], len_buf, 2 );
  666. memcpy(&pak.data[4], pass, len + 1);
  667.    DW_2_Chars( &pak.data[4+len], 0x0072 );
  668.    DW_2_Chars( &pak.data[8+len], 0x0000 );
  669.   size = len + 12;
  670. #else
  671. /* memcpy(&pak.data, "x02x00", 2 );*/
  672.    memcpy(&pak.data[0], len_buf, 2 );
  673. memcpy(&pak.data[2], pass, len + 1);
  674.    DW_2_Chars( &pak.data[2+len], 0xA0 );
  675.    DW_2_Chars( &pak.data[6+len], 0x2461 );
  676.    DW_2_Chars( &pak.data[10+len], 0xa00000 );
  677.    DW_2_Chars( &pak.data[14+len], 0x00 );
  678. size = len + 18;
  679. #endif
  682. last_cmd[seq_num - 1 ] = Chars_2_Word( pak.head.cmd );
  683. SOCKWRITE_LOW( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  684. }
  686. void Update_User_Info( SOK_T sok, USER_INFO_PTR user)
  687. {
  688. net_icq_pak pak;
  689. int size ;
  691. Word_2_Chars( pak.head.ver, ICQ_VER );
  692. Word_2_Chars( pak.head.cmd, CMD_UPDATE_INFO );
  693. Word_2_Chars( pak.head.seq, seq_num++ );
  694. DW_2_Chars( pak.head.UIN, UIN );
  695.    
  696. #if ICQ_VER == 0x0002
  697.    Word_2_Chars( pak.data , seq_num++ );
  698.    size = 2;
  699. #else
  700.    size = 0;
  701. #endif
  702.    Word_2_Chars( pak.data + size, strlen( user->nick ) + 1 );
  703.    size += 2;
  704.    strcpy( pak.data + size , user->nick );
  705.    size += strlen( user->nick ) + 1;
  706.    Word_2_Chars( pak.data + size, strlen( user->first ) + 1 );
  707.    size += 2;
  708.    strcpy( pak.data + size , user->first );
  709.    size += strlen( user->first ) + 1;
  710.    Word_2_Chars( pak.data + size, strlen( user->last ) + 1);
  711.    size += 2;
  712.    strcpy( pak.data + size , user->last );
  713.    size += strlen( user->last ) +1 ;
  714.    Word_2_Chars( pak.data + size, strlen( user->email ) + 1  );
  715.    size += 2;
  716.    strcpy( pak.data + size , user->email );
  717.    size += strlen( user->email ) + 1;
  718.    pak.data[ size ] = user->auth;
  719.    size++;
  720. last_cmd[ ( seq_num - 1 ) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  721. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  723. Word_2_Chars( pak.head.ver, ICQ_VER );
  724. Word_2_Chars( pak.head.cmd, CMD_AUTH_UPDATE );
  725. Word_2_Chars( pak.head.seq, seq_num++ );
  726. DW_2_Chars( pak.head.UIN, UIN );
  728.    DW_2_Chars( pak.data, ! user->auth );
  729. last_cmd[ ( seq_num - 1 ) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  730. SOCKWRITE( sok, &(pak.head.ver), 4 + sizeof( pak.head ) - 2);
  731. }
  733. void Update_More_User_Info( SOK_T sok, MORE_INFO_PTR user)
  734. {
  735. net_icq_pak pak;
  736. int size ;
  738. Word_2_Chars( pak.head.ver, ICQ_VER );
  739. Word_2_Chars( pak.head.cmd, CMD_META_USER );
  740. Word_2_Chars( pak.head.seq, seq_num++ );
  741. DW_2_Chars( pak.head.UIN, UIN );
  742.    
  743.    Word_2_Chars( pak.data , META_INFO_SET );
  744.    size = 2;
  745.    Word_2_Chars( pak.data + size, strlen( user->nick ) + 1 );
  746.    size += 2;
  747.    strcpy( pak.data + size , user->nick );
  748.    size += strlen( user->nick ) + 1;
  749.    Word_2_Chars( pak.data + size, strlen( user->first ) + 1 );
  750.    size += 2;
  751.    strcpy( pak.data + size , user->first );
  752.    size += strlen( user->first ) + 1;
  753.    Word_2_Chars( pak.data + size, strlen( user->last ) + 1);
  754.    size += 2;
  755.    strcpy( pak.data + size , user->last );
  756.    size += strlen( user->last ) +1 ;
  757.    Word_2_Chars( pak.data + size, strlen( user->email ) + 1  );
  758.    size += 2;
  759.    strcpy( pak.data + size , user->email );
  760.    size += strlen( user->email ) + 1;
  761.    Word_2_Chars( pak.data + size, strlen( user->email2 ) + 1  );
  762.    size += 2;
  763.    strcpy( pak.data + size , user->email2 );
  764.    size += strlen( user->email2 ) + 1;
  765.    Word_2_Chars( pak.data + size, strlen( user->email3 ) + 1  );
  766.    size += 2;
  767.    strcpy( pak.data + size , user->email3 );
  768.    size += strlen( user->email3 ) + 1;
  769.    Word_2_Chars( pak.data + size, strlen( user->city ) + 1  );
  770.    size += 2;
  771.    strcpy( pak.data + size , user->city );
  772.    size += strlen( user->city ) + 1;
  773.    Word_2_Chars( pak.data + size, strlen( user->state ) + 1  );
  774.    size += 2;
  775.    strcpy( pak.data + size , user->state );
  776.    size += strlen( user->state ) + 1;
  777.    Word_2_Chars( pak.data + size, strlen( user->phone ) + 1  );
  778.    size += 2;
  779.    strcpy( pak.data + size , user->phone );
  780.    size += strlen( user->phone ) + 1;
  781.    Word_2_Chars( pak.data + size, strlen( user->fax ) + 1  );
  782.    size += 2;
  783.    strcpy( pak.data + size , user->fax );
  784.    size += strlen( user->fax ) + 1;
  785.    Word_2_Chars( pak.data + size, strlen( user->street ) + 1  );
  786.    size += 2;
  787.    strcpy( pak.data + size , user->street );
  788.    size += strlen( user->street ) + 1;
  789.    Word_2_Chars( pak.data + size, strlen( user->cellular ) + 1  );
  790.    size += 2;
  791.    strcpy( pak.data + size , user->cellular );
  792.    size += strlen( user->cellular ) + 1;
  793.    DW_2_Chars( &pak.data[ size ] , user->zip );
  794.    size += 4;
  795.    Word_2_Chars( &pak.data[ size ] , user->country );
  796.    size += 2;
  797.    pak.data[ size ++ ] = user->c_status;
  798.    pak.data[ size ] = user->hide_email;
  799.    size++;
  800. last_cmd[ ( seq_num - 1 ) & 0x3ff ] = Chars_2_Word( pak.head.cmd );
  801. SOCKWRITE( sok, &(pak.head.ver), size + sizeof( pak.head ) - 2);
  802. }
  804. void icq_sendurl( SOK_T sok, DWORD uin, char *description, char *url )
  805. {
  806.    char buf[450];
  807.    
  808.    sprintf( buf, "%sxFE%s", url, description );
  809.    icq_sendmsg( sok, uin, buf, URL_MESS );
  810. }
  812. void Wrinkle( void * ptr, size_t len )
  813. {
  814.    static BOOL before = FALSE;
  815.    BYTE *buf;
  816.    DWORD chksum;
  817.    DWORD key;
  818.    DWORD tkey, temp;
  819.    BYTE r1,r2;
  820.    int n, pos;
  821.    DWORD chk1,chk2;
  823.    buf = ptr;
  825.    if ( ! before ) {
  826.       srand( time( NULL ) );
  827.    }
  829.    buf[2] = rand() & 0xff ;
  830.    buf[3] = rand() & 0xff ;
  831.    buf[4] = 0;
  832.    buf[5] = 0;
  834.    r1 = rand() % ( len - 4 );
  835.    r2 = rand() & 0xff;
  837.    chk1 = (BYTE) buf[8];
  838.    chk1 <<= 8;
  839.    chk1 += (BYTE) buf[4];
  840.    chk1 <<= 8;
  841.    chk1 += (BYTE) buf[2];
  842.    chk1 <<= 8;
  843.    chk1 += (BYTE) buf[6];
  844.    chk2 = r1;
  845.    chk2 <<= 8;
  846.    chk2 +=(BYTE) ( buf[ r1 ] );
  847.    chk2 <<= 8;
  848.    chk2 += r2;
  849.    chk2 <<= 8;
  850.    chk2 +=(BYTE) ( icq_check_data[ r2 ] );
  851.    chk2 ^= 0x00ff00ff;
  852.    
  853.    chksum = chk2 ^ chk1;
  854.    
  855.    DW_2_Chars( &buf[ 0x10 ], chksum );
  856.    key = len;
  857.    key *= 0x66756B65;
  858.    key += chksum;
  859.    n = ( len + 3 ) / 4;   
  860.    pos = 0;
  861.    while ( pos < n )
  862.    {
  863.       if ( pos != 0x10 )
  864.       {
  865.          tkey = key + icq_check_data[ pos & 0xff ];
  866.          temp = Chars_2_DW( &buf[ pos ] );
  867.          temp ^= tkey;
  868.          DW_2_Chars( &buf[ pos ], temp );
  869.       }
  870.       pos += 4;
  871.    }
  872.    Word_2_Chars( &buf[0], ICQ_VER );
  873. }
  875. /***************************************************************
  876. This handles actually sending a packet after it's been assembled.
  877. When V5 is implemented this will wrinkle the packet and calculate 
  878. the checkcode.
  879. Adds packet to the queued messages.
  880. ****************************************************************/
  881. size_t SOCKWRITE( SOK_T sok, void * ptr, size_t len )
  882. {
  883.    struct msg *msg_to_queue;
  884.    WORD cmd;
  886.    Word_2_Chars( &((BYTE *)ptr)[4], 0 );
  887.    ((BYTE *)ptr)[0x0A] = ((BYTE *) ptr)[8];
  888.    ((BYTE *)ptr)[0x0B] = ((BYTE *) ptr)[9];
  890.    cmd = Chars_2_Word( (((ICQ_PAK_PTR)((BYTE*)ptr-2))->cmd ) );
  891.    if ( cmd != CMD_ACK ) {
  892.       msg_to_queue = (struct msg *) malloc(sizeof(struct msg));
  893.       msg_to_queue->seq = Chars_2_Word( &((BYTE *)ptr)[0x0A] );
  894.       msg_to_queue->attempts = 1;
  895.       msg_to_queue->exp_time = time(NULL) + 10;
  896.       msg_to_queue->body = (char *) malloc( len );
  897.       msg_to_queue->len = len;
  898.       memcpy(msg_to_queue->body, ptr, msg_to_queue->len);
  899.       msg_queue_push( msg_to_queue );
  901.       if (msg_queue_peek() == msg_to_queue)
  902.       {
  903.   next_resend = msg_to_queue->exp_time;
  904.       }
  905.    }
  907.    return SOCKWRITE_LOW( sok, ptr, len );
  908. }
  910. /***************************************************************
  911. This handles actually sending a packet after it's been assembled.
  912. When V5 is implemented this will wrinkle the packet and calculate 
  913. the checkcode.
  914. Doesn't add packet to the queue.
  915. ****************************************************************/
  916. static size_t SOCKWRITE_LOW( SOK_T sok, void * ptr, size_t len )
  917. {
  919. #if 1
  920.       if ( Verbose > 1 )
  921.          Hex_Dump( ptr, len );
  922. #endif 
  923.    Wrinkle( ptr, len );
  924. #if 0
  925.       if ( Verbose > 1 )
  926.          Hex_Dump( ptr, len );
  927. #endif 
  929.    return sockwrite( sok, ptr, len );
  930. }
  932. size_t SOCKREAD( SOK_T sok, void * ptr, size_t len )
  933. {
  934.    size_t sz;
  935.    
  936.    sz = sockread( sok, ptr, len );
  937.    if ( ( Verbose > 2 ) && ( sz > 0 ) )
  938.       Hex_Dump( ptr, sz );
  939.    return sz;
  940. }