You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
313 lines
5.2 KiB
C
313 lines
5.2 KiB
C
/**
|
|
* the network chunk-API
|
|
*
|
|
*
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
|
|
#include "chunk.h"
|
|
|
|
chunkqueue *chunkqueue_init(void) {
|
|
chunkqueue *cq;
|
|
|
|
cq = calloc(1, sizeof(*cq));
|
|
|
|
cq->first = NULL;
|
|
cq->last = NULL;
|
|
|
|
cq->unused = NULL;
|
|
|
|
return cq;
|
|
}
|
|
|
|
static chunk *chunk_init(void) {
|
|
chunk *c;
|
|
|
|
c = calloc(1, sizeof(*c));
|
|
|
|
/* c->mem overlaps with c->data.file.name */
|
|
c->data.mem = buffer_init();
|
|
c->next = NULL;
|
|
|
|
return c;
|
|
}
|
|
|
|
static void chunk_free(chunk *c) {
|
|
if (!c) return;
|
|
|
|
/* c->data.mem overlaps with c->data.file.name */
|
|
switch (c->type) {
|
|
case MEM_CHUNK: buffer_free(c->data.mem); break;
|
|
case FILE_CHUNK: buffer_free(c->data.file.name); break;
|
|
default: break;
|
|
}
|
|
|
|
free(c);
|
|
}
|
|
|
|
void chunkqueue_free(chunkqueue *cq) {
|
|
chunk *c, *pc;
|
|
|
|
if (!cq) return;
|
|
|
|
for (c = cq->first; c; ) {
|
|
pc = c;
|
|
c = c->next;
|
|
chunk_free(pc);
|
|
}
|
|
|
|
for (c = cq->unused; c; ) {
|
|
pc = c;
|
|
c = c->next;
|
|
chunk_free(pc);
|
|
}
|
|
|
|
free(cq);
|
|
}
|
|
|
|
static chunk *chunkqueue_get_unused_chunk(chunkqueue *cq) {
|
|
chunk *c;
|
|
|
|
/* check if we have a unused chunk */
|
|
if (!cq->unused) {
|
|
c = chunk_init();
|
|
} else {
|
|
/* take the first element from the list (a stack) */
|
|
c = cq->unused;
|
|
cq->unused = c->next;
|
|
c->next = NULL;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
static int chunkqueue_prepend_chunk(chunkqueue *cq, chunk *c) {
|
|
c->next = cq->first;
|
|
cq->first = c;
|
|
|
|
if (cq->last == NULL) {
|
|
cq->last = c;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int chunkqueue_append_chunk(chunkqueue *cq, chunk *c) {
|
|
if (cq->last) {
|
|
cq->last->next = c;
|
|
}
|
|
cq->last = c;
|
|
|
|
if (cq->first == NULL) {
|
|
cq->first = c;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void chunkqueue_reset(chunkqueue *cq) {
|
|
/* move everything to the unused queue */
|
|
|
|
if (cq->last == NULL) return;
|
|
|
|
cq->last->next = cq->unused;
|
|
cq->unused = cq->first;
|
|
|
|
/* disconnect active chain */
|
|
cq->first = cq->last = NULL;
|
|
}
|
|
|
|
int chunkqueue_append_file(chunkqueue *cq, buffer *fn, off_t offset, off_t len) {
|
|
chunk *c;
|
|
|
|
if (len == 0) return 0;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
|
|
c->type = FILE_CHUNK;
|
|
|
|
buffer_copy_string_buffer(c->data.file.name, fn);
|
|
c->data.file.offset = offset;
|
|
c->data.file.length = len;
|
|
c->offset = 0;
|
|
|
|
chunkqueue_append_chunk(cq, c);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int chunkqueue_append_buffer(chunkqueue *cq, buffer *mem) {
|
|
chunk *c;
|
|
|
|
if (mem->used == 0) return 0;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
c->type = MEM_CHUNK;
|
|
c->offset = 0;
|
|
buffer_copy_string_buffer(c->data.mem, mem);
|
|
|
|
chunkqueue_append_chunk(cq, c);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int chunkqueue_prepend_buffer(chunkqueue *cq, buffer *mem) {
|
|
chunk *c;
|
|
|
|
if (mem->used == 0) return 0;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
c->type = MEM_CHUNK;
|
|
c->offset = 0;
|
|
buffer_copy_string_buffer(c->data.mem, mem);
|
|
|
|
chunkqueue_prepend_chunk(cq, c);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int chunkqueue_append_mem(chunkqueue *cq, const char * mem, size_t len) {
|
|
chunk *c;
|
|
|
|
if (len == 0) return 0;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
c->type = MEM_CHUNK;
|
|
c->offset = 0;
|
|
buffer_copy_string_len(c->data.mem, mem, len - 1);
|
|
|
|
chunkqueue_append_chunk(cq, c);
|
|
|
|
return 0;
|
|
}
|
|
|
|
buffer * chunkqueue_get_prepend_buffer(chunkqueue *cq) {
|
|
chunk *c;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
|
|
c->type = MEM_CHUNK;
|
|
c->offset = 0;
|
|
buffer_reset(c->data.mem);
|
|
|
|
chunkqueue_prepend_chunk(cq, c);
|
|
|
|
return c->data.mem;
|
|
}
|
|
|
|
buffer *chunkqueue_get_append_buffer(chunkqueue *cq) {
|
|
chunk *c;
|
|
|
|
c = chunkqueue_get_unused_chunk(cq);
|
|
|
|
c->type = MEM_CHUNK;
|
|
c->offset = 0;
|
|
buffer_reset(c->data.mem);
|
|
|
|
chunkqueue_append_chunk(cq, c);
|
|
|
|
return c->data.mem;
|
|
}
|
|
|
|
off_t chunkqueue_length(chunkqueue *cq) {
|
|
off_t len = 0;
|
|
chunk *c;
|
|
|
|
for (c = cq->first; c; c = c->next) {
|
|
switch (c->type) {
|
|
case MEM_CHUNK:
|
|
len += c->data.mem->used ? c->data.mem->used - 1 : 0;
|
|
break;
|
|
case FILE_CHUNK:
|
|
len += c->data.file.length;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
off_t chunkqueue_written(chunkqueue *cq) {
|
|
off_t len = 0;
|
|
chunk *c;
|
|
|
|
for (c = cq->first; c; c = c->next) {
|
|
switch (c->type) {
|
|
case MEM_CHUNK:
|
|
case FILE_CHUNK:
|
|
len += c->offset;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
int chunkqueue_is_empty(chunkqueue *cq) {
|
|
return cq->first ? 0 : 1;
|
|
}
|
|
|
|
#ifdef DEBUG_CHUNK
|
|
|
|
static int write_chunkqueue(int fd, chunkqueue *c) {
|
|
UNUSED(fd);
|
|
UNUSED(c);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
chunkqueue *c;
|
|
buffer *b, *fn;
|
|
|
|
UNUSED(argc);
|
|
UNUSED(argv);
|
|
|
|
c = chunkqueue_init();
|
|
|
|
fn = buffer_init_string("server.c");
|
|
|
|
chunkqueue_append_file(c, fn, 0, 10);
|
|
chunkqueue_append_file(c, fn, 10, 10);
|
|
chunkqueue_append_file(c, fn, 20, 10);
|
|
|
|
write_chunkqueue(STDERR_FILENO, c);
|
|
chunkqueue_reset(c);
|
|
|
|
b = buffer_init();
|
|
buffer_copy_string(b, "\ntest string mit vielen Zeichen\n");
|
|
chunkqueue_append_buffer(c, b);
|
|
|
|
write_chunkqueue(STDERR_FILENO, c);
|
|
chunkqueue_reset(c);
|
|
|
|
chunkqueue_append_file(c, fn, 0, 10);
|
|
buffer_copy_string(b, "\ntest string mit vielen Zeichen\n");
|
|
chunkqueue_append_buffer(c, b);
|
|
chunkqueue_append_file(c, fn, 10, 10);
|
|
chunkqueue_append_file(c, fn, 20, 10);
|
|
chunkqueue_append_file(c, fn, 50, 40);
|
|
|
|
write_chunkqueue(STDERR_FILENO, c);
|
|
chunkqueue_reset(c);
|
|
|
|
chunkqueue_free(c);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|