/************************************************************************** This function is called when the client received a new input from the server. **************************************************************************/ void input_from_server(int fd) { int nb; fc_assert_ret(fd == client.conn.sock); nb = read_from_connection(&client.conn, FALSE); if (0 <= nb) { enum packet_type type; agents_freeze_hint(); while (client.conn.used) { bool result; void *packet = get_packet_from_connection(&client.conn, &type, &result); if (result) { fc_assert_action(packet != NULL, break); client_packet_input(packet, type); free(packet); } else { fc_assert(packet == NULL); break; } } if (client.conn.used) { agents_thaw_hint(); } } else if (-2 == nb) {
/************************************************************************** This function is called when the client received a new input from the server. **************************************************************************/ void input_from_server(int fd) { assert(fd == client.conn.sock); if (read_from_connection(&client.conn, FALSE) >= 0) { enum packet_type type; while (TRUE) { bool result; void *packet = get_packet_from_connection(&client.conn, &type, &result); if (result) { assert(packet != NULL); client_packet_input(packet, type); free(packet); } else { assert(packet == NULL); break; } } } else { close_socket_callback(&client.conn); } }
/************************************************************************** This function will sniff at the given fd, get the packet and call client_packet_input. It will return if there is a network error or if the PACKET_PROCESSING_FINISHED packet for the given request is received. **************************************************************************/ void input_from_server_till_request_got_processed(int fd, int expected_request_id) { assert(expected_request_id); assert(fd == client.conn.sock); freelog(LOG_DEBUG, "input_from_server_till_request_got_processed(" "expected_request_id=%d)", expected_request_id); while (TRUE) { if (read_from_connection(&client.conn, TRUE) >= 0) { enum packet_type type; while (TRUE) { bool result; void *packet = get_packet_from_connection(&client.conn, &type, &result); if (!result) { assert(packet == NULL); break; } assert(packet != NULL); client_packet_input(packet, type); free(packet); if (type == PACKET_PROCESSING_FINISHED) { freelog(LOG_DEBUG, "ifstrgp: expect=%d, seen=%d", expected_request_id, client.conn.client.last_processed_request_id_seen); if (client.conn.client.last_processed_request_id_seen >= expected_request_id) { freelog(LOG_DEBUG, "ifstrgp: got it; returning"); return; } } } } else { close_socket_callback(&client.conn); break; } } }
/************************************************************************** ... **************************************************************************/ void get_net_input(XtPointer client_data, int *fid, XtInputId *id) { if(read_socket_data(*fid, &aconnection.buffer)>0) { int type; char *packet; while((packet=get_packet_from_connection(&aconnection, &type))) { handle_packet_input(packet, type); } } else { char buf[512]; sprintf(buf, "Lost connection to server! Quit and reconnect with\n\ the option \"-n %s\", when ready..", game.player_ptr->name); append_output_window(buf); log(LOG_NORMAL, "lost connection to server"); close(*fid); remove_net_input(); } }
/************************************************************************** presult indicates if there is more packets in the cache. We return result instead of just testing if the returning package is NULL as we sometimes return a NULL packet even if everything is OK (receive_packet_goto_route). **************************************************************************/ void *get_packet_from_connection(struct connection *pc, enum packet_type *ptype, bool * presult) { int len_read; int whole_packet_len; struct { enum packet_type type; int itype; } utype; struct data_in din; #ifdef USE_COMPRESSION bool compressed_packet = FALSE; int header_size = 0; #endif *presult = FALSE; if (!pc->used) { return NULL; /* connection was closed, stop reading */ } if (pc->buffer->ndata < 3) { return NULL; /* length and type not read */ } dio_input_init(&din, pc->buffer->data, pc->buffer->ndata); dio_get_uint16(&din, &len_read); /* The non-compressed case */ whole_packet_len = len_read; #ifdef USE_COMPRESSION if (len_read == JUMBO_SIZE) { compressed_packet = TRUE; header_size = 6; if (dio_input_remaining(&din) >= 4) { dio_get_uint32(&din, &whole_packet_len); log_compress("COMPRESS: got a jumbo packet of size %d", whole_packet_len); } else { /* to return NULL below */ whole_packet_len = 6; } } else if (len_read >= COMPRESSION_BORDER) { compressed_packet = TRUE; header_size = 2; whole_packet_len = len_read - COMPRESSION_BORDER; log_compress("COMPRESS: got a normal packet of size %d", whole_packet_len); } #endif if ((unsigned)whole_packet_len > pc->buffer->ndata) { return NULL; /* not all data has been read */ } #ifdef USE_COMPRESSION if (compressed_packet) { uLong compressed_size = whole_packet_len - header_size; /* * We don't know the decompressed size. We assume a bad case * here: an expansion by an factor of 100. */ unsigned long int decompressed_size = 100 * compressed_size; void *decompressed = fc_malloc(decompressed_size); int error; struct socket_packet_buffer *buffer = pc->buffer; error = uncompress(decompressed, &decompressed_size, ADD_TO_POINTER(buffer->data, header_size), compressed_size); if (error != Z_OK) { log_verbose("Uncompressing of the packet stream failed. " "The connection will be closed now."); connection_close(pc, _("decoding error")); return NULL; } buffer->ndata -= whole_packet_len; /* * Remove the packet with the compressed data and shift all the * remaining data to the front. */ memmove(buffer->data, buffer->data + whole_packet_len, buffer->ndata); if (buffer->ndata + decompressed_size > buffer->nsize) { buffer->nsize += decompressed_size; buffer->data = fc_realloc(buffer->data, buffer->nsize); } /* * Make place for the uncompressed data by moving the remaining * data. */ memmove(buffer->data + decompressed_size, buffer->data, buffer->ndata); /* * Copy the uncompressed data. */ memcpy(buffer->data, decompressed, decompressed_size); free(decompressed); buffer->ndata += decompressed_size; log_compress("COMPRESS: decompressed %ld into %ld", compressed_size, decompressed_size); return get_packet_from_connection(pc, ptype, presult); } #endif /* * At this point the packet is a plain uncompressed one. These have * to have to be at least 3 bytes in size. */ if (whole_packet_len < 3) { log_verbose("The packet stream is corrupt. The connection " "will be closed now."); connection_close(pc, _("decoding error")); return NULL; } dio_get_uint8(&din, &utype.itype); utype.type = utype.itype; log_packet("got packet type=(%s)%d len=%d from %s", packet_name(utype.type), utype.itype, whole_packet_len, is_server() ? pc->username : "******"); *ptype = utype.type; *presult = TRUE; if (pc->incoming_packet_notify) { pc->incoming_packet_notify(pc, utype.type, whole_packet_len); } #if PACKET_SIZE_STATISTICS { static struct { int counter; int size; } packets_stats[PACKET_LAST]; static int packet_counter = 0; int packet_type = utype.itype; int size = whole_packet_len; if (!packet_counter) { int i; for (i = 0; i < PACKET_LAST; i++) { packets_stats[i].counter = 0; packets_stats[i].size = 0; } } packets_stats[packet_type].counter++; packets_stats[packet_type].size += size; packet_counter++; if (packet_counter % 100 == 0) { int i, sum = 0; log_test("Received packets:"); for (i = 0; i < PACKET_LAST; i++) { if (packets_stats[i].counter == 0) continue; sum += packets_stats[i].size; log_test(" [%-25.25s %3d]: %6d packets; %8d bytes total; " "%5d bytes/packet average", packet_name(i), i, packets_stats[i].counter, packets_stats[i].size, packets_stats[i].size / packets_stats[i].counter); } log_test("received %d bytes in %d packets;average size " "per packet %d bytes", sum, packet_counter, sum / packet_counter); } } #endif return get_packet_from_connection_helper(pc, utype.type); }