libuv服务器代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <uv.h>


#pragma comment (lib, "ws2_32.lib")
#pragma comment (lib, "Iphlpapi.lib")
#pragma comment (lib, "Psapi.lib")
#pragma comment (lib, "Userenv.lib")

#define ASSERT(expr)                                      \
 do {                                                     \
  if (!(expr)) {                                          \
    fprintf(stderr,                                       \
            "Assertion failed in %s on line %d: %s\n",    \
            __FILE__,                                     \
            __LINE__,                                     \
            #expr);                                       \
    abort();                                              \
  }                                                       \
 } while (0)

int64_t counter = 0;

void wait_for_a_while(uv_idle_t* handle) {
	counter++;

	if (counter >= 10e6)
		uv_idle_stop(handle);
	else
		printf("counter now is %d\n", counter);
}

typedef struct {
	uv_write_t req;
	uv_buf_t buf;
} write_req_t;

uv_loop_t *loop;
struct sockaddr_in addr;
uv_tcp_t server;

void on_close(uv_handle_t* handle)
{
	free(handle);
}

void alloc_buffer(uv_handle_t* handle,
	size_t suggested_size,
	uv_buf_t* buf)
{
	buf->base = malloc(suggested_size);
	buf->len = suggested_size;
}

void free_write_req(uv_write_t *req) 
{
	write_req_t *wr = (write_req_t*)req;
	free(wr->buf.base);
	free(wr);
}

void on_write(uv_write_t* req, int status)
{
	if (status)
	{
		fprintf(stderr, "Write error %s\n", uv_strerror(status));
	}
	free_write_req(req);
}

void on_read(uv_stream_t* stream,
	ssize_t nread,
	const uv_buf_t* buf)
{
	if (nread > 0)
	{
		printf("on_read, nread = %d\n", nread);
		write_req_t *req = (write_req_t*)malloc(sizeof(write_req_t));
		req->buf = uv_buf_init(buf->base, nread);
		//fwrite(buf->base, nread, 1, stdout);
		buf->base[nread] = '\0';
		printf("read msg: %s\n", buf->base);
		uv_write((uv_write_t*)req, stream, &req->buf, 1, on_write);
		return;
	}
	else if (nread == 0)
	{
		printf("on_read, client connection close.\n");
	}
	else
	{
		printf("on_read, nread < 0\n");
		if (nread != UV_EOF)
		{
			fprintf(stderr, "Read error %s\n", uv_err_name(nread));
		}
		uv_close((uv_handle_t*)stream, on_close);
	}
}

void on_new_connection(uv_stream_t* server, int status)
{
	if (status < 0)
	{
		fprintf(stderr, "New connection error %s\n", uv_strerror(status));
		// error!
		return;
	}
	fprintf(stderr, "New connection here.%s\n", uv_strerror(status));
	uv_tcp_t *client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
	int r = uv_tcp_init(loop, client);
	ASSERT(r == 0);
	r = uv_accept(server, (uv_stream_t*)client);
	ASSERT(r == 0);
	r = uv_read_start((uv_stream_t*)client, alloc_buffer, on_read);
	ASSERT(r == 0);
	/*if (uv_accept(server, (uv_stream_t*)client) == 0)
	{
		uv_read_start((uv_stream_t*)client, alloc_buffer, on_read);
	}
	else
	{
		uv_close((uv_handle_t*)client, on_close);
	}*/
}

#define TEST_PORT 6080

int main(int argc, char** argv)
{
	loop = uv_default_loop();
	uv_tcp_init(loop, &server);
	uv_ip4_addr("0.0.0.0", TEST_PORT, &addr);
	uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
	int r = uv_listen((uv_stream_t*)&server, 128, on_new_connection);
	if (r)
	{
		printf("uv_listen error: %s", uv_strerror(r));
	}
	uv_run(loop, UV_RUN_DEFAULT);
	return 0;
}