static void
replay_to_json (gint64 time,
const char *name,
const char *signature,
GValue *arg,
gpointer user_data)
{
ReplayToJsonClosure *closure = user_data;
char *event_str;
if (closure->error != NULL)
return;
if (!closure->first)
{
if (!write_string (closure->out, ",\n ", &closure->error))
return;
}
closure->first = FALSE;
if (strcmp (signature, "") == 0)
{
event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\"]", time, name);
}
else if (strcmp (signature, "i") == 0)
{
event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", %i]",
time,
name,
g_value_get_int (arg));
}
else if (strcmp (signature, "x") == 0)
{
event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", %"G_GINT64_FORMAT "]",
time,
name,
g_value_get_int64 (arg));
}
else if (strcmp (signature, "s") == 0)
{
const char *arg_str = g_value_get_string (arg);
char *escaped = escape_quotes (arg_str);
event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", \"%s\"]",
time,
name,
g_value_get_string (arg));
if (escaped != arg_str)
g_free (escaped);
}
else
{
g_assert_not_reached ();
}
if (!write_string (closure->out, event_str, &closure->error))
return;
}
void llog(const loglevel_t level, ...) {
FILE* outfile = stdout;
va_list vargs; va_start(vargs, level);
time_t now; time(&now);
char* current;
int i = 0;
if (strcmp(hostname, "localhost") == 0) gethostname(hostname, 256);
if (log_json) {
fprintf(outfile, "{\"version\":\"1.1\",\"host\":\"ljspawn@%s\",\"timestamp\":%ld,\"level\":%d", hostname, now, level);
char* prev = malloc(1);
while ((current = va_arg(vargs, char*)) != NULL) {
i++;
char* new_current = escape_quotes(current);
if (i % 2 == 0) {
if (strcmp(prev, "jid") == 0 || strcmp(prev, "status") == 0) {
fprintf(outfile, "%s", new_current);
} else {
fprintf(outfile, "\"%s\"", new_current);
}
} else {
if (strcmp(new_current, "message") == 0) {
fprintf(outfile, ",\"short_message\":");
} else {
fprintf(outfile, ",\"_%s\":", new_current);
}
}
free(prev);
prev = malloc(strlen(new_current));
memmove(prev, new_current, strlen(new_current) + 1);
free(new_current);
}
if (i % 2 != 0) fprintf(outfile, "\"\"");
fprintf(outfile, "}");
} else {
std::string get_process_json(const Process& process, bool prettyprint)
{
std::stringstream ss;
ss << "{";
if (prettyprint) ss << "\n ";
ss << "\"cmdline\":";
ss << "\"" << escape_quotes(process.cmdline) << "\"";
ss << ",";
if (prettyprint) ss << "\n ";
ss << "\"uid\":";
ss << process.userid;
ss << ",";
if (prettyprint) ss << "\n ";
ss << "\"pid\":";
ss << process.processid;
ss << ",";
if (prettyprint) ss << "\n ";
ss << "\"wchan\":";
ss << "\"" << process.wchan << "\"";
if (prettyprint)
ss << "\n";
ss << "}";
return ss.str();
}
void run(int type)
{
escape_quotes(plugin->irc->message.trailing);
if (type == PLUGIN_TYPE_COMMAND) {
handle_command();
} else if (type == PLUGIN_TYPE_GREP) {
handle_grep();
}
}
char *error_to_json(const spidermonkey_error *error) {
/* Allocate 1K to build error (hopefully that's enough!) */
int size = sizeof(char) * 1024;
char *retval = (char *) driver_alloc(size);
char *escaped_source = escape_quotes(error->offending_source);
snprintf(retval, size, "{\"error\": {\"lineno\": %d, \"message\": \"%s\", \"source\": \"%s\"}}", error->lineno,
error->msg, escaped_source);
driver_free(escaped_source);
return retval;
}
char *error_to_json(const jaegermonkey_error *error) {
char *escaped_source = escape_quotes(error->offending_source);
int size = (strlen(escaped_source) + strlen(error->msg) + 128) * sizeof(char);
char *retval = (char *) driver_alloc(size);
snprintf(retval, size, "{\"error\": {\"lineno\": %d, \"message\": \"%s\", \"source\": \"%s\"}}", error->lineno,
error->msg, escaped_source);
driver_free(escaped_source);
return retval;
}
char *error_to_json(const spidermonkey_error *error) {
char *escaped_source = escape_quotes(error->offending_source);
/* size = length(escaped source) + length(error msg) + JSON formatting */
size_t size = strlen(escaped_source) + strlen(error->msg) + 80;
char *retval = ejs_alloc(size);
snprintf(retval, size, "{\"error\": {\"lineno\": %d, \"message\": \"%s\", \"source\": \"%s\"}}",
error->lineno, error->msg, escaped_source);
driver_free(escaped_source);
return retval;
}
int
mkcccmd(char *buf, int argc, char *argv[])
{
char *bp = buf;
char **args = argv;
bp += sprintf(bp, arg_array[ARG_CC]);
while (argc) {
if (strcmp(*args, "-g") == 0) {
bp += sprintf(bp, arg_array[ARG_DEBUG]);
} else if (strcmp(*args, "-W1") == 0) {
bp += sprintf(bp, arg_array[ARG_WARN1]);
} else if (strcmp(*args, "-W2") == 0) {
bp += sprintf(bp, arg_array[ARG_WARN2]);
} else if (strncmp(*args, "-std=", 5) == 0) {
static const char *stds[] = { "c99", "c89", NULL };
int std = 0;
while (stds[std] && strcmp(*args + 5, stds[std])) {
std++;
}
if (stds[std] != NULL) {
bp += sprintf(bp, arg_array[ARG_C99 + std]);
} else { /* just copy */
fprintf(stderr, "Argument '%s' not translated - just copying ...\n", *args);
bp += sprintf(bp, " %s", *args);
}
} else if (strcmp(*args, "-fpic") == 0) {
bp += sprintf(bp, arg_array[ARG_PIC1]);
} else if (strcmp(*args, "-fPIC") == 0) {
bp += sprintf(bp, arg_array[ARG_PIC2]);
} else if (strcmp(*args, "-rpath") == 0) {
args++; argc--;
if (!argc) {
ERR(EINVAL, "-rpath requires an argument");
return -1;
}
bp += sprintf(bp, arg_array[ARG_RPATH], *args);
} else {
/* Just copy the argument */
bp += sprintf(bp, " %s", escape_quotes(*args));
}
args++; argc--;
}
return bp - buf;
}
int replace_dollars(char **str)
{
int i;
i = 0;
while ((*str)[i])
{
if ((*str)[i] == 0x27)
escape_quotes(*str, &i, (*str)[i]);
else if ((*str)[i] == '$')
replace_dollar(str, &i);
else if ((*str)[i] != '\0')
i = ((*str)[i] == 0x5c) ? i + 2 : i + 1;
}
return (0);
}
char* word_to_string(word_t* wd, BOOL ghil)
{
char* first_word = strdup(wd->string);
char* ret;
DIE(!first_word, "No memory in word_to_string()");
if (wd->expand) {
free(first_word);
first_word = ExpandVariable(wd->string);
}
if (ghil) {
char* tmp;
ret = calloc(strlen(first_word) + 5, 1);
DIE(!ret, "No memory in word_to_string()");
tmp = first_word;
first_word = escape_quotes(first_word);
free(tmp);
_snprintf_s(ret, strlen(first_word) + 5, strlen(first_word) + 5, "\"%s\"", first_word);
free(first_word);
}
else
ret = first_word;
if (wd->next_word) {
char* next_word = word_to_string(wd->next_word, ghil);
DIE(!next_word, "No memory in word_to_string()");
append(&ret, next_word);
free(next_word);
}
if (wd->next_part) {
char* next_part = word_to_string(wd->next_part, FALSE);
char* tmp = malloc(strlen(ret) + strlen(next_part) + 1);
if (!strcmp(next_part, "="))
printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
memcpy(tmp, ret, strlen(ret));
memcpy(tmp + strlen(ret), next_part, strlen(next_part) + 1);
free(next_part);
ret = tmp;
}
return ret;
}
/**
* shell_perf_log_dump_events:
* @perf_log: a #ShellPerfLog
* @out: output stream into which to write the event definitions
* @error: location to store #GError, or %NULL
*
* Dump the definition of currently defined events and statistics, formatted
* as JSON, to the specified output stream. The JSON output is an array,
* with each element being a dictionary of the form:
*
* { name: <name of event>,
* description: <descrition of string,
* statistic: true } (only for statistics)
*
* Return value: %TRUE if the dump succeeded. %FALSE if an IO error occurred
*/
gboolean
shell_perf_log_dump_events (ShellPerfLog *perf_log,
GOutputStream *out,
GError **error)
{
GString *output;
int i;
output = g_string_new (NULL);
g_string_append (output, "[ ");
for (i = 0; i < perf_log->events->len; i++)
{
ShellPerfEvent *event = g_ptr_array_index (perf_log->events, i);
char *escaped_description = escape_quotes (event->description);
gboolean is_statistic = g_hash_table_lookup (perf_log->statistics_by_name, event->name) != NULL;
if (i != 0)
g_string_append (output, ",\n ");
g_string_append_printf (output,
"{ \"name\": \"%s\",\n"
" \"description\": \"%s\"",
event->name, escaped_description);
if (is_statistic)
g_string_append (output, ",\n \"statistic\": true");
g_string_append (output, " }");
if (escaped_description != event->description)
g_free (escaped_description);
}
g_string_append (output, " ]");
return write_string (out, g_string_free (output, FALSE), error);
}
/*
* Create a recovery.conf file in memory using a PQExpBuffer
*/
static void
GenerateRecoveryConf(PGconn *conn)
{
PQconninfoOption *connOptions;
PQconninfoOption *option;
PQExpBufferData conninfo_buf;
char *escaped;
recoveryconfcontents = createPQExpBuffer();
if (!recoveryconfcontents)
{
fprintf(stderr, _("%s: out of memory\n"), progname);
disconnect_and_exit(1);
}
connOptions = PQconninfo(conn);
if (connOptions == NULL)
{
fprintf(stderr, _("%s: out of memory\n"), progname);
disconnect_and_exit(1);
}
appendPQExpBufferStr(recoveryconfcontents, "standby_mode = 'on'\n");
initPQExpBuffer(&conninfo_buf);
for (option = connOptions; option && option->keyword; option++)
{
/*
* Do not emit this setting if: - the setting is "replication",
* "dbname" or "fallback_application_name", since these would be
* overridden by the libpqwalreceiver module anyway. - not set or
* empty.
*/
if (strcmp(option->keyword, "replication") == 0 ||
strcmp(option->keyword, "dbname") == 0 ||
strcmp(option->keyword, "fallback_application_name") == 0 ||
(option->val == NULL) ||
(option->val != NULL && option->val[0] == '\0'))
continue;
/* Separate key-value pairs with spaces */
if (conninfo_buf.len != 0)
appendPQExpBufferStr(&conninfo_buf, " ");
/*
* Write "keyword=value" pieces, the value string is escaped and/or
* quoted if necessary.
*/
escaped = escapeConnectionParameter(option->val);
appendPQExpBuffer(&conninfo_buf, "%s=%s", option->keyword, escaped);
free(escaped);
}
/*
* Escape the connection string, so that it can be put in the config file.
* Note that this is different from the escaping of individual connection
* options above!
*/
escaped = escape_quotes(conninfo_buf.data);
appendPQExpBuffer(recoveryconfcontents, "primary_conninfo = '%s'\n", escaped);
free(escaped);
if (PQExpBufferBroken(recoveryconfcontents) ||
PQExpBufferDataBroken(conninfo_buf))
{
fprintf(stderr, _("%s: out of memory\n"), progname);
disconnect_and_exit(1);
}
termPQExpBuffer(&conninfo_buf);
PQconninfoFree(connOptions);
}
