api.cpp.svn-base

UDT 4.0 based on the UDP.

      else
      {
         return 0;
      }
   }
   return ERROR;
}

UDTSOCKET CUDT::accept(UDTSOCKET u, sockaddr* addr, int* addrlen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      UDTSOCKET s = INVALID_SOCK;
      CUDTException e = udtUnited->accept(u, addr, addrlen, s);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         return s;
      }
   }
   return INVALID_SOCK;
}

int CUDT::connect(UDTSOCKET u, const sockaddr* name, int namelen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDTException e = udtUnited->connect(u, name, namelen);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         return 0;
      }
   }
   return ERROR;
}

int CUDT::close(UDTSOCKET u)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
      return udtUnited->close(u);
   else
      return ERROR;
}

int CUDT::getpeername(UDTSOCKET u, sockaddr* name, int* namelen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDTException e = udtUnited->getpeername(u, name, namelen);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         return 0;
      }
   }
   return ERROR;
}

int CUDT::getsockname(UDTSOCKET u, sockaddr* name, int* namelen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDTException e = udtUnited->getsockname(u, name, namelen);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         return 0;
      }
   }
   return ERROR;
}

int CUDT::getsockopt(UDTSOCKET u, int, UDTOpt optname, void* optval, int* optlen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDT* udt = NULL;
      CUDTException e = udtUnited->lookup(u, udt);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         udt->getOpt(optname, optval, *optlen);
         return 0;
      }
   }
   return ERROR;
}

int CUDT::setsockopt(UDTSOCKET u, int, UDTOpt optname, const void* optval, int optlen)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDT* udt = NULL;
      CUDTException e = udtUnited->lookup(u, udt);
      if (e.getErrorCode())
      {
         udtUnited->setError(new (nothrow) CUDTException(e));
      }
      else
      {
         udt->setOpt(optname, optval, optlen);
         return 0;
      }
   }
   return ERROR;
}

int CUDT::send(UDTSOCKET u, const char* buf, int len, int)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int outSize = 0;
            e = udt->send((char*)buf, len, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int CUDT::recv(UDTSOCKET u, char* buf, int len, int)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
         return ERROR;
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int outSize = 0;
            e = udt->recv(buf, len, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int CUDT::sendmsg(UDTSOCKET u, const char* buf, int len, int ttl, bool inorder)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int outSize = 0;
            e = udt->sendmsg((char*)buf, len, ttl, inorder, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int CUDT::recvmsg(UDTSOCKET u, char* buf, int len)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
         return ERROR;
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int outSize = 0;
            e = udt->recvmsg(buf, len, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int64_t CUDT::sendfile(UDTSOCKET u, ifstream& ifs, const int64_t offset, const int64_t size, const int block)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int64_t outSize = 0;
            e = udt->sendfile(ifs, offset, size, block, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int64_t CUDT::recvfile(UDTSOCKET u, ofstream& ofs, const int64_t offset, const int64_t size, const int block)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
           udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            int64_t outSize = 0;
            e = udt->recvfile(ofs, offset, size, block, outSize);
            if (!e.getErrorCode())
               return outSize;
         }
      }
   }
   return ERROR;
}

int CUDT::select(int, ud_set* readfds, ud_set* writefds, ud_set* exceptfds, const timeval* timeout)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if ((NULL == readfds) && (NULL == writefds) && (NULL == exceptfds))
      {
         udtUnited->setError(new (nothrow) CUDTException(5, 3, 0));
      }
      else
      {
         int selectCount = 0;
         CUDTException e = udtUnited->select(readfds, writefds, exceptfds, timeout, selectCount);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            return selectCount;
         }
      }
   }
   return ERROR;
}

CUDTException& CUDT::getlasterror()
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      return *(udtUnited->getError());
   }
   else
   {
      static CUDTException e(3, 2, 0);
      return e;
   }
}

