ustream-example.c File Reference

#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "ustream.h"
#include "uloop.h"
#include "usock.h"

Go to the source code of this file.

Data Structures
struct	client

Functions
static void	client_read_cb (struct ustream *s, int bytes)
static void	client_close (struct ustream *s)
static void	client_notify_write (struct ustream *s, int bytes)
static void	client_notify_state (struct ustream *s)
static void	server_cb (struct uloop_fd *fd, unsigned int events)
static int	run_server (void)
static int	usage (const char *name)
int	main (int argc, char **argv)

Variables
static struct uloop_fd	server
static const char *	port = "10000"
struct client *	next_client = NULL

Function Documentation

client_close()

static void client_close ( struct ustream *  s )

static

Definition at line 52 of file ustream-example.c.

{
        struct client *cl = container_of(s, struct client, s.stream);
 
        fprintf(stderr, "Connection closed\n");
        ustream_free(s);
        close(cl->s.fd.fd);
        free(cl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_notify_state()

static void client_notify_state ( struct ustream *  s )

static

Definition at line 72 of file ustream-example.c.

{
        struct client *cl = container_of(s, struct client, s.stream);
 
        if (!s->eof)
                return;
 
        fprintf(stderr, "eof!, pending: %d, total: %d\n", s->w.data_bytes, cl->ctr);
        if (!s->w.data_bytes)
                return client_close(s);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_notify_write()

static void client_notify_write ( struct ustream *  s, int  bytes  )

static

Definition at line 62 of file ustream-example.c.

{
        fprintf(stderr, "Wrote %d bytes, pending: %d\n", bytes, s->w.data_bytes);
 
        if (s->w.data_bytes < 128 && ustream_read_blocked(s)) {
                fprintf(stderr, "Unblock read\n");
                ustream_set_read_blocked(s, false);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_read_cb()

static void client_read_cb ( struct ustream *  s, int  bytes  )

static

Definition at line 25 of file ustream-example.c.

{
        struct client *cl = container_of(s, struct client, s.stream);
        struct ustream_buf *buf = s->r.head;
        char *newline, *str;
 
        do {
                str = ustream_get_read_buf(s, NULL);
                if (!str)
                        break;
 
                newline = strchr(buf->data, '\n');
                if (!newline)
                        break;
 
                *newline = 0;
                ustream_printf(s, "%s\n", str);
                ustream_consume(s, newline + 1 - str);
                cl->ctr += newline + 1 - str;
        } while(1);
 
        if (s->w.data_bytes > 256 && !ustream_read_blocked(s)) {
                fprintf(stderr, "Block read, bytes: %d\n", s->w.data_bytes);
                ustream_set_read_blocked(s, true);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 133 of file ustream-example.c.

{
        int ch;
 
        while ((ch = getopt(argc, argv, "p:")) != -1) {
                switch(ch) {
                case 'p':
                        port = optarg;
                        break;
                default:
                        return usage(argv[0]);
                }
        }
 
        return run_server();
}

run_server()

static int run_server ( void  )

static

Definition at line 110 of file ustream-example.c.

{
 
        server.cb = server_cb;
        server.fd = usock(USOCK_TCP | USOCK_SERVER | USOCK_IPV4ONLY | USOCK_NUMERIC, "127.0.0.1", port);
        if (server.fd < 0) {
                perror("usock");
                return 1;
        }
 
        uloop_init();
        uloop_fd_add(&server, ULOOP_READ);
        uloop_run();
 
        return 0;
}

Here is the call graph for this function:

server_cb()

static void server_cb ( struct uloop_fd *  fd, unsigned int  events  )

static

Definition at line 85 of file ustream-example.c.

{
        struct client *cl;
        unsigned int sl = sizeof(struct sockaddr_in);
        int sfd;
 
        if (!next_client)
                next_client = calloc(1, sizeof(*next_client));
 
        cl = next_client;
        sfd = accept(server.fd, (struct sockaddr *) &cl->sin, &sl);
        if (sfd < 0) {
                fprintf(stderr, "Accept failed\n");
                return;
        }
 
        cl->s.stream.string_data = true;
        cl->s.stream.notify_read = client_read_cb;
        cl->s.stream.notify_state = client_notify_state;
        cl->s.stream.notify_write = client_notify_write;
        ustream_fd_init(&cl->s, sfd);
        next_client = NULL;
        fprintf(stderr, "New connection\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

usage()

static int usage ( const char *  name )

static

Definition at line 127 of file ustream-example.c.

{
        fprintf(stderr, "Usage: %s -p <port>\n", name);
        return 1;
}

Variable Documentation

next_client

struct client* next_client = NULL

Definition at line 16 of file ustream-example.c.

port

const char* port = "10000"

static

Definition at line 15 of file ustream-example.c.

server

struct uloop_fd server

static

Definition at line 1 of file ustream-example.c.