aniani/icecast-server
1
0
Fork 0
mirror of https://gitlab.xiph.org/xiph/icecast-server.git synced 2024-12-04 14:46:30 -05:00
Code

Cleanup: Removed buffer.[ch]

Browse Source
This commit is contained in:
Philipp Schafft 2018-11-02 15:49:39 +00:00
parent 6c3be854a0
commit 92fe20125c
4 changed files with 0 additions and 513 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.am
View File

@ -28,7 +28,6 @@ noinst_HEADERS = \
md5.h \
matchfile.h \
tls.h \
buffer.h \
module.h \
reportxml.h \
listensocket.h \
@ -73,7 +72,6 @@ icecast_SOURCES = \
md5.c \
matchfile.c \
tls.c \
buffer.c \
module.c \
reportxml.c \
listensocket.c \

313
src/buffer.c
View File

@ -1,313 +0,0 @@
/* Icecast
*
* This program is distributed under the GNU General Public License, version 2.
* A copy of this license is included with this source.
*
* Copyright 2018, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "buffer.h"
#include <igloo/ro.h>
struct buffer_tag {
igloo_ro_base_t __base;
/* Buffer itself */
void *buffer;
/* Length in bytes of buffer */
size_t length;
/* Amount of bytes in use of the buffer. This includes offset bytes */
size_t fill;
/* Bytes of offset at the start of the buffer */
size_t offset;
};
static void __free(igloo_ro_t self);
igloo_RO_PUBLIC_TYPE(buffer_t,
igloo_RO_TYPEDECL_FREE(__free),
igloo_RO_TYPEDECL_NEW_NOOP()
);
static void __free(igloo_ro_t self)
{
buffer_t *buffer = igloo_RO_TO_TYPE(self, buffer_t);
free(buffer->buffer);
}
buffer_t * buffer_new(ssize_t preallocation, const char *name, igloo_ro_t associated)
{
buffer_t *buffer = igloo_ro_new_ext(buffer_t, name, associated);
if (!buffer)
return NULL;
if (preallocation > 0)
buffer_preallocate(buffer, preallocation);
return buffer;
}
buffer_t * buffer_new_simple(void)
{
return igloo_ro_new(buffer_t);
}
void buffer_preallocate(buffer_t *buffer, size_t request)
{
void *n;
size_t newlen;
if (!buffer)
return;
/* Remove the offset if it makes sense to do so. */
if (buffer->offset == buffer->fill) {
buffer->offset = 0;
buffer->fill = 0;
} else if ((2*buffer->offset) < buffer->fill || buffer->offset >= 512 || (buffer->offset > 128 && buffer->offset >= request)) {
buffer->fill -= buffer->offset;
memmove(buffer->buffer, buffer->buffer + buffer->offset, buffer->fill);
buffer->offset = 0;
}
if (!request)
return;
newlen = buffer->fill + request;
if (buffer->length >= newlen)
return;
/* Make sure we at least add 64 bytes and are 64 byte aligned */
newlen = newlen + 64 - (newlen % 64);
n = realloc(buffer->buffer, newlen);
/* Just return if this failed */
if (!n)
return;
buffer->buffer = n;
buffer->length = newlen;
}
int buffer_get_data(buffer_t *buffer, const void **data, size_t *length)
{
if (!buffer)
return -1;
if (data) {
*data = buffer->buffer + buffer->offset;
}
if (length) {
*length = buffer->fill - buffer->offset;
}
return 0;
}
int buffer_get_string(buffer_t *buffer, const char **string)
{
char *ret;
if (!buffer || !string)
return -1;
/* Ensure we have space for one additional byte ('\0'-termination). */
if (buffer->length == buffer->fill) {
buffer_preallocate(buffer, 1);
if (buffer->length == buffer->fill)
return -1;
}
/* Actually add a '\0'-termination. */
ret = buffer->buffer;
ret[buffer->fill] = 0;
*string = ret + buffer->offset;
return 0;
}
int buffer_set_length(buffer_t *buffer, size_t length)
{
if (!buffer)
return -1;
if (length > (buffer->fill - buffer->offset))
return -1;
buffer->fill = length + buffer->offset;
return 0;
}
int buffer_shift(buffer_t *buffer, size_t amount)
{
if (!buffer)
return -1;
if (amount > (buffer->fill - buffer->offset))
return -1;
buffer->offset += amount;
/* run cleanup */
buffer_preallocate(buffer, 0);
return 0;
}
int buffer_push_data(buffer_t *buffer, const void *data, size_t length)
{
void *buf;
int ret;
if (!buffer)
return -1;
if (!length)
return 0;
if (!data)
return -1;
ret = buffer_zerocopy_push_request(buffer, &buf, length);
if (ret != 0)
return ret;
memcpy(buf, data, length);
ret = buffer_zerocopy_push_complete(buffer, length);
return ret;
}
int buffer_push_string(buffer_t *buffer, const char *string)
{
if (!buffer || !string)
return -1;
return buffer_push_data(buffer, string, strlen(string));
}
int buffer_push_printf(buffer_t *buffer, const char *format, ...)
{
int ret;
va_list ap;
if (!buffer || !format)
return -1;
if (!*format)
return 0;
va_start(ap, format);
ret = buffer_push_vprintf(buffer, format, ap);
va_end(ap);
return ret;
}
int buffer_push_vprintf(buffer_t *buffer, const char *format, va_list ap)
{
void *buf;
int ret;
size_t length = 1024;
if (!buffer || !format)
return -1;
if (!*format)
return 0;
ret = buffer_zerocopy_push_request(buffer, &buf, length);
if (ret != 0)
return ret;
ret = vsnprintf(buf, length, format, ap);
if (ret >= 0 && (size_t)ret < length) {
return buffer_zerocopy_push_complete(buffer, ret);
} else if (ret < 0) {
/* This vsnprintf() likely does not follow POSIX.
* We don't know what length we need to asume. So asume a big one and hope for the best. */
length = 8192;
} else {
/* Reallocate the buffer to the size reported plus one for '\0'-termination */
length = ret + 1;
}
/* We have not written any data yet. */
ret = buffer_zerocopy_push_complete(buffer, 0);
if (ret != 0)
return ret;
/* Now let's try again. */
ret = buffer_zerocopy_push_request(buffer, &buf, length);
if (ret != 0)
return ret;
ret = vsnprintf(buf, length, format, ap);
if (ret < 0 || (size_t)ret >= length) {
/* This still didn't work. Giving up. */
buffer_zerocopy_push_complete(buffer, 0);
return -1;
}
return buffer_zerocopy_push_complete(buffer, ret);
}
int buffer_push_buffer(buffer_t *buffer, buffer_t *source)
{
const void *data;
size_t length;
int ret;
if (!buffer || !source)
return -1;
ret = buffer_get_data(source, &data, &length);
if (ret != 0)
return ret;
return buffer_push_data(buffer, data, length);
}
int buffer_zerocopy_push_request(buffer_t *buffer, void **data, size_t request)
{
if (!buffer || !data)
return -1;
buffer_preallocate(buffer, request);
if (request > (buffer->length - buffer->fill))
return -1;
*data = buffer->buffer + buffer->fill;
return 0;
}
int buffer_zerocopy_push_complete(buffer_t *buffer, size_t done)
{
if (!buffer)
return -1;
if (done > (buffer->length - buffer->fill))
return -1;
buffer->fill += done;
return 0;
}

