int ICACHE_FLASH_ATTR stledOps(HttpdConnData *connData)
{
int i, r;
jsmn_parser p;
jsmntok_t t[16]; /* We expect no more than 16 tokens */
char *json = connData->post->buff;
if (connData->requestType == HTTPD_METHOD_OPTIONS) {
sendJSON(connData);
HTTPD_SEND_STR("{\"status\":\"ok\"}\r\n\r\n");
return HTTPD_CGI_DONE;
} else if (connData->requestType == HTTPD_METHOD_GET) {
sendJSON(connData);
HTTPD_PRINTF("{\"status_led\": \"%s\"}\r\n\r\n", opStr[opState]);
return HTTPD_CGI_DONE;
}
jsmn_init(&p);
r = jsmn_parse(&p, json, strlen(json), t, sizeof(t)/sizeof(t[0]));
if (r < 0) {
ERROR("[json] Failed to parse JSON: %d", r);
goto err;
} else
DEBUG("[json]: OK. %d tokens\n", r);
/* Assume the top-level element is an object */
if (r < 1 || t[0].type != JSMN_OBJECT) {
ERROR("Object expected\n");
goto err;
}
/* Loop over all keys of the root object */
for (i = 1; i < r; ) {
if (jsonEq(json, &t[i], "status_led") && i + 1 < r) {
if (jsonEq(json, &t[i+1], "on"))
stledSet(STLED_ON);
else if (jsonEq(json, &t[i+1], "off"))
stledSet(STLED_OFF);
else if (jsonEq(json, &t[i+1], "blink"))
stledSet(STLED_BLINK_SLOW);
else if (jsonEq(json, &t[i+1], "blink_fast"))
stledSet(STLED_BLINK_FAST);
else if (jsonEq(json, &t[i+1], "blink_slow"))
stledSet(STLED_BLINK_SLOW);
else if (jsonEq(json, &t[i+1], "blink_hb"))
stledSet(STLED_BLINK_HB);
i += 2;
} else {
//os_printf("BAD token %d: %s [%d,%d] sz=%d\n", i, type[t[i].type], t[i].start, t[i].end, t[i].size);
ERROR("BAD token %d: type=%d [%d,%d] sz=%d", i, t[i].type, t[i].start, t[i].end, t[i].size);
i++;
}
}
sendOK(connData, "OK");
return HTTPD_CGI_DONE;
err:
sendOK(connData, "Error"); // FIXME
return HTTPD_CGI_DONE;
}
void SocketIOClient::socketHandshake(){
if (!client.connected()) return;
StaticJsonBuffer<DATA_BUFFER_LEN - HEADER_SIZE> jsonBuffer;
JsonObject& args = jsonBuffer.createObject();
args["message"] = "Hey Mate!";
sendJSON("handshake", args);
}
/* Private: Combine the given name and value into a JSON object (conforming to
* the OpenXC standard) and send it out to the listener.
*
* name - The value for the name field of the OpenXC message.
* value - The numerical, string or booelan for the value field of the OpenXC
* message.
* event - (Optional) The event for the event field of the OpenXC message.
* listener - The listener device to send on.
*/
void sendJSONMessage(const char* name, cJSON* value, cJSON* event,
Listener* listener) {
cJSON *root = cJSON_CreateObject();
cJSON_AddStringToObject(root, NAME_FIELD_NAME, name);
cJSON_AddItemToObject(root, VALUE_FIELD_NAME, value);
if(event != NULL) {
cJSON_AddItemToObject(root, EVENT_FIELD_NAME, event);
}
sendJSON(root, listener);
}
void passthroughCanMessage(Listener* listener, int id, uint64_t data) {
cJSON *root = cJSON_CreateObject();
cJSON_AddNumberToObject(root, ID_FIELD_NAME, id);
char encodedData[67];
union {
uint64_t whole;
uint8_t bytes[8];
} combined;
combined.whole = data;
sprintf(encodedData, "0x%02x%02x%02x%02x%02x%02x%02x%02x",
combined.bytes[0],
combined.bytes[1],
combined.bytes[2],
combined.bytes[3],
combined.bytes[4],
combined.bytes[5],
combined.bytes[6],
combined.bytes[7]);
cJSON_AddStringToObject(root, DATA_FIELD_NAME, encodedData);
sendJSON(root, listener);
}
int main(int argc, char *argv[])
{
pid_t pid = getpid();
int str_end,hash_beg,i = 0, sm, lo, rs, dr, hash_len;
char dir[200],report[1000],mdString[40]= {0}, *parcel, tmp[100], *from_str, *from_str_tmp, *hash_et, *help_ptr, *arglist_sm[100], *arglist_lo[100], *arglist_rs[100], *arglist_dr[100];
unsigned char *hash_cand = malloc(50*sizeof(char));
t_elements parsed_elements;
sprintf(dir,"%s%d_log.log",LOG_DIR,pid);
FILE *log = fopen(dir,"w");
if(log == NULL) exit(-4);
from_str_tmp = malloc(sizeof(char)*100000);
sprintf(tmp, "/tmp/%d/", pid);
mkdir(tmp, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
chdir(tmp);
fprintf(log, "PID: %d, dir changed\nthats what we got:\n", pid);
do
{
from_str_tmp[i] = getc(stdin);
fputc(from_str_tmp[i],log);
if(from_str_tmp[i] == '-' && from_str_tmp[i-1] == '-')
{
str_end=i-1;
hash_beg=i+1;
from_str_tmp[str_end]=0;
}
}
while(from_str_tmp[i++] != EOF);
hash_et = from_str_tmp + sizeof(char)*hash_beg;
hash_et[40]=0;
from_str_tmp += 8*sizeof(char);
from_str = curl_decode(from_str_tmp);
help_ptr = from_str;
from_str_tmp = decode(from_str); /*base64 conversion*/
fprintf(log,"\nAfter url_decode:%s",from_str);
//\r\n
from_str=from_str_tmp;
fprintf(log,"\nhashed string:%s\n",help_ptr);
HMAC(EVP_sha1(),SALT, strlen(SALT), (unsigned char*)help_ptr, strlen(help_ptr),hash_cand,(unsigned int*)&hash_len);
for(i = 0; i < 20; i++)
sprintf(&mdString[i*2], "%02x",hash_cand[i]);
//FIXME leaks everywhere
if(strcmp(mdString,hash_et)==0)
{
fprintf(log,"\nhash correct\n");
fprintf(log,"decoded string: %s\n", from_str);
printf("Content-Type: text/plain;charset=us-ascii\n\n");
}
else
{
fprintf(log, "%s\n%s\n hash incorrect\n",mdString,hash_et);
printf("Content-Type: text/html\nStatus: 422 Bad Request\n\n");
free(hash_cand);
free(from_str);
fclose(log);
exit(-1);
}
/*we have now string to parse*/
cJSON *root = cJSON_Parse(from_str);
if (!root)
{
fprintf(log,"Error before: [%s]\n", cJSON_GetErrorPtr());
}
fprintf(log,"exec part\n");
parse_into_elements(&parsed_elements, root, log);
fflush(NULL);
lo = make_arglist_for_login(arglist_lo, parsed_elements);
fork_exec_with_inp_redir(arglist_lo, 1, "whatever");
sm = make_arglist_for_submit_and_run(arglist_sm, parsed_elements, arglist_lo[4]);
fork_exec_with_inp_redir(arglist_sm, 1, "num.txt");
rs = make_arglist_for_run_status(arglist_rs, parsed_elements, arglist_lo[4]);
int rep_num;
if((rep_num=wait_for_report(5, arglist_rs, parsed_elements.status))==-1)
{
strcpy(parsed_elements.status,"error");
strcpy(report,"ejudge marking error");
}
else
{
int flag=0,some;
some = submit_checked(parsed_elements.status, ejudge_common);
if(strcmp(parsed_elements.status,"OK")==0)
{
strcpy(parsed_elements.status,"ok");
flag=1;
}
else if(submit_checked(parsed_elements.status, ejudge_error)!=-1)
{
strcpy(parsed_elements.status,"error");
strcpy(report,ejudge_detailed[some]);
if(some == 1) flag = 2; /*let report be when compilation error*/
}
else
{
strcpy(parsed_elements.status, "fail");
flag=1;
}
if(flag)
{
dr = make_arglist_for_dump_report(arglist_dr, parsed_elements, arglist_lo[4]); //BACKTRACE part
fork_exec_with_inp_redir(arglist_dr, 1, "return_report.xml");
/*xml parse part*/
if(flag==1){
ezxml_t trace = ezxml_parse_file("return_report.xml");
const char * points = ezxml_attr(trace, "score");
const char * tp = ezxml_attr(trace, "tests-passed");
const char * to = ezxml_attr(trace, "run-tests");
sprintf(report, "%s. Your score is = %s, %s/%s tests passed",ejudge_detailed[some], points , tp, to);
ezxml_free(trace);
/* parse part end */
/* BTW ezxml lib used so you have possibility to add smth to report */
}
else if(flag==2)
{
char *iftmp;
iftmp = read_string("return_report.xml");
strcat(report, iftmp);
free(iftmp);
}
}
}
fprintf(log, "exec part end\n");
cJSON_AddStringToObject(root, "trace", report);
cJSON_AddStringToObject(root, "status", parsed_elements.status);
cJSON_DeleteItemFromObject(root,"programming_language");
cJSON_DeleteItemFromObject(root,"file_name");
cJSON_DeleteItemFromObject(root,"file_content");
parcel = cJSON_Print(root);
fprintf(log,"output:%s\n",parcel);
free(from_str);
from_str=encode(parcel);
fprintf(log,"encoded output:%s\n", from_str);
parcel=curl_encode(from_str);
fprintf(log,"curl_encoded output:%s\n", parcel);
HMAC(EVP_sha1(),SALT, strlen(SALT), (unsigned char*)from_str, strlen(from_str),hash_cand,(unsigned int*)&hash_len);
for(i = 0; i < 20; i++)
sprintf(&mdString[i*2], "%02x", (unsigned int)hash_cand[i]);
fprintf(log,"hash HMAC:%s\n", mdString);
sprintf(from_str,"session=%s--%s",parcel,mdString);
fprintf(log,"final output:%s\n", from_str);
/*ready to send backparcel*/
sendJSON(parsed_elements.url, from_str);
sendJSON("http://ejudge.100ege.ru/cgi-bin/a.out", from_str); //FIXME: for logging purposes
//printf("%s",from_str);
/*now clean part*/
fprintf(log,"\n%s\n",from_str);
str_vector_free(arglist_lo, lo);
str_vector_free(arglist_rs, rs);
str_vector_free(arglist_sm, sm);
free(root);
free(from_str);
free(parcel);
fclose(log);
chdir("/tmp/");
execl("/bin/rm", "/bin/rm", "-rf", tmp, NULL);
return 0;
}
