ustream.h File Reference

#include <stdarg.h>
#include "uloop.h"

Go to the source code of this file.

Data Structures
struct	ustream_buf_list
struct	ustream
struct	ustream_fd
struct	ustream_buf

Enumerations
enum	read_blocked_reason { READ_BLOCKED_USER = (1 << 0) , READ_BLOCKED_FULL = (1 << 1) }

Functions
void	ustream_fd_init (struct ustream_fd *s, int fd)
void	ustream_free (struct ustream *s)
void	ustream_consume (struct ustream *s, int len)
int	ustream_read (struct ustream *s, char *buf, int buflen)
int	ustream_write (struct ustream *s, const char *buf, int len, bool more)
int	ustream_printf (struct ustream *s, const char *format,...) __attribute__((format(printf
int int	ustream_vprintf (struct ustream *s, const char *format, va_list arg) __attribute__((format(printf
int int char *	ustream_get_read_buf (struct ustream *s, int *buflen)
void	ustream_set_read_blocked (struct ustream *s, bool set)
static bool	ustream_read_blocked (struct ustream *s)
static int	ustream_pending_data (struct ustream *s, bool write)
static bool	ustream_read_buf_full (struct ustream *s)
void	ustream_init_defaults (struct ustream *s)
char *	ustream_reserve (struct ustream *s, int len, int *maxlen)
void	ustream_fill_read (struct ustream *s, int len)
bool	ustream_write_pending (struct ustream *s)
static void	ustream_state_change (struct ustream *s)
static bool	ustream_poll (struct ustream *s)

Enumeration Type Documentation

read_blocked_reason

enum read_blocked_reason

Enumerator
READ_BLOCKED_USER
READ_BLOCKED_FULL

Definition at line 28 of file ustream.h.

                         {
        READ_BLOCKED_USER = (1 << 0),
        READ_BLOCKED_FULL = (1 << 1),
};

Function Documentation

ustream_consume()

void ustream_consume	(	struct ustream *	s,
		int	len
	)

Definition at line 214 of file ustream.c.

{
        struct ustream_buf *buf = s->r.head;
 
        if (!len)
                return;
 
        s->r.data_bytes -= len;
        if (s->r.data_bytes < 0)
                abort();
 
        do {
                struct ustream_buf *next = buf->next;
                int buf_len = buf->tail - buf->data;
 
                if (len < buf_len) {
                        buf->data += len;
                        break;
                }
 
                len -= buf_len;
                ustream_free_buf(&s->r, buf);
                buf = next;
        } while(len);
 
        __ustream_set_read_blocked(s, s->read_blocked & ~READ_BLOCKED_FULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_fd_init()

void ustream_fd_init	(	struct ustream_fd *	s,
		int	fd
	)

Definition at line 160 of file ustream-fd.c.

{
        struct ustream *s = &sf->stream;
 
        ustream_init_defaults(s);
 
        sf->fd.fd = fd;
        sf->fd.cb = ustream_uloop_cb;
        s->set_read_blocked = ustream_fd_set_read_blocked;
        s->write = ustream_fd_write;
        s->free = ustream_fd_free;
        s->poll = ustream_fd_poll;
        ustream_fd_set_uloop(s, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_fill_read()

void ustream_fill_read	(	struct ustream *	s,
		int	len
	)

Definition at line 301 of file ustream.c.

{
        struct ustream_buf *buf = s->r.data_tail;
        int n = len;
        int maxlen;
 
        s->r.data_bytes += len;
        do {
                if (!buf)
                        abort();
 
                maxlen = buf->end - buf->tail;
                if (len < maxlen)
                        maxlen = len;
 
                len -= maxlen;
                buf->tail += maxlen;
                ustream_fixup_string(s, buf);
 
                s->r.data_tail = buf;
                buf = buf->next;
        } while (len);
 
        if (s->notify_read)
                s->notify_read(s, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_free()

void ustream_free

(

struct ustream *

s

)

Definition at line 92 of file ustream.c.

{
        if (s->free)
                s->free(s);
 
        uloop_timeout_cancel(&s->state_change);
        ustream_free_buffers(&s->r);
        ustream_free_buffers(&s->w);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_get_read_buf()

int int char* ustream_get_read_buf	(	struct ustream *	s,
		int *	buflen
	)

Definition at line 328 of file ustream.c.

{
        char *data = NULL;
        int len = 0;
 
        if (s->r.head) {
                len = s->r.head->tail - s->r.head->data;
                if (len > 0)
                        data = s->r.head->data;
        }
 
        if (buflen)
                *buflen = len;
 
        return data;
}

Here is the caller graph for this function:

ustream_init_defaults()

void ustream_init_defaults

(

struct ustream *

s

)

Definition at line 112 of file ustream.c.

{
#define DEFAULT_SET(_f, _default)       \
        do {                            \
                if (!_f)                \
                        _f = _default;  \
        } while(0)
 
        DEFAULT_SET(s->r.alloc, ustream_alloc_default);
        DEFAULT_SET(s->w.alloc, ustream_alloc_default);
 
        DEFAULT_SET(s->r.min_buffers, 1);
        DEFAULT_SET(s->r.max_buffers, 1);
        DEFAULT_SET(s->r.buffer_len, 4096);
 
        DEFAULT_SET(s->w.min_buffers, 2);
        DEFAULT_SET(s->w.max_buffers, -1);
        DEFAULT_SET(s->w.buffer_len, 256);
 
#undef DEFAULT_SET
 
        s->state_change.cb = ustream_state_change_cb;
        s->write_error = false;
        s->eof = false;
        s->eof_write_done = false;
        s->read_blocked = 0;
 
        s->r.buffers = 0;
        s->r.data_bytes = 0;
 
        s->w.buffers = 0;
        s->w.data_bytes = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_pending_data()

static int ustream_pending_data ( struct ustream *  s, bool  write  )

inlinestatic

Definition at line 173 of file ustream.h.

{
        struct ustream_buf_list *b = write ? &s->w : &s->r;
        return b->data_bytes;
}

ustream_poll()

static bool ustream_poll ( struct ustream *  s )

inlinestatic

Definition at line 213 of file ustream.h.

{
        if (!s->poll)
                return false;
 
        return s->poll(s);
}

ustream_printf()

int ustream_printf	(	struct ustream *	s,
		const char *	format,
			...
	)

ustream_read()

int ustream_read	(	struct ustream *	s,
		char *	buf,
		int	buflen
	)

Definition at line 345 of file ustream.c.

{
        char *chunk;
        int chunk_len;
        int len = 0;
 
        do {
                chunk = ustream_get_read_buf(s, &chunk_len);
                if (!chunk)
                        break;
                if (chunk_len > buflen - len)
                        chunk_len = buflen - len;
                memcpy(buf + len, chunk, chunk_len);
                ustream_consume(s, chunk_len);
                len += chunk_len;
        } while (len < buflen);
 
        return len;
}

Here is the call graph for this function:

ustream_read_blocked()

static bool ustream_read_blocked ( struct ustream *  s )

inlinestatic

Definition at line 168 of file ustream.h.

{
        return !!(s->read_blocked & READ_BLOCKED_USER);
}

Here is the caller graph for this function:

ustream_read_buf_full()

static bool ustream_read_buf_full ( struct ustream *  s )

inlinestatic

Definition at line 179 of file ustream.h.

{
        struct ustream_buf *buf = s->r.data_tail;
        return buf && buf->data == buf->head && buf->tail == buf->end &&
               s->r.buffers == s->r.max_buffers;
}

ustream_reserve()

char* ustream_reserve	(	struct ustream *	s,
		int	len,
		int *	maxlen
	)

Definition at line 286 of file ustream.c.

{
        struct ustream_buf *buf;
 
        if (!ustream_prepare_buf(s, &s->r, len)) {
                __ustream_set_read_blocked(s, s->read_blocked | READ_BLOCKED_FULL);
                *maxlen = 0;
                return NULL;
        }
 
        buf = s->r.data_tail;
        *maxlen = buf->end - buf->tail;
        return buf->tail;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_set_read_blocked()

void ustream_set_read_blocked	(	struct ustream *	s,
		bool	set
	)

Definition at line 204 of file ustream.c.

{
        unsigned char val = s->read_blocked & ~READ_BLOCKED_USER;
 
        if (set)
                val |= READ_BLOCKED_USER;
 
        __ustream_set_read_blocked(s, val);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_state_change()

static void ustream_state_change ( struct ustream *  s )

inlinestatic

Definition at line 208 of file ustream.h.

{
        uloop_timeout_set(&s->state_change, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_vprintf()

int int ustream_vprintf	(	struct ustream *	s,
		const char *	format,
		va_list	arg
	)

ustream_write()

int ustream_write	(	struct ustream *	s,
		const char *	buf,
		int	len,
		bool	more
	)

Definition at line 440 of file ustream.c.

{
        struct ustream_buf_list *l = &s->w;
        int wr = 0;
 
        if (s->write_error)
                return 0;
 
        if (!l->data_bytes) {
                wr = s->write(s, data, len, more);
                if (wr == len)
                        return wr;
 
                if (wr < 0) {
                        ustream_write_error(s);
                        return wr;
                }
 
                data += wr;
                len -= wr;
        }
 
        return ustream_write_buffered(s, data, len, wr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ustream_write_pending()

bool ustream_write_pending

(

struct ustream *

s

)

Definition at line 372 of file ustream.c.

{
        struct ustream_buf *buf = s->w.head;
        int wr = 0, len;
 
        if (s->write_error)
                return false;
 
        while (buf && s->w.data_bytes) {
                struct ustream_buf *next = buf->next;
                int maxlen = buf->tail - buf->data;
 
                len = s->write(s, buf->data, maxlen, !!buf->next);
                if (len < 0) {
                        ustream_write_error(s);
                        break;
                }
 
                if (len == 0)
                        break;
 
                wr += len;
                s->w.data_bytes -= len;
                if (len < maxlen) {
                        buf->data += len;
                        break;
                }
 
                ustream_free_buf(&s->w, buf);
                buf = next;
        }
 
        if (s->notify_write)
                s->notify_write(s, wr);
 
        if (s->eof && wr && !s->w.data_bytes)
                ustream_state_change(s);
 
        return !s->w.data_bytes;
}

Here is the call graph for this function:

Here is the caller graph for this function: