static char *
command_line_append_input_line (struct buffer *cmd_line_buffer, char *rl)
{
char *cmd;
size_t len;
len = strlen (rl);
if (len > 0 && rl[len - 1] == '\\')
{
/* Don't copy the backslash and wait for more. */
buffer_grow (cmd_line_buffer, rl, len - 1);
cmd = NULL;
}
else
{
/* Copy whole line including terminating null, and we're
done. */
buffer_grow (cmd_line_buffer, rl, len + 1);
cmd = cmd_line_buffer->buffer;
}
/* Allocated in readline. */
xfree (rl);
return cmd;
}
/*
** str/nil, addr/nil, port/nil, err = socket.recvfrom(fd)
**
** won't block even if the fd is working in blocking mode.
*/
static int lsocket_recvfrom(lua_State *L) {
int fd = luaL_checkint(L, 1);
char addr[MAX_ADDRSTRLEN];
int port;
Buffer buf;
size_t navaiable = 0;
int err = 0;
buffer_init(&buf, 0);
err = os_getnread(fd, &navaiable);
if (navaiable > 0) {
uint8 *p = buffer_grow(&buf, (size_t)navaiable);
size_t nread = 0;
err = socket_recvfrom(fd, p, navaiable, 0, addr, &port, &nread);
if (nread < navaiable)
buffer_pop(&buf, navaiable - nread);
}
if (err != 0 || navaiable == 0) {
lua_pushnil(L);
lua_pushnil(L);
lua_pushnil(L);
lua_pushinteger(L, err);
} else {
lua_pushlstring(L, (const char*)buf.data, buf.datasiz);
lua_pushstring(L, addr);
lua_pushinteger(L, port);
lua_pushinteger(L, 0);
}
buffer_finalize(&buf);
return 4;
}
/*
** nread, addr/nil, port/nil, err = socket.recvfromb(fd, buffer)
**
** won't block even if the fd is working in blocking mode.
*/
static int lsocket_recvfromb(lua_State *L) {
int fd = luaL_checkint(L, 1);
Buffer *buf = buffer_lcheck(L, 2);
char addr[MAX_ADDRSTRLEN];
int port;
size_t navaiable = 0, nread = 0;
int err = 0;
err = os_getnread(fd, &navaiable);
if (navaiable > 0) {
uint8 *p = buffer_grow(buf, (size_t)navaiable);
err = socket_recvfrom(fd, p, navaiable, 0, addr, &port, &nread);
if (nread < navaiable)
buffer_pop(buf, navaiable - nread);
}
if (err != 0 || navaiable == 0) {
lua_pushinteger(L, 0);
lua_pushnil(L);
lua_pushnil(L);
lua_pushinteger(L, err);
} else {
lua_pushinteger(L, nread);
lua_pushstring(L, addr);
lua_pushinteger(L, port);
lua_pushinteger(L, 0);
}
return 4;
}
bool buffer_put(Buffer *buf, const void *data, size_t len) {
if (!buffer_grow(buf, len))
return false;
memmove(buf->data, data, len);
buf->len = len;
return true;
}
void ewah_add_dirty_words(
struct ewah_bitmap *self, const eword_t *buffer,
size_t number, int negate)
{
size_t literals, can_add;
while (1) {
literals = rlw_get_literal_words(self->rlw);
can_add = min_size(number, RLW_LARGEST_LITERAL_COUNT - literals);
rlw_set_literal_words(self->rlw, literals + can_add);
if (self->buffer_size + can_add >= self->alloc_size)
buffer_grow(self, (self->buffer_size + can_add) * 3 / 2);
if (negate) {
size_t i;
for (i = 0; i < can_add; ++i)
self->buffer[self->buffer_size++] = ~buffer[i];
} else {
memcpy(self->buffer + self->buffer_size,
buffer, can_add * sizeof(eword_t));
self->buffer_size += can_add;
}
self->bit_size += can_add * BITS_IN_EWORD;
if (number - can_add == 0)
break;
buffer_push_rlw(self, 0);
buffer += can_add;
number -= can_add;
}
}
/*
** opaque_value = buffer:beginlen()
*/
static int lbuffer_beginlen(lua_State *L)
{
Buffer *buffer = buffer_lcheck(L, 1);
buffer_grow(buffer, 4);
lua_pushinteger(L, buffer->datasiz);
return 1;
}
static inline void buffer_push(struct ewah_bitmap *self, eword_t value)
{
if (self->buffer_size + 1 >= self->alloc_size)
buffer_grow(self, self->buffer_size * 3 / 2);
self->buffer[self->buffer_size++] = value;
}
/*
** self = buffer:fill(value, length)
*/
static int lbuffer_fill(lua_State *L)
{
Buffer *buffer = buffer_lcheck(L, 1);
size_t length = (size_t)luaL_checkint(L, 3);
memset(buffer_grow(buffer, length), (uint8)luaL_checkint(L, 2), length);
lua_pushvalue(L, 1);
return 1;
}
uint8* buffer_safegrow(Buffer *buffer, size_t growth, lua_State *L)
{
uint8 *p = buffer_grow(buffer, growth);
if (p == NULL) {
luaL_error(L, "buffer overflow (requiring %dB)", growth + buffer->datasiz);
}
return p;
}
size_t buffer_push(Buffer *buf, const void *mem, size_t memsiz)
{
uint8 *p = buffer_grow(buf, memsiz);
if (p != NULL) {
memcpy(p, mem, memsiz);
return memsiz;
} else {
return 0;
}
}
static ssize_t write_data(const void *bytes, size_t len, void *ctx) {
rt_buffer_t *buffer = (rt_buffer_t *)ctx;
buffer_grow(buffer, len);
if (buffer->bytes == NULL) {
return -1;
}
memcpy(buffer->bytes + buffer->used, bytes, len);
buffer->used += len;
return len;
}
bool buffer_insert(Buffer *buf, size_t pos, const void *data, size_t len) {
if (pos > buf->len)
return false;
if (!buffer_grow(buf, buf->len + len))
return false;
memmove(buf->data + pos + len, buf->data + pos, buf->len - pos);
memcpy(buf->data + pos, data, len);
buf->len += len;
return true;
}
int
buffer_append(Buffer *buf, char *append, int length)
{
int status = 0;
int desired_length = length + 1; // Space for NUL byte
if (!buffer_has_space(buf, desired_length)) {
status = buffer_grow(buf, desired_length);
jump_to_error_unless(status == 0)
}
int buffer_read(buffer *buffer, size_t count) {
while (buffer->size < count + 1) {
if (buffer_grow(buffer) == FALSE) {
return FALSE;
}
}
size_t in = fread((void *) buffer->buffer, 1, count, stdin);
buffer->buffer[count] = '\0';
return in == count;
}
char *
replace_references(int delim, const char *str, const char *source, regmatch_t *sub, size_t nsub)
{
long index;
const char *s;
char *expand, *stop;
size_t offset, size, length;
if (str == NULL)
return NULL;
expand = NULL;
offset = size = 0;
for (s = str; *s != '\0'; s++) {
if (*s == delim) {
if (str < s && s[-1] == '\\') {
/* Remove backslash from expansion. */
expand[offset-1] = *s;
continue;
}
index = strtol(s+1, &stop, 10);
if (0 <= index && index <= nsub) {
s = stop-1;
length = sub[index].rm_eo - sub[index].rm_so;
if ((expand = buffer_grow(expand, GROW_SIZE, offset+length, &size)) == NULL)
return NULL;
(void) memcpy(expand+offset, source+sub[index].rm_so, length);
offset += length;
}
} else {
if ((expand = buffer_grow(expand, GROW_SIZE, offset, &size)) == NULL)
return NULL;
expand[offset++] = *s;
}
}
if (expand != NULL)
expand[offset] = '\0';
return expand;
}
int buffer_append(buffer_t *buffer, char byte) {
if (buffer->capacity - buffer->written == 0) {
if (buffer->flags & BUFFER_GROWABLE) {
if (!buffer_grow(buffer, buffer->capacity + 1)) {
return 0;
}
} else {
return 0;
}
}
buffer->data[buffer->written++] = byte;
return 1;
}
bool buffer_vprintf(Buffer *buf, const char *fmt, va_list ap) {
va_list ap_save;
va_copy(ap_save, ap);
int len = vsnprintf(NULL, 0, fmt, ap);
if (len == -1 || !buffer_grow(buf, len+1)) {
va_end(ap_save);
return false;
}
bool ret = vsnprintf(buf->data, len+1, fmt, ap_save) == len;
if (ret)
buf->len = len+1;
va_end(ap_save);
return ret;
}
int buffer_write(buffer_t *buffer, const char *data, size_t len) {
if (buffer->capacity - buffer->written < len) {
if (buffer->flags & BUFFER_GROWABLE) {
if (!buffer_grow(buffer, buffer->capacity + len)) {
return 0;
}
} else {
return 0;
}
}
memcpy(buffer->data + buffer->written, data, len);
buffer->written += len;
return 1;
}
static bool buffer_vappendf(Buffer *buf, const char *fmt, va_list ap) {
va_list ap_save;
va_copy(ap_save, ap);
int len = vsnprintf(NULL, 0, fmt, ap);
if (len == -1 || !buffer_grow(buf, len+1)) {
va_end(ap_save);
return false;
}
size_t nul = (buf->len > 0 && buf->data[buf->len-1] == '\0') ? 1 : 0;
buf->len -= nul;
bool ret = vsnprintf(buf->data+buf->len, len+1, fmt, ap_save) == len;
buf->len += ret ? (size_t)len+1 : nul;
va_end(ap_save);
return ret;
}
int client_handle_request(struct clients *cls, int fd)
{
int n, t;
int toread;
struct buffer *buffer = cls->clients[fd].msg;
char *str;
if (ioctl(fd, FIONREAD, &toread)) {
debugprintf("%s: FIONREAD\n", errno);
return -1;
}
if (buffer->used + toread >= MAX_MSG_SIZE) {
debugprintf("client sent %d bytes, too much data!\n",
buffer->used + toread);
client_remove(cls, fd);
close(fd);
return -1;
}
buffer_grow(buffer, toread);
n = recv(fd, buffer->buf + buffer->used, MAX_MSG_SIZE - buffer->used, 0);
buffer->used += n;
if (n <= 0) {
if (n < 0) perror("recv");
client_remove(cls, fd);
close(fd);
return;
}
if (buffer->buf[buffer->used - 1] != '\n')
return 0;
buffer->buf[buffer->used] = '\0';
str = malloc(MAX_MSG_SIZE);
if (!str)
perror("malloc");
t = snprintf(str, MAX_MSG_SIZE, "%i: %s", fd, buffer->buf);
spam_everyone(cls, fd, str, t);
buffer->used = 0;
free(str);
}
void SSLConnection::init () {
did_init = false;
buffer_t path;
buffer_init(&path);
buffer_grow(&path,_POSIX_PATH_MAX+1);
if (!HAVE_ENTROPY ()) {
/* load entropy from files */
if (SSLEntropyFile)
add_entropy (SSLEntropyFile);
add_entropy (RAND_file_name (path.str,path.size));
/* load entropy from egd sockets */
#ifdef HAVE_RAND_EGD
add_entropy (getenv ("EGDSOCKET"));
buffer_shrink(&path,0);
buffer_add_str(&path,NONULL(Homedir),-1);
buffer_add_str(&path,"/.entropy",9);
add_entropy (path.str);
add_entropy ("/tmp/entropy");
#endif
/* shuffle $RANDFILE (or ~/.rnd if unset) */
RAND_write_file (RAND_file_name (path.str,path.size));
if (!HAVE_ENTROPY ()) {
buffer_t msg; buffer_init(&msg);
buffer_add_str(&msg,_("Failed to find enough entropy on your system"),-1);
displayError.emit(&msg);
buffer_free(&msg);
buffer_free(&path);
return;
}
}
/*
* I don't think you can do this just before reading the error.
* The call itself might clobber the last SSL error.
*/
SSL_load_error_strings ();
SSL_library_init ();
did_init = true;
buffer_free(&path);
}
int SSLConnection::doRead(buffer_t * buf, unsigned int len) {
int read_len;
buffer_grow(buf,len);
buffer_shrink(buf,0);
read_len = SSL_read(ssl,buf->str,len);
switch (read_len) {
case -1:
is_connected = false;
return -1;
case 0:
is_connected = false;
default:
break;
}
return read_len;
}
/* Assure that `buffer` has at least `size` free bytes (and grow if needed).
* Return non-zero on allocation failure. */
static int buffer_assure_space(buffer_t buffer, int size) {
if (buffer->position + size <= buffer->size) {
return 0;
}
return buffer_grow(buffer, buffer->position + size);
}
void buffer_putc(buffer* b, char c)
{
if(++b->pos >= b->size) buffer_grow(b);
b->buf [b->pos - 1] = c;
}
