char *string_replace_percents( const char *str, const char *replace )
{
/* Common case: do nothing if no percents. */
if(!strchr(str,'%')) return xxstrdup(str);
buffer_t buffer;
buffer_init(&buffer);
const char *s;
for(s=str;*s;s++) {
if(*s=='%' && *(s+1)=='%' ) {
if( *(s+2)=='%' && *(s+3)=='%') {
buffer_putlstring(&buffer,"%%",2);
s+=3;
} else {
buffer_putstring(&buffer,replace);
s++;
}
} else {
buffer_putlstring(&buffer,s,1);
}
}
char *result;
buffer_dup(&buffer,&result);
buffer_free(&buffer);
return result;
}
char * jx_print_string( struct jx *j )
{
buffer_t buffer;
char *str;
buffer_init(&buffer);
jx_print_buffer(j,&buffer);
buffer_dup(&buffer,&str);
buffer_free(&buffer);
return str;
}
MemBuffer *
membuffer_new_from_buffer_dup (DWORD addr, Buffer *buf)
{
MemBuffer *membuffer;
if ((membuffer = malloc(sizeof(MemBuffer))) == NULL)
return NULL;
membuffer_init (membuffer, addr, buffer_dup(buf));
return membuffer;
}
/*
// --------------------------------------------------------------------
// called by fwrite()
*/
Int write_to_file(Obj * obj, cBuf * buf)
{
filec_t *file = find_file_controller(obj);
if (file == NULL || !file->f.writable)
return 0;
if (file->wbuf)
file->wbuf = buffer_append(file->wbuf, buf);
else
file->wbuf = buffer_dup(buf);
return 1;
}
char *make_field_names_str(char *separator)
{
char *str;
struct buffer b;
buffer_init(&b);
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
if(f->active)
buffer_printf(&b, "%s: %s%s", f->abbrev, f->name, separator);
buffer_dup(&b, &str);
buffer_free(&b);
return str;
}
struct jx * jx_format( const char *fmt, ... )
{
va_list va;
struct jx *j;
buffer_t B[1];
char *str;
buffer_init(B);
buffer_abortonfailure(B, 1);
va_start(va, fmt);
buffer_putvfstring(B, fmt, va);
va_end(va);
buffer_dup(B, &str);
buffer_free(B);
j = jx_create(JX_STRING);
j->u.string_value = str;
return j;
}
/*
* Based on opengroup.org's definition of the Shell Command Language (also gnu's)
* In section 2.2.3 on Double-Quoted Strings, it indicates you only need to
* escape dollar sign, backtick, and backslash. I also escape double quote as
* we are adding and exterior double quote around the string.
*
* [ $ \ ` " ] Are always escaped.
* */
char *string_escape_shell( const char *str )
{
buffer_t B[1];
buffer_init(B);
buffer_abortonfailure(B, 1);
const char *s;
buffer_putliteral(B,"\"");
for(s=str;*s;s++) {
if(*s=='"' || *s=='\\' || *s=='$' || *s=='`')
buffer_putliteral(B,"\\");
buffer_putlstring(B,s,1);
}
buffer_putliteral(B,"\"");
char *result;
buffer_dup(B,&result);
buffer_free(B);
return result;
}
ssize_t link_stream_to_buffer(struct link * link, char **buffer, time_t stoptime)
{
ssize_t total = 0;
buffer_t B;
buffer_init(&B);
while(1) {
char buf[1<<16];
ssize_t actual = link_read(link, buf, sizeof(buf), stoptime);
if(actual <= 0)
break;
if (buffer_putlstring(&B, buf, actual) == -1) {
buffer_free(&B);
return -1;
}
total += actual;
}
if (buffer_dup(&B, buffer) == -1)
total = -1;
buffer_free(&B);
return total;
}
static void METHOD_IMPL(read_headers, buffer *b)
{
off_t pos = CALL(this->buffer, seek, 0, SEEK_CUR);
CALL(this->buffer, write_buffer, buffer_dup(b));
struct search_state *state = this->search;
if(!state)
{
state = this->search = (struct search_state*)malloc(
sizeof(struct search_state));
strcpy(state->needle, "\r\n");
state->pos = 0;
}
char *ptr = (char*)b->ptr;
for(;b->pos < b->used;b->pos++, ptr++, pos++)
{
if(*ptr == state->needle[state->pos])
{
if(state->needle[++state->pos] == '\0')
{
size_t line_len = pos+1;
if(line_len == strlen(state->needle))
{
DPRINTF("end of headers found\n");
this->state = STATE_BODY;
}
char *hdr_str = (char*)malloc(line_len);
CALL(this->buffer, seek, 0, SEEK_SET);
CALL(this->buffer, read, hdr_str, line_len);
hdr_str[line_len-2] = '\0';
off_t end = CALL(this->buffer, seek, 0, SEEK_END);
ASSERT(end >= line_len);
CALL(this->buffer, rtruncate,
end - line_len);
if(this->state == STATE_REQUEST)
{
char *request_type = strtok(hdr_str, " \t");
char *request_path = strtok(NULL, " \t");
char *http_version = strtok(NULL, " \t");
this->msg.request_type = strdup(request_type);
this->msg.request_path = strdup(request_path);
this->msg.http_version = strdup(http_version);
this->state = STATE_HEADERS;
DPRINTF("request: %s %s %s\n",
request_type,
request_path,
http_version);
}
else if(this->state == STATE_RESPONSE)
{
char *http_version = strtok(hdr_str, " \t");
char *response_code = strtok(NULL, " \t");
char *response_msg = strtok(NULL, " \t");
//ASSERT(strcmp(http_version, this->msg.http_version) == 0);
this->msg.response_code = strtoll(response_code, NULL, 0);
this->msg.response_msg = strdup(response_msg);
this->state = STATE_HEADERS;
DPRINTF("response: %s %d %s\n",
http_version,
this->msg.response_code,
response_msg);
}
else
{
char *name = hdr_str, *value = NULL, *i;
for(i = hdr_str;*i != '\0';i++)
{
if(*i == ':')
{
*i = '\0';
value = i+1;
break;
}
}
if(value)
{
for(;(*value == ' ' || *value == '\t') &&
*value != '\0'; value++);
this->msg.headers[this->msg.header_count] =
(char**)malloc(2 * sizeof(char*));
this->msg.headers[this->msg.header_count][0] =
strdup(name);
this->msg.headers[this->msg.header_count][1] =
strdup(value);
this->msg.header_count++;
}
}
free(hdr_str);
state->pos = 0;
pos = -1;
}
}
else
{
state->pos = 0;
}
}
buffer_recycle(b);
}
"The subrange extends to %d, past the end of the buffer (%d).",
start + len, blen));
buf = buffer_dup(BUF1);
anticipate_assignment();
CLEAN_RETURN_BUFFER(buffer_subrange(buf, start, len));
}
NATIVE_METHOD(bufsub) {
cBuf *buf, *old, *new;
INIT_3_ARGS(BUFFER, BUFFER, BUFFER);
buf = buffer_dup(BUF1);
old = buffer_dup(BUF2);
new = buffer_dup(BUF3);
if (old->len == 0)
THROW((type_id, ""));
anticipate_assignment();
CLEAN_RETURN_BUFFER(buffer_bufsub(buf, old, new));
}
NATIVE_METHOD(buf_to_str) {
cBuf * buf;
INIT_1_ARG(BUFFER);
