inline static ssize_t
__send (struct connection * conn, struct message * msg, void * header, const size_t header_size) {
ssize_t sent = connection_send (conn, header, header_size);
sent += connection_send (conn, msg->control, msg->control_size);
sent += connection_send (conn, msg->classcode, msg->classcode_size);
return sent;
}
static bool default_send_receive(connection_t *connection, transaction_t *transaction)
{
transaction_t reply;
const options_t *options = get_options_object();
connection_send(connection, transaction, sizeof(transaction_t));
ssize_t num_read = connection_read(connection, options->timeout, &reply,
sizeof(transaction_t));
if (num_read <= 0) {
return false;
}
if (reply.status == SUCCESS) {
fprintf(stderr, "Request executed successfully\n");
}
else {
if (reply.status == PROCESSING) {
fprintf(stderr, "The server is busy processing your request: %s\n",
reply.payload.data);
}
else {
fprintf(stderr, "Error processing the request: %s\n",
reply.payload.data);
return false;
}
}
return true;
}
void proto_nc_established_source(struct connection *con)
{
g_debug("%s con %p ctx %p",__PRETTY_FUNCTION__, con, con->protocol.ctx);
char *x = g_malloc0(1024*1024);
connection_send(con, x, 1024*1024);
g_free(x);
}
int32_t timer_callback(uint32_t event,uint64_t _,void *ud){
if(event == TEVENT_TIMEOUT){
connection *c = (connection*)ud;
packet *p = (packet*)wpacket_new(64);
wpacket_write_uint64((wpacket*)p,(uint64_t)c);
wpacket_write_string((wpacket*)p,"hello world\n");
connection_send(c,p,NULL);
}
return 0;
}
void irc_send(irc_t* irc, const char* format, ...)
{
char buf[512];
va_list ap;
va_start(ap, format);
vsnprintf(buf, 512, format, ap);
va_end(ap);
connection_send(irc->sockfd, buf, strlen(buf));
}
void on_process_packet(struct connection *c,rpacket_t r)
{
//send2_all_client(r);
wpacket_t w = wpacket_create_by_rpacket(wpacket_allocator,r);
connection_send(c,w,NULL);
++send_request;
total_bytes_recv += rpacket_len(r);
rpacket_destroy(&r);
++packet_recv;
}
void on_process_packet(struct connection *c,rpacket_t r)
{
//uint32_t i = 0;
//send2_all_client(r);
uint32_t pk_size = rpacket_len(r);
wpacket_t w = wpacket_create_by_rpacket(r);
printf("pk_size:%d\n",pk_size);
connection_send(c,w,0);
rpacket_destroy(&r);
//++packet_recv;
}
static uint8_t prv_buffer_send(void * sessionH,
uint8_t * buffer,
size_t length,
void * userdata)
{
connection_t * connP = (connection_t*) sessionH;
if (-1 == connection_send(connP, buffer, length))
{
return COAP_500_INTERNAL_SERVER_ERROR;
}
return COAP_NO_ERROR;
}
void
compile_and_send(const char *charset, struct nit_connection *sock,
struct nnn_prog *prog, struct nnn_bcode *bcode)
{
/* int parsed = 1; */
uint32_t msg_len;
nnn_prog_get(prog, (uint8_t *) bcode->code);
nnn_prog_type_check(prog);
if (!prog->parsed)
return;
nnn_prog_bytecode(prog, bcode);
msg_len = bcode->size;
if (!prog->parsed)
return;
connection_send(sock, &msg_len, sizeof(msg_len));
connection_send(sock, bcode->code, msg_len);
}
void on_packet(connection_t c,packet_t p){
//printf("on_packet\n");
//stream_conn_send(c,p);
//stream_conn_close(c);
rpacket_t rpk = (rpacket_t)p;
const char *str = rpk_read_string(rpk);
if(strcmp(str,"hello") != 0)
{
printf("error\n");
exit(0);
}
++packet_count;
connection_send(c,(packet_t)make_writepacket(p),NULL,NULL);
}
void
compile_and_send(const char *charset, struct nit_connection *sock,
struct nnn_prog *prog, struct nnn_bcode *bcode)
{
int parsed = 1;
uint32_t msg_len;
get_u8(charset, bcode->code, msg_len, &uni_buff, &uni_size);
nnn_prog_get(prog, (uint8_t *) uni_buff, &parsed);
nnn_prog_type_check(prog, &parsed);
if (!parsed)
return;
nnn_prog_bytecode(prog, bcode, &parsed);
msg_len = bcode->size;
if (!parsed)
return;
connection_send(sock, &msg_len, sizeof(msg_len));
connection_send(sock, bcode->code, msg_len);
}
uint32_t proto_nc_io_in_http(struct connection *con, void *context, unsigned char *data, uint32_t size)
{
static const char *header = "200 HTTP/1.0\r\nContent-Length: 1048576\r\n\r\n";
if( f == NULL )
{
f = malloc(1024*1024 + strlen(header));
memcpy(f, header, strlen(header));
}
// connection_send(con, header, strlen(header));
connection_send(con, f, 1024*1024 + strlen(header));
connection_close(con);
// free(f);
return size;
}
static bool status_command(connection_t *connection, transaction_t *transaction) {
const options_t *options = get_options_object();
transaction_t reply;
do {
bzero(&reply, sizeof(reply));
connection_send(connection, transaction, sizeof(transaction_t));
do {
ssize_t num_read = connection_read(connection, options->timeout,
&reply, sizeof(transaction_t));
if (num_read <= 0) {
printf("Timed out while trying to read");
continue;
}
if (reply.status == PROCESSING) {
entry_t *entry = (entry_t *) reply.payload.data;
switch (entry->status) {
case STARTED: {
printf("Downloading %.0f of %.0f of file %s at %.0f Kb/s\n",
entry->complete, entry->size, entry->id.name,
(entry->speed / 1024));
break;
}
case WAITING: {
printf("Downloaded file %s is waiting for available slots\n",
entry->id.name);
break;
}
case COMPLETED:
case PAUSED: {
printf("Downloaded %.0f of %.0f of file %s\n",
entry->complete, entry->size, entry->id.name);
break;
}
default: {
break;
}
}
}
} while (reply.status == PROCESSING);
//printf("Finished processing ... \n")
sleep(1);
} while (options->keep_alive);
}
void send2_all_client(rpacket_t r)
{
uint32_t i = 0;
wpacket_t w;
for(; i < MAX_CLIENT; ++i)
{
if(clients[i])
{
w = wpacket_create_by_rpacket(wpacket_allocator,r);
assert(w);
++send_request;
connection_send(clients[i],w,NULL);
//connection_push_packet(clients[i],w,NULL);
}
}
}
void on_process_packet(struct connection *c,rpacket_t r)
{
uint32_t coro_id = rpacket_read_uint32(r);
const char *function_name = rpacket_read_string(r);
int32_t arg1 = rpacket_read_uint32(r);
int32_t arg2 = rpacket_read_uint32(r);
uint32_t i = 0;
wpacket_t w = wpacket_create(SINGLE_THREAD,wpacket_allocator,64,0);
wpacket_write_uint32(w,coro_id);
if(strcmp(function_name,"sum") == 0)
wpacket_write_uint32(w,arg1+arg2);
else
wpacket_write_uint32(w,arg1*arg2);
assert(w);
connection_send(c,w,NULL);
rpacket_destroy(&r);
}
static int _luasocket_stream_send(lua_State *L,void (*complete_callback)(connection_t)){
luasocket_t luasock = lua_touserdata(L,1);
int type = luasock->type;
if(type != _STREAM_CONN){
lua_pushstring(L,"invaild socket");
return 1;
}
lua_packet_t pk = lua_getluapacket(L,2);
if(pk->_packet->type == RPACKET){
lua_pushstring(L,"invaild data");
return 1;
}
if(0 != connection_send(luasock->streamconn,(packet_t)pk->_packet,complete_callback))
lua_pushstring(L,"send error");
else
lua_pushnil(L);
pk->_packet = NULL;
return 1;
}
uint8_t lwm2m_buffer_send(void * sessionH,
uint8_t * buffer,
size_t length,
void * userdata)
{
dtls_connection_t * connP = (dtls_connection_t*) sessionH;
if (connP == NULL)
{
fprintf(stderr, "#> failed sending %lu bytes, missing connection\r\n", length);
return COAP_500_INTERNAL_SERVER_ERROR ;
}
if (-1 == connection_send(connP, buffer, length))
{
fprintf(stderr, "#> failed sending %lu bytes\r\n", length);
return COAP_500_INTERNAL_SERVER_ERROR ;
}
return COAP_NO_ERROR;
}
static uint8_t prv_buffer_send(void * sessionH,
uint8_t * buffer,
size_t length,
void * userdata)
{
connection_t * connP = (connection_t*) sessionH;
if (connP == NULL)
{
fprintf(stderr, "#> failed sending %lu bytes, missing connection\r\n", length);
return COAP_500_INTERNAL_SERVER_ERROR ;
}
if (-1 == connection_send(connP, buffer, length))
{
fprintf(stderr, "#> failed sending %lu bytes\r\n", length);
return COAP_500_INTERNAL_SERVER_ERROR ;
}
conn_s_updateTxStatistic(objArray[7], (uint16_t)length, false);
fprintf(stderr, "#> sent %lu bytes\r\n", length);
return COAP_NO_ERROR;
}
int server(unsigned short port, int demarcaciones, int taxPorDemarcacion, int iters, int timeout_millis, int txdelay_millis, bool debug) {
connection_t conn;
packet_t outgoing;
packet_t * incoming;
if (!connection_server(&conn, port)) {
fprintf(stderr, "Unable to spawn server on port %u: ", port);
connection_error(&conn, stderr);
fprintf(stderr, "\n");
return 1;
}
if (debug) {
connection_debug(&conn, stderr);
}
gestion_taxi_t * taxis = calloc(demarcaciones * taxPorDemarcacion, sizeof(gestion_taxi_t));
if (taxis == NULL) {
fprintf(stderr, "Failed to allocate memory for taxi stats structure: %s\n", strerror(errno));
return 1;
}
fprintf(stderr, "Waiting for clientes at port: [%d]\n", port);
int connected = 0;
int pendingAccAck = demarcaciones * taxPorDemarcacion;
while (pendingAccAck > 0) {
if (!connection_receive(&conn, &incoming, NULL)) { /* TODO: check how to safely implement a timeout here */
fprintf(stderr, "Error receiving login packet: ");
connection_error(&conn, stderr);
fprintf(stderr, "\n");
if (connection_dead(&conn)) {
connection_close(&conn);
free(taxis);
return 1;
}
continue;
}
bool duplicate = false;
int pos;
switch (incoming->type) {
case PACKET_TYPE_LOGIN:
if (incoming->login.version != PACKET_VERSION) {
fprintf(stderr, "Got LOGIN with version %08X but server version is %08X\n", incoming->login.version, PACKET_VERSION);
connection_discard(&conn);
continue;
}
connection_accept(&conn);
for (pos = 0; pos < connected; pos++) {
if (connection_cmp(&taxis[pos].conexionConTaxi, &conn)) {
duplicate = true;
fprintf(stderr, "Got duplicated login packet from taxi %d-%d. Re-sending acknowledgement\n", pos / taxPorDemarcacion, pos % taxPorDemarcacion);
break;
}
}
if (!duplicate) {
if (connected == taxPorDemarcacion * demarcaciones) {
fprintf(stderr, "Received new LOGIN but all taxis have been already registered\n");
continue;
}
fprintf(stderr, "Registered new taxi %d-%d\n", connected / taxPorDemarcacion, connected % taxPorDemarcacion);
memcpy(&taxis[connected].conexionConTaxi, &conn, sizeof(conn));
connected++;
}
outgoing.type = PACKET_TYPE_ACCEPT;
outgoing.accept.zone = pos / taxPorDemarcacion;
outgoing.accept.id = pos % taxPorDemarcacion;
outgoing.accept.neighbors = taxPorDemarcacion - 1;
outgoing.accept.ticks = iters;
outgoing.accept.timeout = timeout_millis;
outgoing.accept.txdelay = txdelay_millis;
if (!connection_send(&conn, &outgoing)) {
fprintf(stderr, "Error replying to login packet: ");
connection_error(&conn, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
free(taxis);
return 1;
}
break;
case PACKET_TYPE_ACCACK:
if (incoming->accack.zone >= demarcaciones || incoming->accack.id >= taxPorDemarcacion) {
fprintf(stderr, "Received illegal accept acknowledgement from taxi %u-%u\n", incoming->accack.zone, incoming->accack.id);
connection_discard(&conn);
continue;
}
connection_accept(&conn);
gestion_taxi_t * taxi = &taxis[incoming->accack.zone * taxPorDemarcacion + incoming->accack.id];
if (!taxi->hasAckdAccept) {
taxi->hasAckdAccept = true;
pendingAccAck--;
}
break;
default:
connection_discard(&conn);
fprintf(stderr, "Unexpected packet %s during login phase. Discarding.\n", packet_name(incoming));
continue;
}
}
outgoing.type = PACKET_TYPE_START;
for (int pos = 0; pos < demarcaciones * taxPorDemarcacion; pos++) {
if (!connection_send(&taxis[pos].conexionConTaxi, &outgoing)) {
fprintf(stderr, "Error sending start packet: ");
connection_error(&conn, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
free(taxis);
return 1;
}
}
int statsRcv = 0;
struct timeval defaulttimeout = { (timeout_millis * 2) / 1000, ((timeout_millis * 2) % 1000) * 1000 };
struct timeval timeout = defaulttimeout;
while (statsRcv < demarcaciones * taxPorDemarcacion) {
if (!connection_receive(&conn, &incoming, NULL)) {
fprintf(stderr, "Error receiving packet in main loop: ");
connection_error(&conn, stderr);
fprintf(stderr, "\n");
if (conn.err == CONNERR_TIMEOUT) {
break;
}
if (connection_dead(&conn)) {
connection_close(&conn);
free(taxis);
return 1;
}
continue;
}
gestion_taxi_t * taxi;
switch (incoming->type) {
case PACKET_TYPE_ACCACK:
outgoing.type = PACKET_TYPE_START;
if (!connection_send(&conn, &outgoing)) {
fprintf(stderr, "Failed to send start packet in main loop: ");
connection_error(&conn, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
return 1;
}
timeout = defaulttimeout;
break;
case PACKET_TYPE_POSITION:
if (incoming->position.zone > demarcaciones || incoming->position.id > taxPorDemarcacion) {
fprintf(stderr, "Received position from illegal taxi %u-%u\n", outgoing.position.zone, outgoing.position.id);
connection_discard(&conn);
continue;
}
for (int neighbor = 0; neighbor < taxPorDemarcacion; neighbor++) {
if (neighbor == incoming->position.id) {
continue;
}
if (!connection_send(&taxis[incoming->position.zone * taxPorDemarcacion + neighbor].conexionConTaxi, incoming)) {
fprintf(stderr, "Error forwarding position packet: ");
connection_error(&taxis[incoming->position.zone * taxPorDemarcacion + neighbor].conexionConTaxi, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
free(taxis);
return 1;
}
}
timeout = defaulttimeout;
connection_accept(&conn);
break;
case PACKET_TYPE_POSACK:
if (incoming->posack.zone > demarcaciones || incoming->posack.id > taxPorDemarcacion) {
fprintf(stderr, "Received acknowledgement from illegal taxi %u-%u\n", incoming->posack.zone, incoming->posack.id);
break;
}
if (incoming->posack.neighbor > taxPorDemarcacion) {
fprintf(stderr, "Received acknowledgement from %u-%u targeting out-of-bounds taxi %u-%u\n", incoming->posack.zone, incoming->posack.id, incoming->posack.zone, incoming->posack.neighbor);
break;
}
taxi = &taxis[incoming->posack.zone * taxPorDemarcacion + incoming->posack.neighbor];
if (!connection_send(&taxi->conexionConTaxi, incoming)) {
fprintf(stderr, "Error forwarding acknowledgement packet: ");
connection_error(&taxi->conexionConTaxi, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
free(taxis);
return 1;
}
timeout = defaulttimeout;
connection_accept(&conn);
break;
case PACKET_TYPE_STATS:
taxi = &taxis[incoming->stats.zone * taxPorDemarcacion + incoming->stats.id];
if (!taxi->hasSentStats) {
printf("%u, %u, %u, %u, %u, %u, %u, %u\n",
incoming->stats.zone,
incoming->stats.id,
incoming->stats.ticks,
incoming->stats.posrcv,
incoming->stats.ackrcv,
incoming->stats.itmin,
incoming->stats.itavg,
incoming->stats.itmax
);
taxi->hasSentStats = true;
statsRcv++;
}
outgoing.type = PACKET_TYPE_STATACK;
if (!connection_send(&taxi->conexionConTaxi, &outgoing)) {
fprintf(stderr, "Error sending stats acknowledgement packet: ");
connection_error(&taxi->conexionConTaxi, stderr);
fprintf(stderr, "\n");
connection_close(&conn);
free(taxis);
return 1;
}
timeout = defaulttimeout;
connection_accept(&conn);
break;
default:
fprintf(stderr, "Unexpected packet %s during main loop\n", packet_name(incoming));
connection_discard(&conn);
continue;
}
}
// TODO: Interpretar estadísticas
return 0;
}
uint32_t proto_nc_io_in_redir(struct connection *con, void *context, unsigned char *data, uint32_t size)
{
g_debug("%s con %p ctx %p data %p size %i",__PRETTY_FUNCTION__, con, context, data, size);
connection_send(con, data, size);
return size;
}
static int send_msg(Client *a_client, const char *a_message)
{
assert(a_client);
return connection_send(a_client->conn, a_message, strlen(a_message));
}
