int play_button()
{
if(lobby_state == PLAYER2_READY)
{
transmit_message(MES_READY);
lobby_state = BOTH_READY;
fade_condition = true;
}
else if(lobby_state == PLAYER1_READY)
{
transmit_message(MES_UNREADY);
lobby_state = NOT_READY;
}
else {
transmit_message(MES_READY);
lobby_state = PLAYER1_READY;
}
}
static inline int equip_radio(void)
{
int radio = socket(PF_INET, SOCK_DGRAM, 0);
if(radio < 0) fail("socket()");
int bc = 1;
if(setsockopt(radio, SOL_SOCKET, SO_BROADCAST, &bc, sizeof(bc)) != 0) fail("setsockopt()");
struct timeval tv = {
.tv_sec = 2,
.tv_usec = 0
};
if(setsockopt(radio, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) != 0) fail("setsockopt()");
return radio;
}
static inline void transmit_message(int radio, const char *specific, ui port, const char *message, size_t size)
{
struct addrinfo *ai0 = NULL;
struct sockaddr_in *t = NULL;
if(specific != NULL)
{
if(getaddrinfo(specific, NULL, NULL, &ai0) != 0) fail("getaddrinfo()");
for(struct addrinfo *ai = ai0; ai != NULL; ai = ai->ai_next)
{
if(ai->ai_family != PF_INET)
continue;
t = (struct sockaddr_in *)(void *)ai->ai_addr;
break;
}
}
struct sockaddr_in to = {
.sin_family = AF_INET,
.sin_port = htons(port),
.sin_addr = {.s_addr = t ? t->sin_addr.s_addr : INADDR_BROADCAST}
};
#define B(k) ((ui)(((bt *)(&to.sin_addr))[k]))
if(specific != NULL)
printf("specific target: %u.%u.%u.%u\n", B(0), B(1), B(2), B(3));
ssize_t sz = sendto(radio, message, size, 0, (struct sockaddr *)&to, sizeof(to));
if(ai0)
freeaddrinfo(ai0);
if(sz < 0 || (size_t)sz != size)
perror("sendto()");
}
static inline void transmit_string(int radio, const char *specific, ui port, const char *string)
{
transmit_message(radio, specific, port, string, strlen(string));
}
static inline void probe_field(int radio, const char *specific)
{
transmit_message(radio, specific, PORT, PROMPT_PHRASE, sizeof(PROMPT_PHRASE) - 1);
char buf[16384];
struct sockaddr_in from;
ssize_t sz = pick_up_signal(radio, buf, sizeof(buf), &from);
if(sz >= 0)
handle_signal(buf, (size_t)sz, specific != NULL ? NULL : &from);
}
int on_rtc_alarm_int_transmission()
{
if(get_role() == CLIENT || get_role() == SERVER || get_role() == FAILED)
return 0;
if(get_role() == SEARCHING || get_role() == CONNECTING)
{
message_type_t message;
if(get_role() == SEARCHING)
message = MES_HELLO;
else if (get_role() == CONNECTING)
message = MES_ACK;
transmit_message(message);
}
return 0;
}
BOOL CSMTP::SendMessage(CMailMessage * msg)
{
if( !m_bConnected )
{
//m_sError = _T( "通信未建立" );//<%IDS_SMTP_12%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_12%>");
return FALSE;
}
if( FormatMailMessage( msg ) == FALSE )
{
return FALSE;
}
if( transmit_message( msg ) == FALSE )
{
return FALSE;
}
return TRUE;
}
BOOL CSMTP::SendMessage(CMailMessage * msg)
{
ASSERT( msg != NULL );
if( !m_bConnected )
{
m_sError = _T( "Must be connected" );
return FALSE;
}
if( FormatMailMessage( msg ) == FALSE )
{
return FALSE;
}
if( transmit_message( msg ) == FALSE )
{
return FALSE;
}
return TRUE;
}
void establish_connection_transmission()
{
if(get_role() == CLIENT || get_role() == SERVER || get_role() == FAILED)
return;
if(get_ticks() % 60 == 0)
{
if(get_role() == SEARCHING || get_role() == CONNECTING)
{
message_type_t message;
if(get_role() == SEARCHING)
message = MES_HELLO;
else if (get_role() == CONNECTING)
message = MES_ACK;
transmit_message(message);
}
else
if(get_role() == CONNECTED)
{}
}
}
BOOL CSMTP::SendMessage(MailHeader * msg)
{
ASSERT( msg != NULL );
msg->Date = GetCurrentTimeStr();
if( !m_Connected )
{
m_Error = _T( "Must be connect" );
AfxMessageBox(_T(m_Error));
return FALSE;
}
if( FormatMailMessage( msg ) == FALSE )
{
return FALSE;
}
if( transmit_message( msg ) == FALSE )
{
return FALSE;
}
return TRUE;
}
BOOL CSMTP::SendMessage(CMailMessage * msg)
{
ASSERT( msg != NULL );
if( !m_bConnected )
{
m_sError = _T( "Must be connected" );
return FALSE;
}
if( FormatMailMessage( msg ) == FALSE )
{
OutputDebugString("failed to format mail message\n");
//TRACE("failed to format mail message\n");
return FALSE;
}
if( transmit_message( msg ) == FALSE )
{
OutputDebugString("failed to transmit message\n");
//TRACE("failed to transmit message\n");
return FALSE;
}
return TRUE;
}
/* This function transmits the flight that has been previously
* buffered.
*
* This function is called from the handshake layer and calls the
* record layer.
*/
int
_dtls_transmit (gnutls_session_t session)
{
int ret;
uint8_t* buf = NULL;
unsigned int timeout;
/* PREPARING -> SENDING state transition */
mbuffer_head_st *const send_buffer =
&session->internals.handshake_send_buffer;
mbuffer_st *cur;
gnutls_handshake_description_t last_type = 0;
unsigned int diff;
struct timespec now;
gettime(&now);
/* If we have already sent a flight and we are operating in a
* non blocking way, check if it is time to retransmit or just
* return.
*/
if (session->internals.dtls.flight_init != 0 && session->internals.dtls.blocking == 0)
{
/* just in case previous run was interrupted */
ret = _gnutls_io_write_flush (session);
if (ret < 0)
{
gnutls_assert();
goto cleanup;
}
if (session->internals.dtls.last_flight == 0 || !_dtls_is_async(session))
{
/* check for ACK */
ret = _gnutls_io_check_recv(session, 0);
if (ret == GNUTLS_E_TIMEDOUT)
{
/* if no retransmission is required yet just return
*/
if (_dtls_timespec_sub_ms(&now, &session->internals.dtls.last_retransmit) < TIMER_WINDOW)
{
gnutls_assert();
goto nb_timeout;
}
}
else /* received something */
{
if (ret == 0)
{
ret = is_next_hpacket_expected(session);
if (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED)
goto nb_timeout;
if (ret < 0 && ret != GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET)
{
gnutls_assert();
goto cleanup;
}
if (ret == 0) goto end_flight;
/* if ret == GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET retransmit */
}
else
goto nb_timeout;
}
}
}
do
{
timeout = TIMER_WINDOW;
diff = _dtls_timespec_sub_ms(&now, &session->internals.dtls.handshake_start_time);
if (diff >= session->internals.dtls.total_timeout_ms)
{
_gnutls_dtls_log("Session timeout: %u ms\n", diff);
ret = gnutls_assert_val(GNUTLS_E_TIMEDOUT);
goto end_flight;
}
diff = _dtls_timespec_sub_ms(&now, &session->internals.dtls.last_retransmit);
if (session->internals.dtls.flight_init == 0 || diff >= TIMER_WINDOW)
{
_gnutls_dtls_log ("DTLS[%p]: %sStart of flight transmission.\n", session, (session->internals.dtls.flight_init == 0)?"":"re-");
for (cur = send_buffer->head;
cur != NULL; cur = cur->next)
{
ret = transmit_message (session, cur, &buf);
if (ret < 0)
{
gnutls_assert();
goto end_flight;
}
last_type = cur->htype;
}
gettime(&session->internals.dtls.last_retransmit);
if (session->internals.dtls.flight_init == 0)
{
session->internals.dtls.flight_init = 1;
RESET_TIMER;
timeout = TIMER_WINDOW;
if (last_type == GNUTLS_HANDSHAKE_FINISHED)
{
/* On the last flight we cannot ensure retransmission
* from here. _dtls_wait_and_retransmit() is being called
* by handshake.
*/
session->internals.dtls.last_flight = 1;
}
else
session->internals.dtls.last_flight = 0;
}
else
{
UPDATE_TIMER;
}
}
ret = _gnutls_io_write_flush (session);
if (ret < 0)
{
ret = gnutls_assert_val(ret);
goto cleanup;
}
/* last message in handshake -> no ack */
if (session->internals.dtls.last_flight != 0)
{
/* we don't wait here. We just return 0 and
* if a retransmission occurs because peer didn't receive it
* we rely on the record or handshake
* layer calling this function again.
*/
ret = 0;
goto cleanup;
}
else /* all other messages -> implicit ack (receive of next flight) */
{
if (session->internals.dtls.blocking != 0)
ret = _gnutls_io_check_recv(session, timeout);
else
{
ret = _gnutls_io_check_recv(session, 0);
if (ret == GNUTLS_E_TIMEDOUT)
{
goto nb_timeout;
}
}
if (ret == 0)
{
ret = is_next_hpacket_expected(session);
if (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED)
goto nb_timeout;
if (ret == GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET)
{
ret = GNUTLS_E_TIMEDOUT;
goto keep_up;
}
if (ret < 0)
{
gnutls_assert();
goto cleanup;
}
goto end_flight;
}
}
keep_up:
gettime(&now);
} while(ret == GNUTLS_E_TIMEDOUT);
if (ret < 0)
{
ret = gnutls_assert_val(ret);
goto end_flight;
}
ret = 0;
end_flight:
_gnutls_dtls_log ("DTLS[%p]: End of flight transmission.\n", session);
_dtls_reset_hsk_state(session);
cleanup:
if (buf != NULL)
gnutls_free(buf);
/* SENDING -> WAITING state transition */
return ret;
nb_timeout:
if (buf != NULL)
gnutls_free(buf);
RETURN_DTLS_EAGAIN_OR_TIMEOUT(session, ret);
}
int back_button()
{
transmit_message(MES_BYE);
fade_condition = true;
}
int mp_lobby()
{
int failure = 0;
if((set_com1_irq_set(generic_ser_subscribe_int_tx_rx(COM1))) < 0)
{//subscribe interrupts
printf("mp_lobby(): generic_ser_subscribe_int_tx_rx() failed \n");
failure = 1;
}
if(SET_COMMUNICATION_PARAM())
{
printf("ser_set() failed\n");
return 1;
}
initialize_lobby_buttons();
set_role(SEARCHING);
lobby_state = NOT_READY;
enable_per_second_alarm(on_rtc_alarm_int_transmission);
if(im_message_log != NULL)
{
size_t del_i;
for(del_i = 0 ; del_i < size(im_message_log); del_i++)
{
free(*(char**)at(im_message_log, del_i));
}
delete_vector_t(im_message_log);
}
im_message_log = new_vector_t(sizeof(char*));
memset(current_im, 0, sizeof(char)*IM_MESSAGE_MAX);
current_im_index = 0;
draw_im_index = 0;
int wait = 0;
function_to_call = NULL;
continue_condition = true;
fade_condition = false;
darken = FADE_MAX;
int ipc_status;
message msg;
int r;
set_program_player2name((char*)malloc(sizeof(char)*MAX_PLAYER_NAME_LENGTH+1));
if(get_program_playername2() == NULL)
return 1;
memset(get_program_playername2(),0,sizeof(char)*MAX_PLAYER_NAME_LENGTH+1);
size_t next_char_index = 0;
char last_char = 0;
if(!failure){
do{
/* Get a request message. */
if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) {
printf("driver_receive failed with: %d", r);
continue;
}
if (is_ipc_notify(ipc_status)) { /* received notification */
switch (_ENDPOINT_P(msg.m_source)) {
case HARDWARE: /* hardware interrupt notification */
if (msg.NOTIFY_ARG & get_com1_irq_set()) { /* subscribed interrupt */
if(ser_ih(COM1))
failure = 1;
}
if (msg.NOTIFY_ARG & get_kbd_irq_set()){ /* subscribed kbd interrupt */
kbd_int_handler();
if(get_scancode() == ESC_BREAK)
{
lobby_state = NOT_READY;
fade_condition = true;
transmit_message(MES_BYE);
}
if(get_role() == SERVER || get_role() == CLIENT)
{
if(get_scancode() == ENTER_MAKE && current_im_index != 0)
{
current_im_index = 0;
transmit_protocol(current_im, TYPE_STRING, strlen(current_im)+1);
char* temp = (char*) calloc(IM_MESSAGE_MAX + 4,1);
strcpy(temp, "me: ");
strcat(temp,current_im);
push_back(im_message_log, &temp);
memset(current_im, 0, IM_MESSAGE_MAX);
memset(transmission_message,0,IM_MESSAGE_MAX+4);
}
else
{
int action;
action = process_input(get_scancode(), &last_char);
if(action == CHAR_RECEIVED)
{
if(current_im_index < IM_MESSAGE_MAX -1)
{
current_im[current_im_index] = last_char;
current_im_index++;
}
}
else if(action == BACKSPACE_MAKE)
{
if(current_im_index > 0)
{
current_im_index--;
current_im[current_im_index] = '\0';
}
}
}
}
}
if (msg.NOTIFY_ARG & get_rtc_irq_set()) { /* subscribed timer interrupt */
if(rtc_ih())
failure = 1;
getDateString(get_date_str_ptr());
}
if(msg.NOTIFY_ARG & get_timer_irq_set()){
timer_int_handler();
mp_lobby_render();
//establish_connection_transmission();
}
if (msg.NOTIFY_ARG & get_mouse_irq_set()) { /* subscribed timer interrupt */
mouse_int_handler();
}
break;
default:
break; /* no other notifications expected: do nothing */
}
} else {
}
establish_connection_reception();
if(mouse_is_updated())
{
assign_mouse(get_previous_mouse(), get_mouse());
assign_mouse(get_mouse(), get_mouse_state());
if(get_role() == SERVER || get_role() == CLIENT)
lobby_mouse_event(get_previous_mouse(), get_mouse());
move_cursor(get_cursor(), get_mouse()->coords);
}
} while(continue_condition);
}
if(im_message_log != NULL)
{
size_t del_i;
for(del_i = 0 ; del_i < size(im_message_log); del_i++)
{
free(*(char**)at(im_message_log, del_i));
}
delete_vector_t(im_message_log);
im_message_log = NULL;
}
if(generic_ser_unsubscribe_int_tx_rx(COM1))
{//unsubscribe interrupts
printf("ser_int_receive(): generic_ser_unsubscribe_int() failed \n");
failure = 1;
}
disable_per_second_alarm();
continue_condition = true;
fade_condition = false;
darken = FADE_MAX;
return 0;
}
void establish_connection_reception()
{
if(get_role() == SEARCHING || get_role() == CONNECTING)
{
message_type_t received = 0;
signal_type_t received_signal_type;
size_t received_size = 0;
if(receive_protocol(&received,&received_signal_type, &received_size) == 0)
{
if(received == MES_HELLO && get_role()== SEARCHING)
{
transmit_message(MES_ACK);
set_role(CONNECTING);
}
else if(received == MES_ACK && (get_role() == CONNECTING||get_role() == SEARCHING))
{
transmit_message(MES_ACK);
set_role(CONNECTED);
transmit_protocol(get_program_playername(), TYPE_STRING, strlen(get_program_playername()));
transmit_protocol(get_programinitialtime_ptr(), TYPE_INT, sizeof(int));
}
}
}
else if(get_role() == CONNECTED)
{
message_type_t received = 0;
signal_type_t received_signal_type;
size_t received_size = 0;
if(receive_protocol(get_program_playername2(),&received_signal_type, &received_size) == 0)
{
if(received_signal_type == TYPE_STRING)
{
strcat(opponentmessage, get_program_playername2());
if(strcmp(get_program_playername(), get_program_playername2()) == 0)
set_role(FAILED);
else if(strcmp(get_program_playername(), get_program_playername2()) < 0)
{
set_role(SERVER);
}
else set_role(CLIENT);
}
}
}
else {
char received[100];
memset(received, 0, 100);
signal_type_t received_signal_type;
size_t received_size = 0;
if(receive_protocol(received,&received_signal_type, &received_size) == 0)
{
if(*(unsigned long*)received == MES_BYE)
{
set_role(SEARCHING);
memset(get_program_playername2(),0,sizeof(char)*MAX_PLAYER_NAME_LENGTH+1);
if(im_message_log != NULL)
{
size_t del_i;
for(del_i = 0 ; del_i < size(im_message_log); del_i++)
{
free(*(char**)at(im_message_log, del_i));
}
clear(im_message_log);
}
}
else if(received_signal_type == TYPE_INT)
{
set_player2time( *(unsigned long*)received);
if(get_role() == SERVER)
srand(*get_programinitialtime_ptr());
else srand(get_player2time());
}
else if(*(unsigned long*)received == MES_READY)
{
if(lobby_state == NOT_READY)
lobby_state = PLAYER2_READY;
else if(lobby_state == PLAYER1_READY)
{
lobby_state = BOTH_READY;
fade_condition = true;
}
}
else if(*(unsigned long*)received == MES_UNREADY)
{
if(lobby_state == PLAYER2_READY)
{
lobby_state = NOT_READY;
}
else if(lobby_state == BOTH_READY)
{
lobby_state = PLAYER1_READY;
fade_condition = false;
}
}
else if(received_signal_type == TYPE_STRING)
{
char* temp = (char*) calloc(IM_MESSAGE_MAX + 5,1);
strcpy(temp, "you: ");
strcat(temp,received);
push_back(im_message_log, &temp);
}
}
}
}
