/* receive all params in chunks of 20 chars including terminator*/
void receive_args(int sock_fd, char *params[]) {
msg_chunk param_chunk;
char *tmp;
do {
memset(¶m_chunk, 0, sizeof(msg_chunk));
receive_chunk(sock_fd, ¶m_chunk);
#ifdef DBG
DEBUG("Chunk op_code: %d , Chunk payload: %s\n", param_chunk.op_code,
¶m_chunk.arg);
#endif
if (param_chunk.op_code != -1) {
if (params[param_chunk.op_code] == NULL) {
tmp = calloc(1, sizeof(param_chunk.arg));
} else {
tmp = realloc(params[param_chunk.op_code], strlen(params[param_chunk.op_code])+
sizeof(param_chunk.arg));
}
params[param_chunk.op_code] = tmp;
strcpy(params[param_chunk.op_code] + strlen(params[param_chunk.op_code]),
param_chunk.arg);
#ifdef DBG
DEBUG("Chunk op_code: %d , parameter: %s\n", param_chunk.op_code,
params[param_chunk.op_code]);
#endif
}
}while(param_chunk.op_code != -1); /* not EOM chunk*/
}
void on_receive(struct moag *m, ENetEvent *ev)
{
struct chunk_header *chunk;
chunk = receive_chunk(ev->packet);
intptr_t id = (intptr_t)ev->peer->data;
switch (chunk->type)
{
case INPUT_CHUNK:
{
struct input_chunk *input = (void *)chunk;
switch (input->key)
{
case KLEFT_PRESSED: m->players[id].kleft = true; break;
case KLEFT_RELEASED: m->players[id].kleft = false; break;
case KRIGHT_PRESSED: m->players[id].kright = true; break;
case KRIGHT_RELEASED: m->players[id].kright = false; break;
case KUP_PRESSED: m->players[id].kup = true; break;
case KUP_RELEASED: m->players[id].kup = false; break;
case KDOWN_PRESSED: m->players[id].kdown = true; break;
case KDOWN_RELEASED: m->players[id].kdown = false; break;
case KFIRE_PRESSED: m->players[id].kfire = true; break;
case KFIRE_RELEASED:
{
uint16_t power = input->ms;
m->players[id].kfire = false;
m->players[id].tank.power = power / 2;
m->players[id].tank.power = CLAMP(0, 1000, m->players[id].tank.power);
break;
}
}
break;
}
case CLIENT_MSG_CHUNK:
{
struct client_msg_chunk *client_msg = (void *)chunk;
handle_msg(m, id, (char *)client_msg->data, ev->packet->dataLength - 1);
break;
}
default: break;
}
free(chunk);
}
static int websocket_callback(struct libwebsocket_context *context, struct libwebsocket *wsi, enum libwebsocket_callback_reasons reason, void *user, void *in, size_t len)
{
struct per_session_data *pss = (struct per_session_data *)user;
context_data *ctx_data = (context_data *)libwebsocket_context_user(context);
switch(reason)
{
case LWS_CALLBACK_ESTABLISHED:
{
int port = -1;
for(int i = 0; i < WS_CLIENTS; i++)
{
int j = (ctx_data->last_used_port + i + 1) % WS_CLIENTS;
if(ctx_data->port_map[j] == NULL)
{
port = j;
break;
}
}
if(port == -1)
{
dbg_msg("websockets", "no free ports, dropping");
pss->port = -1;
return -1;
}
ctx_data->last_used_port = port;
pss->wsi = wsi;
int fd = libwebsocket_get_socket_fd(wsi);
socklen_t addr_size = sizeof(pss->addr);
getpeername(fd, (struct sockaddr *)&pss->addr, &addr_size);
int orig_port = ntohs(pss->addr.sin_port);
pss->addr.sin_port = htons(port);
pss->send_buffer.Init();
pss->port = port;
ctx_data->port_map[port] = pss;
char addr_str[NETADDR_MAXSTRSIZE];
inet_ntop(AF_INET, &pss->addr.sin_addr, addr_str, sizeof(addr_str));
dbg_msg("websockets", "connection established with %s:%d , assigned fake port %d", addr_str, orig_port, port);
}
break;
case LWS_CALLBACK_CLOSED:
{
dbg_msg("websockets", "connection with fake port %d closed", pss->port);
if (pss->port > -1) {
unsigned char close_packet[] = { 0x10, 0x0e, 0x00, 0x04 };
receive_chunk(ctx_data, pss, &close_packet, sizeof(close_packet));
pss->wsi = 0;
ctx_data->port_map[pss->port] = NULL;
}
}
break;
case LWS_CALLBACK_SERVER_WRITEABLE:
{
websocket_chunk *chunk = (websocket_chunk *)pss->send_buffer.First();
if(chunk == NULL)
break;
int len = chunk->size - chunk->read;
int n = libwebsocket_write(wsi, &chunk->data[LWS_SEND_BUFFER_PRE_PADDING + chunk->read], chunk->size - chunk->read, LWS_WRITE_BINARY);
if(n < 0)
return 1;
if(n < len)
{
chunk->read += n;
libwebsocket_callback_on_writable(context, wsi);
break;
}
pss->send_buffer.PopFirst();
libwebsocket_callback_on_writable(context, wsi);
}
break;
case LWS_CALLBACK_RECEIVE:
if(pss->port == -1)
return -1;
if(!receive_chunk(ctx_data, pss, in, len))
return 1;
break;
default:
break;
}
return 0;
}
static void
sign(X509 *cert, EVP_PKEY *key, int pipefd)
{
PKCS7 *pkcs7;
BIO *bio, *out;
const EVP_MD *md;
PKCS7_SIGNER_INFO *info;
void *digest, *signature;
size_t digest_len, signature_len;
int ok;
assert(cert != NULL);
assert(key != NULL);
receive_chunk(&digest, &digest_len, pipefd);
bio = BIO_new_mem_buf(digest, digest_len);
if (bio == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "BIO_new_mem_buf(3) failed");
}
pkcs7 = PKCS7_sign(NULL, NULL, NULL, bio, PKCS7_BINARY | PKCS7_PARTIAL);
if (pkcs7 == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "PKCS7_sign(3) failed");
}
md = EVP_get_digestbyname(DIGEST);
if (md == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "EVP_get_digestbyname(\"%s\") failed", DIGEST);
}
info = PKCS7_sign_add_signer(pkcs7, cert, key, md, 0);
if (info == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "PKCS7_sign_add_signer(3) failed");
}
/*
* XXX: All the signed binaries seem to have this, but where is it
* described in the spec?
*/
PKCS7_add_signed_attribute(info, NID_pkcs9_contentType,
V_ASN1_OBJECT, OBJ_txt2obj("1.3.6.1.4.1.311.2.1.4", 1));
magic(pkcs7, digest, digest_len);
#if 0
out = BIO_new(BIO_s_file());
BIO_set_fp(out, stdout, BIO_NOCLOSE);
PKCS7_print_ctx(out, pkcs7, 0, NULL);
i2d_PKCS7_bio(out, pkcs7);
#endif
out = BIO_new(BIO_s_mem());
if (out == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "BIO_new(3) failed");
}
ok = i2d_PKCS7_bio(out, pkcs7);
if (ok == 0) {
ERR_print_errors_fp(stderr);
errx(1, "i2d_PKCS7_bio(3) failed");
}
signature_len = BIO_get_mem_data(out, &signature);
if (signature_len <= 0) {
ERR_print_errors_fp(stderr);
errx(1, "BIO_get_mem_data(3) failed");
}
(void)BIO_set_close(out, BIO_NOCLOSE);
BIO_free(out);
send_chunk(signature, signature_len, pipefd);
}
static void
receive_signature(struct executable *x, int pipefd)
{
receive_chunk(&x->x_signature, &x->x_signature_len, pipefd);
}
