t_bool do_take(t_server *s, t_user *user, char *buff)
{
int pos;
int i;
char **tab;
if ((tab = str_to_wordtab(buff, " \n")) == NULL)
return (false);
i = 0;
pos = user->y * s->option->width + user->x;
while (i < 7)
{
if (tab[1] && strcmp(s->map[pos].stone_list[i].name, tab[1]) == 0
&& s->map[pos].stone_list[i].nb > 0)
{
update_box_content(s, -1, pos);
s->map[pos].stone_list[i].nb--;
add_stone_to_user(s, user, tab[1]);
send_ok(user->fd);
gc_do_take(s, user, i);
free_wordtab(tab);
return (true);
}
++i;
}
free_wordtab(tab);
return (false);
}
static void ok_start_game(int fd)
{
struct game * g = find_game_by_fd(fd);
if (g) {
if (g->status == GAME_STATUS_PLAYING) {
int i;
for (i = 0; i < g->players_number; i++) {
if (g->players_conn[i] == fd) {
if (!g->players_started[i]) {
if (remote_proto_minor[g->players_conn[i]] >= 1)
send_ok(fd, "OK_GAME_START");
g->players_started[i] = 1;
l1(OUTPUT_TYPE_DEBUG, "[%d] entering prio mode", g->players_conn[i]);
add_prio(g->players_conn[i]);
} else {
send_line_log(fd, wn_already_ok_started, "OK_GAME_START");
}
}
}
} else {
send_line_log(fd, wn_not_started, "OK_GAME_START");
}
} else {
l0(OUTPUT_TYPE_ERROR, "Internal error");
exit(EXIT_FAILURE);
}
}
void Control_Confirmation::on_Applay_clicked()
{
if(flag){
emit send_ok(name,Is_Delay,on_off);
}
this->accept();
}
int get_objs(int fd, t_scene *scene)
{
int i;
if (send_ok(fd) || (scene->nb_obj = read_number(fd)) <= 0 ||
!(scene->objs = my_calloc(scene->nb_obj + 1, sizeof(t_obj))))
return (1);
i = 0;
while (i < scene->nb_obj)
{
write(1, "Loading objs\n", 13);
if (send_ok(fd) || read(fd, &scene->objs[i], sizeof(t_obj)) == -1)
return (1);
++i;
}
send_ok(fd);
write(1, "Obj loaded\n", 11);
return (0);
}
/** Add new RR data */
static void
do_data_add(SSL* ssl, struct worker* worker, char* arg)
{
if(!local_zones_add_RR(worker->daemon->local_zones, arg,
worker->env.scratch_buffer)) {
ssl_printf(ssl,"error in syntax or out of memory, %s\n", arg);
return;
}
send_ok(ssl);
}
/** do the verbosity command */
static void
do_verbosity(SSL* ssl, char* str)
{
int val = atoi(str);
if(val == 0 && strcmp(str, "0") != 0) {
ssl_printf(ssl, "error in verbosity number syntax: %s\n", str);
return;
}
verbosity = val;
send_ok(ssl);
}
static void kick_player(int fd, struct game * g, char * nick)
{
int i;
for (i = 0; i < g->players_number; i++) {
if (g->players_conn[i] != fd && streq(g->players_nick[i], nick)) {
send_ok(fd, "KICK");
send_line_log_push(g->players_conn[i], "KICKED");
player_part_game_(g->players_conn[i], ok_player_kicked);
return;
}
}
send_line_log(fd, wn_no_such_player, "KICK");
}
/** Remove RR data */
static void
do_data_remove(SSL* ssl, struct worker* worker, char* arg)
{
uint8_t* nm;
int nmlabs;
size_t nmlen;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return;
local_zones_del_data(worker->daemon->local_zones, nm,
nmlen, nmlabs, LDNS_RR_CLASS_IN);
free(nm);
send_ok(ssl);
}
/** Add a new zone */
static void
do_zone_add(SSL* ssl, struct worker* worker, char* arg)
{
uint8_t* nm;
int nmlabs;
size_t nmlen;
char* arg2;
enum localzone_type t;
struct local_zone* z;
if(!find_arg2(ssl, arg, &arg2))
return;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return;
if(!local_zone_str2type(arg2, &t)) {
ssl_printf(ssl, "error not a zone type. %s\n", arg2);
free(nm);
return;
}
lock_quick_lock(&worker->daemon->local_zones->lock);
if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen,
nmlabs, LDNS_RR_CLASS_IN))) {
/* already present in tree */
lock_rw_wrlock(&z->lock);
z->type = t; /* update type anyway */
lock_rw_unlock(&z->lock);
free(nm);
lock_quick_unlock(&worker->daemon->local_zones->lock);
send_ok(ssl);
return;
}
if(!local_zones_add_zone(worker->daemon->local_zones, nm, nmlen,
nmlabs, LDNS_RR_CLASS_IN, t)) {
lock_quick_unlock(&worker->daemon->local_zones->lock);
ssl_printf(ssl, "error out of memory\n");
return;
}
lock_quick_unlock(&worker->daemon->local_zones->lock);
send_ok(ssl);
}
/** flush a type */
static void
do_flush_type(SSL* ssl, struct worker* worker, char* arg)
{
uint8_t* nm;
int nmlabs;
size_t nmlen;
char* arg2;
uint16_t t;
if(!find_arg2(ssl, arg, &arg2))
return;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return;
t = ldns_get_rr_type_by_name(arg2);
do_cache_remove(worker, nm, nmlen, t, LDNS_RR_CLASS_IN);
free(nm);
send_ok(ssl);
}
int do_dirlist(const char * name, http_state_t * hs, file_t f) {
char * dl, *dlout;
dirent_t * d;
int dlsize, r;
dl = malloc(65536);
dlout = dl;
sprintf(dlout, "<html><head><title>Listing of %s</title></head></html>\n<body bgcolor=\"white\">\n", name);
dlout += strlen(dlout);
sprintf(dlout, "<h4>Listing of %s</h4>\n<hr>\n<table>\n", name);
dlout += strlen(dlout);
while ((d = fs_readdir(f))) {
if (d->size >= 0) {
sprintf(dlout, "<tr><td><a href=\"%s\">%s</a></td><td>%d</td></tr>\n", d->name, d->name, d->size);
dlout += strlen(dlout);
} else {
sprintf(dlout, "<tr><td><a href=\"%s/\">%s/</a></td><td>%d</td></tr>\n", d->name, d->name, d->size);
dlout += strlen(dlout);
}
}
sprintf(dlout, "</table>\n<hr>\nKOSHttp/1.0 server\n</body></html>\n");
dlout += strlen(dlout);
dlsize = strlen(dl);
send_ok(hs, "text/html");
dlout = dl;
while (dlsize > 0) {
r = write(hs->socket, dlout, dlsize);
if (r <= 0)
return -1;
dlsize -= r;
dlout += r;
}
free(dl);
return 0;
}
/** Remove a zone */
static void
do_zone_remove(SSL* ssl, struct worker* worker, char* arg)
{
uint8_t* nm;
int nmlabs;
size_t nmlen;
struct local_zone* z;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return;
lock_quick_lock(&worker->daemon->local_zones->lock);
if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen,
nmlabs, LDNS_RR_CLASS_IN))) {
/* present in tree */
local_zones_del_zone(worker->daemon->local_zones, z);
}
lock_quick_unlock(&worker->daemon->local_zones->lock);
free(nm);
send_ok(ssl);
}
static void close_game(int fd)
{
struct game * g = find_game_by_fd(fd);
if (g) {
if (g->players_conn[0] == fd) {
if (g->players_number == 1) {
send_line_log(fd, wn_alone_in_the_dark, "CLOSE");
return;
}
send_ok(fd, "CLOSE");
g->status = GAME_STATUS_CLOSED;
calculate_list_games();
} else {
send_line_log(fd, wn_not_creator, "CLOSE");
}
} else {
l0(OUTPUT_TYPE_ERROR, "Internal error");
exit(EXIT_FAILURE);
}
}
static void
msn_xfer_init(PurpleXfer *xfer)
{
MsnSlpCall *slpcall;
/* MsnSlpLink *slplink; */
char *content;
pecan_info ("xfer_init");
slpcall = xfer->data;
/* Send Ok */
content = pecan_strdup_printf("SessionID: %lu\r\n\r\n",
slpcall->session_id);
send_ok(slpcall, slpcall->branch, "application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
msn_slplink_unleash(slpcall->slplink);
}
/** remove name rrset from cache */
static void
do_flush_name(SSL* ssl, struct worker* w, char* arg)
{
uint8_t* nm;
int nmlabs;
size_t nmlen;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return;
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_AAAA, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NS, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SOA, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_CNAME, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_DNAME, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_MX, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_PTR, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SRV, LDNS_RR_CLASS_IN);
do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NAPTR, LDNS_RR_CLASS_IN);
free(nm);
send_ok(ssl);
}
static void start_game(int fd)
{
struct game * g = find_game_by_fd(fd);
if (g) {
if (g->players_conn[0] == fd) {
if (g->players_number == 1) {
send_line_log(fd, wn_alone_in_the_dark, "START");
return;
}
send_ok(fd, "START");
real_start_game(g);
calculate_list_games();
l2(OUTPUT_TYPE_INFO, "running games increments to: %d (%d players)", games_running, players_in_game);
} else {
send_line_log(fd, wn_not_creator, "START");
}
} else {
l0(OUTPUT_TYPE_ERROR, "Internal error");
exit(EXIT_FAILURE);
}
}
static void setoptions(int fd, char* options)
{
struct game * g = find_game_by_fd(fd);
if (g) {
if (g->players_conn[0] == fd) {
int i;
char* msg;
send_ok(fd, "SETOPTIONS");
msg = asprintf_("OPTIONS: %s,PROTOCOLLEVEL:%d", options, min_protocol_level(g));
for (i = 0; i < g->players_number; i++)
if (remote_proto_minor[g->players_conn[i]] >= 1)
send_line_log_push(g->players_conn[i], msg);
free(msg);
} else {
send_line_log(fd, wn_not_creator, "SETOPTIONS");
}
} else {
l0(OUTPUT_TYPE_ERROR, "Internal error");
exit(EXIT_FAILURE);
}
}
static void leader_check_game_start(int fd)
{
struct game * g = find_game_by_fd(fd);
if (g) {
if (g->status == GAME_STATUS_PLAYING) {
int i;
for (i = 0; i < g->players_number; i++) {
if (fd != g->players_conn[i]) {
if (!g->players_started[i]) {
send_line_log(fd, wn_others_not_ready, "LEADER_CHECK_GAME_START");
return;
}
}
}
send_ok(fd, "LEADER_CHECK_GAME_START");
} else {
send_line_log(fd, wn_not_started, "LEADER_CHECK_GAME_START");
}
} else {
l0(OUTPUT_TYPE_ERROR, "Internal error");
exit(EXIT_FAILURE);
}
}
static void
handler (ShpHttpRequest request, const gchar * path, const gchar * query,
GSocketConnection * connection, gpointer user_data)
{
ShpRest *self = SHP_REST (user_data);
GOutputStream *out;
g_debug ("rest: incomming connection");
out = g_io_stream_get_output_stream (G_IO_STREAM (connection));
if (request != SHP_HTTP_GET && request != SHP_HTTP_POST) {
g_debug ("rest: unsupported request type");
send_error (out, 400, "Invalid request");
return;
}
g_debug ("rest: path: %s, query: %s", path, query);
if (request == SHP_HTTP_GET && query == NULL) {
/* no query, just collect data for all sensors belonging to requested
* path */
ShpJsonNode *node;
ResponseData *response_data;
node = shp_json_node_new_object (NULL);
response_data = g_new0 (ResponseData, 1);
response_data->node = node;
response_data->path = (gchar *)path;
g_mutex_lock (&self->mutex);
g_hash_table_foreach (self->devices, json_builder_add_device_objects,
response_data);
g_mutex_unlock (&self->mutex);
g_free (response_data);
send_ok (out, node);
shp_json_node_free (node);
} else if (request == SHP_HTTP_GET) {
/* create request based on input command */
ShpMessage *event;
/* first check if requested path is valid and we know about it */
g_mutex_lock (&self->mutex);
event = g_hash_table_lookup (self->devices, path);
if (event)
event = g_object_ref (event);
g_mutex_unlock (&self->mutex);
if (!event) {
send_error (out, 400, "Invalid request");
goto out;
}
if (!g_strcmp0 (query, "history")) {
ShpJsonNode *node;
ShpJsonNode *array_node;
ShpJsonNode *object;
GPtrArray *arr;
node = shp_json_node_new_object (NULL);
array_node = shp_json_node_new_array (path);
shp_json_node_append_element (node, array_node);
object = shp_json_node_new_object (NULL);
shp_message_foreach (event, json_builder_add_event_elements, object);
shp_json_node_append_element (array_node, object);
g_object_unref (event);
arr = g_hash_table_lookup (self->history, path);
if (arr) {
gint i;
for (i = 0; i < arr->len; i++) {
event = g_ptr_array_index (arr, i);
object = shp_json_node_new_object (NULL);
shp_message_foreach (event, json_builder_add_event_elements, object);
shp_json_node_append_element (array_node, object);
}
}
send_ok (out, node);
shp_json_node_free (node);
} else {
send_error (out, 400, "Invalid request");
g_object_unref (event);
goto out;
}
} else if (request == SHP_HTTP_POST) {
gchar *event_str;
ShpMessage *event;
ShpJsonNode *object;
event = shp_message_new_command (path);
if (!event) {
send_error (out, 400, "Invalid request");
goto out;
}
event_str = shp_message_to_string (event);
g_debug ("rest: about to post: %s", event_str);
g_free (event_str);
object = shp_json_node_new_object (NULL);
send_ok (out, object);
shp_json_node_free (object);
shp_component_post_message (SHP_COMPONENT (self), event);
}
out:
return;
}
/** flush requestlist */
static void
do_flush_requestlist(SSL* ssl, struct worker* worker)
{
mesh_delete_all(worker->env.mesh);
send_ok(ssl);
}
/** flush statistics */
static void
do_flush_stats(SSL* ssl, struct worker* worker)
{
worker_stats_clear(worker);
send_ok(ssl);
}
int main(int argc, char **argv)
{
ETERM *tuplep;
ETERM *fnp, *argp;
byte buf[1024];
sqlite3 *db;
char *zErrMsg = 0;
int rc;
log = fopen("/tmp/sqlite_port.log", "a+");
fprintf(log, "******start log (%s)******\n", argv[1]);
fflush(log);
rc = sqlite3_open(argv[1], &db);
if (rc) {
sqlite3_close(db);
exit(1);
}
erl_init(NULL, 0);
while (read_cmd(buf) > 0) {
tuplep = erl_decode(buf);
fnp = erl_element(1, tuplep);
argp = erl_element(2, tuplep);
if (strncmp((const char *)ERL_ATOM_PTR(fnp), "close", 5) == 0) {
fprintf(log, "closing sqlite3_close\n");
fflush(log);
sqlite3_close(db);
break;
}
else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "list_tables", 11) == 0) {
fprintf(log, "calling list_tables\n");
result = 0;
rc = sqlite3_exec(db, MASTER_QUERY, list_tables, 0, &zErrMsg);
if (rc != SQLITE_OK) {
send_error(zErrMsg);
sqlite3_free(zErrMsg);
}
else if (result != 0) {
send_result();
}
else {
// not an error and no results. still need to return something
send_ok();
}
fflush(log);
}
else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "sql_exec", 8) == 0) {
fprintf(log, "calling sqlite3_exec %s\n", erl_iolist_to_string(argp));
result = 0;
rc = sqlite3_exec(db, erl_iolist_to_string(argp), callback, 0, &zErrMsg);
if (rc != SQLITE_OK) {
send_error(zErrMsg);
sqlite3_free(zErrMsg);
}
else if (result != 0) {
send_result();
}
else {
// not an error and no results. still need to return something
send_ok();
}
fflush(log);
}
erl_free_compound(tuplep);
erl_free_term(fnp);
erl_free_term(argp);
}
fprintf(log, "******end log******\n");
fclose(log);
return 0;
}
static void do_set_cfg(void* arg)
{
PortState* state = (PortState*)arg;
erl_drv_mutex_lock(G_ENGINE_STATE_LOCK);
if (G_ENGINE_STATE == ENGINE_STOPPED)
{
char* key = UNPACK_STRING(state->work_buffer, 0);
const char* value = UNPACK_STRING(state->work_buffer, strlen(key)+1);
if (strcmp(key, "error_log") == 0)
{
if (set_log_file(value) == 0)
{
send_ok(state);
}
else
{
send_error_atom(state, "einval");
}
}
else
{
// Check the expected type of the provided key so as to 1. validate it's a good key
// and 2. know what setter to use.
ib_cfg_type_t key_type;
ib_err_t error = ib_cfg_var_get_type(key, &key_type);
if (error == DB_SUCCESS)
{
if (key_type == IB_CFG_TEXT)
{
// HACK: Semantics of setting a text configuration value for innodb changed
// to be pointer assignment (from copy) for vsn 1.0.6.6750. So, we strdup the
// value to ensure everything works as expected.
// TODO: Setup some sort of list of strdup'd values to ensure they all get
// cleaned up properly. In typical usage, this isn't going to be a problem
// as you only initialize once per run, but it bothers me just the same.
error = ib_cfg_set(key, strdup(value));
}
else
{
ErlDrvUInt value_i;
UNPACK_INT(state->work_buffer, strlen(key)+1, &value_i);
error = ib_cfg_set(key, value_i);
}
}
if (error == DB_SUCCESS)
{
send_ok(state);
}
else
{
send_error_str(state, ib_strerror(error));
}
}
}
else
{
send_error_atom(state, "starting");
}
erl_drv_mutex_unlock(G_ENGINE_STATE_LOCK);
}
static int parse_client_line(const int client_socket, char *msg)
{
char *token;
/* On récupère le premier mot, s'il est vide, on retourne direct */
if (!(token = strtok(msg, " ")))
return MSG_OK;
/*****************************************************************************
* CMD_QUIT
****************************************************************************/
if (!strcmp(CMD_QUIT, token))
{
send_ok(client_socket, DETAIL_RET_QUIT);
return MSG_QUIT;
}
/*****************************************************************************
* CMD_CREATE_PROCESS
****************************************************************************/
else if (!strcmp(CMD_CREATE_PROCESS, token))
{
char *args[MAX_ARGS];
char **pc = args;
/* On récup le nom du prog */
if (!(token = strtok(NULL, " ")))
{
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_SYNTAX);
return MSG_ERR;
}
/* strtok renvoie un buffer static, on le copie */
/* *pc = args[0] = nom du programme */
if (!(*pc++ = strdup(token)))
{
perror("strdup");
return MSG_ERR;
}
/* La suite devient optionelle, c'est les arguments */
while ((token = strtok(NULL, " ")))
{
if ((*pc++ = strdup(token)) == NULL)
{
perror("strdup");
return MSG_ERR;
}
}
*pc = NULL; /* Fin des arguments */
/* On crée le processus */
pid_t proc = create_process(args[0], args);
/* Le processus n'a pas pu être créé */
if (proc == -1) {
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(proc));
return MSG_OK;
}
/*****************************************************************************
* CMD_DESTROY_PROCESS
****************************************************************************/
else if (!strcmp(CMD_DESTROY_PROCESS, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_DESTROY_PROCESS_SYNTAX);
return MSG_ERR;
}
pid_t process_to_kill = atoi(token);
if (!process_exists(process_to_kill))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
destroy_process(process_to_kill);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_SEND_INPUT
****************************************************************************/
else if (!strcmp(CMD_SEND_INPUT, token))
{
char buffer[MESSAGE_BUFFER_SIZE];
buffer[0] = '\0';
/* On récup le PID */
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Il existe ? */
pid_t send_to_process = atoi(token);
if (!process_exists(send_to_process))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
/* Il est déjà terminé ? */
if (get_return_code(send_to_process) != PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_PROCESS_TERMINATED);
return MSG_ERR;
}
/* Son stdin est ouvert ? */
if (!input_open(send_to_process))
{
send_failure(client_socket, DETAIL_RET_INPUT_CLOSE);
return MSG_ERR;
}
/* On récup' le message à envoyer */
/* TODO: Prendre la chaîne telle qu'elle, sans splitter puis merger avec un espace */
while ((token = strtok(NULL, " ")))
{
strcat(buffer, token);
strcat(buffer, " ");
}
/* Si le message est vide, erreur ! */
if (strlen(buffer) == 0)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Sinon on envoie ! */
send_input(send_to_process, buffer);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_CLOSE_INPUT
****************************************************************************/
else if (!strcmp(CMD_CLOSE_INPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_CLOSE_INPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_close_input = atoi(token);
if (!process_exists(process_to_close_input))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
close_input(process_to_close_input);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_OUTPUT
****************************************************************************/
else if (!strcmp(CMD_GET_OUTPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_OUTPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_output = atoi(token);
if (!process_exists(process_to_get_output))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_output(client_socket, process_to_get_output);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_ERROR
****************************************************************************/
else if (!strcmp(CMD_GET_ERROR, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_ERROR_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_error = atoi(token);
if (!process_exists(process_to_get_error))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_error(client_socket, process_to_get_error);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_RETURN_CODE
****************************************************************************/
else if (!strcmp(CMD_GET_RETURN_CODE, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_ret = atoi(token);
if (!process_exists(process_to_get_ret))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
int ret = get_return_code(process_to_get_ret);
if (ret == PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(ret));
return MSG_OK;
}
/*****************************************************************************
* CMD_LIST_PROCESS
****************************************************************************/
else if (!strcmp(CMD_LIST_PROCESS, token))
{
list_process(client_socket);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_HELP
****************************************************************************/
else if (!strcmp(CMD_GET_HELP, token))
{
send_basic(client_socket, help, strlen(help));
return MSG_OK;
}
/*****************************************************************************
* COMMANDE INCONNUE
****************************************************************************/
else
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_COMMAND);
return MSG_UNKNOWN_COMMAND;
}
}
/* On success, return socket_fd for UDP socket.
* On failure, exit.
*/
int init_receiver()
{
/* 1. Make sure we can talk to parent (client control process) */
printf("Trying to open client channel\n");
open_client_channel(&ctrl2rcvr_qid);
/**** YOUR CODE TO FILL IMPLEMENT STEPS 2 AND 3 ****/
/* 2. Initialize UDP socket for receiving chat messages. */
//L: We need to ask the OS for an available UDP port.
// This may be a random port-number currently available, not the one we specified by command line.
// This is the port that the server should send a reply to.
int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) {
perror("RECEIVER ERROR: Failed to open socket. Sorry bro.\n");
send_error(ctrl2rcvr_qid, SOCKET_FAILED);
exit(EXIT_FAILURE);
}
// L: set socket so that it can be re-used if client is killed:
int optval = 1; //option value. (not optional value)
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof (int)) == -1) {
perror("RECEIVER ERROR: Failed to set tocket options. Sorry bro\n");
send_error(ctrl2rcvr_qid, SOCKET_OPTION_FAILED);
exit(EXIT_FAILURE);
}
// L: Configure to use any local ip address, and request port from OS.
struct sockaddr_in server_addr;
socklen_t server_addr_len = sizeof(server_addr);
memset((char *) &server_addr, '\0', sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // Bind to any available IP address on local host.
server_addr.sin_port = 0; // Request port from OS.
if (bind(sockfd, (struct sockaddr *) & server_addr, server_addr_len) < 0) {
perror("RECEIVER ERROR: Failed to bind socket. Sorry bro\n");
send_error(ctrl2rcvr_qid, BIND_FAILED);
exit(EXIT_FAILURE);
}
// find out which port the OS has given us.
if( getsockname(sockfd, (struct sockaddr *)&server_addr, &server_addr_len) < 0 ) {
perror("RECEIVER ERROR: getsockname failed. Sorry bro\n");
send_error(ctrl2rcvr_qid, NAME_FAILED);
exit(EXIT_FAILURE);
}
u_int16_t os_assigned_udp_port = ntohs(server_addr.sin_port);
#ifdef DEBUG
printf("client receiver listening on UDP port: %d\n", (unsigned) os_assigned_udp_port);
#endif
/* 3. Tell parent the port number if successful, or failure code if not.
* Use the send_error and send_ok functions
*/
send_ok(ctrl2rcvr_qid, os_assigned_udp_port);
return sockfd;
}
//! process a request message
static index_error process_request ( index_data_t *index_data_,
void *server, void *data, size_t data_sz)
{ dbg_message (__func__);
index_error errcode = FUNC_OK;
// decode the message
AiTownIndex * incoming = AiTownIndex__unpack (data_sz, data);
if ( incoming == NULL ) {
send_error (server, "Error decoding incoming message");
return FUNC_OK;
}
// check the version - the only one that we know of is 1
if ( incoming->version != 1 ) {
send_error (server, "Unsupported version");
AiTownIndex__free_unpacked (incoming);
return FUNC_OK;
}
// type based processing
switch ( incoming->type ) {
case AI_TOWN_INDEX_MESSAGE_TYPE__AITMT_INDEX_ADD: {
// check the sanity of incoming data
if ( ( incoming->add == NULL ) ||
( incoming->add->name == NULL ) ||
( incoming->add->address == NULL ) ||
( !incoming->add->has_port ) ||
( incoming->add->port <= 0 ) ) {
send_error (server, "Malformed add request");
break;
}
// allocate a new server structure for this
server_data_t * sd;
server_data_t * sd_other;
errcode = server_data_new (&sd, incoming->add->name,
incoming->add->address, incoming->add->port);
if ( errcode != FUNC_OK ) {
send_error (server, "Internal error");
break;
}
// see if a server with this name already exists and remove it if so
sd_other = index_data_get_server (index_data_, sd->name);
if ( sd_other != NULL ) {
index_data_rem_server (index_data_, sd_other );
server_data_delete (&sd_other);
}
index_data_add_server (index_data_, sd);
log_message ("Added server %s", sd->name);
send_ok (server);
break; }
case AI_TOWN_INDEX_MESSAGE_TYPE__AITMT_INDEX_REM: {
// check the sanity of incoming data
if ( ( incoming->rem == NULL ) ||
( incoming->rem->name == NULL ) ) {
send_error (server, "Malformed remove request");
break;
}
// find the server in question
const char * name = incoming->rem->name;
server_data_t * sd;
sd = index_data_get_server (index_data_, name);
// and remove it
if ( sd == NULL ) {
send_error (server, "Attempt to close unexisting server");
err_message (name);
} else {
index_data_rem_server (index_data_, sd );
server_data_delete (&sd);
log_message ("Removed server %s", name);
send_ok (server);
}
break; }
case AI_TOWN_INDEX_MESSAGE_TYPE__AITMT_INDEX_LIST: {
send_list (index_data_, server);
break; }
default:
send_error (server, "Unknown incoming message type");
err_message( "Requested type was %d", incoming->type );
}
// release serialized data
AiTownIndex__free_unpacked (incoming);
return errcode;
}
void client_thread(void *p) {
http_state_t * hs = (http_state_t *)p;
char * buf, * ext;
const char * ct;
file_t f = -1;
int r, o, cnt;
stat_t st;
printf("httpd: client thread started, sock %d\n", hs->socket);
buf = malloc(BUFSIZE);
if (read_headers(hs, buf, BUFSIZE) < 0) {
goto out;
}
printf("httpd: client requested '%s'\n", buf);
// Is it a directory or a file?
f = fs_open(buf, O_RDONLY | O_DIR);
if (f >= 0) {
do_dirlist(buf, hs, f);
} else {
f = fs_open(buf, O_RDONLY);
if (f < 0) {
send_error(hs, 404, "File not found or unreadable");
goto out;
}
ext = strrchr(buf, '.');
ct = "application/octet-stream";
if (ext) {
ext++;
if (!strcasecmp(ext, "jpg"))
ct = "image/jpeg";
else if (!strcasecmp(ext, "png"))
ct = "image/png";
else if (!strcasecmp(ext, "gif"))
ct = "image/gif";
else if (!strcasecmp(ext, "txt"))
ct = "text/plain";
else if (!strcasecmp(ext, "mp3"))
ct = "audio/mpeg";
else if (!strcasecmp(ext, "ogg"))
ct = "application/ogg";
else if (!strcasecmp(ext, "html"))
ct = "text/html";
}
send_ok(hs, ct);
while ((cnt = fs_read(f, buf, BUFSIZE)) != 0) {
o = 0;
while (cnt > 0) {
r = write(hs->socket, buf+o, cnt);
if (r <= 0)
goto out;
cnt -= r;
o += r;
}
}
}
fs_close(f);
out:
free(buf);
printf("httpd: closed client connection %d\n", hs->socket);
close(hs->socket);
st_destroy(hs);
if (f >= 0)
fs_close(f);
}
static void
web_handler (ShpHttpRequest request, const gchar * path, const gchar * query,
GSocketConnection * connection, gpointer user_data)
{
ShpRest *self = SHP_REST (user_data);
GFile *file;
GFileInputStream *input_stream;
GDataInputStream *data;
GError *error = NULL;
GOutputStream *out;
gchar *line;
ShpJsonNode *node;
out = g_io_stream_get_output_stream (G_IO_STREAM (connection));
if (request != SHP_HTTP_GET) {
g_debug ("rest: unsupported request type");
send_error (out, 400, "Invalid request");
return;
}
if (self->config_file == NULL) {
g_warning ("rest: config file not specified");
send_error (out, 500, "Internal server error");
return;
}
/* FIXME: load file at start */
file = g_file_new_for_path (self->config_file);
input_stream = g_file_read (file, NULL, &error);
if (!input_stream) {
g_warning ("rest: error reading config file: %s", error->message);
g_clear_error (&error);
send_error (out, 500, "Internal server error");
return;
}
data = g_data_input_stream_new (G_INPUT_STREAM (input_stream));
node = shp_json_node_new_object (NULL);
while (TRUE) {
guint i;
gchar **options_list;
ShpJsonNode *obj = NULL;
ShpJsonNode *arr = NULL;
//plugin:device-type:type1,option1:type2,option2
line = g_data_input_stream_read_line (data, NULL, NULL, NULL);
if (!line)
break;
g_debug ("rest: config file line: %s", line);
options_list = g_strsplit (line, ":", 0);
for (i = 0; options_list[i] != NULL; i++) {
ShpJsonNode *child;
ShpJsonNode *grand_child;
gchar **params;
switch (i) {
case 0:
obj = shp_json_node_new_object (options_list[i]);
break;
case 1:
child = shp_json_node_new_string ("device-type", options_list[i]);
shp_json_node_append_element (obj, child);
break;
case 2:
arr = shp_json_node_new_array ("display-options");
/* fall trhough */
default:
params = g_strsplit (options_list[i], " ", 0);
if (params && params[0] && params[1] && !params[2]) {
child = shp_json_node_new_object (NULL);
grand_child = shp_json_node_new_string ("option", params[0]);
shp_json_node_append_element (child, grand_child);
grand_child = shp_json_node_new_string ("type", params[1]);
shp_json_node_append_element (child, grand_child);
shp_json_node_append_element (arr, child);
}
g_strfreev (params);
break;
}
}
g_strfreev (options_list);
if (obj != NULL) {
if (arr != NULL)
shp_json_node_append_element (obj, arr);
shp_json_node_append_element (node, obj);
}
g_free (line);
}
g_object_unref (input_stream);
g_object_unref (file);
send_ok (out, node);
shp_json_node_free (node);
}
void exec_002(int conn, char *str)
{
int waitb, n;
sigset_t mask, oldmask;
pid_t pid;
long code;
if (!have_authorization)
{
send_int(conn, MR_PERM);
return;
}
if (config_lookup("noexec"))
{
send_int(conn, EPERM);
com_err(whoami, EPERM, "Not allowed to execute");
return;
}
str += 8;
while (*str == ' ')
str++;
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, &oldmask);
pid = fork();
switch (pid)
{
case -1:
n = errno;
sigprocmask(SIG_UNBLOCK, &oldmask, &mask);
com_err(whoami, n, ": can't fork to run install script");
code = send_int(conn, n);
if (code)
exit(1);
return;
case 0:
if (setuid(uid) < 0)
{
com_err(whoami, errno, "Unable to setuid to %d\n", uid);
exit(1);
}
sigprocmask(SIG_UNBLOCK, &oldmask, &mask);
execlp(str, str, NULL);
n = errno;
sigprocmask(SIG_UNBLOCK, &oldmask, &mask);
com_err(whoami, n, ": %s", str);
send_int(conn, n);
exit(1);
default:
do
n = wait(&waitb);
while (n != -1 && n != pid);
sigprocmask(SIG_UNBLOCK, &oldmask, &mask);
if ((WIFEXITED(waitb) && (WEXITSTATUS(waitb) != 0)) ||
WIFSIGNALED(waitb))
{
if (WIFSIGNALED(waitb))
{
n = MR_COREDUMP;
com_err(whoami, n, " child exited on signal %d",
WTERMSIG(waitb));
}
else
{
n = WEXITSTATUS(waitb) + ERROR_TABLE_BASE_sms;
com_err(whoami, n, " child exited with status %d",
WEXITSTATUS(waitb));
}
code = send_int(conn, n);
if (code)
exit(1);
}
else
{
code = send_ok(conn);
if (code)
exit(1);
}
}
return;
}
void ICACHE_FLASH_ATTR server_recv_cb(void *arg, char *http_raw, unsigned short length) {
struct espconn *pespconn = (struct espconn *)arg;
//print("[server_recv_cb] Received data:");
char method[10];
char path[60];
char headers[60];
char body[256];
parse_http(http_raw, length, method, path, headers, body);
int GET = (os_strcmp(method, "GET") == 0);
int POST = (os_strcmp(method, "POST") == 0);
if (GET) { // No body if not [post/put/patch]ing
// Static files
if (os_strcmp(path, "/base.css") == 0) { send_ok(pespconn, base_css); }
else if (os_strcmp(path, "/connect.js") == 0) { send_ok(pespconn, connect_js); }
else if (os_strcmp(path, "/register.js") == 0) { send_ok(pespconn, register_js); }
// JSON responses
else if (os_strcmp(path, "/connection.json") == 0) {
int station_connect_status = wifi_station_get_connect_status();
if (station_connect_status == STATION_GOT_IP) {
struct ip_info ipConfig;
wifi_get_ip_info(STATION_IF, &ipConfig);
char json_str[54];
os_sprintf(json_str, "{\"status\": \"connected\", \"ip\": \"%d.%d.%d.%d\"}", IP2STR(&ipConfig.ip));
send_json(pespconn, json_str);
}
else {
char *status_str;
if (connection_status == CONNECTION_UNCONFIGURED) status_str = "unconfigured";
else
switch (station_connect_status) {
case STATION_CONNECTING: status_str = "connecting"; break;
case STATION_WRONG_PASSWORD: status_str = "failed"; break;
case STATION_NO_AP_FOUND: status_str = "failed"; break;
case STATION_CONNECT_FAIL: status_str = "failed"; break;
}
char json_str[54];
os_sprintf(json_str, "{\"status\": \"%s\"}", status_str);
send_json(pespconn, json_str);
}
}
else if (os_strcmp(path, "/registration.json") == 0) {
char *status_str;
switch (registration_status) {
case REGISTER_UNREGISTERED: status_str = "unregistered"; break;
case REGISTER_REGISTERING: status_str = "registering"; break;
case REGISTER_REGISTERED: status_str = "registered"; break;
case REGISTER_FAILED: status_str = "failed"; break;
}
char json_str[54];
os_sprintf(json_str, "{\"status\": \"%s\"}", status_str);
send_json(pespconn, json_str);
}
// HTML pages
else if (os_strcmp(path, "/read") == 0) {
if (registration_status == REGISTER_REGISTERED) {
char temp_json_str[128];
char hum_json_str[128];
measurement_json(temp_json_str, "temperature", "F", last_temp);
measurement_json(hum_json_str, "humidity", "%", last_hum);
char full_json_str[256] = "";
strcat(full_json_str, temp_json_str);
strcat(full_json_str, hum_json_str);
full_json_str[os_strlen(temp_json_str)+os_strlen(hum_json_str)] = 0;
send_ok_templated(pespconn, full_json_str);
} else {
send_ok_templated(pespconn, last_unknown);
}
}
else if (os_strcmp(path, "/register") == 0) {
send_ok_templated(pespconn, register_html);
}
else if (os_strcmp(path, "/scan.json") == 0) {
char json_str[256] = "[";
int si = 0;
for (; si < n_scanned; si++) {
char json_obj[100];
os_sprintf(json_obj, "{\"ssid\": \"%s\", \"rssi\": %d}", scanned_stations[si], scanned_dbs[si]);
os_strcat(json_str, json_obj);
if (si < n_scanned - 1) {
os_strcat(json_str, ",");
} else {
os_strcat(json_str, "]");
}
}
send_json(pespconn, json_str);
}
else if (os_strcmp(path, "/") == 0) {
send_ok_templated(pespconn, index_html);
}
else {
send_404(pespconn);
}
return;
}
else if (POST) {
// Parse JSON with jsmn
jsmn_parser parser;
jsmn_init(&parser);
jsmntok_t tokens[32];
jsmnerr_t r;
r = jsmn_parse(&parser, body, 1024, tokens, 256);
if (r < 0) {
//print("JSON Parse error?");
return;
}
// Look for ssid and pass
char station_ssid[20];
char station_pass[20];
//print("JSON Parse success?");
if (os_strcmp(path, "/connect.json") == 0) {
// Parse ssid and pass from JSON
int ti = 0;
int has_ssid = 0;
int has_pass = 0;
int on_ssid = 0;
int on_pass = 0;
for(; tokens[ti].end; ti++) {
char tv[256];
token_string(tv, body, tokens[ti]);
if (on_ssid) {
//print("Found ssid");
on_ssid = 0;
os_strcpy(station_ssid, tv);
has_ssid = 1;
}
if (on_pass) {
//print("Found pass");
on_pass = 0;
os_strcpy(station_pass, tv);
has_pass = 1;
if (has_ssid) { break; }
}
on_ssid = ti % 2 == 1 && os_strcmp(tv, "ssid") == 0;
on_pass = ti % 2 == 1 && os_strcmp(tv, "pass") == 0;
}
//ets_uart_printf("Hopefully ssid=%s and pass=%s\r\n", station_ssid, station_pass);
send_ok(pespconn, "<h1>maia</h1><p>OK</p>");
setup_station(station_ssid, station_pass);
}
else if (os_strcmp(path, "/register.json") == 0) {
// Parse email and password from JSON
int ti = 0;
char user_email[64];
char user_password[64];
int has_email = 0;
int has_password = 0;
int on_email = 0;
int on_password = 0;
for(; tokens[ti].end; ti++) {
char tv[256];
token_string(tv, body, tokens[ti]);
if (on_email) {
//print("Found email");
on_email = 0;
os_strcpy(user_email, tv);
has_email = 1;
}
if (on_password) {
//print("Found password");
on_password = 0;
os_strcpy(user_password, tv);
has_password = 1;
if (has_email) { break; }
}
on_email = ti % 2 == 1 && os_strcmp(tv, "email") == 0;
on_password = ti % 2 == 1 && os_strcmp(tv, "password") == 0;
}
char register_response[256];
os_sprintf(register_response, "Registering as %d...", DEVICE_ID);
send_ok_templated(pespconn, register_response);
char register_json[256];
os_sprintf(register_json, "{"
"\"device_id\": \"0x%x\","
"\"kind\": \"%s\","
"\"email\": \"%s\","
"\"password\": \"%s\""
"}", DEVICE_ID, DEVICE_KIND, user_email, user_password);
registration_status = REGISTER_REGISTERING;
post_json(API_BASE "/devices.json", register_json);
}
else {
send_404(pespconn);
}
return;
}
send_404(pespconn);
return;
}
