示例#1
0
H_CONNECTION KUVSocket::Accept(uv_stream_t* pListen)
{
	H_CONNECTION hAccept = INVALID_HANDLER;

	if (!pListen)
	{
		sprintf_s(g_ErrorMsg, "KUVSocket::Accept Fail, pListen is empty\n%s", g_ErrorMsg);
		return hAccept;
	}

	ConnectionUserData* pData = (ConnectionUserData*)pListen->data;
	if (!pData)
	{
		sprintf_s(g_ErrorMsg, "KUVSocket::Accept Fail, the user data of uv_listen is empty\n%s", g_ErrorMsg);
		return hAccept;
	}

	H_CONNECTION handle = pData->Conn;
	if (handle < 0 || handle > m_nIdGen)
	{
		sprintf_s(g_ErrorMsg, "KUVSocket::Accept Fail, the handle of uv_listen is empty\n%s", g_ErrorMsg);
		return hAccept;
	}

	uv_tcp_t* pAccept = CreateSocket(hAccept);
	if (!pAccept)
	{
		sprintf_s(g_ErrorMsg, "KUVSocket::Accept Fail, CreateSocket Error\n%s", g_ErrorMsg);
		return hAccept;
	}

	m_nError = uv_accept(pListen, (uv_stream_t*)pAccept);
	if (m_nError == 0)
	{
		fprintf_s(stdout, "\n Accpet some one connection");
		this->OnAccepted(handle, hAccept, m_nError);
		m_nError = uv_read_start((uv_stream_t*)pAccept, AllocReadBuffer, OnConnectionRead);
	}
	else 
	{
		this->OnAccepted(handle, INVALID_HANDLER, m_nError);
		Close(hAccept);
		hAccept = INVALID_HANDLER;
	}
	return hAccept;
}
示例#2
0
static void
on_connection(uv_stream_t* server, int status) {
  uv_stream_t* stream;
  int r;

  if (status != 0) {
    fprintf(stderr, "Connect error: %s: %s\n", uv_err_name(status), uv_strerror(status));
    return;
  }

  stream = malloc(sizeof(uv_tcp_t));
  if (stream == NULL) {
    fprintf(stderr, "Allocate error: %s\n", strerror(errno));
    return;
  }

  r = uv_tcp_init(loop, (uv_tcp_t*) stream);
  if (r) {
    fprintf(stderr, "Socket creation error: %s: %s\n", uv_err_name(r), uv_strerror(r));
    return;
  }

  r = uv_tcp_simultaneous_accepts((uv_tcp_t*) stream, 1);
  if (r) {
    fprintf(stderr, "Flag error: %s: %s\n", uv_err_name(r), uv_strerror(r));
    return;
  }

  r = uv_accept(server, stream);
  if (r) {
    fprintf(stderr, "Accept error: %s: %s\n", uv_err_name(r), uv_strerror(r));
    return;
  }

  r = uv_tcp_nodelay((uv_tcp_t*) stream, 1);
  if (r) {
    fprintf(stderr, "Flag error: %s: %s\n", uv_err_name(r), uv_strerror(r));
    return;
  }

  r = uv_read_start(stream, on_alloc, on_read);
  if (r) {
    fprintf(stderr, "Read error: %s: %s\n", uv_err_name(r), uv_strerror(r));
    uv_close((uv_handle_t*) stream, on_close);
  }
}
示例#3
0
void KUVSocket::OnConnectionConnected(uv_connect_t* req, int status)
{
	uv_stream_t* pHandle = req->handle;
	ConnectionUserData* pData = (ConnectionUserData*)req->handle->data;
	KUVSocket* pSocket = pData->ServerSocket;
	free(req);
	req = NULL;

	if (status != 0)
	{
		pSocket->OnConnected(pData->Conn, false);
		pSocket->OnError(pData->Conn, status);
		return;
	}
	uv_read_start((uv_stream_t*)pHandle, AllocReadBuffer, OnConnectionRead);
	pSocket->OnConnected(pData->Conn, true);
}
示例#4
0
// read cb may fire multiple times.
int lua_uv_stream_read_start(lua_State * L) {
	uv_stream_t * s = lua_generic_object<uv_stream_t>(L, 1);
	luaL_checktype(L, 2, LUA_TFUNCTION);
	
	// bind ptr to callback function:
	lua_pushlightuserdata(L, s);
	lua_pushvalue(L, 2);	// func
	lua_pushvalue(L, 1);	// stream
	lua_pushcclosure(L, lua_uv_stream_read_cb_closure, 2);	// closure(func, timer)
	//Lua(L).dump("read start"); 
	// registry[s] = closure(func, stream)
	lua_rawset(L, LUA_REGISTRYINDEX);
	
	uv_read_start(s, lua_uv_alloc, lua_uv_stream_read_cb);
	lua_uv_ok(L);
	lua_settop(L, 1);
	return 1;	// return stream
}
示例#5
0
/**
 * The callback function while server socket listening. It accepts connection
 * from client and reads request data.
 */
