C++ TCPStream::setOnReadable方法代码示例

int mbed_socket::doconnect(const struct sockaddr *addr, socklen_t addrlen) {
  (void)addrlen;

  TCPStream* stream;
  stream = new TCPStream(SOCKET_STACK_LWIP_IPV4);
  if (stream == NULL) {
    set_errno(ENOMEM);
    return -1;
  }

  socket_error_t err;
  err = stream->open(SOCKET_AF_INET4);
  if (stream->error_check(err)) {
    TDLOG(".. doconnect error: open failed %s (%d)",
          socket_strerror(err), err);
    set_errno(EBADF); // fix value to connect error no
    return -1;
  }

  set_stream(stream, false);

  sockaddr_in* inaddr = (sockaddr_in*)addr;
  socket_addr s_addr;
  SocketAddr  saddr;

  //char addrstr[20];
  //makeaddr4string(addrstr, inaddr);
  //TDDDLOG(".. connect to %s:%d\r\n", addrstr, inaddr->sin_port);

  socket_addr_set_ipv4_addr(&s_addr, inaddr->sin_addr.s_addr);
  saddr.setAddr(&s_addr);

  stream->setOnError(on_error_t(this, &mbed_socket::on_error));
  stream->setOnReadable(on_readable_t(this, &mbed_socket::on_readable));
  stream->setOnSent(on_sent_t(this, &mbed_socket::on_sent));
  stream->setOnDisconnect(on_disconnect_t(this, &mbed_socket::on_disconnect));

  sock_flag_ |= MBED_SOCKET_FLAG_CONNECTING;
  err = stream->connect(saddr, inaddr->sin_port,
                        on_connect_t(this, &mbed_socket::on_connect));
  if (stream->error_check(err)) {
    TDLOG(".. doconnect error: open failed %s (%d)",
          socket_strerror(err), err);
    set_errno(EBADF); // fix value to connect error no
    return -1;
  }
  set_errno(EINPROGRESS);
  return -1;
}

void lws_conn_listener::onIncoming(TCPListener *tl, void *impl)
{
	mbed::util::CriticalSectionLock lock;
	TCPStream *ts = srv.accept(impl);
	lws_conn *conn;

	if (!impl || !ts) {
		onError(tl, SOCKET_ERROR_NULL_PTR);
		return;
	}
	
	conn = new(lws_conn);
	if (!conn) {
		lwsl_err("OOM\n");
		return;
	}
	conn->ts = ts;

	/* 
	 * we use the listen socket wsi to get started, but a new wsi is
	 * created.  mbed3_tcp_stream_accept() is also called from
	 * here to bind the conn and new wsi together
	 */
	lws_server_socket_service(wsi->protocol->owning_server,
				  wsi, (struct pollfd *)conn);

	ts->setOnSent(Socket::SentHandler_t(conn, &lws_conn::onSent));
	ts->setOnReadable(TCPStream::ReadableHandler_t(conn, &lws_conn::onRX));
	ts->setOnError(TCPStream::ErrorHandler_t(conn, &lws_conn::onError));
	ts->setOnDisconnect(TCPStream::DisconnectHandler_t(conn,
			    &lws_conn::onDisconnect));
	/*
	 * mbed3 is messed up as of 2015-11-08, data packets may
	 * appear on the listening socket initially
	 */
	conn->actual_onRX((Socket *)tl);
	conn->actual_onRX((Socket *)conn->ts);

	lwsl_debug("%s: exit\n", __func__);
}

int mbed_socket::doaccept(struct sockaddr *addr, socklen_t *addrlen) {
  void* impl;

  impl = incomming_pop();
  if (impl == NULL) {
    set_errno(EINVAL);
    TDLOG(".. doaccept error: incomming null");
    return -1;
  }

  TCPListener* listener = get_listener();
  if (listener == NULL) {
    set_errno(EOPNOTSUPP);
    TDLOG(".. doaccept error: no listener");
    return -1;
  }

  mbed_socket* socli;
  socli = new mbed_socket(domain_, type_, protocol_);
  if (socli == NULL) {
    set_errno(ENOMEM);
    TDLOG(".. doaccept error: out of memory");
    return -1;
  }
  if (socli->get_sock_fd() < 0) {
    delete socli;
    TDLOG(".. doaccept error: out of fd");
    set_errno(ENOMEM);
    return -1;
  }

  TCPStream* stream;
  stream = listener->accept(impl);
  if (stream == NULL) {
    TDLOG(".. doaccept error: accept failed");
    delete socli;
    set_errno(ENOMEM);
    return -1;
  }

  // it's already connected. there will be no "on_connected" cb called
  socli->set_stream(stream, true);

  stream->setOnError(on_error_t(socli, &mbed_socket::on_error));
  stream->setOnReadable(on_readable_t(socli, &mbed_socket::on_readable));
  stream->setOnSent(on_sent_t(socli, &mbed_socket::on_sent));
  stream->setOnDisconnect(on_disconnect_t(socli, &mbed_socket::on_disconnect));

  //
  if (addr && addrlen) {
    memset(addr, 0, *addrlen);

    struct sockaddr_in* inaddr = (struct sockaddr_in*)addr;

    SocketAddr sockaddr;
    uint16_t sockport;
    stream->getRemoteAddr(&sockaddr);
    stream->getRemotePort(&sockport);
    assert(sockaddr.is_v4());

    inaddr = (struct sockaddr_in*)addr;

    inaddr->sin_family = AF_INET;
    inaddr->sin_addr.s_addr = socket_addr_get_ipv4_addr(sockaddr.getAddr());
    inaddr->sin_port = sockport;

    *addrlen = sizeof(struct sockaddr_in);
  }

  return socli->get_sock_fd();
}