recvfile.cpp.svn-base

UDT 4.0 based on the UDP.

#ifndef WIN32
   #include <arpa/inet.h>
#else
   #include <winsock2.h>
   #include <ws2tcpip.h>
#endif
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <udt.h>

using namespace std;

#ifdef UDT_FT_USE_NON_BLOCKING
# define UDT_FT_SND_BUF_SIZE  4096000
# define UDT_FT_RCV_BUF_SIZE  4096000
#else
# define UDT_FT_SND_BUF_SIZE  128 * 1024
# define UDT_FT_RCV_BUF_SIZE  UDT_FT_SND_BUF_SIZE 
#endif

#define UDT_FT_MSS 1400

// static
bool setSocketOpt(UDTSOCKET udtSocket)
{
   bool succeed = false;
   int optValue = UDT_FT_MSS;
   // !nash! set less MTU
   int error = UDT::setsockopt(udtSocket, 0, UDT_MSS, &optValue, sizeof(int));
   assert(error == 0);
   succeed |= (error == 0);
   // !nash! set smaller sending and receiving buffer limit
   optValue = UDT_FT_SND_BUF_SIZE; // 1MB
   error = UDT::setsockopt(udtSocket, 0, UDT_SNDBUF, &optValue, sizeof(int));
   assert(error == 0);
   succeed |= (error == 0);
   optValue = UDT_FT_RCV_BUF_SIZE;
   error = UDT::setsockopt(udtSocket, 0, UDT_RCVBUF, &optValue, sizeof(int));
   assert(error == 0);
   succeed |= (error == 0);
   // !nash! set smaller UDP rcv buffer size, set to this value is due to that Darwin has relatively small default UDP rcv buffer
   optValue = 42080;
   error = UDT::setsockopt(udtSocket, 0, UDP_RCVBUF, &optValue, sizeof(int));
   assert(error == 0);
   succeed |= (error == 0);
   return succeed;
}

int main(int argc, char* argv[])
{
   if ((argc != 5) || (0 == atoi(argv[2])))
   {
      cout << "usage: recvfile server_ip server_port remote_filename local_filename" << endl;
      return 0;
   }

   UDTSOCKET fhandle = UDT::socket(AF_INET, SOCK_STREAM, 0);

   setSocketOpt(fhandle);

   sockaddr_in serv_addr;
   serv_addr.sin_family = AF_INET;
   serv_addr.sin_port = htons(short(atoi(argv[2])));
#ifndef WIN32
   if (inet_pton(AF_INET, argv[1], &serv_addr.sin_addr) <= 0)
#else
   if (INADDR_NONE == (serv_addr.sin_addr.s_addr = inet_addr(argv[1])))
#endif
   {
      cout << "incorrect network address.\n";
      return 0;
   }
   memset(&(serv_addr.sin_zero), '\0', 8);

   if (UDT::ERROR == UDT::connect(fhandle, (sockaddr*)&serv_addr, sizeof(serv_addr)))
   {
      cout << "connect: " << UDT::getlasterror().getErrorMessage() << endl;
      return 0;
   }
   else
   {
      cout << "connected" << endl;
   }

   // send name information of the requested file
   int len = strlen(argv[3]);

   if (UDT::ERROR == UDT::send(fhandle, (char*)&len, sizeof(int), 0))
   {
      cout << "send: " << UDT::getlasterror().getErrorMessage() << endl;
      return 0;
   }

   if (UDT::ERROR == UDT::send(fhandle, argv[3], len, 0))
   {
      cout << "send: " << UDT::getlasterror().getErrorMessage() << endl;
      return 0;
   }

   // get size information
   int64_t size;

   if (UDT::ERROR == UDT::recv(fhandle, (char*)&size, sizeof(int64_t), 0))
   {
      cout << "send: " << UDT::getlasterror().getErrorMessage() << endl;
      return 0;
   }

   // receive the file
   ofstream ofs(argv[4], ios::out | ios::binary | ios::trunc);
   int64_t recvsize; 

   UDT::UDSET readFds;
   timeval tv;

   int64_t sizeRecvd = 0;
   
   cout << "recv file size: " << size << endl;
   do 
   {
      tv.tv_sec = 0;
      tv.tv_usec = 500;
      readFds.clear();
      UD_SET(fhandle, &readFds);
      if (UDT::select(0, &readFds, NULL, NULL, &tv))
      {
         if (UD_ISSET(fhandle, &readFds))
         {
            int sizeToRecv = size - sizeRecvd;
            if (sizeToRecv > 8192)
            {
               sizeToRecv = 8192;
            }
            recvsize = UDT::recvfile(fhandle, ofs, sizeRecvd, sizeToRecv);
            if (UDT::ERROR == recvsize)
            {
               cout << "recvfile: " << UDT::getlasterror().getErrorMessage() << endl;
               return 0;
            }
            else
            {
               sizeRecvd += recvsize;
            }
         }
      }
   } while(sizeRecvd < size);
   

   UDT::close(fhandle);

   ofs.close();

   return 1;
}