static void on_connect(uv_stream_t *server, int status)
{
    if (status == -1)
        return;

    uv_tcp_t *client = (uv_tcp_t *) malloc(sizeof(uv_tcp_t));
    uv_tcp_init(uv_default_loop(), client);

    if (uv_accept(server, (uv_stream_t *) client) == 0)
    {
        client->data = server->data;
        uv_read_start((uv_stream_t *) client, alloc_buffer, on_request);
    }
    else
    {
        uv_close((uv_handle_t*) client, NULL);
    }
}
示例#6
0
int ws_read_start(ws_connect_t *ptr, ws_cb_malloc cb_malloc, ws_cb_read cb_read, void *cb_read_obj)
{
    if (WS_ONLINE == ptr->state)
    {
        ptr->cb.cb_malloc = cb_malloc;
        
        ptr->cb.cb_read = cb_read;
        ptr->cb.obj_read = cb_read_obj;
        
        uv_read_start((uv_stream_t *)&ptr->connect, cb_read_malloc, cb_read_operation);
    }
	else
    {
        return 1;
    }
    
	return 0;
}
示例#7
0
void durotanOnConnection(uv_stream_t* durotan, int status) {
    if(status == -1) ERROR("durotan on connect", status);

    client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
    uv_tcp_init(loop, client);
    int err = uv_accept(durotan, (uv_stream_t*) client);
    if(err) {
        uv_close((uv_handle_t*) client, durotanOnClose);
        ERROR("durotan accept", err);
    }

    // Buffer for incoming messages.
    client->data = calloc(BUFFER_SIZE, sizeof(char));

    printf("durotan: got connection\n");

    uv_read_start((uv_stream_t*) client, durotanOnAllocate, durotanOnRead);
}
示例#8
0
static void connect_cb(uv_stream_t* listener, int status)
{
	int n;

	if (status) {
		SHOW_UV_ERROR(listener->loop);
		return;
	}

	server_ctx *ctx = calloc(1, sizeof(server_ctx));
	ctx->handshake_buffer = calloc(1, HANDSHAKE_BUFFER_SIZE);

	if (!ctx || !ctx->handshake_buffer)
		FATAL("malloc() failed!");

	ctx->client.data = ctx;
	ctx->remote.data = ctx;
	
	make_encryptor(&crypto, &ctx->encoder, 0, NULL);

	n = uv_tcp_init(listener->loop, &ctx->client);
	if (n)
		SHOW_UV_ERROR_AND_EXIT(listener->loop);

	n = uv_accept(listener, (uv_stream_t *)(void *)&ctx->client);
	if (n)
		SHOW_UV_ERROR_AND_EXIT(listener->loop);

	n = uv_tcp_nodelay(&ctx->client, 1);
	if (n)
		SHOW_UV_ERROR_AND_EXIT(listener->loop);

	#ifdef KEEPALIVE_TIMEOUT
	n = uv_tcp_keepalive(&ctx->client, 1, KEEPALIVE_TIMEOUT);
	if (n)
		SHOW_UV_ERROR_AND_EXIT(listener->loop);
	#endif /* KEEPALIVE_TIMEOUT */

	n = uv_read_start((uv_stream_t *)(void *)&ctx->client, client_handshake_alloc_cb, client_handshake_read_cb);
	if (n)
		SHOW_UV_ERROR_AND_EXIT(listener->loop);

	LOGCONN(&ctx->client, "Accepted connection from %s");
}
示例#9
0
static void connect_cb(uv_req_t* req, int status) {
  uv_buf send_bufs[CHUNKS_PER_WRITE];
  uv_handle_t* handle;
  int i, j, r;

  ASSERT(req != NULL);
  ASSERT(status == 0);

  handle = req->handle;

  connect_cb_called++;
  free(req);

  /* Write a lot of data */
  for (i = 0; i < WRITES; i++) {
    for (j = 0; j < CHUNKS_PER_WRITE; j++) {
      send_bufs[j].len = CHUNK_SIZE;
      send_bufs[j].base = send_buffer + bytes_sent;
      bytes_sent += CHUNK_SIZE;
    }

    req = (uv_req_t*)malloc(sizeof *req);
    ASSERT(req != NULL);

    uv_req_init(req, handle, write_cb);
    r = uv_write(req, (uv_buf*)&send_bufs, CHUNKS_PER_WRITE);
    ASSERT(r == 0);
  }

  /* Shutdown on drain. FIXME: dealloc req? */
  req = (uv_req_t*) malloc(sizeof(uv_req_t));
  ASSERT(req != NULL);
  uv_req_init(req, handle, shutdown_cb);
  r = uv_shutdown(req);
  ASSERT(r == 0);

  /* Start reading */
  req = (uv_req_t*)malloc(sizeof *req);
  ASSERT(req != NULL);

  uv_req_init(req, handle, read_cb);
  r = uv_read_start(handle, read_cb);
  ASSERT(r == 0);
}
示例#10
0
static void connection_cb(uv_stream_t* stream, int status) {
  conn_rec* conn;
  int r;

  ASSERT(status == 0);
  ASSERT(stream == (uv_stream_t*)&tcp_server);

  conn = malloc(sizeof *conn);
  ASSERT(conn != NULL);

  r = uv_tcp_init(stream->loop, &conn->handle);
  ASSERT(r == 0);

  r = uv_accept(stream, (uv_stream_t*)&conn->handle);
  ASSERT(r == 0);

  r = uv_read_start((uv_stream_t*)&conn->handle, alloc_cb, read_cb);
  ASSERT(r == 0);
}
示例#11
0
文件: main.c 项目: 26597925/uvbook
int main(int argc, char **argv) {
    loop = uv_default_loop();

    uv_pipe_init(loop, &stdin_pipe, 0);
    uv_pipe_open(&stdin_pipe, 0);

    uv_pipe_init(loop, &stdout_pipe, 0);
    uv_pipe_open(&stdout_pipe, 1);
    
    uv_fs_t file_req;
    int fd = uv_fs_open(loop, &file_req, argv[1], O_CREAT | O_RDWR, 0644, NULL);
    uv_pipe_init(loop, &file_pipe, 0);
    uv_pipe_open(&file_pipe, fd);

    uv_read_start((uv_stream_t*)&stdin_pipe, alloc_buffer, read_stdin);

    uv_run(loop, UV_RUN_DEFAULT);
    return 0;
}
示例#12
0
static void connect_cb(uv_connect_t * req, int status)
{

	int r;
	uv_stream_t *stream;

	stream = req->handle;

#if USE_PIPE
	printf("pipe connected....\n");
#else
	printf("tcp connected....\n");
#endif
	// do no write
	//r = uv_write(&pmyWr->write_req, stream, &pmyWr->buf, 1, write_cb);
	//printf("wr: r=%d\n",r);
	/* Start reading */
	r = uv_read_start(stream, alloc_cb, tcp_read_cb);
}
示例#13
0
static void connect_cb(uv_connect_t *req, int status) {
  ASSERT(status == 0);
  ASSERT(req == &connect_req);

  /* Start reading from our connection so we can receive the EOF.  */
  uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb);

  /*
   * Write the letter 'Q' to gracefully kill the echo-server. This will not
   * effect our connection.
   */
  uv_write(&write_req, (uv_stream_t*) &tcp, &qbuf, 1, NULL);

  /* Shutdown our end of the connection.  */
  uv_shutdown(&shutdown_req, (uv_stream_t*) &tcp, shutdown_cb);

  called_connect_cb++;
  ASSERT(called_shutdown_cb == 0);
}
示例#14
0
文件: ls-tcp.c 项目: zenkj/lserver
static void tcp_connect_cb(uv_connect_t *connect_req, int status)
{
    ls_tcp_t *client = containerof(connect_req->handle, ls_tcp_t, handle);
    uv_tcp_t *handle = &client->handle;
    lua_State *l = ls_default_state();
    lua_State *nl;
    uv_loop_t *loop = uv_default_loop();

    ls_free(l, connect_req);

    if (ls_object_is_waited(&client->wait_object))
    {
        int ref = client->wait_object.mthread_ref;
        client->wait_object.mthread_ref = LUA_NOREF;
        ls_getref(l, ref);
        nl = lua_tothread(l, -1);
        lua_pop(l, 1);
        if (nl)
        {
            ls_clear_waiting(nl);
            if (status)
            {
                uv_close((uv_handle_t*)handle, tcp_close_cb);
                ls_last_error_resume(nl, loop);
            }
            else
            {
                if (uv_read_start((uv_stream_t*)handle, tcp_alloc_cb, tcp_read_cb))
                {
                    uv_close((uv_handle_t*)handle, tcp_close_cb);
                    ls_last_error_resume(nl, loop);
                }
                else
                {
                    lua_pushboolean(nl, 1);
                    new_tcp_connection_udata(nl, client);
                    ls_resume(nl, 2);
                }
            }
        }
        ls_unref(l, ref);
    }
}
示例#15
0
void tcp_new_connection_cb(uv_stream_t* uv_server, int status) {
  if (uv_server != (uv_stream_t*)&_uv_server) return;
  if (status != 0) return;

  printf("connected\n");

  client_t* client = malloc(sizeof(client_t));  
  uv_tcp_init(_uv_loop, &client->handle);
  printf("%p\n", client);

  int error = uv_accept((uv_stream_t*)&_uv_server, (uv_stream_t*)&client->handle);
  if (error == 0) {
    client->handle.data = client;
    
    uv_read_start((uv_stream_t*)&client->handle, alloc_buffer_cb, tcp_read_cb);
  } else {
    uv_close((uv_handle_t*)&client->handle, tcp_close_cb);
  }
}
示例#16
0
void TCPClient::ConnectCallback(uv_connect_t * connect_request, int status)
{
    auto tcp_client = (TCPClient *) connect_request->data;

    if (status < 0)
    {
        LogError(LOG_NETWORKING, "Connecting to server - failure, reason: (%s)", uv_err_name(status));
        NetworkManager::_state = NetworkState::Disconnected;
    }
    else
    {
        LogTrace(LOG_NETWORKING, "Connecting to server - success");
        NetworkManager::_state = NetworkState::Connected;

        uv_read_start((uv_stream_t *) tcp_client, AllocBuffer, IncomingData);
    }

    free(connect_request);
}
示例#17
0
static void uv_on_tcp_accept(uv_stream_t *tcpacc, int status)
{
	debug("%s(status=%d)\n", __FUNCTION__, status);
	int ret;

	outlet_t *ol = tcpacc->data;
	assert(ol);

	if (status < 0)
		return;

	acc_pend_t *pend = get_free_pending(ol);
	if (pend == 0)
		return;  // fatal error?

	uv_tcp_t *conn = malloc(sizeof(uv_tcp_t));
	if (!conn)
		goto pend_cleanup;

	ret = uv_tcp_init(uv_default_loop(), conn);
	if (ret)
		goto pend_cleanup;

	conn->data = pend;

	ret = uv_accept(tcpacc, (uv_stream_t *)conn);
	if (ret)
		goto pend_cleanup;

	ret = uv_read_start((uv_stream_t *)conn, on_alloc, uv_on_tcpacc_recv);
	if (ret)
		goto pend_cleanup;

	pend->tcp = conn;
	try_to_bake(ol, pend);
	return;

pend_cleanup:
	if (conn)
		uv_close((uv_handle_t *)conn, NULL);
	reuse_pending(&ol->free_pends, pend);
	return;
}
示例#18
0
void conn_done( uv_stream_t *listener, int status )
{
    int n;
    ctx_t *ctx = ( ctx_t *) malloc( sizeof( ctx_t ) ); //创建实例,返回实例指针
    ctx->tcp.data = ctx;
    ctx->isChunked = 0;
    ctx->db = ( sqlite3 *)listener->data;
    n = uv_tcp_init( listener->loop, &ctx->tcp );
    if ( n ) {
        return;
    }
    n = uv_accept( listener, ( uv_stream_t *)&ctx->tcp );
    if ( n ) {
        return;
    }
    n = uv_read_start( ( uv_stream_t *)&ctx->tcp, alloc_buffer, read_done );
    if ( n ) {
        return;
    }
}
示例#19
0
/**
 * the static callback called by the C-level routines in uv. it's main job is to call a C++ level callback to do the work with higher layers
 *
 * from uv.h
 * typedef void (*uv_connect_cb)(uv_connect_t* req, int status);
 */