193
src/buffer.h
View File

@ -1,193 +0,0 @@
/* Icecast
*
* This program is distributed under the GNU General Public License, version 2.
* A copy of this license is included with this source.
*
* Copyright 2018, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
*/
/*
* This file contains the API for a refobject based buffer object.
* It can be used to store data and allows on the fly re-allocation.
*/
#ifndef __BUFFER_H__
#define __BUFFER_H__
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdarg.h>
#include "icecasttypes.h"
#include "compat.h"
#include <igloo/ro.h>
/* About thread safety:
* This set of functions is intentinally not thread safe.
*/
igloo_RO_FORWARD_TYPE(buffer_t);
/* This creates a new buffer object.
* Parameters:
* preallocation
* The number of bytes to allocate for use later on. See buffer_preallocate() for details.
* userdata, name, associated
* See refobject_new().
*/
buffer_t * buffer_new(ssize_t preallocation, const char *name, igloo_ro_t associated);
/* Depreciated: This creates a new buffer with defaults.
* Do NOT use this. Use refobject_new(buffer_t)
*
* This is the same as:
* buffer_new(-1, NULL, NULL, REFOBJECT_NULL)
*/
buffer_t * buffer_new_simple(void);
/* This function preallocates space for later use.
* Parameters:
* buffer
* The buffer to operate on.
* request
* Number of bytes to additionally allocate.
* Notes:
* This function is very usedful when adding a large number of smaller buffers to avoid
* internal reallocation calls happening to often. However it is not required to call
* this function before adding data to the buffer.
*/
void buffer_preallocate(buffer_t *buffer, size_t request);
/* Gets data and length of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* data
* Pointer to the stored data. If NULL the pointer is not returned.
* length
* Pointer to the length of how many bytes are in the buffer. If NULL
* length is not returned.
*/
int buffer_get_data(buffer_t *buffer, const void **data, size_t *length);
/* Gets data as a string. The string is '\0'-terminated.
* Parameters:
* buffery
* The buffer to operate on.
* string
* The string representing the data hold by the buffer.
*/
int buffer_get_string(buffer_t *buffer, const char **string);
/* Sets the length of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* length
* New length of the buffer.
* Notes:
* This can only be used to reduce the size of the buffer. To add data to
* the buffer use buffer_push_*().
*
* Calling this with length set to 0 clears the buffer but does not deallocate it.
*/
int buffer_set_length(buffer_t *buffer, size_t length);
/* Shifts data out of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* amount
* The amount of bytes to be removed from the begin of the buffer.
* Notes:
* This function can be useful for skipping some small header. However this
* must not be used to implement a kind of ring buffer as it will result in
* poor performance caused by massive reallocations and memory copies.
*/
int buffer_shift(buffer_t *buffer, size_t amount);
/* This pushes data to the end of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* data
* The data to push.
* length
* The length of the data to push in byte.
* Notes:
* Consider using buffer_zerocopy_*().
*/
int buffer_push_data(buffer_t *buffer, const void *data, size_t length);
/* This pushes a string to the end of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* string
* The string to be pushed. The tailing '\0'-termination will not be
* part of the buffer.
* Notes:
* Consider using buffer_zerocopy_*().
*/
int buffer_push_string(buffer_t *buffer, const char *string);
/* This pushes a formated string to the end of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* format
* The format string as for printf() family functions.
* ...
* The parameters according to the format string.
*/
int buffer_push_printf(buffer_t *buffer, const char *format, ...);
/* This pushes a formated string to the end of the buffer using a va_list.
* Parameters:
* buffer
* The buffer to operate on.
* format
* The format string as for printf() family functions.
* ap
* The parameters according to the format string as va_list.
* See also:
* vprintf(3).
*/
int buffer_push_vprintf(buffer_t *buffer, const char *format, va_list ap);
/* This pushes the content of another buffer to the end of the buffer.
* Parameters:
* buffer
* The buffer to operate on.
* source
* The buffer which's content is to be copied.
*/
int buffer_push_buffer(buffer_t *buffer, buffer_t *source);
/* This requests for a memory buffer that can be pushed to without the need for copy.
* Parameters:
* buffer
* The buffer to operate on.
* data
* Pointer to memory that can be written and will become part of the buffer object.
* request
* Size of the memory area that is returned by data in bytes.
* Notes:
* This is the first step of the zero copy push. After the memory returned by data has been
* written (e.g. used in a call to read(2)) buffer_zerocopy_push_complete() must be called.
*/
int buffer_zerocopy_push_request(buffer_t *buffer, void **data, size_t request);
/* This is the final step of a zero copy push.
* Parameters:
* buffer
* The buffer to operate on.
* done
* Amount of data in bytes that has actually been written into the memory area.
* May be zero to what has been requested with request.
*/
int buffer_zerocopy_push_complete(buffer_t *buffer, size_t done);
#endif

5
src/icecasttypes.h
View File

@ -95,10 +95,6 @@ typedef enum {
typedef struct relay_tag relay_t;
/* ---[ buffer.[ch] ]--- */
typedef struct buffer_tag buffer_t;
/* ---[ module.[ch] ]--- */
typedef struct module_tag module_t;
@ -119,7 +115,6 @@ typedef struct listensocket_tag listensocket_t;
/* ---[ refobject.[ch] ]--- */
#define igloo_RO_APPTYPES \
igloo_RO_TYPE(buffer_t) \
igloo_RO_TYPE(module_t) \
igloo_RO_TYPE(module_container_t) \
igloo_RO_TYPE(reportxml_t) \