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
void *	switch_buffer_get_head_pointer (switch_buffer_t *buffer)
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

switch_buffer_flag_t

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

switch_buffer_add_mutex()

void switch_buffer_add_mutex	(	switch_buffer_t *	buffer,
		switch_mutex_t *	mutex
	)

Definition at line 151 of file switch_buffer.c.

References switch_buffer::mutex.

{
        buffer->mutex = mutex;
}

switch_buffer_create()

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

Definition at line 99 of file switch_buffer.c.

References buffer_id, switch_buffer::data, switch_buffer::datalen, switch_buffer::head, switch_buffer::id, switch_buffer::max_len, 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_buffer_create_dynamic()

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 113 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) {
                        start_len = 250;
                }

                if (!blocksize) {
                        blocksize = 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_buffer_freespace()

switch_size_t switch_buffer_freespace

(

switch_buffer_t *

buffer

)

Definition at line 183 of file switch_buffer.c.

References switch_buffer::datalen, switch_buffer::max_len, SWITCH_BUFFER_FLAG_DYNAMIC, switch_test_flag, and switch_buffer::used.

{
        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_buffer_inuse()

switch_size_t switch_buffer_inuse

(

switch_buffer_t *

buffer

)

Definition at line 195 of file switch_buffer.c.

References switch_buffer::used.

{
        return buffer->used;
}

switch_buffer_len()

switch_size_t switch_buffer_len

(

switch_buffer_t *

buffer

)

Definition at line 178 of file switch_buffer.c.

References switch_buffer::datalen.

{
        return buffer->datalen;
}

switch_buffer_lock()

void switch_buffer_lock

(

switch_buffer_t *

buffer

)

Definition at line 156 of file switch_buffer.c.

References switch_buffer::mutex, and switch_mutex_lock().

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

switch_buffer_peek()

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

Definition at line 261 of file switch_buffer.c.

References switch_buffer::datalen, switch_buffer::head, and switch_buffer::used.

{
        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_buffer_peek_zerocopy()

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

Definition at line 279 of file switch_buffer.c.

References switch_buffer::head, and switch_buffer::used.

{
        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_buffer_read()

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

Definition at line 241 of file switch_buffer.c.

References switch_buffer::datalen, switch_buffer::head, and switch_buffer::used.

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_buffer_read_loop()

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

Definition at line 224 of file switch_buffer.c.

References switch_buffer::actually_used, switch_buffer::data, switch_buffer::head, switch_buffer::loops, switch_buffer_read(), and switch_buffer::used.

{
        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;
}

switch_buffer_set_loops()

void switch_buffer_set_loops	(	switch_buffer_t *	buffer,
		int32_t	loops
	)

Definition at line 219 of file switch_buffer.c.

References switch_buffer::loops.

{
        buffer->loops = loops;
}

switch_buffer_toss()

switch_size_t switch_buffer_toss	(	switch_buffer_t *	buffer,
		switch_size_t	datalen
	)

Definition at line 200 of file switch_buffer.c.

References switch_buffer::datalen, switch_buffer::head, and switch_buffer::used.

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_buffer_trylock()

switch_status_t switch_buffer_trylock

(

switch_buffer_t *

buffer

)

Definition at line 163 of file switch_buffer.c.

References switch_buffer::mutex, switch_mutex_lock(), and SWITCH_STATUS_FALSE.

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

switch_buffer_unlock()

void switch_buffer_unlock

(

switch_buffer_t *

buffer

)

Definition at line 171 of file switch_buffer.c.

References switch_buffer::mutex, and switch_mutex_unlock().

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

switch_buffer_write()

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

Definition at line 296 of file switch_buffer.c.

References switch_buffer::actually_used, switch_buffer::blocksize, switch_buffer::data, switch_buffer::datalen, switch_buffer::head, switch_buffer::max_len, memset(), switch_assert, SWITCH_BUFFER_FLAG_DYNAMIC, SWITCH_BUFFER_FLAG_PARTITION, switch_test_flag, and switch_buffer::used.

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;
        }

        if (data) {
                memcpy(buffer->head + buffer->used, data, datalen);
        } else {
                memset(buffer->head + buffer->used, 0, datalen);
        }

        buffer->used += datalen;
        buffer->actually_used += datalen;
        return buffer->used;
}

switch_buffer_zero()

void switch_buffer_zero

(

switch_buffer_t *

buffer

)

Definition at line 358 of file switch_buffer.c.

References switch_buffer::actually_used, switch_buffer::data, switch_buffer::head, switch_assert, and switch_buffer::used.

Referenced by switch_buffer_zwrite().

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

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

switch_buffer_zwrite()

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

Definition at line 367 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

buffer_id

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().