libicq2000/src/FileTransferClient.cpp

   1 /*
   2  * FileTransferClient
   3  *
   4  * Copyright (C) 2001 Barnaby Gray <barnaby@beedesign.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  19  *
  20  */
  21
  22 #include "FileTransferClient.h"
  23
  24 #include "ICQ.h"
  25 #include "constants.h"
  26
  27 #include "sstream_fix.h"
  28
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <dirent.h>
  35
  36 #include <iostream>
  37 #include <algorithm>
  38
  39 using std::string;
  40 using std::ostringstream;
  41 using std::endl;
  42 using std::ofstream;
  43 using std::min;
  44 using std::max;
  45
  46 namespace ICQ2000
  47 {
  48   /*
  49    * Constructor when receiving an incoming connection
  50    */
  51   FileTransferClient::FileTransferClient(ContactRef self, MessageHandler *mh,
  52                                          ContactTree *cl, unsigned int ext_ip, FileTransferEvent* ev)
  53     : m_state(WAITING_FOR_INIT), m_recv(),
  54       m_self_contact(self), m_contact(NULL), m_contact_list(cl),
  55       m_message_handler(mh), m_incoming(true), m_local_ext_ip(ext_ip),
  56       m_ev(ev)
  57   {
  58     Init();
  59     m_listenserver.StartServer();
  60   }
  61
  62   /*
  63    * Constructor for making an outgoing connection
  64    */
  65   FileTransferClient::FileTransferClient(ContactRef self, ContactRef c, MessageHandler *mh, unsigned int ext_ip, FileTransferEvent* ev)
  66     : m_state(NOT_CONNECTED), m_recv(), m_self_contact(self),
  67       m_contact(c), m_message_handler(mh), m_incoming(false), m_local_ext_ip(ext_ip),
  68       m_ev(ev)
  69
  70   {
  71     Init();
  72     m_socket = new TCPSocket();
  73     m_remote_uin = c->getUIN();
  74   }
  75
  76   FileTransferClient::~FileTransferClient()
  77   {
  78     if (m_listenserver.isStarted())
  79     {
  80       SignalRemoveSocket( m_listenserver.getSocketHandle() );
  81       m_listenserver.Disconnect();
  82     }
  83
  84     if ( m_socket->getSocketHandle() > -1)
  85       SignalRemoveSocket( m_socket->getSocketHandle() );
  86
  87     delete m_socket;
  88
  89     if (m_fout.is_open()) m_fout.close();
  90     if (m_fin.is_open()) m_fin.close();
  91   }
  92
  93   void FileTransferClient::Init()
  94   {
  95     m_more = false;
  96     m_continue = false;
  97     m_msgqueue = false;
  98     m_senddir = false;
  99     m_base_dir = NULL;
 100     m_timestamp = time(NULL);
 101     m_timeout = 60;  // will time out in 60 seconds
 102   }
 103
 104   void FileTransferClient::Connect()
 105   {
 106     m_remote_tcp_version = m_contact->getTCPVersion();
 107     if (m_remote_tcp_version >= 7) m_eff_tcp_version = 7;
 108     else if (m_remote_tcp_version == 6) m_eff_tcp_version = 6;
 109     else throw DisconnectedException("Cannot direct connect to client with too old TCP version");
 110
 111     m_socket->setRemoteIP( m_contact->getLanIP() );
 112     m_socket->setRemotePort( m_ev->getPort() );
 113     m_socket->setBlocking(false);
 114     m_socket->Connect();
 115     SignalAddSocket( m_socket->getSocketHandle(), SocketEvent::WRITE );
 116
 117     if (m_contact->getDCCookie() != 0)
 118       m_session_id = m_contact->getDCCookie();
 119     else
 120       m_session_id = (unsigned int)(0xffffffff*(rand()/(RAND_MAX+1.0)));
 121
 122     m_state = WAITING_FOR_INIT_ACK;
 123   }
 124
 125   void FileTransferClient::FinishNonBlockingConnect()
 126   {
 127     SendInitPacket();
 128   }
 129
 130   void FileTransferClient::clearoutMessagesPoll()
 131   {
 132     if ((m_state != CONNECTED) &&
 133         (time(NULL) > (m_timestamp + m_timeout)))
 134       expired();
 135   }
 136
 137   void FileTransferClient::SendFile() {
 138     if (m_state == CONNECTED && m_msgqueue)
 139     {
 140       SendPacket0x00();
 141       m_msgqueue = false;
 142     }
 143     else if (m_continue)
 144     {
 145       if (m_more)
 146       {
 147         SendPacket0x06();
 148       }
 149       else if (m_ev->getCurrFile() < m_ev->getTotalFiles())
 150       {
 151         SendPacket0x02();
 152         m_continue = false;
 153         m_more = false;
 154       }
 155       else
 156       {
 157         m_ev->setState(FileTransferEvent::COMPLETE);
 158         SignalLog(LogEvent::INFO, "FileTransfer is Complete");
 159         throw DisconnectedException("FileTransfer is Complete");
 160
 161         m_continue = false;
 162       }
 163     }
 164     m_message_handler->handleUpdateFT(m_ev);
 165   }
 166
 167   void FileTransferClient::expired()
 168   {
 169     m_ev->setFinished(false);
 170     m_ev->setDelivered(false);
 171     m_ev->setDirect(true);
 172     m_ev->setState(FileTransferEvent::TIMEOUT);
 173     messageack.emit(m_ev);
 174   }
 175
 176   void FileTransferClient::Recv()
 177   {
 178     try
 179     {
 180       while ( m_socket->connected() )
 181       {
 182         if ( !m_socket->Recv(m_recv) ) break;
 183         Parse();
 184       }
 185     }
 186     catch(SocketException e)
 187     {
 188       ostringstream ostr;
 189       ostr << "Failed on recv: " << e.what();
 190       throw DisconnectedException( ostr.str() );
 191     }
 192     catch(ParseException e)
 193     {
 194       ostringstream ostr;
 195       ostr << "Failed parsing: " << e.what();
 196       throw DisconnectedException( ostr.str() );
 197     }
 198   }
 199
 200   void FileTransferClient::Parse()
 201   {
 202     if (m_recv.empty()) return;
 203
 204     unsigned short length;
 205
 206     while (!m_recv.empty())
 207     {
 208       m_recv.setPos(0);
 209
 210       m_recv.setLittleEndian();
 211       m_recv >> length;
 212       if (length > Incoming_Packet_Limit) throw ParseException("Received too long incoming packet");
 213       if (length == 0) return;
 214       if (m_recv.remains() < length) return; // waiting for more of the packet
 215
 216       // Optimize??? not create new buffer and copy and erase in old.
 217       Buffer sb;
 218       m_recv.chopOffBuffer( sb, length+2 );
 219
 220       if (m_state != CONNECTED)
 221       {
 222         ostringstream ostr;
 223         ostr << "Received filepacket from " << IPtoString( m_socket->getRemoteIP() ) << ":" << m_socket->getRemotePort() << endl << sb;
 224         SignalLog(LogEvent::DIRECTPACKET, ostr.str());
 225       }
 226
 227       if (m_state == WAITING_FOR_INIT)
 228       {
 229         ParseInitPacket(sb);
 230
 231         if (m_incoming) {
 232           SendInitAck();
 233           SendInitPacket();
 234           m_state = WAITING_FOR_INIT_ACK;
 235         } else {
 236           SendInitAck();
 237           m_state = CONNECTED;
 238           flush_queue();
 239           connected.emit(this);
 240         }
 241
 242       }
 243       else if (m_state == WAITING_FOR_INIT_ACK)
 244       {
 245         ParseInitAck(sb);
 246
 247         if (m_incoming) {
 248           // Incoming
 249           ConfirmUIN();
 250           m_state = CONNECTED;          // v5 is done handshaking now
 251           flush_queue();
 252           connected.emit(this);
 253
 254         }
 255         else
 256         {
 257           // Outgoing - next packet should be their INIT
 258           m_state = WAITING_FOR_INIT;
 259         }
 260
 261       }
 262       else if (m_state == WAITING_FOR_INIT2)
 263       {
 264         ParseInit2(sb);
 265         // This is a V7 only packet
 266
 267         if (m_incoming)
 268         {
 269           SendInit2();
 270           ConfirmUIN();
 271         }
 272
 273         m_state = CONNECTED;
 274         flush_queue();
 275         connected.emit(this);
 276
 277       }
 278       else if (m_state == CONNECTED)
 279       {
 280         ParsePacket(sb);
 281       }
 282
 283       if (sb.beforeEnd())
 284       {
 285         ostringstream ostr;
 286         ostr  << "Buffer pointer not at end after parsing packet was: 0x" << std::hex << sb.pos()
 287               << " should be: 0x" << sb.size();
 288         SignalLog(LogEvent::WARN, ostr.str());
 289       }
 290
 291     }
 292
 293   }
 294
 295   void FileTransferClient::ConfirmUIN()
 296   {
 297     if ( m_contact_list->exists(m_remote_uin) )
 298     {
 299       ContactRef c = (*m_contact_list)[ m_remote_uin ];
 300       if ( (c->getExtIP() == m_local_ext_ip && c->getLanIP() == getIP() )
 301            /* They are behind the same masquerading box,
 302             * and the Lan IP matches
 303             */
 304            || c->getExtIP() == getIP())
 305       {
 306         m_contact = c;
 307       }
 308       else
 309       {
 310         // spoofing attempt most likely
 311         ostringstream ostr;
 312         ostr << "Refusing direct connection from someone that claims to be UIN "
 313              << m_remote_uin << " since their IP " << IPtoString( getIP() ) << " != " << IPtoString( c->getExtIP() );
 314         throw DisconnectedException( ostr.str() );
 315       }
 316
 317     }
 318     else
 319     {
 320       // don't accept direct connections from contacts not on contact list
 321       throw DisconnectedException("Refusing direct connection to contact not on contact list");
 322     }
 323   }
 324
 325   void FileTransferClient::SendInitPacket()
 326   {
 327     Buffer b;
 328     b.setLittleEndian();
 329     Buffer::marker m1 = b.getAutoSizeShortMarker();
 330
 331     b << (unsigned char)0xff;    // start byte
 332     b << (unsigned short)0x0007; // tcp version
 333     Buffer::marker m2 = b.getAutoSizeShortMarker();
 334
 335     b << m_remote_uin;
 336     b << (unsigned short)0x0000;
 337     b << (unsigned int)m_local_server_port;
 338
 339     b << m_self_contact->getUIN();
 340     b.setBigEndian();
 341     b << m_local_ext_ip;
 342     b << m_socket->getLocalIP();
 343     b << (unsigned char)0x04;    // mode
 344     b.setLittleEndian();
 345     b << (unsigned int)m_local_server_port;
 346     b << m_session_id;
 347
 348     b << (unsigned int)0x00000050; // unknown
 349     b << (unsigned int)0x00000003; // unknown
 350     if (m_eff_tcp_version == 7)
 351       b << (unsigned int)0x00000000; // unknown
 352
 353     b.setAutoSizeMarker(m1);
 354     b.setAutoSizeMarker(m2);
 355
 356     Send(b);
 357   }
 358
 359   void FileTransferClient::ParseInitPacket(Buffer &b)
 360   {
 361     b.setLittleEndian();
 362     unsigned short length;
 363     b >> length;
 364
 365     unsigned char start_byte;
 366     b >> start_byte;
 367     if (start_byte != 0xff) throw ParseException("Init Packet didn't start with 0xff");
 368
 369     unsigned short tcp_version;
 370     b >> tcp_version;
 371     b.advance(2); // revision or a length ??
 372
 373     if (m_incoming)
 374     {
 375       m_remote_tcp_version = tcp_version;
 376       if (tcp_version <= 5) throw ParseException("Too old client < ICQ99");
 377       if (tcp_version == 6) m_eff_tcp_version = 6;
 378       else m_eff_tcp_version = 7;
 379     }
 380     else
 381     {
 382       if (tcp_version != m_remote_tcp_version)
 383         throw ParseException("Client claiming different TCP versions");
 384     }
 385
 386     unsigned int our_uin;
 387     b >> our_uin;
 388     if (our_uin != m_self_contact->getUIN())
 389       throw ParseException("Local UIN in Init Packet not same as our Local UIN");
 390
 391     // 00 00
 392     // xx xx       senders open port
 393     // 00 00
 394     b.advance(6);
 395
 396     unsigned int remote_uin;
 397     b >> remote_uin;
 398     if (m_incoming)
 399     {
 400       m_remote_uin = remote_uin;
 401     }
 402     else
 403     {
 404       if (m_remote_uin != remote_uin)
 405         throw ParseException("Remote UIN in Init Packet for Remote Client not what was expected");
 406     }
 407
 408     // xx xx xx xx  senders external IP
 409     // xx xx xx xx  senders lan IP
 410     b.advance(8);
 411
 412     b >> m_tcp_flags;
 413
 414     // xx xx        senders port again
 415     // 00 00
 416     b.advance(4);
 417
 418     // xx xx xx xx  session id
 419     unsigned int session_id;
 420     b >> session_id;
 421     if (m_incoming)
 422     {
 423       m_session_id = session_id;
 424     }
 425     else
 426     {
 427       if (m_session_id != session_id) throw ParseException("Session ID from Remote Client doesn't match the one we sent");
 428     }
 429
 430     // 50 00 00 00  unknown
 431     // 03 00 00 00  unknown
 432     b.advance(8);
 433
 434     if (m_eff_tcp_version == 7)
 435     {
 436       b.advance(4); // 00 00 00 00  unknown
 437     }
 438
 439   }
 440
 441   void FileTransferClient::ParseInitAck(Buffer &b)
 442   {
 443     b.setLittleEndian();
 444     unsigned short length;
 445     b >> length;
 446     if (length != 4) throw ParseException("Init Ack not as expected");
 447
 448     unsigned int a;
 449     b >> a;       // should be 0x00000001 really
 450   }
 451
 452   void FileTransferClient::ParseInit2(Buffer &b)
 453   {
 454     b.setLittleEndian();
 455     unsigned short length;
 456     b >> length;
 457     if (length != 0x0021)
 458       throw ParseException("V7 final handshake packet incorrect length");
 459
 460     unsigned char type;
 461     b >> type;
 462     if (type != 0x03)
 463       throw ParseException("Expecting V7 final handshake packet, received something else");
 464
 465     unsigned int unknown;
 466     b >> unknown // 0x0000000a
 467       >> unknown;// 0x00000001 on genuine connections, otherwise some weird connections which we drop
 468     if (unknown != 0x00000001) throw DisconnectedException("Ignoring weird direct connection");
 469     b.advance(24); // unknowns
 470   }
 471
 472   void FileTransferClient::SendInit2()
 473   {
 474     Buffer b;
 475     b.setLittleEndian();
 476     Buffer::marker m1 = b.getAutoSizeShortMarker();
 477     b << (unsigned char) 0x03       // start byte
 478       << (unsigned int)  0x0000000a // unknown
 479       << (unsigned int)  0x00000001 // unknown
 480       << (unsigned int)  (m_incoming ? 0x00000001 : 0x00000000) // unknown
 481       << (unsigned int)  0x00000000 // unknown
 482       << (unsigned int)  0x00000000; // unknown
 483     if (m_incoming)
 484     {
 485       b << (unsigned int) 0x00040001 // unknown
 486         << (unsigned int) 0x00000000 // unknown
 487         << (unsigned int) 0x00000000; // unknown
 488     }
 489     else
 490     {
 491       b << (unsigned int) 0x00000000 // unknown
 492         << (unsigned int) 0x00000000 // unknown
 493         << (unsigned int) 0x00040001; // unknown
 494     }
 495     b.setAutoSizeMarker(m1);
 496     Send(b);
 497   }
 498
 499   void FileTransferClient::ParsePacket(Buffer& b)
 500   {
 501     b.setLittleEndian();
 502     unsigned short length;
 503
 504     b >> length;
 505
 506     unsigned char type;
 507     b >> type;
 508
 509     switch (type)
 510     {
 511     case 0: ParsePacket0x00(b);
 512       SendPacket0x05();
 513       SendPacket0x01();
 514       break;
 515     case 1: ParsePacket0x01(b);
 516       SendPacket0x02();
 517       break;
 518     case 2: ParsePacket0x02(b);
 519       SendPacket0x03(0,m_ev->getCurrFile());
 520       break;
 521     case 3: ParsePacket0x03(b);
 522       m_continue = true;
 523       SendFile();
 524       break;
 525     case 5: ParsePacket0x05(b);
 526       break;
 527     case 6: ParsePacket0x06(b);
 528       break;
 529     default:
 530       SignalLog(LogEvent::WARN, "Received unknown FileTransfer Packet");
 531     }
 532   }
 533
 534   void FileTransferClient::ParsePacket0x00(Buffer& b)
 535   {
 536     unsigned int x1, t_num_files, t_size, speed;
 537     string nick;
 538
 539     b >> x1
 540       >> t_num_files
 541       >> t_size
 542       >> speed;
 543     b.UnpackUint16StringNull(nick);
 544
 545     m_ev->setTotalSize(t_size);
 546     m_ev->setTotalFiles(t_num_files);
 547     m_ev->setCurrFile(0);
 548     m_ev->setSpeed(speed);
 549
 550     m_path = m_ev->getSavePath();
 551   }
 552
 553   void FileTransferClient::ParsePacket0x01(Buffer& b)
 554   {
 555     unsigned int speed;
 556     std::string nick;
 557
 558     b >> speed;
 559     b.UnpackUint16StringNull(nick);
 560
 561     m_ev->setSpeed(speed);
 562   }
 563
 564   void FileTransferClient::ParsePacket0x02(Buffer& b)
 565   {
 566     unsigned int size, speed;
 567     string filename, subdir;
 568     unsigned char file_or_dir, tmp1;
 569
 570     b >> file_or_dir;
 571     b.UnpackUint16StringNull(filename);
 572     b.UnpackUint16StringNull(subdir);
 573     b >> size;
 574     b >> tmp1;
 575     b >> tmp1;
 576     b >> tmp1;
 577     b >> tmp1;
 578
 579     b >> speed;
 580
 581     m_ev->setSize(size);
 582     m_ev->setPos(0);
 583     m_ev->setCurrFile(m_ev->getCurrFile()+1);
 584     m_ev->setSpeed(speed);
 585
 586     m_path = m_ev->getSavePath();
 587     // Add backslash if missing in path
 588     if (m_path.find_last_of('/') != (m_path.length()-1))
 589     {
 590       m_path += "/";
 591     }
 592
 593     int pos = 0;
 594     while ((pos = subdir.find('\\')) != std::string::npos)
 595     {
 596       subdir[pos] = '/';
 597     }
 598
 599     m_path += subdir;
 600     // Add backslash if missing in path again
 601     if (m_path.find_last_of('/') != (m_path.length()-1))
 602     {
 603       m_path += "/";
 604     }
 605
 606     if (file_or_dir == 1)
 607     {
 608       m_path += filename;
 609       m_path += "/";
 610       mkdir(m_path.c_str(), S_IXUSR |
 611             S_IWUSR |
 612             S_IRUSR |
 613             S_IXGRP |
 614             S_IRGRP |
 615             S_IXOTH |
 616             S_IROTH);
 617     }
 618     else
 619     {
 620       if (m_ev->getCurrFile() > 1)
 621       {
 622         if (m_fout.is_open())
 623         {
 624           m_fout.close();
 625         }
 626       }
 627
 628       m_fout.open(std::string(m_path+filename).c_str(), std::ios::out | std::ios::binary);
 629       if (!m_fout.good())
 630       {
 631         ostringstream ostr;
 632         ostr << "Opening "
 633              << m_path << filename
 634              << " for writing.";
 635         m_ev->setState(FileTransferEvent::ERROR);
 636         m_ev->setError(ostr.str());
 637         throw DisconnectedException("I/O error");
 638       }
 639     }
 640
 641     // Notify the Gui that an new file is on it's way..
 642     m_message_handler->handleUpdateFT(m_ev);
 643   }
 644
 645   void FileTransferClient::ParsePacket0x03(Buffer& b)
 646   {
 647     unsigned int npos, nfiles, x1, x2;
 648
 649     b >> npos
 650       >> x1
 651       >> x2
 652       >> nfiles;
 653
 654     // Resume is handled
 655     m_ev->setPos(npos);
 656     m_ev->setTotalPos(m_ev->getTotalPos()+npos);
 657     m_ev->setCurrFile(nfiles);
 658
 659     if (npos > m_ev->getSize())
 660     {
 661       ostringstream ostr;
 662       ostr << "FileTransfer resume request got wrong offset: "
 663            << npos << " when file only is " << m_ev->getSize();
 664       m_ev->setState(FileTransferEvent::ERROR);
 665       m_ev->setError(ostr.str());
 666       throw DisconnectedException("I/O error");
 667     }
 668     else
 669     {
 670       // We support resume
 671       ostringstream ostr;
 672       ostr << "Resuming filetransfer " << npos << "/" << m_ev->getSize();
 673       SignalLog(LogEvent::INFO, ostr.str());
 674       m_fin.seekg(npos);
 675     }
 676
 677     if (!m_senddir)
 678     {
 679       m_more = true;
 680     }
 681   }
 682
 683   void FileTransferClient::ParsePacket0x05(Buffer& b)
 684   {
 685     unsigned int speed;
 686
 687     b >> speed;
 688     m_ev->setSpeed(speed);
 689   }
 690
 691   void FileTransferClient::ParsePacket0x06(Buffer& b)
 692   {
 693     unsigned short length;
 694     length = b.remains();
 695
 696     m_ev->setPos(m_ev->getPos()+length);
 697     m_ev->setTotalPos(m_ev->getTotalPos()+length);
 698
 699     while ( length>0 )
 700     {
 701         b.Unpack( m_const_buf, min(length, (unsigned short)MAX_FileChunk) );
 702         m_fout.write((const char*)m_const_buf, std::min(length, (unsigned short)MAX_FileChunk) );
 703         length = max(0, length-(unsigned short)MAX_FileChunk);
 704     }
 705     m_fout.flush();  //prob. isn't needed.. but I feel safer ;)
 706
 707    if (m_ev->getTotalPos() >= m_ev->getTotalSize())
 708     {
 709       m_ev->setState(FileTransferEvent::COMPLETE);
 710       throw DisconnectedException("FileTransfer is Complete");
 711     }
 712   }
 713
 714   void FileTransferClient::SendPacket0x00()
 715   {
 716     Buffer b;
 717     unsigned int tmp_speed = m_ev->getSpeed();
 718     unsigned int tmp_tot_nr = m_ev->getTotalFiles();
 719     unsigned int tmp_tot_size = m_ev->getTotalSize();
 720     b.setLittleEndian();
 721
 722     Buffer::marker m1 = b.getAutoSizeShortMarker();
 723     b << (unsigned char)0x00;
 724     b << (unsigned int)0x00000000;   //0x00000000 X1
 725     b << tmp_tot_nr;  //total number of files to send   CHANGE!!!!
 726     b << tmp_tot_size;  //total number of bytes to send   CHANGE!!!!
 727     b << tmp_speed;
 728     b.PackUint16StringNull(m_self_contact->getAlias());
 729     b.setAutoSizeMarker(m1);
 730
 731     Send(b);
 732   }
 733
 734   void FileTransferClient::SendPacket0x01()
 735   {
 736     Buffer b;
 737     unsigned int tmp_speed = m_ev->getSpeed();
 738     b.setLittleEndian();
 739
 740     Buffer::marker m1 = b.getAutoSizeShortMarker();
 741     b << (unsigned char)0x01;
 742     b << tmp_speed;   //Speed   CHANGE!!!!
 743     b.PackUint16StringNull(m_self_contact->getAlias());
 744     b.setAutoSizeMarker(m1);
 745
 746     Send(b);
 747   }
 748
 749   void FileTransferClient::SendPacket0x02()
 750   {
 751     Buffer b;
 752     string tmp_name = m_ev->getFile();
 753     unsigned int tmp_size;
 754     unsigned int tmp_speed = m_ev->getSpeed();
 755     struct stat tmp_stat;
 756     unsigned char file_or_dir;
 757
 758     stat(tmp_name.c_str(), &tmp_stat);
 759     if (S_ISDIR(tmp_stat.st_mode))
 760     {
 761       file_or_dir = 1;
 762       tmp_size = 0;
 763       m_senddir = true;
 764
 765       //setting base_dir
 766       if (m_base_dir == NULL)
 767       {
 768         m_base_dir = new std::string(tmp_name.substr(0, tmp_name.find_last_of('/', tmp_name.find_last_not_of('/'))+1));
 769       }
 770
 771     }
 772     else if (S_ISREG(tmp_stat.st_mode))
 773     {
 774       file_or_dir = 0;
 775       tmp_size = tmp_stat.st_size;
 776
 777       //setting base_dir
 778       if (m_base_dir == NULL)
 779       {
 780         m_base_dir = new std::string("");
 781       }
 782
 783       m_senddir = false;
 784
 785       if (m_fin.is_open())
 786       {
 787         m_fin.clear();
 788         m_fin.close();
 789       }
 790
 791       m_fin.open(tmp_name.c_str(), std::ios::in | std::ios::binary);
 792       if (!m_fin.good())
 793       {
 794         ostringstream ostr;
 795         ostr << "Opening "
 796              << tmp_name
 797              << " for Reading.";
 798
 799         m_ev->setState(FileTransferEvent::ERROR);
 800         m_ev->setError(ostr.str());
 801         throw DisconnectedException("I/O error");
 802       }
 803
 804     }
 805     else
 806     {
 807       ostringstream ostr;
 808       ostr  << "Trying to send unknown file type: "<< tmp_name;
 809       SignalLog(LogEvent::WARN, ostr.str());
 810       return;
 811     }
 812
 813     std::string subdir = "";
 814
 815     if (m_base_dir->length() != 0)
 816       subdir =
 817       tmp_name.substr(m_base_dir->length(),
 818                       tmp_name.find_last_of('/', tmp_name.find_last_not_of('/')));
 819
 820     int pos = 0;
 821     while ((pos = subdir.find('/')) != std::string::npos)
 822       subdir[pos] = '\\';
 823
 824     // Chopping of so just name is sent.
 825     pos = tmp_name.find_last_of('/');
 826     if (pos == tmp_name.length()-1)
 827     {
 828       tmp_name = tmp_name.substr(0,pos);
 829       pos = tmp_name.find_last_of('/');
 830     }
 831     tmp_name = tmp_name.substr(pos+1, tmp_name.length()-pos);
 832
 833     // Chopping of filename
 834     if (m_base_dir->length() != 0)
 835       subdir = subdir.substr(0, subdir.length() - tmp_name.length() -1);
 836
 837
 838     // Remove last backslash from subdir
 839     if ((file_or_dir == 1) &&
 840         (subdir.find_last_of('\\') == (subdir.length()-1)))
 841       subdir = subdir.substr(0, subdir.length() -1);
 842
 843     m_ev->setCurrFile(m_ev->getCurrFile()+1);
 844     m_ev->setPos(0);
 845     m_ev->setSize(tmp_size);
 846
 847     b.setLittleEndian();
 848
 849     Buffer::marker m1 = b.getAutoSizeShortMarker();
 850     b << (unsigned char)0x02;
 851     b << file_or_dir;
 852     b.PackUint16StringNull(tmp_name);  //name of next file.
 853     b.PackUint16StringNull(subdir);  //subdir
 854     b << tmp_size;
 855     b << (unsigned char)0x00;
 856     b << (unsigned char)0x00;
 857     b << (unsigned char)0x00;
 858     b << (unsigned char)0x00;
 859     b << tmp_speed;
 860     b.setAutoSizeMarker(m1);
 861
 862     Send(b);
 863   }
 864
 865   void FileTransferClient::SendPacket0x03(unsigned int npos, unsigned int nfiles)
 866   {
 867     Buffer b;
 868     unsigned int speed = m_ev->getSpeed();
 869     b.setLittleEndian();
 870     Buffer::marker m1 = b.getAutoSizeShortMarker();
 871     b << (unsigned char)0x03;
 872     b << npos;  //filepos  RESUME?
 873     b << (unsigned int)0x00000000;   // X1 Unknown
 874     b << speed; //(unsigned int)0x00000064;  // speed
 875     b << nfiles;
 876
 877     b.setAutoSizeMarker(m1);
 878
 879     Send(b);
 880   }
 881
 882   void FileTransferClient::SendPacket0x05()
 883   {
 884     Buffer b;
 885     unsigned int speed;
 886     b.setLittleEndian();
 887     Buffer::marker m1 = b.getAutoSizeShortMarker();
 888
 889     speed = m_ev->getSpeed();
 890
 891     b << (unsigned char)0x05;
 892     b << speed;
 893
 894     b.setAutoSizeMarker(m1);
 895
 896     Send(b);
 897   }
 898
 899   void FileTransferClient::SendPacket0x06()
 900   {
 901     Buffer b;
 902     unsigned short length;
 903     b.setLittleEndian();
 904     Buffer::marker m1 = b.getAutoSizeShortMarker();
 905
 906     if (!m_fin.good())
 907     {
 908       m_ev->setState(FileTransferEvent::ERROR);
 909       m_ev->setError("I/O error while sending data");
 910       throw DisconnectedException("I/O error in SendPacket0x06");
 911     }
 912
 913     m_fin.read((char*)m_const_buf, 2048);
 914     length = m_fin.gcount();
 915
 916     b << (unsigned char)0x06;
 917
 918     b.Pack(m_const_buf, length);
 919     b.setAutoSizeMarker(m1);
 920
 921     m_ev->setPos(m_ev->getPos()+length);
 922     m_ev->setTotalPos(m_ev->getTotalPos()+length);
 923
 924     Send(b);
 925
 926     // Send more?
 927     if (m_ev->getPos() < m_ev->getSize())
 928     {
 929       m_more = true;
 930     }
 931     else
 932     {
 933       m_more = false;
 934       if (m_ev->getFilesInQueue() == 0)
 935       {
 936         m_ev->setState(FileTransferEvent::COMPLETE);
 937         SignalLog(LogEvent::INFO, "FileTransfer is Complete");
 938         throw DisconnectedException("FileTransfer is Complete");
 939       }
 940     }
 941   }
 942
 943   void FileTransferClient::SendInitAck()
 944   {
 945     Buffer b;
 946     b.setLittleEndian();
 947     Buffer::marker m1 = b.getAutoSizeShortMarker();
 948     b << (unsigned int)0x00000001;
 949     b.setAutoSizeMarker(m1);
 950     Send(b);
 951   }
 952
 953   void FileTransferClient::SendPacketAck(ICQSubType *icqsubtype)
 954   {
 955     Buffer b;
 956
 957     b.setLittleEndian();
 958     b << (unsigned int)0x00000000 // checksum (filled in by Encrypt)
 959       << V6_TCP_ACK
 960       << (unsigned short)0x000e
 961       << icqsubtype->getSeqNum()
 962       << (unsigned int)0x00000000
 963       << (unsigned int)0x00000000
 964       << (unsigned int)0x00000000;
 965
 966     icqsubtype->Output(b);
 967     Buffer c;
 968     //Encrypt(b,c);
 969     Send(c);
 970   }
 971
 972   void FileTransferClient::Send(Buffer &b)
 973   {
 974     try
 975     {
 976       m_socket->Send(b);
 977     }
 978     catch(SocketException e)
 979     {
 980       ostringstream ostr;
 981       ostr << "Failed to send: " << e.what();
 982       throw DisconnectedException( ostr.str() );
 983     }
 984   }
 985
 986   void FileTransferClient::SendEvent(MessageEvent *ev)
 987   {
 988     if (m_state == CONNECTED)
 989     {
 990       // send straight away
 991       SendFile();
 992     }
 993     else
 994     {
 995       // queue message
 996       m_msgqueue = true;
 997     }
 998   }
 999
1000   void FileTransferClient::flush_queue()
1001   {
1002     if (m_msgqueue)
1003     {
1004       SendFile();
1005     }
1006   }
1007
1008   unsigned int FileTransferClient::getUIN() const { return m_remote_uin; }
1009
1010   unsigned int FileTransferClient::getIP() const { return m_socket->getRemoteIP(); }
1011
1012   unsigned short FileTransferClient::getPort() const { return m_socket->getRemotePort(); }
1013
1014   unsigned short FileTransferClient::getlistenPort() const { return m_listenserver.getPort(); }
1015
1016   int FileTransferClient::getfd() const { return m_socket->getSocketHandle(); }
1017
1018   int FileTransferClient::getlistenfd() { return m_listenserver.getSocketHandle(); }
1019
1020   TCPSocket* FileTransferClient::getSocket() const { return m_socket; }
1021
1022   void FileTransferClient::setSocket()
1023   {
1024     m_socket = m_listenserver.Accept();
1025     SignalLog(LogEvent::INFO, "Accepting incoming filetransfer");
1026   }
1027
1028   void FileTransferClient::setContact(ContactRef c) { m_contact = c; }
1029
1030   ContactRef FileTransferClient::getContact() const { return m_contact; }
1031
1032   bool FileTransferClient::SetupFileTransfer(FileTransferEvent *ev)
1033   {
1034     struct stat tmp_stat;
1035     std::string str = ev->getDescription();
1036     stat(str.c_str(), &tmp_stat);
1037 /* MITZ - what's the idea?!
1038     if (S_ISDIR(tmp_stat.st_mode))
1039     {
1040       int size = 0;
1041       int files = 0;
1042       int dirs = 0;
1043       listDirectory(str, size, files, dirs, ev);
1044
1045       ev->setTotalSize(size);
1046       ostringstream ostr;
1047       ostr << files << " files in " << dirs << " directories";
1048       ev->setDescription(ostr.str());
1049
1050     }
1051     else if (S_ISREG(tmp_stat.st_mode))
1052     {
1053       ev->addFile(str);
1054       ev->setTotalSize(tmp_stat.st_size);
1055       // Chopping of so just name is sent.
1056       int pos = str.find_last_of('/');
1057       if (pos == str.length()-1)
1058       {
1059         str = str.substr(0,pos);
1060         pos = str.find_last_of('/');
1061       }
1062       str = str.substr(pos+1, str.length()-pos);
1063       ev->setDescription(str);
1064     }
1065     else
1066     {
1067       return false;
1068     }
1069 */
1070
1071     ev->setTotalFiles(ev->getFilesInQueue());
1072     ev->setCurrFile(0);
1073
1074     return true;
1075   }
1076
1077   void FileTransferClient::listDirectory(std::string str, int &size, int &files, int &dirs, FileTransferEvent *ev)
1078   {
1079     struct stat tmp_stat;
1080     if (str.length() > 1
1081         && (str.substr(str.length()-1, str.length()) == "."
1082             || str.substr(str.length()-2, str.length()) == ".."))
1083       return;
1084
1085     // Add backslash if missing in path
1086     if (str.find_last_of('/') != (str.length()-1))
1087       str += "/";
1088     ev->addFile(str);
1089     dirs++;
1090     DIR *dir = opendir(str.c_str());
1091     if (dir == NULL)
1092       return;
1093     struct dirent *dent = readdir(dir);
1094
1095     std::string tmp_str;
1096
1097     while (dent != NULL)
1098     {
1099       tmp_str = str;
1100       tmp_str += dent->d_name;
1101       stat(tmp_str.c_str(), &tmp_stat);
1102       if (S_ISREG(tmp_stat.st_mode))
1103       {
1104         ev->addFile(tmp_str);
1105         size += tmp_stat.st_size;
1106         files++;
1107       }
1108       else if (S_ISDIR(tmp_stat.st_mode))
1109       {
1110         listDirectory(tmp_str, size, files, dirs, ev);
1111       }
1112
1113       dent = readdir(dir); //delete on old dent?
1114     }
1115     closedir(dir);
1116   }
1117
1118   FileTransferEvent* FileTransferClient::getEvent()
1119   {
1120     return m_ev;
1121   }
1122 }