bool
voir(t_cli *c, t_msg UNUSED(*msg))
{
int i;
char *buffer;
ERR(PINK"[%s], client %d from team '%s'\n"WHITE,
__func__, c->sock.fd, c->team->name);
i = 0;
if (!(buffer = malloc(VOIR_BUFFER_SIZE)))
return (perror("malloc()"), false);
*buffer = '\0';
g_i = &i;
g_buffer = buffer;
print_str_to_buffer("{");
if (c->direction == UP || c->direction == DOWN)
up_down(c);
else
left_right(c);
print_str_to_buffer("}\n");
enqueue_msg(c, buffer);
free(buffer);
return (true);
}
//
// I capped the max speed at µms.
//
bool
sst(t_cli *c, t_msg *msg)
{
char buff[32];
int i;
uint64_t new_time;
i = 0;
memset(buff, 0, 32);
if (msg == NULL || msg->params == NULL || msg->params->first == NULL ||
msg->params->first->data == NULL ||
(new_time = atol((char *)msg->params->first->data)) == 0)
{
ERR(PINK"[%s], client %d from team '%s'\n"WHITE,
__func__, c->sock.fd, c->team->name);
ERR(RED" invalid parameter\n"WHITE);
return (false);
}
if (new_time <= 1000000)
c->servptr->opt->time = new_time;
else
c->servptr->opt->time = 1000;
i = snprintf(buff, 32, "sst ");
i += snprintf(buff, 32 - i, "%lu\n", c->servptr->opt->time);
enqueue_msg(c, buff);
return (true);
}
bool
send_broadcast(t_cli *c, char const *msg, int min_index)
{
char buffer[2048];
*buffer = '\0';
snprintf(buffer, sizeof(buffer),
"message %d,%s\n",
min_index, msg);
enqueue_msg(c, buffer);
return (true);
}
bool
plv(t_cli *c, t_msg *msg)
{
char buff[64];
t_cli *target;
int id;
if ((target = get_client(c, msg)) == NULL || target->inventory == NULL)
return ((ERR(PINK"[%s], client %d from team '%s': client not found\n"WHITE,
__func__, c->sock.fd, c->team->name)), false);
memset(buff, 0, 64);
g_i = 0;
id = target->sock.fd;
g_i = snprintf(buff, 16, "plv %d ", id);
snprintf(buff + g_i, 64 - g_i, "%d\n", target->level);
enqueue_msg(c, buff);
return (true);
}
/**
* Receive thread handle function
* @Never return.
*/
static void *msg_waiting_thread(void *s) {
int recv_size = -1, sock = -1;
msg_t *msg = NULL;
if(s == NULL) {
ALOGE("%s: No sock id received", __FUNCTION__);
return NULL;
}
sock = *(int *) s;
while(1) {
/** Receive a reply from the MMI server */
msg = (msg_t *) zmalloc(sizeof(msg_t));
if(msg == NULL) {
ALOGE("%s:out of memory, abort the current request:(%s)\n", __FUNCTION__, strerror(errno));
break;
}
if((recv_size = recv(sock, msg, sizeof(msg_t), MSG_WAITALL)) < 0) {
ALOGE("%s:Recv fail: %s, received size:%d\n", __FUNCTION__, strerror(errno), recv_size);
break;
}
ALOGI("%s:Received one message from server[%s,%d,%s],recv_size=%d", __FUNCTION__, msg->module, msg->cmd,
msg->subcmd, recv_size);
/** Enquenue the request which handled in a single thread*/
enqueue_msg(&g_msg_queue, msg);
/**Notify the handle thread*/
sem_post(&g_msg_sem);
}
return NULL;
}
bool
pin(t_cli *c, t_msg *msg)
{
t_cli *target;
int id;
if ((target = get_client(c, msg)) == NULL || target->inventory == NULL)
return ((ERR(PINK"[%s], client %d from team '%s': client not found\n"WHITE,
__func__, c->sock.fd, c->team->name)), false);
id = target->sock.fd;
i = snprintf(buff, 64, "pin %d %ld %ld ", id, target->x_pos, target->y_pos);
i += get_object(target->inventory, "nourriture");
i += get_object(target->inventory, "linemate");
i += get_object(target->inventory, "deraumere");
i += get_object(target->inventory, "sibur");
i += get_object(target->inventory, "mendiane");
i += get_object(target->inventory, "phiras");
i += get_object(target->inventory, "thystame");
snprintf(buff + i - 1, 2, "\n");
i = 0;
enqueue_msg(c, buff);
return (true);
}
static
int
handle_msg(il_octet_string_t *event, long offset)
{
struct server_msg *msg = NULL;
#if !defined(IL_NOTIFICATIONS)
struct event_queue *eq_l;
#endif
struct event_queue *eq_s;
struct event_store *es;
int ret;
/* convert event to message for server */
if((msg = server_msg_create(event, offset)) == NULL) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_WARN,
" handle_msg: error parsing event '%s': %s",
event->data, error_get_msg());
return(0);
}
/* sync event store with IPC (if neccessary)
* This MUST be called before inserting event into output queue! */
if((es = event_store_find(msg->job_id_s, NULL)) == NULL)
return(-1);
msg->es = es;
#ifdef LB_PERF
if(nosync)
ret = 1;
else
#endif
ret = event_store_sync(es, offset);
/* no longer informative:
il_log(LOG_DEBUG, " syncing event store at %d with event at %d, result %d\n", es->offset, offset, ret);
*/
if(ret < 0) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_ERROR,
" handle_msg: error syncing event store: %s",
error_get_msg());
/* XXX should error during event store recovery cause us to drop the message? */
/* Probably no, because the attempt to recover means we have missed some events,
and delivery of this one will not move offset ahead. So try our best and deliver it
even if it may cause duplicates on server. */
/* COMMENTED OUT: uncommented again */
server_msg_free(msg);
event_store_release(es);
return(0);
/* */
} else if(ret == 0) {
/* we have seen this event already */
server_msg_free(msg);
event_store_release(es);
return(1);
}
/* find apropriate queue for this event */
#if defined(IL_NOTIFICATIONS)
eq_s = queue_list_get(msg->dest);
#else
eq_s = queue_list_get(msg->job_id_s);
#endif
if(eq_s == NULL) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_ERROR,
" handle_msg: apropriate queue not found: %s",
error_get_msg());
clear_error();
} else {
if(enqueue_msg(eq_s, msg) < 0)
goto err;
}
#if !defined(IL_NOTIFICATIONS)
eq_l = queue_list_get(NULL);
if(!bs_only && eq_l != eq_s) {
/* send to default queue (logging server) as well */
if(enqueue_msg(eq_l, msg) < 0)
goto err;
}
#endif
/* if there was no error, set the next expected event offset */
event_store_next(es, offset, msg->ev_len);
/* allow cleanup thread to check on this event_store */
event_store_release(es);
/* free the message */
server_msg_free(msg);
return(1);
err:
event_store_release(es);
server_msg_free(msg);
return(-1);
}
