switch_buffer.c File Reference

#include <switch.h>
#include <switch_buffer.h>

Include dependency graph for switch_buffer.c:

Go to the source code of this file.

Data Structures
struct	switch_buffer

Enumerations
enum	switch_buffer_flag_t { SWITCH_BUFFER_FLAG_DYNAMIC = (1 << 0), SWITCH_BUFFER_FLAG_PARTITION = (1 << 1) }

Functions
switch_status_t	switch_buffer_reset_partition_data (switch_buffer_t *buffer)
switch_status_t	switch_buffer_set_partition_data (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_status_t	switch_buffer_create_partition (switch_memory_pool_t *pool, switch_buffer_t **buffer, void *data, switch_size_t datalen)
switch_status_t	switch_buffer_create (switch_memory_pool_t *pool, switch_buffer_t **buffer, switch_size_t max_len)
switch_status_t	switch_buffer_create_dynamic (switch_buffer_t **buffer, switch_size_t blocksize, switch_size_t start_len, switch_size_t max_len)
void	switch_buffer_add_mutex (switch_buffer_t *buffer, switch_mutex_t *mutex)
void	switch_buffer_lock (switch_buffer_t *buffer)
switch_status_t	switch_buffer_trylock (switch_buffer_t *buffer)
void	switch_buffer_unlock (switch_buffer_t *buffer)
switch_size_t	switch_buffer_len (switch_buffer_t *buffer)
switch_size_t	switch_buffer_freespace (switch_buffer_t *buffer)
switch_size_t	switch_buffer_inuse (switch_buffer_t *buffer)
switch_size_t	switch_buffer_toss (switch_buffer_t *buffer, switch_size_t datalen)
void	switch_buffer_set_loops (switch_buffer_t *buffer, int32_t loops)
switch_size_t	switch_buffer_read_loop (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_size_t	switch_buffer_read (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_size_t	switch_buffer_peek (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_size_t	switch_buffer_peek_zerocopy (switch_buffer_t *buffer, const void **ptr)
switch_size_t	switch_buffer_write (switch_buffer_t *buffer, const void *data, switch_size_t datalen)
void	switch_buffer_zero (switch_buffer_t *buffer)
switch_size_t	switch_buffer_zwrite (switch_buffer_t *buffer, const void *data, switch_size_t datalen)
switch_size_t	switch_buffer_slide_write (switch_buffer_t *buffer, const void *data, switch_size_t datalen)
void	switch_buffer_destroy (switch_buffer_t **buffer)
	Destroy the buffer. More...

Variables
static uint32_t	buffer_id = 0

Enumeration Type Documentation

enum switch_buffer_flag_t

Enumerator
SWITCH_BUFFER_FLAG_DYNAMIC
SWITCH_BUFFER_FLAG_PARTITION

Definition at line 37 of file switch_buffer.c.

             {
        SWITCH_BUFFER_FLAG_DYNAMIC = (1 << 0),
        SWITCH_BUFFER_FLAG_PARTITION = (1 << 1)
} switch_buffer_flag_t;

Function Documentation

void switch_buffer_add_mutex	(	switch_buffer_t *	buffer,
		switch_mutex_t *	mutex
	)

Definition at line 138 of file switch_buffer.c.

References mutex.

{
        buffer->mutex = mutex;
}

switch_status_t switch_buffer_create	(	switch_memory_pool_t *	pool,
		switch_buffer_t **	buffer,
		switch_size_t	max_len
	)

Definition at line 93 of file switch_buffer.c.

References buffer_id, switch_buffer::data, switch_buffer::datalen, switch_buffer::head, switch_buffer::id, switch_core_alloc, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

{
        switch_buffer_t *new_buffer;

        if ((new_buffer = switch_core_alloc(pool, sizeof(switch_buffer_t))) != 0 && (new_buffer->data = switch_core_alloc(pool, max_len)) != 0) {
                new_buffer->datalen = max_len;
                new_buffer->id = buffer_id++;
                new_buffer->head = new_buffer->data;
                *buffer = new_buffer;
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_MEMERR;
}

switch_status_t switch_buffer_create_dynamic	(	switch_buffer_t **	buffer,
		switch_size_t	blocksize,
		switch_size_t	start_len,
		switch_size_t	max_len
	)

Definition at line 107 of file switch_buffer.c.

References switch_buffer::blocksize, buffer_id, switch_buffer::data, switch_buffer::datalen, switch_buffer::head, switch_buffer::id, switch_buffer::max_len, memset(), SWITCH_BUFFER_FLAG_DYNAMIC, switch_set_flag, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

{
        switch_buffer_t *new_buffer;

        if ((new_buffer = malloc(sizeof(*new_buffer)))) {
                memset(new_buffer, 0, sizeof(*new_buffer));

                if (start_len) {
                        if (!(new_buffer->data = malloc(start_len))) {
                                free(new_buffer);
                                *buffer = NULL;
                                return SWITCH_STATUS_MEMERR;
                        }
                        memset(new_buffer->data, 0, start_len);
                }

                new_buffer->max_len = max_len;
                new_buffer->datalen = start_len;
                new_buffer->id = buffer_id++;
                new_buffer->blocksize = blocksize;
                new_buffer->head = new_buffer->data;
                switch_set_flag(new_buffer, SWITCH_BUFFER_FLAG_DYNAMIC);

                *buffer = new_buffer;
                return SWITCH_STATUS_SUCCESS;
        }
        *buffer = NULL;
        return SWITCH_STATUS_MEMERR;
}

switch_size_t switch_buffer_freespace

(

switch_buffer_t *

buffer

)

Definition at line 170 of file switch_buffer.c.

References SWITCH_BUFFER_FLAG_DYNAMIC, and switch_test_flag.

{
        if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
                if (buffer->max_len) {
                        return (switch_size_t) (buffer->max_len - buffer->used);
                }
                return 1000000;
        }

        return (switch_size_t) (buffer->datalen - buffer->used);
}

switch_size_t switch_buffer_inuse

(

switch_buffer_t *

buffer

)

Definition at line 182 of file switch_buffer.c.

{
        return buffer->used;
}

switch_size_t switch_buffer_len

(

switch_buffer_t *

buffer

)

Definition at line 165 of file switch_buffer.c.

{
        return buffer->datalen;
}

void switch_buffer_lock

(

switch_buffer_t *

buffer

)

Definition at line 143 of file switch_buffer.c.

References switch_mutex_lock().

{
        if (buffer->mutex) {
                switch_mutex_lock(buffer->mutex);
        }
}

switch_size_t switch_buffer_peek	(	switch_buffer_t *	buffer,
		void *	data,
		switch_size_t	datalen
	)

Definition at line 248 of file switch_buffer.c.

{
        switch_size_t reading = 0;

        if (buffer->used < 1) {
                buffer->used = 0;
                return 0;
        } else if (buffer->used >= datalen) {
                reading = datalen;
        } else {
                reading = buffer->used;
        }

        memcpy(data, buffer->head, reading);

        return reading;
}

switch_size_t switch_buffer_peek_zerocopy	(	switch_buffer_t *	buffer,
		const void **	ptr
	)

Definition at line 266 of file switch_buffer.c.

{
        switch_size_t reading = 0;

        if (buffer->used < 1) {
                buffer->used = 0;
                *ptr = NULL;
                return 0;
        } else {
                reading = buffer->used;
        }

        *ptr = buffer->head;

        return reading;
}

switch_size_t switch_buffer_read	(	switch_buffer_t *	buffer,
		void *	data,
		switch_size_t	datalen
	)

Definition at line 228 of file switch_buffer.c.

Referenced by switch_buffer_read_loop().

{
        switch_size_t reading = 0;

        if (buffer->used < 1) {
                buffer->used = 0;
                return 0;
        } else if (buffer->used >= datalen) {
                reading = datalen;
        } else {
                reading = buffer->used;
        }

        memcpy(data, buffer->head, reading);
        buffer->used -= reading;
        buffer->head += reading;

        return reading;
}

switch_size_t switch_buffer_read_loop	(	switch_buffer_t *	buffer,
		void *	data,
		switch_size_t	datalen
	)

Definition at line 211 of file switch_buffer.c.

References switch_buffer_read().

{
        switch_size_t len;
        if ((len = switch_buffer_read(buffer, data, datalen)) == 0) {
                if (buffer->loops > 0) {
                        buffer->loops--;
                }
                if (buffer->loops == 0) {
                        return 0;
                }
                buffer->head = buffer->data;
                buffer->used = buffer->actually_used;
                len = switch_buffer_read(buffer, data, datalen);
        }
        return len;
}

void switch_buffer_set_loops	(	switch_buffer_t *	buffer,
		int32_t	loops
	)

Definition at line 206 of file switch_buffer.c.

{
        buffer->loops = loops;
}

switch_size_t switch_buffer_toss	(	switch_buffer_t *	buffer,
		switch_size_t	datalen
	)

Definition at line 187 of file switch_buffer.c.

Referenced by switch_buffer_slide_write().

{
        switch_size_t reading = 0;

        if (buffer->used < 1) {
                buffer->used = 0;
                return 0;
        } else if (buffer->used >= datalen) {
                reading = datalen;
        } else {
                reading = buffer->used;
        }

        buffer->used -= reading;
        buffer->head += reading;

        return buffer->used;
}

switch_status_t switch_buffer_trylock

(

switch_buffer_t *

buffer

)

Definition at line 150 of file switch_buffer.c.

References switch_mutex_lock(), and SWITCH_STATUS_FALSE.

{
        if (buffer->mutex) {
                return switch_mutex_lock(buffer->mutex);
        }
        return SWITCH_STATUS_FALSE;
}

void switch_buffer_unlock

(

switch_buffer_t *

buffer

)

Definition at line 158 of file switch_buffer.c.

References switch_mutex_unlock().

{
        if (buffer->mutex) {
                switch_mutex_unlock(buffer->mutex);
        }
}

switch_size_t switch_buffer_write	(	switch_buffer_t *	buffer,
		const void *	data,
		switch_size_t	datalen
	)

Definition at line 283 of file switch_buffer.c.

References switch_assert, SWITCH_BUFFER_FLAG_DYNAMIC, SWITCH_BUFFER_FLAG_PARTITION, and switch_test_flag.

Referenced by switch_buffer_slide_write(), and switch_buffer_zwrite().

{
        switch_size_t freespace, actual_freespace;

        if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_PARTITION)) {
                return 0;
        }

        switch_assert(buffer->data != NULL);

        if (!datalen) {
                return buffer->used;
        }

        actual_freespace = buffer->datalen - buffer->actually_used;

        if (actual_freespace < datalen) {
                memmove(buffer->data, buffer->head, buffer->used);
                buffer->head = buffer->data;
                buffer->actually_used = buffer->used;
        }

        freespace = buffer->datalen - buffer->used;

        if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
                if (freespace < datalen && (!buffer->max_len || (buffer->used + datalen <= buffer->max_len))) {
                        switch_size_t new_size, new_block_size;
                        void *tmp;

                        new_size = buffer->datalen + datalen;
                        new_block_size = buffer->datalen + buffer->blocksize;

                        if (new_block_size > new_size) {
                                new_size = new_block_size;
                        }
                        buffer->head = buffer->data;
                        if (!(tmp = realloc(buffer->data, new_size))) {
                                return 0;
                        }
                        buffer->data = tmp;
                        buffer->head = buffer->data;
                        buffer->datalen = new_size;
                }
        }

        freespace = buffer->datalen - buffer->used;

        if (freespace < datalen) {
                return 0;
        }

        memcpy(buffer->head + buffer->used, data, datalen);
        buffer->used += datalen;
        buffer->actually_used += datalen;
        return buffer->used;
}

void switch_buffer_zero

(

switch_buffer_t *

buffer

)

Definition at line 340 of file switch_buffer.c.

References switch_assert.

Referenced by switch_buffer_zwrite().

{
        switch_assert(buffer->data != NULL);

        buffer->used = 0;
        buffer->actually_used = 0;
        buffer->head = buffer->data;
}

switch_size_t switch_buffer_zwrite	(	switch_buffer_t *	buffer,
		const void *	data,
		switch_size_t	datalen
	)

Definition at line 349 of file switch_buffer.c.

References SWITCH_BUFFER_FLAG_PARTITION, switch_buffer_write(), switch_buffer_zero(), and switch_test_flag.

{
        switch_size_t w;

        if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_PARTITION)) {
                return 0;
        }

        if (!(w = switch_buffer_write(buffer, data, datalen))) {
                switch_buffer_zero(buffer);
                return switch_buffer_write(buffer, data, datalen);
        }

        return w;
}

Variable Documentation

uint32_t buffer_id = 0

static

Definition at line 35 of file switch_buffer.c.

Referenced by switch_buffer_create(), switch_buffer_create_dynamic(), and switch_buffer_create_partition().