lighttpd
/
lighttpd2
2
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Prefix inline api functions with li_

personal/stbuehler/wip
Stefan Bühler 13 years ago
parent
8b5379ae04
commit
1acacd5737
9 changed files with 47 additions and 47 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

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

Write Preview
Loading…
Cancel
Save