int CUDT::perfmon(UDTSOCKET u, CPerfMon* perf, bool clear)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      if (CUDTSocket::BROKEN == udtUnited->getStatus(u))
      {
         udtUnited->setError(new (nothrow) CUDTException(2, 1, 0));
      }
      else
      {
         CUDT* udt = NULL;
         CUDTException e = udtUnited->lookup(u, udt);
         if (e.getErrorCode())
         {
            udtUnited->setError(new (nothrow) CUDTException(e));
         }
         else
         {
            udt->sample(perf, clear);
            return 0;
         }
      }
   }
   return ERROR;
}

CUDT* CUDT::getUDTHandle(UDTSOCKET u)
{
   CUDTUnited* udtUnited = getUDTUnited();
   if (udtUnited)
   {
      CUDT* udt = NULL;
      CUDTException e = udtUnited->lookup(u, udt);
      if (!e.getErrorCode())
         return udt;
   }
   return NULL;
}

////////////////////////////////////////////////////////////////////////////////

namespace UDT
{

UDTSOCKET socket(int af, int type, int protocol)
{
   return CUDT::socket(af, type, protocol);
}

int bind(UDTSOCKET u, const struct sockaddr* name, int namelen)
{
   return CUDT::bind(u, name, namelen);
}

int bind(UDTSOCKET u, UDPSOCKET udpsock)
{
   return CUDT::bind(u, udpsock);
}

int listen(UDTSOCKET u, int backlog)
{
   return CUDT::listen(u, backlog);
}

UDTSOCKET accept(UDTSOCKET u, struct sockaddr* addr, int* addrlen)
{
   return CUDT::accept(u, addr, addrlen);
}

int connect(UDTSOCKET u, const struct sockaddr* name, int namelen)
{
   return CUDT::connect(u, name, namelen);
}

int close(UDTSOCKET u)
{
   return CUDT::close(u);
}

int getpeername(UDTSOCKET u, struct sockaddr* name, int* namelen)
{
   return CUDT::getpeername(u, name, namelen);
}

int getsockname(UDTSOCKET u, struct sockaddr* name, int* namelen)
{
   return CUDT::getsockname(u, name, namelen);
}

int getsockopt(UDTSOCKET u, int level, SOCKOPT optname, void* optval, int* optlen)
{
   return CUDT::getsockopt(u, level, optname, optval, optlen);
}

int setsockopt(UDTSOCKET u, int level, SOCKOPT optname, const void* optval, int optlen)
{
   return CUDT::setsockopt(u, level, optname, optval, optlen);
}

int send(UDTSOCKET u, const char* buf, int len, int flags)
{
   return CUDT::send(u, buf, len, flags);
}

int recv(UDTSOCKET u, char* buf, int len, int flags)
{
   return CUDT::recv(u, buf, len, flags);
}

int sendmsg(UDTSOCKET u, const char* buf, int len, int ttl, bool inorder)
{
   return CUDT::sendmsg(u, buf, len, ttl, inorder);
}

int recvmsg(UDTSOCKET u, char* buf, int len)
{
   return CUDT::recvmsg(u, buf, len);
}

int64_t sendfile(UDTSOCKET u, ifstream& ifs, int64_t offset, int64_t size, int block)
{
   return CUDT::sendfile(u, ifs, offset, size, block);
}

int64_t recvfile(UDTSOCKET u, ofstream& ofs, int64_t offset, int64_t size, int block)
{
   return CUDT::recvfile(u, ofs, offset, size, block);
}

int select(int nfds, UDSET* readfds, UDSET* writefds, UDSET* exceptfds, const struct timeval* timeout)
{
   return CUDT::select(nfds, readfds, writefds, exceptfds, timeout);
}

ERRORINFO& getlasterror()
{
   return CUDT::getlasterror();
}

int perfmon(UDTSOCKET u, TRACEINFO* perf, bool clear)
{
   return CUDT::perfmon(u, perf, clear);
}

}