void WebController::ListDir(struct json_token *paramtoken){
char *dir = NULL;
toks(paramtoken, &dir, 0);
if (dir) {
DIR *dp;
struct dirent *ep;
int w = 0,first=1;
dp = opendir (dir);
if (dp != NULL){
w += snprintf(gp_response+w, MAX_LINE-w, "[");
while ((ep = readdir(dp))){
//printf("%d %s\n", ep->d_type, ep->d_name);
if(first){
first = 0;
w += json_emit(gp_response+w, MAX_LINE-w, "{s: s, s: i}", "name", ep->d_name,"type",ep->d_type );
} else {
w += json_emit(gp_response+w, MAX_LINE-w, ",{s: s, s: i}", "name", ep->d_name,"type",ep->d_type );
}
}
w += snprintf(gp_response+w, MAX_LINE-w, "]");
(void) closedir (dp);
} else {
this->DoErrorMessage(strerror(errno));
}
}
free(dir);
}
/*
* Create JSON-RPC request in a given buffer.
*
* Return length of the request, which
* can be larger then `len` that indicates an overflow.
*/
int ns_rpc_create_request(char *buf, int len, const char *method,
const char *id, const char *params_fmt, ...) {
va_list ap;
int n = 0;
n += json_emit(buf + n, len - n, "{s:s,s:s,s:s,s:", "jsonrpc", "2.0", "id",
id, "method", method, "params");
va_start(ap, params_fmt);
n += json_emit_va(buf + n, len - n, params_fmt, ap);
va_end(ap);
n += json_emit(buf + n, len - n, "}");
return n;
}
static
int settings_save() {
FILE* fp;
size_t len;
char settings_buf[256];
char effects_buf[MAX_EFFECTS * 512];
len = settings_json(settings_buf, sizeof(settings_buf));
LOG(("settings_json: %zu bytes\n", len));
len = effects_json(effects_buf, sizeof(effects_buf));
LOG(("effects_json: %zu bytes\n", len));
len = json_emit(work_buf, sizeof(work_buf), JSON_DOC,
SETTINGS, settings_buf,
EFFECTS, effects_buf
);
fp = fopen(SETTINGS_FILE, "w");
if (!fp) {
LOG(("settings_save> fopen() failed: (%d) %s\n", errno, strerror(errno)));
return errno;
}
fwrite(work_buf, len, 1, fp);
fclose(fp);
return 0;
}
/*
* Create JSON-RPC error reply in a given buffer.
*
* Return length of the error, which
* can be larger then `len` that indicates an overflow.
*/
int ns_rpc_create_error(char *buf, int len, struct ns_rpc_request *req,
int code, const char *message, const char *fmt, ...) {
va_list ap;
int n = 0;
n += json_emit(buf + n, len - n, "{s:s,s:V,s:{s:i,s:s,s:", "jsonrpc", "2.0",
"id", req->id == NULL ? "null" : req->id->ptr,
req->id == NULL ? 4 : req->id->len, "error", "code", code,
"message", message, "data");
va_start(ap, fmt);
n += json_emit_va(buf + n, len - n, fmt, ap);
va_end(ap);
n += json_emit(buf + n, len - n, "}}");
return n;
}
int ns_rpc_create_reply(char *buf, int len, const struct ns_rpc_request *req,
const char *result_fmt, ...) {
va_list ap;
int n = 0;
n += json_emit(buf + n, len - n, "{s:s,s:V,s:",
"jsonrpc", "2.0", "id",
req->id == NULL ? "null" : req->id->ptr,
req->id == NULL ? 4 : req->id->len,
"result");
va_start(ap, result_fmt);
n += json_emit_va(buf + n, len - n, result_fmt, ap);
va_end(ap);
n += json_emit(buf + n, len - n, "}");
return n;
}
static
int channel_json(char* buf, size_t len, struct channel* channel) {
int i;
int ret;
int first = 1;
char all_buf[MAX_EFFECTS * 512];
char* ptr = all_buf;
*ptr = 0;
// LOG(("channel_json> %p\n", channel));
for (i = 0; i < channel->num_effects; i++) {
struct effect* effect = channel->effects[i];
char color_buf[1024];
char effect_buf[1024];
// LOG(("channel_json> effect: %s\n", effect->name));
color_json(color_buf, sizeof(color_buf), channel, &effect->color_arg);
json_emit(effect_buf, sizeof(effect_buf), JSON_EFFECT,
NAME, effect->name,
ARGUMENT, effect->argument,
ARGUMENT_DESC, effect->arg_desc ? effect->arg_desc : "",
COLOR, color_buf,
IS_SSAVER, effect->screen_saver
);
if (first) {
first = 0;
ret = sprintf(ptr, "%s", effect_buf);
} else {
ret = sprintf(ptr, ",\n%s", effect_buf);
}
ptr += ret;
}
return json_emit(buf, len, JSON_CHANNEL,
ACTIVE, channel->active,
ALL, all_buf
);
}
int WebController::CreateMcodeUserCallbackData(int mCode, bool blocking, char *buf, size_t buf_len){
int id = callback_counter++;
json_emit(buf, buf_len,"{ s: i, s: { s: S, s: s, s: i }}",
"id", id,
"payload",
"block",blocking?"true":"false",
"type", CB_NAMES[CB_USER_M_CODE],
"code", mCode);
return id;
}
int WebController::CreateErrorMessageCallbackData(const char *msg, bool blocking, char *buf, size_t buf_len) {
int id = callback_counter++;
json_emit(buf, buf_len, "{ s: i, s: { s: S, s: s, s: s }}",
"id", id,
"payload",
"block",blocking?"true":"false",
"type", CB_NAMES[CB_ERR_MSG],
"message", msg);
return id;
}
int WebController::CreateStatusCallbackData(int line_no, const char *msg, bool blocking, char *buf, size_t buf_len){
int id = callback_counter++;
json_emit(buf, buf_len, "{ s: i, s: { s: S, s: s, s: i, s: s }}",
"id", id,
"payload",
"block", blocking?"true":"false",
"type", CB_NAMES[CB_STATUS],
"line", line_no,
"message", msg);
return id;
}
static
int settings_json(char* buf, size_t len) {
return json_emit(buf, len, JSON_SETTINGS,
BRIGHTNESS, settings.brightness,
MANUAL_TICK, settings.manual_tick,
IDLE_INTERVAL, settings.idle_interval,
MANUAL_TOGGLE, settings.manual_toggle,
SCREEN_SAVER_TOGGLE, settings.screen_saver_toggle,
ALPHA, settings.alpha
);
}
int WebController::CreateMessageBoxCallbackData(const char *title, const char *msg, int options, bool blocking, char *buf, size_t buf_len) {
int id = callback_counter++;
json_emit(buf, buf_len, "{ s: i, s: { s: S, s: s, s: i, s: s, s: s }}",
"id", id,
"payload",
"block",blocking?"true":"false",
"type", CB_NAMES[CB_MESSAGEBOX],
"options", options,
"title", title,
"message", msg);
return id;
}
int WebController::CreateCompleteCallbackData(int status, int line_no, int sequence_number,const char *err, bool blocking, char *buf, size_t buf_len){
int id = callback_counter++;
json_emit(buf, buf_len, "{ s: i, s: { s: S, s: s, s: i, s: i, s: i, s: s }}",
"id", id,
"payload",
"block",blocking?"true":"false",
"type", CB_NAMES[CB_COMPLETE],
"line", line_no,
"status", status,
"sequence", sequence_number,
"message", err);
return id;
}
/*
* Create JSON-RPC reply in a given buffer.
*
* Return length of the reply, which
* can be larger then `len` that indicates an overflow.
*/
int ns_rpc_create_reply(char *buf, int len, const struct ns_rpc_request *req,
const char *result_fmt, ...) {
static const struct json_token null_tok = {"null", 4, 0, JSON_TYPE_NULL};
const struct json_token *id = req->id == NULL ? &null_tok : req->id;
va_list ap;
int n = 0;
n += json_emit(buf + n, len - n, "{s:s,s:", "jsonrpc", "2.0", "id");
if (id->type == JSON_TYPE_STRING) {
n += json_emit_quoted_str(buf + n, len - n, id->ptr, id->len);
} else {
n += json_emit_unquoted_str(buf + n, len - n, id->ptr, id->len);
}
n += json_emit(buf + n, len - n, ",s:", "result");
va_start(ap, result_fmt);
n += json_emit_va(buf + n, len - n, result_fmt, ap);
va_end(ap);
n += json_emit(buf + n, len - n, "}");
return n;
}
static
int effects_json(char* buf, size_t len) {
char treads_buf[MAX_EFFECTS * 512];
char panels_buf[MAX_EFFECTS * 512];
char barrel_buf[MAX_EFFECTS * 512];
channel_json(treads_buf, sizeof(treads_buf), &channel_treads);
channel_json(panels_buf, sizeof(panels_buf), &channel_panels);
channel_json(barrel_buf, sizeof(barrel_buf), &channel_barrel);
return json_emit(buf, len, JSON_EFFECTS,
TREADS, treads_buf,
PANELS, panels_buf,
BARREL, barrel_buf
);
}
static
int color_json(char* buf, size_t len, struct channel* channel, union color_arg* arg) {
if (channel == &channel_panels) {
union color* values = arg->colors;
return json_emit(buf, len, JSON_PANELS_COLOR,
values[0].value,
values[1].value,
values[2].value,
values[3].value,
values[4].value,
values[5].value,
values[6].value,
values[7].value,
values[8].value,
values[9].value
);
}
return json_emit_long(buf, len, arg->color.value);
}
static PyObject *
PongoDict_json(PongoDict *self, PyObject *args)
{
char *key = NULL, *val = NULL;
Py_ssize_t klen, vlen;
PyObject *ret = Py_None;
dbtype_t dict, obj, k;
jsonctx_t *jctx;
if (!PyArg_ParseTuple(args, "|s#s#:json", &key, &klen, &val, &vlen))
return NULL;
dblock(self->ctx);
dict = self->dbptr;
jctx = json_init(self->ctx);
if (key) {
if (val) {
// 2-arg form is dict.json('key', 'value')
// inserts dict['key'] = json_parse('value')
k = dbstring_new(self->ctx, key, klen);
obj = json_parse(jctx, val, vlen);
dbobject_setitem(SELF_CTX_AND_DBPTR, k, obj, self->ctx->sync);
} else {
// 1-arg form is replace dict.items with parsed json
obj = json_parse(jctx, key, klen);
dict.ptr = dbptr(self->ctx, dict);
obj.ptr = dbptr(self->ctx, obj);
dict.ptr->obj = obj.ptr->obj;
}
Py_INCREF(ret);
} else {
// The 0-arg form is to generate the json string from dictionary
// contents
json_emit(jctx, dict);
if (jctx->outstr)
ret = PyUnicode_FromStringAndSize(
(const char*)jctx->outstr, jctx->outlen);
}
json_cleanup(jctx);
dbunlock(self->ctx);
return ret;
}
