You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
236 lines
5.6 KiB
236 lines
5.6 KiB
#include "tunala.h" |
|
|
|
#ifndef NO_BUFFER |
|
|
|
void buffer_init(buffer_t * buf) |
|
{ |
|
buf->used = 0; |
|
buf->total_in = buf->total_out = 0; |
|
} |
|
|
|
void buffer_close(buffer_t * buf) |
|
{ |
|
/* Our data is static - nothing needs "release", just reset it */ |
|
buf->used = 0; |
|
} |
|
|
|
/* Code these simple ones in compact form */ |
|
unsigned int buffer_used(buffer_t * buf) |
|
{ |
|
return buf->used; |
|
} |
|
|
|
unsigned int buffer_unused(buffer_t * buf) |
|
{ |
|
return (MAX_DATA_SIZE - buf->used); |
|
} |
|
|
|
int buffer_full(buffer_t * buf) |
|
{ |
|
return (buf->used == MAX_DATA_SIZE ? 1 : 0); |
|
} |
|
|
|
int buffer_notfull(buffer_t * buf) |
|
{ |
|
return (buf->used < MAX_DATA_SIZE ? 1 : 0); |
|
} |
|
|
|
int buffer_empty(buffer_t * buf) |
|
{ |
|
return (buf->used == 0 ? 1 : 0); |
|
} |
|
|
|
int buffer_notempty(buffer_t * buf) |
|
{ |
|
return (buf->used > 0 ? 1 : 0); |
|
} |
|
|
|
unsigned long buffer_total_in(buffer_t * buf) |
|
{ |
|
return buf->total_in; |
|
} |
|
|
|
unsigned long buffer_total_out(buffer_t * buf) |
|
{ |
|
return buf->total_out; |
|
} |
|
|
|
/* |
|
* These 3 static (internal) functions don't adjust the "total" variables as |
|
* it's not sure when they're called how it should be interpreted. Only the |
|
* higher-level "buffer_[to|from]_[fd|SSL|BIO]" functions should alter these |
|
* values. |
|
*/ |
|
# if 0 /* To avoid "unused" warnings */ |
|
static unsigned int buffer_adddata(buffer_t * buf, const unsigned char *ptr, |
|
unsigned int size) |
|
{ |
|
unsigned int added = MAX_DATA_SIZE - buf->used; |
|
if (added > size) |
|
added = size; |
|
if (added == 0) |
|
return 0; |
|
memcpy(buf->data + buf->used, ptr, added); |
|
buf->used += added; |
|
buf->total_in += added; |
|
return added; |
|
} |
|
|
|
static unsigned int buffer_tobuffer(buffer_t * to, buffer_t * from, int cap) |
|
{ |
|
unsigned int moved, tomove = from->used; |
|
if ((int)tomove > cap) |
|
tomove = cap; |
|
if (tomove == 0) |
|
return 0; |
|
moved = buffer_adddata(to, from->data, tomove); |
|
if (moved == 0) |
|
return 0; |
|
buffer_takedata(from, NULL, moved); |
|
return moved; |
|
} |
|
# endif |
|
|
|
static unsigned int buffer_takedata(buffer_t * buf, unsigned char *ptr, |
|
unsigned int size) |
|
{ |
|
unsigned int taken = buf->used; |
|
if (taken > size) |
|
taken = size; |
|
if (taken == 0) |
|
return 0; |
|
if (ptr) |
|
memcpy(ptr, buf->data, taken); |
|
buf->used -= taken; |
|
/* Do we have to scroll? */ |
|
if (buf->used > 0) |
|
memmove(buf->data, buf->data + taken, buf->used); |
|
return taken; |
|
} |
|
|
|
# ifndef NO_IP |
|
|
|
int buffer_from_fd(buffer_t * buf, int fd) |
|
{ |
|
int toread = buffer_unused(buf); |
|
if (toread == 0) |
|
/* Shouldn't be called in this case! */ |
|
abort(); |
|
toread = read(fd, buf->data + buf->used, toread); |
|
if (toread > 0) { |
|
buf->used += toread; |
|
buf->total_in += toread; |
|
} |
|
return toread; |
|
} |
|
|
|
int buffer_to_fd(buffer_t * buf, int fd) |
|
{ |
|
int towrite = buffer_used(buf); |
|
if (towrite == 0) |
|
/* Shouldn't be called in this case! */ |
|
abort(); |
|
towrite = write(fd, buf->data, towrite); |
|
if (towrite > 0) { |
|
buffer_takedata(buf, NULL, towrite); |
|
buf->total_out += towrite; |
|
} |
|
return towrite; |
|
} |
|
|
|
# endif /* !defined(NO_IP) */ |
|
|
|
# ifndef NO_OPENSSL |
|
|
|
static void int_ssl_check(SSL *s, int ret) |
|
{ |
|
int e = SSL_get_error(s, ret); |
|
switch (e) { |
|
/* |
|
* These seem to be harmless and already "dealt with" by our |
|
* non-blocking environment. NB: "ZERO_RETURN" is the clean "error" |
|
* indicating a successfully closed SSL tunnel. We let this happen |
|
* because our IO loop should not appear to have broken on this |
|
* condition - and outside the IO loop, the "shutdown" state is |
|
* checked. |
|
*/ |
|
case SSL_ERROR_NONE: |
|
case SSL_ERROR_WANT_READ: |
|
case SSL_ERROR_WANT_WRITE: |
|
case SSL_ERROR_WANT_X509_LOOKUP: |
|
case SSL_ERROR_ZERO_RETURN: |
|
return; |
|
/* |
|
* These seem to be indications of a genuine error that should result |
|
* in the SSL tunnel being regarded as "dead". |
|
*/ |
|
case SSL_ERROR_SYSCALL: |
|
case SSL_ERROR_SSL: |
|
SSL_set_app_data(s, (char *)1); |
|
return; |
|
default: |
|
break; |
|
} |
|
/* |
|
* For any other errors that (a) exist, and (b) crop up - we need to |
|
* interpret what to do with them - so "politely inform" the caller that |
|
* the code needs updating here. |
|
*/ |
|
abort(); |
|
} |
|
|
|
void buffer_from_SSL(buffer_t * buf, SSL *ssl) |
|
{ |
|
int ret; |
|
if (!ssl || buffer_full(buf)) |
|
return; |
|
ret = SSL_read(ssl, buf->data + buf->used, buffer_unused(buf)); |
|
if (ret > 0) { |
|
buf->used += ret; |
|
buf->total_in += ret; |
|
} |
|
if (ret < 0) |
|
int_ssl_check(ssl, ret); |
|
} |
|
|
|
void buffer_to_SSL(buffer_t * buf, SSL *ssl) |
|
{ |
|
int ret; |
|
if (!ssl || buffer_empty(buf)) |
|
return; |
|
ret = SSL_write(ssl, buf->data, buf->used); |
|
if (ret > 0) { |
|
buffer_takedata(buf, NULL, ret); |
|
buf->total_out += ret; |
|
} |
|
if (ret < 0) |
|
int_ssl_check(ssl, ret); |
|
} |
|
|
|
void buffer_from_BIO(buffer_t * buf, BIO *bio) |
|
{ |
|
int ret; |
|
if (!bio || buffer_full(buf)) |
|
return; |
|
ret = BIO_read(bio, buf->data + buf->used, buffer_unused(buf)); |
|
if (ret > 0) { |
|
buf->used += ret; |
|
buf->total_in += ret; |
|
} |
|
} |
|
|
|
void buffer_to_BIO(buffer_t * buf, BIO *bio) |
|
{ |
|
int ret; |
|
if (!bio || buffer_empty(buf)) |
|
return; |
|
ret = BIO_write(bio, buf->data, buf->used); |
|
if (ret > 0) { |
|
buffer_takedata(buf, NULL, ret); |
|
buf->total_out += ret; |
|
} |
|
} |
|
|
|
# endif /* !defined(NO_OPENSSL) */ |
|
|
|
#endif /* !defined(NO_BUFFER) */
|
|
|