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