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

Classes
struct	write_req_t

Functions
void	free_write_req (uv_write_t *req)

void	alloc_buffer (uv_handle_t handle, size_t suggested_size, uv_buf_t buf)

void	echo_write (uv_write_t *req, int status)

void	echo_read (uv_stream_t client, ssize_t nread, const uv_buf_t buf)

void	on_new_connection (uv_stream_t q, ssize_t nread, const uv_buf_t buf)

int	main ()

Variables
uv_loop_t *	loop

uv_pipe_t	queue

Function Documentation

◆ alloc_buffer()

void alloc_buffer	(	uv_handle_t *	handle,
		size_t	suggested_size,
		uv_buf_t *	buf
	)

Definition at line 22 of file worker.c.

                                                                              {
   buf->base = malloc(suggested_size);
   buf->len = suggested_size;
 }

References malloc().

Referenced by main(), and on_new_connection().

◆ echo_read()

void echo_read	(	uv_stream_t *	client,
		ssize_t	nread,
		const uv_buf_t *	buf
	)

Definition at line 34 of file worker.c.

                                                                         {
     if (nread > 0) {
         write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
         req->buf = uv_buf_init(buf->base, nread);
         uv_write((uv_write_t*) req, client, &req->buf, 1, echo_write);
         return;
     }
  
     if (nread < 0) {
         if (nread != UV_EOF)
             fprintf(stderr, "Read error %s\n", uv_err_name(nread));
         uv_close((uv_handle_t*) client, NULL);
     }
  
     free(buf->base);
 }

References echo_write(), free(), malloc(), NULL, req, uv_buf_init(), uv_close(), uv_err_name(), and uv_write().

Referenced by on_new_connection().

◆ echo_write()

void echo_write	(	uv_write_t *	req,
		int	status
	)

Definition at line 27 of file worker.c.

                                              {
     if (status) {
         fprintf(stderr, "Write error %s\n", uv_err_name(status));
     }
     free_write_req(req);
 }

References free_write_req(), req, status, and uv_err_name().

Referenced by echo_read().

◆ free_write_req()

void free_write_req ( uv_write_t * req )

Definition at line 16 of file worker.c.

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

References uv_buf_t::base, write_req_t::buf, free(), and req.

Referenced by echo_write().

◆ main()

int main ( void )

Definition at line 81 of file worker.c.

            {
     loop = uv_default_loop();
  
     uv_pipe_init(loop, &queue, 1 /* ipc */);
     uv_pipe_open(&queue, 0);
     uv_read_start((uv_stream_t*)&queue, alloc_buffer, on_new_connection);
     return uv_run(loop, UV_RUN_DEFAULT);
 }

References alloc_buffer(), loop, on_new_connection(), queue, uv_default_loop(), uv_pipe_init(), uv_pipe_open(), uv_read_start(), uv_run(), and UV_RUN_DEFAULT.

◆ on_new_connection()

void on_new_connection	(	uv_stream_t *	q,
		ssize_t	nread,
		const uv_buf_t *	buf
	)

Definition at line 51 of file worker.c.

                                                                            {
     if (nread < 0) {
         if (nread != UV_EOF)
             fprintf(stderr, "Read error %s\n", uv_err_name(nread));
         uv_close((uv_handle_t*) q, NULL);
         return;
     }
  
     uv_pipe_t *pipe = (uv_pipe_t*) q;
     if (!uv_pipe_pending_count(pipe)) {
         fprintf(stderr, "No pending count\n");
         return;
     }
  
     uv_handle_type pending = uv_pipe_pending_type(pipe);
     assert(pending == UV_TCP);
  
     uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
     uv_tcp_init(loop, client);
     if (uv_accept(q, (uv_stream_t*) client) == 0) {
         uv_os_fd_t fd;
         uv_fileno((const uv_handle_t*) client, &fd);
         fprintf(stderr, "Worker %d: Accepted fd %d\n", getpid(), fd);
         uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);
     }
     else {
         uv_close((uv_handle_t*) client, NULL);
     }
 }