sockstream.cpp

openvxi3.4是一个voicexml对话脚本语言的解释器源码.可用VC６.０编译．

  if ((rval = ::recvfrom (rep->sock, (char*) buf, len,
			  msgf, sa.addr (), &sa_len)) == -1)
    LOG_ERROR_DETAILED (500, L"recvfrom");
  return (rval==0) ? EOF: rval;
}

int sockbuf::write(const void* buf, int len)
{
#ifdef _WIN32
  return send(buf, len); // Winsock uses send
#else
  if (stmo != -1 && is_writeready (stmo)==0) return 0;

  int	wlen=0;
  while(len>0) {
    int	wval;
    if ((wval = ::write (rep->sock, (char*) buf, len)) == -1) {
      error ("sockbuf::write");
      return wval;
    }
    len -= wval;
    wlen += wval;
  }
  return wlen; // == len if every thing is all right
#endif // _WIN32
}

int sockbuf::send (const void* buf, int len, int msgf)
{
  if (stmo != -1 && is_writeready (stmo)==0) return 0;

  int	wlen=0;
  while(len>0) {
    int	wval;
    if ((wval = ::send (rep->sock, (char*) buf, len, msgf)) == -1) {
      LOG_ERROR_DETAILED (500, L"send");
      return wval;
    }
    len -= wval;
    wlen += wval;
  }
  return wlen;
}

int sockbuf::sendto (sockAddr& sa, const void* buf, int len, int msgf)
{
  if (stmo != -1 && is_writeready (stmo)==0) return 0;

  int	wlen=0;
  while(len>0) {
    int	wval;
    if ((wval = ::sendto (rep->sock, (char*) buf, len,
			  msgf, sa.addr (), sa.size())) == -1) {
      LOG_ERROR_DETAILED (500, L"sendto");
      return wval;
    }
    len -= wval;
    wlen += wval;
  }
  return wlen;
}

#if !defined (__linux__) && !defined(_WIN32)
// linux does not have sendmsg or recvmsg

int sockbuf::recvmsg (msghdr* msg, int msgf)
{
  if (rtmo != -1 && is_readready (rtmo)==0) return 0;

  int	rval;
  if ((rval = ::recvmsg(rep->sock, msg, msgf)) == -1)
    error ("sockbuf::recvmsg");
  return (rval==0)? EOF: rval;
}

int sockbuf::sendmsg (msghdr* msg, int msgf)
{
  if (stmo != -1 && is_writeready (stmo)==0) return 0;

  int	wval;
  if ((wval = ::sendmsg (rep->sock, msg, msgf)) == -1)
    error("sendmsg");
  return wval;
}

#endif //!__linux__

int sockbuf::sendtimeout (int wp)
{
  int oldstmo = stmo;
  stmo = (wp < 0) ? -1: wp;
  return oldstmo;
}

int sockbuf::recvtimeout (int wp)
{
  int oldrtmo = rtmo;
  rtmo = (wp < 0) ? -1: wp;
  return oldrtmo;
}

int sockbuf::is_readready (int wp_sec, int wp_usec) const
{
  fd_set rfds;
  FD_ZERO (&rfds);
  FD_SET (rep->sock, &rfds);

  fd_set efds;
  FD_ZERO (&efds);
  FD_SET (rep->sock, &efds);

  timeval tv;
  tv.tv_sec  = wp_sec;
  tv.tv_usec = wp_usec;

  int ret = select (rep->sock+1, &rfds, 0, &efds, (wp_sec == -1) ? 0: &tv);

  if (ret < 0) 
  {
    LOG_ERROR_DETAILED (500, L"select");
    return ret;
  }
  else if (ret == 0)
  {
    LOG_ERROR (501, L"select");
    return ret;
  }

  if (FD_ISSET(rep->sock, &efds))
  {
    LOG_ERROR (502, L"select");
    return -1;
  }

  return FD_ISSET(rep->sock,&rfds);
}

int sockbuf::is_writeready (int wp_sec, int wp_usec) const
{
  fd_set wfds;
  FD_ZERO (&wfds);
  FD_SET (rep->sock, &wfds);

  fd_set efds;
  FD_ZERO (&efds);
  FD_SET (rep->sock, &efds);

  timeval tv;
  tv.tv_sec  = wp_sec;
  tv.tv_usec = wp_usec;

  int ret = select (rep->sock+1, 0, &wfds, &efds, (wp_sec == -1) ? 0: &tv);

  if (ret < 0) 
  {
    LOG_ERROR_DETAILED (500, L"select");
    return ret;
  }
  else if (ret == 0)
  {
    LOG_ERROR (501, L"select");
    return ret;
  }

  if (FD_ISSET(rep->sock, &efds))
  {
    LOG_ERROR (502, L"select");
    return -1;
  }

  return FD_ISSET(rep->sock,&wfds);
}