void
UVEventLoop::OnConnect(uv_connect_t *req, int status)
{
	DEBUG_OUT("OnConnect() ... " << status);
	UVReader* ocCBp=nullptr;
	if (req) {
		ocCBp=static_cast<UVReader*>(req->data);
	}
	if (ocCBp) {
		ocCBp->client->socket->data = ocCBp;
		if (status >= 0) {
			status = uv_read_start((uv_stream_t*)ocCBp->client->socket, AllocBuffer, OnRead);
		}
		if (ocCBp->connectCB) {
			(*ocCBp->connectCB)(req, status);
		}
//		ocCBp->client->socket->data = ocCBp->readerCB;
//		ocCBp->disposed = true;
	}
}
示例#20
0
static void timer_cb(uv_timer_t* handle, int status) {
  int r;

  ASSERT(handle == &timer);
  ASSERT(status == 0);
  ASSERT(nested == 0 && "timer_cb must be called from a fresh stack");

  puts("Timeout complete. Now read data...");

  nested++;
  if (uv_read_start((uv_stream_t*)&client, alloc_cb, read_cb)) {
    FATAL("uv_read_start failed");
  }
  nested--;

  timer_cb_called++;

  r = uv_close((uv_handle_t*)handle, close_cb);
  ASSERT(r == 0);
}
示例#21
0
static void connection_cb(uv_handle_t* s, int status) {
  uv_tcp_t* tcp;
  int r;

  ASSERT(&server == (uv_tcp_t*)s);
  ASSERT(status == 0);

  tcp = malloc(sizeof(uv_tcp_t));

  uv_tcp_init(tcp);

  r = uv_accept(s, (uv_stream_t*)tcp);
  ASSERT(r == 0);

  r = uv_read_start((uv_stream_t*)tcp, buf_alloc, read_cb);
  ASSERT(r == 0);

  read_sockets++;
  max_read_sockets++;
}
示例#22
0
static int start_read(lcb_io_opt_t iobase,
                      lcb_sockdata_t *sockbase,
                      lcb_io_read_cb callback)
{
    my_sockdata_t *sock = (my_sockdata_t *)sockbase;
    my_iops_t *io = (my_iops_t *)iobase;
    int ret;

    sock->cur_iov = 0;
    sock->tcp.callback = callback;

    ret = uv_read_start((uv_stream_t *)&sock->tcp.t, alloc_cb, read_cb);
    set_last_error(io, ret);

    if (ret == 0) {
        SOCK_INCR_PENDING(sock, read);
        incref_sock(sock);
    }
    return ret;
}
示例#23
0
文件: main.cpp 项目: hauke/hanfun
int main (int argc, char *argv[])
{
   UNUSED (argc);
   UNUSED (argv);

   uv_loop_t *loop = uv_default_loop ();

#ifdef HF_BASE_APP
   HF::UID::URI *uid = new HF::UID::URI ("hf://base.example.com");
#endif

#ifdef HF_NODE_APP

   if (argc < 2)
   {
      std::cout << "usage : " << argv[0] << " [number]" << std::endl;
      exit (-1);
   }

   std::stringstream ss;
   ss << "hf://node.example.com/" << argv[1];

   HF::UID::URI *uid = new HF::UID::URI (ss.str ());
#endif

   HF::Application::Initialize (transport);
   transport.uid (uid);

   HF::Application::Handle ("?");

   uv_pipe_init (loop, &stdin_pipe, 0);
   uv_pipe_open (&stdin_pipe, 0);

   uv_read_start ((uv_stream_t *) &stdin_pipe, alloc_buffer, read_stdin);

   uv_run (loop, UV_RUN_DEFAULT);

   HF::Application::Save ();

   return 0;
}
示例#24
0
    void client::onConnect(uv_connect_t* conn_req_, int status_)
    {
        if (status_ == -1)
        {
            uv_close((uv_handle_t*)conn_req_->handle, onClose);
            throw std::runtime_error(uv_err_name(status_));
        }

        data_t* data = (data_t*)conn_req_->data;

        uv_write_t* req;
        uv_buf_t buf;
        int r;

        std::string request = data->req->toString();

        buf = uv_buf_init((char*)request.c_str(), request.length());

        req = (uv_write_t*)malloc(sizeof *req);

        if (req == NULL)
        {
            throw std::runtime_error("Error malloc.");
        }

        r = uv_write(req, conn_req_->handle, &buf, 1, onWrite);

        if (r)
        {
            throw std::runtime_error(uv_err_name(r));
        }

        conn_req_->handle->data = data;

        r = uv_read_start(conn_req_->handle, onAlloc, onRead);

        if (r)
        {
            throw std::runtime_error(uv_err_name(r));
        }
    }
