Browse Source

Prefix inline api functions with li_

personal/stbuehler/wip
Stefan Bühler 13 years ago
parent
commit
1acacd5737
  1. 26
      include/lighttpd/chunk.h
  2. 6
      include/lighttpd/chunk_parser.h
  3. 28
      src/main/chunk.c
  4. 10
      src/main/chunk_parser.c
  5. 6
      src/main/network_sendfile.c
  6. 2
      src/main/network_write.c
  7. 12
      src/main/network_writev.c
  8. 2
      src/modules/mod_cache_disk_etag.c
  9. 2
      src/modules/mod_openssl.c

26
include/lighttpd/chunk.h

@ -83,9 +83,9 @@ LI_API liHandlerResult li_chunkfile_open(liVRequest *vr, liChunkFile *cf);
* chunk iterator *
******************/
INLINE liChunk* chunkiter_chunk(liChunkIter iter);
INLINE gboolean chunkiter_next(liChunkIter *iter);
INLINE goffset chunkiter_length(liChunkIter iter);
INLINE liChunk* li_chunkiter_chunk(liChunkIter iter);
INLINE gboolean li_chunkiter_next(liChunkIter *iter);
INLINE goffset li_chunkiter_length(liChunkIter iter);
/* get the data from a chunk; easy in case of a STRING_CHUNK,
* but needs to do io in case of FILE_CHUNK; the data is _not_ marked as "done"
@ -102,7 +102,7 @@ LI_API liHandlerResult li_chunkiter_read_mmap(liVRequest *vr, liChunkIter iter,
* chunk *
******************/
INLINE goffset chunk_length(liChunk *c);
INLINE goffset li_chunk_length(liChunk *c);
/******************
* cqlimit *
@ -172,9 +172,9 @@ LI_API goffset li_chunkqueue_skip_all(liChunkQueue *cq);
/* if the chunk an iterator refers gets stolen/skipped/...,
* the iterator isn't valid anymore
*/
INLINE liChunkIter chunkqueue_iter(liChunkQueue *cq);
INLINE liChunkIter li_chunkqueue_iter(liChunkQueue *cq);
INLINE liChunk* chunkqueue_first_chunk(liChunkQueue *cq);
INLINE liChunk* li_chunkqueue_first_chunk(liChunkQueue *cq);
LI_API gboolean li_chunkqueue_extract_to(liVRequest *vr, liChunkQueue *cq, goffset len, GString *dest);
LI_API gboolean li_chunkqueue_extract_to_bytearr(liVRequest *vr, liChunkQueue *cq, goffset len, GByteArray *dest);
@ -183,21 +183,21 @@ LI_API gboolean li_chunkqueue_extract_to_bytearr(liVRequest *vr, liChunkQueue *c
* Inline functions *
********************/
INLINE liChunk* chunkiter_chunk(liChunkIter iter) {
INLINE liChunk* li_chunkiter_chunk(liChunkIter iter) {
if (!iter.element) return NULL;
return (liChunk*) iter.element->data;
}
INLINE gboolean chunkiter_next(liChunkIter *iter) {
INLINE gboolean li_chunkiter_next(liChunkIter *iter) {
if (!iter || !iter->element) return FALSE;
return NULL != (iter->element = g_list_next(iter->element));
}
INLINE goffset chunkiter_length(liChunkIter iter) {
return chunk_length(chunkiter_chunk(iter));
INLINE goffset li_chunkiter_length(liChunkIter iter) {
return li_chunk_length(li_chunkiter_chunk(iter));
}
INLINE goffset chunk_length(liChunk *c) {
INLINE goffset li_chunk_length(liChunk *c) {
if (!c) return 0;
switch (c->type) {
case UNUSED_CHUNK:
@ -212,13 +212,13 @@ INLINE goffset chunk_length(liChunk *c) {
return 0;
}
INLINE liChunkIter chunkqueue_iter(liChunkQueue *cq) {
INLINE liChunkIter li_chunkqueue_iter(liChunkQueue *cq) {
liChunkIter i;
i.element = g_queue_peek_head_link(cq->queue);
return i;
}
INLINE liChunk* chunkqueue_first_chunk(liChunkQueue *cq) {
INLINE liChunk* li_chunkqueue_first_chunk(liChunkQueue *cq) {
return (liChunk*) g_queue_peek_head(cq->queue);
}

6
include/lighttpd/chunk_parser.h

@ -34,19 +34,19 @@ LI_API void li_chunk_parser_done(liChunkParserCtx *ctx, goffset len);
LI_API gboolean li_chunk_extract_to(liVRequest *vr, liChunkParserMark from, liChunkParserMark to, GString *dest);
LI_API GString* li_chunk_extract(liVRequest *vr, liChunkParserMark from, liChunkParserMark to);
INLINE liChunkParserMark chunk_parser_getmark(liChunkParserCtx *ctx, const char *fpc);
INLINE liChunkParserMark li_chunk_parser_getmark(liChunkParserCtx *ctx, const char *fpc);
/********************
* Inline functions *
********************/
INLINE liChunkParserMark chunk_parser_getmark(liChunkParserCtx *ctx, const char *fpc) {
INLINE liChunkParserMark li_chunk_parser_getmark(liChunkParserCtx *ctx, const char *fpc) {
liChunkParserMark m;
m.ci = ctx->curi;
m.pos = ctx->start + fpc - ctx->buf;
return m;
}
#define GETMARK(FPC) (chunk_parser_getmark(&ctx->chunk_ctx, FPC))
#define GETMARK(FPC) (li_chunk_parser_getmark(&ctx->chunk_ctx, FPC))
#endif

28
src/main/chunk.c

@ -84,14 +84,14 @@ liHandlerResult li_chunkfile_open(liVRequest *vr, liChunkFile *cf) {
* may return HANDLER_GO_ON, HANDLER_ERROR
*/
liHandlerResult li_chunkiter_read(liVRequest *vr, liChunkIter iter, off_t start, off_t length, char **data_start, off_t *data_len) {
liChunk *c = chunkiter_chunk(iter);
liChunk *c = li_chunkiter_chunk(iter);
off_t we_have, our_start;
liHandlerResult res = LI_HANDLER_GO_ON;
if (!c) return LI_HANDLER_ERROR;
if (!data_start || !data_len) return LI_HANDLER_ERROR;
we_have = chunk_length(c) - start;
we_have = li_chunk_length(c) - start;
if (length > we_have) length = we_have;
if (length <= 0) return LI_HANDLER_ERROR;
@ -159,7 +159,7 @@ read_chunk:
* as accessing mmap()-ed areas may result in SIGBUS, you have to handle that signal somehow.
*/
liHandlerResult li_chunkiter_read_mmap(liVRequest *vr, liChunkIter iter, off_t start, off_t length, char **data_start, off_t *data_len) {
liChunk *c = chunkiter_chunk(iter);
liChunk *c = li_chunkiter_chunk(iter);
off_t we_want, we_have, our_start, our_offset;
liHandlerResult res = LI_HANDLER_GO_ON;
int mmap_errno = 0;
@ -167,7 +167,7 @@ liHandlerResult li_chunkiter_read_mmap(liVRequest *vr, liChunkIter iter, off_t s
if (!c) return LI_HANDLER_ERROR;
if (!data_start || !data_len) return LI_HANDLER_ERROR;
we_have = chunk_length(c) - start;
we_have = li_chunk_length(c) - start;
if (length > we_have) length = we_have;
if (length <= 0) return LI_HANDLER_ERROR;
@ -586,8 +586,8 @@ goffset li_chunkqueue_steal_len(liChunkQueue *out, liChunkQueue *in, goffset len
goffset bytes = 0, meminbytes = 0, memoutbytes = 0;
goffset we_have;
while ( (NULL != (c = chunkqueue_first_chunk(in))) && length > 0 ) {
we_have = chunk_length(c);
while ( (NULL != (c = li_chunkqueue_first_chunk(in))) && length > 0 ) {
we_have = li_chunk_length(c);
if (!we_have) { /* remove empty chunks */
if (c->type == STRING_CHUNK) meminbytes -= c->str->len;
else if (c->type == MEM_CHUNK) meminbytes -= c->mem->len;
@ -700,7 +700,7 @@ goffset li_chunkqueue_steal_chunk(liChunkQueue *out, liChunkQueue *in) {
g_queue_push_tail_link(out->queue, l);
c = (liChunk*) l->data;
length = chunk_length(c);
length = li_chunk_length(c);
in->bytes_out += length;
in->length -= length;
out->bytes_in += length;
@ -723,7 +723,7 @@ goffset li_chunkqueue_skip(liChunkQueue *cq, goffset length) {
goffset bytes = 0;
goffset we_have;
while ( (NULL != (c = chunkqueue_first_chunk(cq))) && (0 == (we_have = chunk_length(c)) || length > 0) ) {
while ( (NULL != (c = li_chunkqueue_first_chunk(cq))) && (0 == (we_have = li_chunk_length(c)) || length > 0) ) {
if (we_have <= length) {
/* skip (delete) complete chunk */
if (c->type == STRING_CHUNK) cqlimit_update(cq, - (goffset)c->str->len);
@ -762,11 +762,11 @@ gboolean li_chunkqueue_extract_to(liVRequest *vr, liChunkQueue *cq, goffset len,
g_string_set_size(dest, 0);
if (len > cq->length) return FALSE;
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
while (len > 0) {
coff = 0;
clen = chunkiter_length(ci);
clen = li_chunkiter_length(ci);
while (coff < clen) {
gchar *buf;
off_t we_have;
@ -776,7 +776,7 @@ gboolean li_chunkqueue_extract_to(liVRequest *vr, liChunkQueue *cq, goffset len,
len -= we_have;
if (len <= 0) return TRUE;
}
chunkiter_next(&ci);
li_chunkiter_next(&ci);
}
return TRUE;
@ -795,11 +795,11 @@ gboolean li_chunkqueue_extract_to_bytearr(liVRequest *vr, liChunkQueue *cq, goff
g_byte_array_set_size(dest, len);
g_byte_array_set_size(dest, 0);
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
while (len > 0) {
coff = 0;
clen = chunkiter_length(ci);
clen = li_chunkiter_length(ci);
while (coff < clen) {
gchar *buf;
off_t we_have;
@ -809,7 +809,7 @@ gboolean li_chunkqueue_extract_to_bytearr(liVRequest *vr, liChunkQueue *cq, goff
len -= we_have;
if (len <= 0) return TRUE;
}
chunkiter_next(&ci);
li_chunkiter_next(&ci);
}
return TRUE;

10
src/main/chunk_parser.c

@ -16,7 +16,7 @@ void li_chunk_parser_reset(liChunkParserCtx *ctx) {
liHandlerResult li_chunk_parser_prepare(liChunkParserCtx *ctx) {
if (NULL == ctx->curi.element) {
ctx->curi = chunkqueue_iter(ctx->cq);
ctx->curi = li_chunkqueue_iter(ctx->cq);
if (NULL == ctx->curi.element) return LI_HANDLER_WAIT_FOR_EVENT;
}
return LI_HANDLER_GO_ON;
@ -28,10 +28,10 @@ liHandlerResult li_chunk_parser_next(liVRequest *vr, liChunkParserCtx *ctx, char
if (NULL == ctx->curi.element) return LI_HANDLER_WAIT_FOR_EVENT;
while (ctx->start >= (l = chunkiter_length(ctx->curi))) {
while (ctx->start >= (l = li_chunkiter_length(ctx->curi))) {
liChunkIter i = ctx->curi;
/* Wait at the end of the last chunk if it gets extended */
if (!chunkiter_next(&i)) return LI_HANDLER_WAIT_FOR_EVENT;
if (!li_chunkiter_next(&i)) return LI_HANDLER_WAIT_FOR_EVENT;
ctx->curi = i;
ctx->start -= l;
}
@ -57,8 +57,8 @@ gboolean li_chunk_extract_to(liVRequest *vr, liChunkParserMark from, liChunkPars
g_string_set_size(dest, 0);
for ( i = from; i.ci.element != to.ci.element; chunkiter_next(&i.ci) ) {
goffset len = chunkiter_length(i.ci);
for ( i = from; i.ci.element != to.ci.element; li_chunkiter_next(&i.ci) ) {
goffset len = li_chunkiter_length(i.ci);
while (i.pos < len) {
char *buf;
off_t we_have;

6
src/main/network_sendfile.c

@ -161,9 +161,9 @@ static liNetworkStatus network_backend_sendfile(liVRequest *vr, int fd, liChunkQ
if (0 == cq->length) return LI_NETWORK_STATUS_FATAL_ERROR;
do {
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
if (FILE_CHUNK != (c = chunkiter_chunk(ci))->type) {
if (FILE_CHUNK != (c = li_chunkiter_chunk(ci))->type) {
return did_write_something ? LI_NETWORK_STATUS_SUCCESS : LI_NETWORK_STATUS_FATAL_ERROR;
}
@ -222,7 +222,7 @@ liNetworkStatus li_network_write_sendfile(liVRequest *vr, int fd, liChunkQueue *
if (cq->length == 0) return LI_NETWORK_STATUS_FATAL_ERROR;
do {
switch (chunkqueue_first_chunk(cq)->type) {
switch (li_chunkqueue_first_chunk(cq)->type) {
case MEM_CHUNK:
case STRING_CHUNK:
LI_NETWORK_FALLBACK(li_network_backend_writev, write_max);

2
src/main/network_write.c

@ -13,7 +13,7 @@ liNetworkStatus li_network_backend_write(liVRequest *vr, int fd, liChunkQueue *c
if (0 == cq->length)
return did_write_something ? LI_NETWORK_STATUS_SUCCESS : LI_NETWORK_STATUS_FATAL_ERROR;
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
/* TODO: handle SIGBUS */
switch (li_chunkiter_read_mmap(vr, ci, 0, blocksize, &block_data, &block_len)) {
case LI_HANDLER_GO_ON:

12
src/main/network_writev.c

@ -38,9 +38,9 @@ liNetworkStatus li_network_backend_writev(liVRequest *vr, int fd, liChunkQueue *
if (0 == cq->length) goto cleanup; /* FATAL ERROR */
do {
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
if (STRING_CHUNK != (c = chunkiter_chunk(ci))->type && MEM_CHUNK != c->type) {
if (STRING_CHUNK != (c = li_chunkiter_chunk(ci))->type && MEM_CHUNK != c->type) {
res = did_write_something ? LI_NETWORK_STATUS_SUCCESS : LI_NETWORK_STATUS_FATAL_ERROR;
goto cleanup;
}
@ -48,7 +48,7 @@ liNetworkStatus li_network_backend_writev(liVRequest *vr, int fd, liChunkQueue *
we_have = 0;
do {
guint i = chunks->len;
off_t len = chunk_length(c);
off_t len = li_chunk_length(c);
struct iovec *v;
g_array_set_size(chunks, i + 1);
v = &g_array_index(chunks, struct iovec, i);
@ -60,8 +60,8 @@ liNetworkStatus li_network_backend_writev(liVRequest *vr, int fd, liChunkQueue *
v->iov_len = len;
we_have += len;
} while (we_have < *write_max &&
chunkiter_next(&ci) &&
(STRING_CHUNK == (c = chunkiter_chunk(ci))->type || MEM_CHUNK == c->type) &&
li_chunkiter_next(&ci) &&
(STRING_CHUNK == (c = li_chunkiter_chunk(ci))->type || MEM_CHUNK == c->type) &&
chunks->len < UIO_MAXIOV);
while (-1 == (r = writev(fd, (struct iovec*) chunks->data, chunks->len))) {
@ -114,7 +114,7 @@ cleanup:
liNetworkStatus li_network_write_writev(liVRequest *vr, int fd, liChunkQueue *cq, goffset *write_max) {
if (cq->length == 0) return LI_NETWORK_STATUS_FATAL_ERROR;
do {
switch (chunkqueue_first_chunk(cq)->type) {
switch (li_chunkqueue_first_chunk(cq)->type) {
case STRING_CHUNK:
LI_NETWORK_FALLBACK(li_network_backend_writev, write_max);
break;

2
src/modules/mod_cache_disk_etag.c

@ -154,7 +154,7 @@ static liHandlerResult cache_etag_filter_miss(liVRequest *vr, liFilter *f) {
ssize_t res;
gchar *buf;
off_t buflen;
liChunkIter citer = chunkqueue_iter(f->in);
liChunkIter citer = li_chunkqueue_iter(f->in);
UNUSED(vr);
if (0 == f->in->length) return LI_HANDLER_GO_ON;

2
src/modules/mod_openssl.c

@ -98,7 +98,7 @@ static liNetworkStatus openssl_con_write(liConnection *con, goffset write_max) {
if (0 == cq->length)
return LI_NETWORK_STATUS_SUCCESS;
ci = chunkqueue_iter(cq);
ci = li_chunkqueue_iter(cq);
switch (li_chunkiter_read(con->mainvr, ci, 0, blocksize, &block_data, &block_len)) {
case LI_HANDLER_GO_ON:
break;

Loading…
Cancel
Save