int chirp_sqlite3_column_jsonify(sqlite3_stmt *stmt, int n, buffer_t *B)
{
int rc;
switch (sqlite3_column_type(stmt, n)) {
case SQLITE_NULL:
CATCHUNIX(buffer_putliteral(B, "null"));
break;
case SQLITE_INTEGER:
CATCHUNIX(buffer_putfstring(B, "%" PRId64, (int64_t) sqlite3_column_int64(stmt, n)));
break;
case SQLITE_FLOAT:
CATCHUNIX(buffer_putfstring(B, "%.*e", DBL_DIG, sqlite3_column_double(stmt, n)));
break;
case SQLITE_TEXT:
CATCHUNIX(buffer_putliteral(B, "\""));
CATCHUNIX(jsonA_escapestring(B, (const char *)sqlite3_column_text(stmt, n)));
CATCHUNIX(buffer_putliteral(B, "\""));
break;
default:
abort();
}
rc = 0;
goto out;
out:
return rc;
}
int tracer_args_set( struct tracer *t, INT64_T syscall, const INT64_T *args, int nargs )
{
if(!t->gotregs) {
if(ptrace(PTRACE_GETREGS,t->pid,0,&t->regs) == -1)
ERROR;
t->gotregs = 1;
}
#if 0 /* Enable this for extreme debugging... */
{
int i;
buffer_t B;
buffer_init(&B);
buffer_putfstring(&B, "SET args[%zu] = {", (size_t)nargs);
for (i = 0; i < nargs; i++)
buffer_putfstring(&B, "%" PRId64 ", ", args[i]);
buffer_putliteral(&B, "}");
debug(D_DEBUG, "%s", buffer_tostring(&B, NULL));
buffer_free(&B);
}
#endif
#ifdef CCTOOLS_CPU_I386
t->regs.regs32.orig_eax = syscall;
if(nargs>=1) t->regs.regs32.ebx = args[0];
if(nargs>=2) t->regs.regs32.ecx = args[1];
if(nargs>=3) t->regs.regs32.edx = args[2];
if(nargs>=4) t->regs.regs32.esi = args[3];
if(nargs>=5) t->regs.regs32.edi = args[4];
if(nargs>=6) t->regs.regs32.ebp = args[5];
#else
if(tracer_is_64bit(t)) {
t->regs.regs64.orig_rax = syscall;
if(nargs>=1) t->regs.regs64.rdi = args[0];
if(nargs>=2) t->regs.regs64.rsi = args[1];
if(nargs>=3) t->regs.regs64.rdx = args[2];
if(nargs>=4) t->regs.regs64.r10 = args[3];
if(nargs>=5) t->regs.regs64.r8 = args[4];
if(nargs>=6) t->regs.regs64.r9 = args[5];
} else {
t->regs.regs64.orig_rax = syscall;
if(nargs>=1) t->regs.regs64.rbx = args[0];
if(nargs>=2) t->regs.regs64.rcx = args[1];
if(nargs>=3) t->regs.regs64.rdx = args[2];
if(nargs>=4) t->regs.regs64.rsi = args[3];
if(nargs>=5) t->regs.regs64.rdi = args[4];
if(nargs>=6) {
if (t->has_args5_bug) t->regs.regs64.r9 = args[5];
else t->regs.regs64.rbp = args[5];
}
}
#endif
t->setregs = 1;
return 1;
}
int jsonA_escapestring(buffer_t *B, const char *str)
{
for (; *str; str++) {\
switch (*str) {\
case '/':
if (buffer_putliteral(B, "\\/") == -1) return -1;
break;
case '\\':
if (buffer_putliteral(B, "\\\\") == -1) return -1;
break;
case '\"':
if (buffer_putliteral(B, "\\\"") == -1) return -1;
break;
case '\b':
if (buffer_putliteral(B, "\\b") == -1) return -1;
break;
case '\f':
if (buffer_putliteral(B, "\\f") == -1) return -1;
break;
case '\n':
if (buffer_putliteral(B, "\\n") == -1) return -1;
break;
case '\r':
if (buffer_putliteral(B, "\\r") == -1) return -1;
break;
case '\t':
if (buffer_putliteral(B, "\\t") == -1) return -1;
break;
default:
if (buffer_putfstring(B, "%c", (int)*str) == -1) return -1;
break;
}
}
return 0;
}
static void do_debug(INT64_T flags, const char *fmt, va_list args)
{
buffer_t B;
char ubuf[1<<16];
buffer_init(&B);
buffer_ubuf(&B, ubuf, sizeof(ubuf));
buffer_max(&B, sizeof(ubuf));
if (debug_write == debug_file_write || debug_write == debug_stderr_write || debug_write == debug_stdout_write) {
struct timeval tv;
struct tm *tm;
gettimeofday(&tv, 0);
tm = localtime(&tv.tv_sec);
buffer_putfstring(&B, "%04d/%02d/%02d %02d:%02d:%02d.%02ld ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, (long) tv.tv_usec / 10000);
buffer_putfstring(&B, "%s[%d] ", debug_program_name, getpid());
}
/* Parrot prints debug messages for children: */
if (getpid() != debug_getpid()) {
buffer_putfstring(&B, "<child:%d> ", (int)debug_getpid());
}
buffer_putfstring(&B, "%s: ", debug_flags_to_name(flags));
buffer_putvfstring(&B, fmt, args);
while(isspace(buffer_tostring(&B)[buffer_pos(&B)-1]))
buffer_rewind(&B, buffer_pos(&B)-1); /* chomp whitespace */
buffer_putliteral(&B, "\n");
debug_write(flags, buffer_tostring(&B));
if(terminal_available && (flags & (D_ERROR | D_NOTICE | D_FATAL))) {
if(debug_write != debug_stderr_write || !isatty(STDERR_FILENO)) {
if(!terminal_f) {
if((terminal_f = fopen(terminal_path, "a")) == NULL) {
/* print to wherever stderr is pointing that we could not open the terminal. */
terminal_available = 0;
}
}
}
if(terminal_f)
fprintf(terminal_f, "%s", buffer_tostring(&B));
}
buffer_free(&B);
}
size_t cfs_fwrite(const void *ptr, size_t size, size_t nitems, CHIRP_FILE * file)
{
size_t bytes = 0, nbytes = size * nitems;
if(file->type == LOCAL)
return fwrite(ptr, size, nitems, file->f.lfile);
for(; bytes < nbytes; bytes++)
buffer_putfstring(&file->f.cfile.B, "%c", (int) (((const char *) ptr)[bytes]));
return nbytes;
}
void chirp_stats_summary(buffer_t *B)
{
char *addr;
struct chirp_stats *s;
if(!stats_table)
stats_table = hash_table_create(0, 0);
buffer_putfstring(B, "bytes_written %" PRIu64 "\n", total_bytes_written);
buffer_putfstring(B, "bytes_read %" PRIu64 "\n", total_bytes_read);
buffer_putfstring(B, "total_ops %" PRIu64 "\n", total_ops);
buffer_putliteral(B, "clients ");
hash_table_firstkey(stats_table);
while(hash_table_nextkey(stats_table, &addr, (void **) &s)) {
buffer_putfstring(B, "%s,1,1,%" PRIu64 ",%" PRIu64 ",%" PRIu64 "; ", s->addr, s->ops, s->bytes_read, s->bytes_written);
}
buffer_putliteral(B, "\n");
}
int chirp_sqlite3_row_jsonify(sqlite3_stmt *stmt, buffer_t *B)
{
int rc;
int i, first;
CATCHUNIX(buffer_putliteral(B, "{"));
for (i = 0, first = 1; i < sqlite3_column_count(stmt); i++, first = 0) {
if (!first)
CATCHUNIX(buffer_putliteral(B, ","));
CATCHUNIX(buffer_putfstring(B, "\"%s\":", sqlite3_column_name(stmt, i)));
chirp_sqlite3_column_jsonify(stmt, i, B);
}
CATCHUNIX(buffer_putliteral(B, "}"));
rc = 0;
goto out;
out:
return rc;
}