示例#25
0
文件: uvx_client.c 项目: cosim/uvx
static void _uv_on_connect(uv_connect_t* conn, int status) {
    uvx_client_t* xclient = (uvx_client_t*) conn->data;
    xclient->uvclient.data = xclient;

	if(status == 0) {
		if(xclient->config.log_out)
            fprintf(xclient->config.log_out, "[uvx-client] %s connect to server ok\n", xclient->config.name);
		assert(conn->handle == (uv_stream_t*) &xclient->uvclient);
		xclient->uvserver = (uv_tcp_t*) conn->handle;
        if(xclient->config.on_conn_ok)
            xclient->config.on_conn_ok(xclient);
		uv_read_start(conn->handle, uvx__on_alloc_buf, uvx__on_client_read);
	} else {
		xclient->uvserver = NULL;
		if(xclient->config.log_err)
            fprintf(xclient->config.log_err, "\n!!! [uvx-client] %s connect to server failed: %s\n", xclient->config.name, uv_strerror(status));
        if(xclient->config.on_conn_fail)
            xclient->config.on_conn_fail(xclient);
		_uvx_client_close(xclient); // will try reconnect on next on_heartbeat
	}
}
示例#26
0
static void on_connect(uv_stream_t *server, int status) {
  int r;

  CHECK(status, "connecting");
  debug("connecting req");

  // the tcp handle points to our sws_handle_req_t which can store a bit extra info
  sws_handle_req_t *handle_req = malloc(sizeof(sws_handle_req_t));
  sws_handle_req_init(handle_req, id++);

  r = uv_accept(server, (uv_stream_t*) &handle_req->handle);
  if (r) {
    log_err("error accepting connection %d", r);
    uv_close((uv_handle_t*) handle_req, NULL);
  } else {
    // read the req into the tcp socket to cause it to get parsed
    // once the headers are in we'll get called back the first time (see on_headers_complete)
    // for now we assume no body since this is just a static webserver
    uv_read_start((uv_stream_t*) handle_req, alloc_cb, on_req_read);
  }
}
示例#27
0
文件: main.c 项目: kasicass/kasicass
void on_new_connection(uv_stream_t *server, int status)
{
	uv_tcp_t *client;

	if (status < 0)
	{
		fprintf(stderr, "New connection error %s\n", uv_strerror(status));
		return;
	}

	client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
	uv_tcp_init(loop, client);
	if (uv_accept(server, (uv_stream_t*)client) == 0)
	{
		uv_read_start((uv_stream_t*)client, alloc_buffer, echo_read);
	}
	else
	{
		uv_close((uv_handle_t*)client, NULL);
	}
}
示例#28
0
void
on_connection(uv_stream_t *server, int status)
{
     uv_tcp_t *client = malloc(sizeof(uv_tcp_t));

     if (status == -1) {
	  /* error */
     }

     uv_tcp_init(loop, client);

     if (uv_accept(server, (uv_stream_t *)client) == 0) {
	  int r = uv_read_start((uv_stream_t *)client, alloc_buffer, on_read);

	  if (r) {
	       /* error */
	  }
     } else {
	  uv_close((uv_handle_t *)client, NULL);
     }
}
示例#29
0
static void on_connect(ws_connect_t *ptr)
{
	//print_info();

	ptr->state = WS_CONNECT;

	uv_read_start((uv_stream_t *)&ptr->connect, cb_pre_malloc, cb_read_over);

	if(WS_CLIENT == ptr->type)
	{
		// step1 websocket握手

		ptr->write_buf[0] = uv_buf_init(str_client_req, strlen(str_client_req));

		uv_write(&(ptr->write_req[0]), (uv_stream_t*)&ptr->connect, ptr->write_buf, 1, cb_write);
	}
    else
    {
        
    }
}
示例#30
0
int async_read(uv_stream_t *const stream, size_t const size, uv_buf_t *const out) {
	if(!stream) return UV_EINVAL;
	if(!out) return UV_EINVAL;
	async_state state[1];
	state->thread = async_active();
	state->size = size;
	state->status = 0;
	*state->buf = uv_buf_init(NULL, 0);
	stream->data = state;
	int rc = uv_read_start(stream, alloc_cb, read_cb);
	if(rc < 0) return rc;
	rc = async_yield_cancelable();
	uv_read_stop(stream);
	if(rc < 0) {
		free(state->buf->base);
		return rc;
	}
	out->base = state->buf->base;
	out->len = state->buf->len;
	return state->status;
}