int sockbuf::is_exceptionpending (int wp_sec, int wp_usec) const
{
  fd_set fds;
  FD_ZERO (&fds);
  FD_SET  (rep->sock, &fds);

  timeval tv;
  tv.tv_sec = wp_sec;
  tv.tv_usec = wp_usec;

  int ret = select (rep->sock+1, 0, 0, &fds, (wp_sec == -1) ? 0: &tv);
  if (ret == -1) {
    LOG_ERROR_DETAILED (500, L"select");
    return 0;
  }
  return ret;
}

void sockbuf::shutdown (shuthow sh)
{
  switch (sh) {
  case shut_read:
    xsetflags(_S_NO_READS);
    break;
  case shut_write:
    xsetflags(_S_NO_WRITES);
    break;
  case shut_readwrite:
    xsetflags(_S_NO_READS|_S_NO_WRITES);
    break;
  }
  if (::shutdown(rep->sock, sh) == INVALID_SOCKET)
    error("shutdown");
}

int sockbuf::getopt (option op, void* buf, int len, level l) const
{
  socklen_t rlen = len;
  if (::getsockopt (rep->sock, l, op, (char*) buf, &rlen) == -1)
    error ("sockbuf::getopt");
  return rlen;
}

int sockbuf::setBlocking(bool blocking)
{
  unsigned long x = (unsigned long) !blocking;
#ifdef _WIN32
  return ioctlsocket(rep->sock, FIONBIO, &x);
#else
  return ioctl(rep->sock, FIONBIO, &x);
#endif
}

void sockbuf::setopt (option op, void* buf, int len, level l) const
{
  if (::setsockopt (rep->sock, l, op, (char*) buf, len) == -1)
    error ("sockbuf::setopt");
}

sockbuf::type sockbuf::gettype () const
{
  int	ty=0;
  getopt (so_type, &ty, sizeof (ty));
  return sockbuf::type(ty);
}

int sockbuf::clearerror () const
{
  int 	err=0;
  getopt (so_error, &err, sizeof (err));
  return err;
}

int sockbuf::debug (int opt) const
{
  int old=0;
  getopt (so_debug, &old, sizeof (old));
  if (opt != -1)
    setopt (so_debug, &opt, sizeof (opt));
  return old;
}

int sockbuf::reuseaddr (int opt) const
{
  int old=0;
  getopt (so_reuseaddr, &old, sizeof (old));
  if (opt != -1)
    setopt (so_reuseaddr, &opt, sizeof (opt));
  return old;
}

int sockbuf::keepalive (int opt) const
{
  int old=0;
  getopt (so_keepalive, &old, sizeof (old));
  if (opt != -1)
    setopt (so_keepalive, &opt, sizeof (opt));
  return old;
}

int sockbuf::dontroute (int opt) const
{
  int old=0;
  getopt (so_dontroute, &old, sizeof (old));
  if (opt != -1)
    setopt (so_dontroute, &opt, sizeof (opt));
  return old;
}

int sockbuf::broadcast (int opt) const
{
  int old=0;
  getopt (so_broadcast, &old, sizeof (old));
  if (opt != -1)
    setopt (so_broadcast, &opt, sizeof (opt));
  return old;
}

int sockbuf::oobinline (int opt) const
{
  int old=0;
  getopt (so_oobinline, &old, sizeof (old));
  if (opt != -1)
    setopt (so_oobinline, &opt, sizeof (opt));
  return old;
}

int sockbuf::linger (int opt) const
{
  socklinger	old (0, 0);
  getopt (so_linger, &old, sizeof (old));
  if (opt > 0) {
    socklinger nw (1, opt);
    setopt (so_linger, &nw, sizeof (nw));
  }else if (opt == 0) {
    socklinger nw (0, old.l_linger);
    setopt (so_linger, &nw, sizeof (nw));
  }
  return old.l_onoff ? old.l_linger: -1;
}

int sockbuf::sendbufsz (int  sz) const
{
  int old=0;
  getopt (so_sndbuf, &old, sizeof (old));
  if (sz >= 0)
    setopt (so_sndbuf, &sz, sizeof (sz));
  return old;
}

int sockbuf::recvbufsz (int sz) const
{
  int old=0;
  getopt (so_rcvbuf, &old, sizeof (old));
  if (sz >= 0)
    setopt (so_rcvbuf, &sz, sizeof (sz));
  return old;
}

void sockbuf::error (const char* msg) const
{
  SOCK_ERROR("sockbuf", msg);
}

isockstream::~isockstream ()
{
}

osockstream::~osockstream ()
{
}

iosockstream::~iosockstream ()
{
}