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)); }