int rcon_command(int rsock, char *command)
{
int ret;
rc_packet *packet = packet_build(RCON_PID, RCON_EXEC_COMMAND, command);
if(packet == NULL) {
connection_alive = 0;
return 0;
}
ret = net_send_packet(rsock, packet);
if(!ret) return 0; /* send failed */
packet = net_recv_packet(rsock);
if(packet == NULL) return 0;
if(packet->id != RCON_PID) return 0; /* wrong packet id */
if(!silent_mode) {
/*
if(packet->size == 10) {
printf("Unknown command \"%s\". Type \"help\" or \"?\" for help.\n", command);
}
else
*/
if(packet->size > 10)
packet_print(packet);
}
/* return 1 if world was saved */
return 1;
}
int main(int argc, const char *argv[])
{
packet_t *packet;
uint8_t *bytes;
size_t length;
/* Create a SYN */
packet = packet_create_syn(0x1234, 0x0000, 0x0000);
packet_print(packet);
/* Convert it to bytes and free the original */
bytes = packet_to_bytes(packet, &length);
packet_destroy(packet);
/* Parse the bytes from the old packet to create a new one */
packet = packet_parse(bytes, length);
packet_print(packet);
packet_destroy(packet);
safe_free(bytes);
/* Create a MSG */
packet = packet_create_msg(0x1234, 0x0000, 0x0001, (uint8_t*)"AAAAA", 5);
packet_print(packet);
/* Convert it to bytes and free the orignal */
bytes = packet_to_bytes(packet, &length);
packet_destroy(packet);
/* Parse the bytes from the old packet to create a new one */
packet = packet_parse(bytes, length);
packet_print(packet);
packet_destroy(packet);
safe_free(bytes);
/* Create a FIN */
packet = packet_create_fin(0x1234);
packet_print(packet);
/* Convert it to bytes and free the orignal */
bytes = packet_to_bytes(packet, &length);
packet_destroy(packet);
safe_free(bytes);
/* Parse the bytes from the old packet to create a new one */
packet = packet_parse(bytes, length);
packet_print(packet);
packet_destroy(packet);
print_memory();
return 0;
}
int mouse_handler() {
unsigned long byte;
if(counter == 0){
byte = mouse_read();
if(byte & BIT(3)){
packet[0] = byte;
counter++;
}
return 0;
}
else{
byte = mouse_read();
packet[counter] = byte;
counter++;
if(counter == 3){
counter = 0;
time = 0;
packet_print();
}
return 0;
}
return 1;
}
static void
rtp_event_handler (struct rtp *session, rtp_event * e)
{
rtp_packet *p;
rtcp_sdes_item *r;
switch (e->type)
{
case RX_RTP:
p = (rtp_packet *) e->data;
packet_print (session, p);
free (p); /* xfree() is mandatory to release RTP packet data */
break;
case RX_SDES:
r = (rtcp_sdes_item *) e->data;
sdes_print (session, e->ssrc, r->type);
break;
case RX_BYE:
break;
case SOURCE_CREATED:
fprintf (stderr, "New source created, SSRC = 0x%08x\n", e->ssrc);
break;
case SOURCE_DELETED:
fprintf (stderr, "Source deleted, SSRC = 0x%08x\n", e->ssrc);
break;
case RX_SR:
case RX_RR:
case RX_RR_EMPTY:
case RX_RTCP_START:
case RX_RTCP_FINISH:
case RR_TIMEOUT:
case RX_APP:
break;
}
fflush (stdout);
}
uint8_t *session_get_outgoing(session_t *session, size_t *length, size_t max_length)
{
packet_t *packet = NULL;
uint8_t *result = NULL;
uint8_t *data = NULL;
size_t data_length = -1;
/* Suck in any data we can from the driver. */
poll_for_data(session);
/* Don't transmit too quickly without receiving anything. */
if(!can_i_transmit_yet(session))
return NULL;
/* It's pretty ugly, but I don't see any other way, since ping requires
* special packets we have to handle it separately. */
if(session->is_ping)
{
/* Read data without consuming it (ie, leave it in the buffer till it's ACKed) */
data = buffer_read_remaining_bytes(session->outgoing_buffer, &data_length, max_length - packet_get_ping_size(), FALSE);
packet = packet_create_ping(session->id, (char*)data);
safe_free(data);
LOG_INFO("In PING, sending a PING packet (%zd bytes of data...)", data_length);
}
else
{
switch(session->state)
{
case SESSION_STATE_NEW:
LOG_INFO("In SESSION_STATE_NEW, sending a SYN packet (SEQ = 0x%04x)...", session->my_seq);
packet = packet_create_syn(session->id, session->my_seq, (options_t)0);
if(session->is_command)
packet_syn_set_is_command(packet);
if(session->name)
packet_syn_set_name(packet, session->name);
break;
case SESSION_STATE_ESTABLISHED:
/* Read data without consuming it (ie, leave it in the buffer till it's ACKed) */
data = buffer_read_remaining_bytes(session->outgoing_buffer, &data_length, max_length - packet_get_msg_size(session->options), FALSE);
LOG_INFO("In SESSION_STATE_ESTABLISHED, sending a MSG packet (SEQ = 0x%04x, ACK = 0x%04x, %zd bytes of data...)", session->my_seq, session->their_seq, data_length);
if(data_length == 0 && session->is_shutdown)
packet = packet_create_fin(session->id, "Stream closed");
else
packet = packet_create_msg_normal(session->id, session->my_seq, session->their_seq, data, data_length);
safe_free(data);
break;
default:
LOG_FATAL("Wound up in an unknown state: 0x%x", session->state);
exit(1);
}
}
if(packet)
{
/* Print packet data if we're supposed to. */
if(packet_trace)
{
printf("OUTGOING: ");
packet_print(packet, session->options);
}
update_counter(session);
result = packet_to_bytes(packet, length, session->options);
packet_destroy(packet);
}
return result;
}
NBBOOL session_data_incoming(session_t *session, uint8_t *data, size_t length)
{
/* Parse the packet to get the session id */
packet_t *packet = packet_parse(data, length, session->options);
/* Set to TRUE if data was properly ACKed and we should send more right away. */
NBBOOL send_right_away = FALSE;
/* Suck in any data we can from the driver. */
poll_for_data(session);
/* Print packet data if we're supposed to. */
if(packet_trace)
{
printf("INCOMING: ");
packet_print(packet, session->options);
}
if(session->is_ping)
{
/* This only returns if the receive is bad. */
driver_data_received(session->driver, (uint8_t*)packet->body.ping.data, strlen(packet->body.ping.data));
}
else
{
switch(session->state)
{
case SESSION_STATE_NEW:
if(packet->packet_type == PACKET_TYPE_SYN)
{
LOG_INFO("In SESSION_STATE_NEW, received SYN (ISN = 0x%04x)", packet->body.syn.seq);
session->their_seq = packet->body.syn.seq;
session->options = (options_t) packet->body.syn.options;
session->state = SESSION_STATE_ESTABLISHED;
/* Since we established a valid session, we can send stuff right away. */
session->last_transmit = 0;
session->missed_transmissions = 0;
send_right_away = TRUE;
}
else if(packet->packet_type == PACKET_TYPE_MSG)
{
LOG_WARNING("In SESSION_STATE_NEW, received unexpected MSG (ignoring)");
}
else if(packet->packet_type == PACKET_TYPE_FIN)
{
/* TODO: I shouldn't exit here. */
LOG_FATAL("In SESSION_STATE_NEW, received FIN: %s", packet->body.fin.reason);
exit(0);
}
else
{
/* TODO: I shouldn't exit here. */
LOG_FATAL("Unknown packet type: 0x%02x", packet->packet_type);
exit(1);
}
break;
case SESSION_STATE_ESTABLISHED:
if(packet->packet_type == PACKET_TYPE_SYN)
{
LOG_WARNING("In SESSION_STATE_ESTABLISHED, recieved SYN (ignoring)");
}
else if(packet->packet_type == PACKET_TYPE_MSG)
{
LOG_INFO("In SESSION_STATE_ESTABLISHED, received a MSG");
/* Validate the SEQ */
if(packet->body.msg.options.normal.seq == session->their_seq)
{
/* Verify the ACK is sane */
uint16_t bytes_acked = packet->body.msg.options.normal.ack - session->my_seq;
/* If there's still bytes waiting in the buffer.. */
if(bytes_acked <= buffer_get_remaining_bytes(session->outgoing_buffer))
{
/* Since we got a valid response back, the connection isn't dying. */
session->missed_transmissions = 0;
/* Reset the retransmit counter since we got some valid data. */
if(bytes_acked > 0)
{
/* Only reset the counter if we want to re-transmit
* right away. */
if(transmit_instantly_on_data)
{
session->last_transmit = 0;
session->missed_transmissions = 0;
send_right_away = TRUE;
}
}
/* Increment their sequence number */
session->their_seq = (session->their_seq + packet->body.msg.data_length) & 0xFFFF;
/* Remove the acknowledged data from the buffer */
buffer_consume(session->outgoing_buffer, bytes_acked);
/* Increment my sequence number */
if(bytes_acked != 0)
{
session->my_seq = (session->my_seq + bytes_acked) & 0xFFFF;
}
/* Print the data, if we received any, and then immediately receive more. */
if(packet->body.msg.data_length > 0)
{
driver_data_received(session->driver, packet->body.msg.data, packet->body.msg.data_length);
}
}
else
{
LOG_WARNING("Bad ACK received (%d bytes acked; %d bytes in the buffer)", bytes_acked, buffer_get_remaining_bytes(session->outgoing_buffer));
}
}
else
{
LOG_WARNING("Bad SEQ received (Expected %d, received %d)", session->their_seq, packet->body.msg.options.normal.seq);
}
}
else if(packet->packet_type == PACKET_TYPE_FIN)
{
LOG_FATAL("In SESSION_STATE_ESTABLISHED, received FIN: %s - closing session", packet->body.fin.reason);
session->last_transmit = 0;
session->missed_transmissions = 0;
session_kill(session);
}
else
{
LOG_FATAL("Unknown packet type: 0x%02x - closing session", packet->packet_type);
session_kill(session);
}
break;
default:
LOG_FATAL("Wound up in an unknown state: 0x%x", session->state);
packet_destroy(packet);
session_kill(session);
exit(1);
}
}
packet_destroy(packet);
return send_right_away;
}
void packet_print(Packet* packet)
{
switch (packet_get_type(packet))
{
case PACKET_TYPE_SEND_MESSAGE:
{
printf("Send Message: Length=%d, Message=%s\n",
packet_get_length(packet),
packet_get_string(packet, SEND_MESSAGE_TEXT));
break;
}
case PACKET_TYPE_SEND_NAME:
{
printf("Send Name: Length=%d, Name=%s\n",
packet_get_length(packet),
packet_get_string(packet, SEND_NAME_NAME));
break;
}
case PACKET_TYPE_MOUSE_DOWN:
{
printf("Mouse Down: Length=%d, X=%lf, Y=%lf\n",
packet_get_length(packet),
packet_get_double(packet, MOUSE_DOWN_X),
packet_get_double(packet, MOUSE_DOWN_Y));
break;
}
case PACKET_TYPE_MOUSE_MOVE:
{
printf("Mouse Move: Length=%d, X=%lf, Y=%lf\n",
packet_get_length(packet),
packet_get_double(packet, MOUSE_MOVE_X),
packet_get_double(packet, MOUSE_MOVE_Y));
break;
}
case PACKET_TYPE_MOUSE_UP:
{
printf("Mouse Up: Length=%d, X=%lf, Y=%lf\n",
packet_get_length(packet),
packet_get_double(packet, MOUSE_UP_X),
packet_get_double(packet, MOUSE_UP_Y));
break;
}
case PACKET_TYPE_NEW_STROKE:
{
printf("New Stroke: Length=%d, ID=%d, X=%lf, Y=%lf, TYPE=%d, FILL=%d, WIDTH=%lf, R=%lf, G=%lf, B=%lf\n",
packet_get_length(packet),
packet_get_int(packet, NEW_STROKE_ID),
packet_get_double(packet, NEW_STROKE_X),
packet_get_double(packet, NEW_STROKE_Y),
packet_get_byte(packet, NEW_STROKE_SHAPE_TYPE),
packet_get_byte(packet, NEW_STROKE_FILL),
packet_get_double(packet, NEW_STROKE_WIDTH),
packet_get_double(packet, NEW_STROKE_R),
packet_get_double(packet, NEW_STROKE_G),
packet_get_double(packet, NEW_STROKE_B));
break;
}
case PACKET_TYPE_ADD_POINT:
{
printf("Add Point: Length=%d, ID=%d, X=%lf, Y=%lf\n",
packet_get_length(packet),
packet_get_int(packet, ADD_POINT_ID),
packet_get_double(packet, ADD_POINT_X),
packet_get_double(packet, ADD_POINT_Y));
break;
}
case PACKET_TYPE_DELETE:
{
printf("New Stroke: Length=%d, ID=%d\n",
packet_get_length(packet),
packet_get_int(packet, DELETE_ID));
break;
}
case PACKET_TYPE_UPDATE:
{
printf("Update: Length=%d, ID=%d, X=%lf, Y=%lf, T=%lf\n",
packet_get_length(packet),
packet_get_int(packet, UPDATE_ID),
packet_get_double(packet, UPDATE_X),
packet_get_double(packet, UPDATE_Y),
packet_get_double(packet, UPDATE_ROTATION));
break;
}
case PACKET_TYPE_PACKETS:
{
printf("Packets: Length=%d\n", packet_get_length(packet));
int i = 0;
Packet* p = NULL;
do
{
printf("\t");
p = packet_get_packet(packet, i);
packet_print(p);
i++;
} while (packet_get_type(p) != PACKET_TYPE_UNDEFINED);
break;
}
case PACKET_TYPE_NEW_CONNECTION:
{
printf("New Connection: Length=1\n");
break;
}
case PACKET_TYPE_INK_POT:
{
printf("Ink: %d\n", packet_get_byte(packet, INK_POT_INK));
break;
}
case PACKET_TYPE_UNDEFINED:
default:
{
printf("Packet Undefined\n");
break;
}
}
}
