int system_sleep_impl(Spark_Sleep_TypeDef sleepMode, long seconds, uint32_t param, void* reserved)
{
SYSTEM_THREAD_CONTEXT_SYNC(system_sleep_impl(sleepMode, seconds, param, reserved));
// TODO - determine if these are valuable:
// - Currently publishes will get through with or without #1.
// - More data is consumed with #1.
// - Session is not resuming after waking from DEEP sleep,
// so a full handshake currently outweighs leaving the
// modem on for #2.
//
//---- #1
// If we're connected to the cloud, make sure all
// confirmable UDP messages are sent before sleeping
// if (spark_cloud_flag_connected()) {
// Spark_Sleep();
// }
//---- #2
// SLEEP_NETWORK_STANDBY can keep the modem on during DEEP sleep
// System.sleep(10) always powers down the network, even if SLEEP_NETWORK_STANDBY flag is used.
if (network_sleep_flag(param) || SLEEP_MODE_WLAN == sleepMode) {
network_suspend();
}
switch (sleepMode)
{
case SLEEP_MODE_WLAN:
if (seconds)
{
HAL_RTC_Set_UnixAlarm((time_t) seconds);
}
break;
case SLEEP_MODE_DEEP:
if (network_sleep_flag(param))
{
network_disconnect(0, NETWORK_DISCONNECT_REASON_SLEEP, NULL);
network_off(0, 0, 0, NULL);
}
system_power_management_sleep();
return HAL_Core_Enter_Standby_Mode(seconds,
(param & SLEEP_DISABLE_WKP_PIN.value()) ? HAL_STANDBY_MODE_FLAG_DISABLE_WKP_PIN : 0);
break;
#if Wiring_SetupButtonUX
case SLEEP_MODE_SOFTPOWEROFF:
network_disconnect(0, NETWORK_DISCONNECT_REASON_SLEEP, NULL);
network_off(0, 0, 0, NULL);
sleep_fuel_gauge();
system_power_management_sleep();
return HAL_Core_Enter_Standby_Mode(seconds,
(param & SLEEP_DISABLE_WKP_PIN.value()) ? HAL_STANDBY_MODE_FLAG_DISABLE_WKP_PIN : 0);
break;
#endif
}
return 0;
}
void network_do()
{
struct EVDP_EVENT l_events[EVENTS_PER_CYCLE];
register struct EVDP_EVENT *ev;
register int n, nfds;
register SESSION *s;
nfds = evdp_wait(l_events, EVENTS_PER_CYCLE, 1000); // @TODO: timer_getnext()
for(n = 0; n < nfds; n++) {
ev = &l_events[n];
s = &g_Session[ ev->fd ];
if(ev->events & EVDP_EVENT_HUP) {
network_disconnect(ev->fd);
continue; // no further event processing.
}// endif vent is HUP (disconnect)
if(ev->events & EVDP_EVENT_IN) {
if(s->onRecv != NULL) {
if(false == s->onRecv(ev->fd)) {
network_disconnect(ev->fd);
continue; // ..
}
} else {
ShowError(read_message("Source.common.network_do"), ev->fd);
network_disconnect(ev->fd);
continue;
}
}// endif event is IN (recv)
if(ev->events & EVDP_EVENT_OUT) {
if(s->onSend != NULL) {
if(false == s->onSend(ev->fd)) {
network_disconnect(ev->fd);
continue;
}
} else {
ShowError(read_message("Source.common.network_do2"), ev->fd);
network_disconnect(ev->fd);
continue;
}
}// endif event is OUT (send)
}//endfor
}//end: network_do()
void app_send(struct item *key, struct item *message)
/*@ requires [?f0]world(ss_pub) &*&
item(key, symmetric_key_item(?creator, ?id), ss_pub) &*&
item(message, ?msg, ss_pub) &*& [_]ss_pub(msg) &*&
app_send_event(creator, msg) == true;
@*/
/*@ ensures [f0]world(ss_pub) &*&
item(key, symmetric_key_item(creator, id), ss_pub) &*&
item(message, msg, ss_pub);
@*/
{
struct network_status *net_stat =
network_connect("localhost", APP_RECEIVE_PORT);
struct item *hash = create_hmac(key, message);
//@ assert item(hash, ?h, ss_pub);
//@ get_info_for_item(h);
//@ close ss_pub(h);
//@ leak ss_pub(h);
struct item *m = create_pair(hash, message);
//@ assert item(m, ?pmessage, ss_pub);
//@ get_info_for_item(pmessage);
//@ close ss_pub(pmessage);
//@ leak ss_pub(pmessage);
network_send(net_stat, m);
item_free(hash);
item_free(m);
network_disconnect(net_stat);
}
void ui_network_dialog(void)
{
APTR window = mui_make_simple_window(build_gui(), translate_text(IDS_NETPLAY_SETTINGS));
/* FIXME: Bad workaround */
resources_set_value("EventSnapshotDir", (resource_value_t)"");
if (window != NULL) {
mui_add_window(window);
ui_get_to(ui_to_from);
set(window, MUIA_Window_Open, TRUE);
switch (mui_run()) {
case BTN_START_SERVER:
ui_get_from(ui_to_from);
if (network_start_server() < 0) {
ui_error(translate_text(IDMES_ERROR_STARTING_SERVER));
}
break;
case BTN_CONNECT_TO:
ui_get_from(ui_to_from);
if (network_connect_client() < 0) {
ui_error(translate_text(IDMES_ERROR_CONNECTING_CLIENT));
}
break;
case BTN_DISCONNECT:
network_disconnect();
break;
}
set(window, MUIA_Window_Open, FALSE);
mui_rem_window(window);
MUI_DisposeObject(window);
}
}
static void netplay_disconnect(GtkWidget *w, gpointer data)
{
netplay_update_resources();
network_disconnect();
netplay_update_status();
gtk_dialog_response(GTK_DIALOG(netplay_dialog), GTK_RESPONSE_CANCEL);
}
struct item *app_receive(struct item *key)
/*@ requires [?f0]world(ss_pub) &*&
item(key, symmetric_key_item(?creator, ?id), ss_pub);
@*/
/*@ ensures [f0]world(ss_pub) &*&
item(key, symmetric_key_item(creator, id), ss_pub) &*&
item(result, ?msg, ss_pub) &*&
(
bad(creator) ||
collision_in_run() ||
app_send_event(creator, msg)
);
@*/
{
struct network_status *net_stat = network_bind_and_accept(APP_RECEIVE_PORT);
struct item *m = network_receive(net_stat);
struct item *hash = pair_get_first(m);
struct item *message = pair_get_second(m);
//@ assert item(m, pair_item(?hmac_i, ?message_i), ss_pub);
//@ open [_]ss_pub(pair_item(hmac_i, message_i));
//@ if (!collision_in_run()) open [_]ss_pub(hmac_i);
//@ if (!collision_in_run()) open [_]ss_pub(message_i);
item_free(m);
hmac_verify(hash, key, message);
item_free(hash);
network_disconnect(net_stat);
return message;
}
static void network_hook_connected_send(void)
{
BYTE *local_event_buf = NULL;
unsigned int send_len;
BYTE send_len4[4];
/* create and send current event buffer */
network_event_record(EVENT_LIST_END, NULL, 0);
send_len = network_create_event_buffer(&local_event_buf, &(frame_event_list[current_frame]));
#ifdef NETWORK_DEBUG
t1 = vsyncarch_gettime();
#endif
util_int_to_le_buf4(send_len4, (int)send_len);
if (network_send_buffer(network_socket, send_len4, 4) < 0
|| network_send_buffer(network_socket, local_event_buf, send_len) < 0) {
ui_display_statustext(translate_text(IDGS_REMOTE_HOST_DISCONNECTED), 1);
network_disconnect();
}
#ifdef NETWORK_DEBUG
t2 = vsyncarch_gettime();
#endif
lib_free(local_event_buf);
}
void system_sleep(Spark_Sleep_TypeDef sleepMode, long seconds, uint32_t param, void* reserved)
{
// TODO - determine if these are valuable:
// - Currently publishes will get through with or without #1.
// - More data is consumed with #1.
// - Session is not resuming after waking from DEEP sleep,
// so a full handshake currently outweighs leaving the
// modem on for #2.
//
//---- #1
// If we're connected to the cloud, make sure all
// confirmable UDP messages are sent before sleeping
// if (spark_cloud_flag_connected()) {
// Spark_Sleep();
// }
//---- #2
// SLEEP_NETWORK_STANDBY can keep the modem on during DEEP sleep
// System.sleep(10) always powers down the network, even if SLEEP_NETWORK_STANDBY flag is used.
if (network_sleep_flag(param) || SLEEP_MODE_WLAN == sleepMode) {
network_suspend();
}
switch (sleepMode)
{
case SLEEP_MODE_WLAN:
break;
case SLEEP_MODE_DEEP:
if (network_sleep_flag(param))
{
network_disconnect(0, 0, NULL);
network_off(0, 0, 0, NULL);
}
HAL_Core_Enter_Standby_Mode(seconds, nullptr);
break;
#if Wiring_SetupButtonUX
case SLEEP_MODE_SOFTPOWEROFF:
network_disconnect(0,0,NULL);
network_off(0, 0, 0, NULL);
sleep_fuel_gauge();
HAL_Core_Enter_Standby_Mode(seconds, nullptr);
break;
#endif
}
}
void network_shutdown(void)
{
if (network_connected())
network_disconnect();
network_free_frame_event_list();
lib_free(server_name);
lib_free(server_bind_address);
}
struct item *receive()
//@ requires [?f0]world(dummy_pub, dummy_key_clsfy) &*& principal(?p, ?c);
/*@ ensures [f0]world(dummy_pub, dummy_key_clsfy) &*& principal(p, c) &*&
item(result, ?msg, dummy_pub) &*& msg == data_item(_); @*/
{
struct network_status *net_stat = network_bind_and_accept(APP_RECEIVE_PORT);
struct item *m = network_receive(net_stat);
check_is_data(m);
network_disconnect(net_stat);
return m;
}
int ps4link_disconnect(void)
{
// Disconnect from the command port.
//if (network_disconnect(command_socket) < 0) { return -1; }
// Disconnect from the request port.
if (network_disconnect(request_socket) < 0)
{
return -1;
}
// Disconnect from console port.
if (network_disconnect(console_socket) < 0)
{
return -1;
}
// End function.
return 0;
}
static void ondata(NETWORK_HANDLE handle, void* userptr)
{
CUBE_CONNECTION* conn;
SVR_USER_CTX ctx;
conn = (CUBE_CONNECTION*)userptr;
ctx.conn = conn;
os_mutex_lock(&room_mtx);
while(1) {
int ret;
unsigned short len;
char pkg_buf[sizeof(conn->recv_buf)];
MEM_STREAM stream;
if(network_recvbuf_len(handle)<2) break;
network_recvbuf_get(handle, &len, 0, sizeof(len));
if(network_recvbuf_len(handle)<len) break;
network_recvbuf_get(handle, pkg_buf, sizeof(len), len-sizeof(len));
if(conn->nick[0]=='\0' && *((unsigned short*)pkg_buf)!=LOGIN_FILTER_ID) {
network_disconnect(handle);
break;
}
memstream_init(&stream, pkg_buf, len, len);
ret = SVR_Dispatcher(&ctx, (STREAM*)&stream);
if(ret!=ERR_NOERROR) {
network_disconnect(handle);
break;
}
network_recvbuf_commit(handle, len);
}
os_mutex_unlock(&room_mtx);
}
static void network_suspend() {
// save the current state so it can be restored on wakeup
#ifndef SPARK_NO_CLOUD
wakeupState.cloud = spark_cloud_flag_auto_connect();
#endif
wakeupState.wifi = !SPARK_WLAN_SLEEP;
wakeupState.wifiConnected = wakeupState.cloud || network_ready(0, 0, NULL) || network_connecting(0, 0, NULL);
// Disconnect the cloud and the network
network_disconnect(0, NETWORK_DISCONNECT_REASON_SLEEP, NULL);
#ifndef SPARK_NO_CLOUD
// Clear the auto connect status
spark_cloud_flag_disconnect();
#endif
network_off(0, 0, 0, NULL);
}
void send()
//@ requires [?f0]world(dummy_pub, dummy_key_clsfy) &*& principal(?p, ?c);
//@ ensures [f0]world(dummy_pub, dummy_key_clsfy) &*& principal(p, c);
{
struct network_status *net_stat =
network_connect("localhost", APP_RECEIVE_PORT);
char i;
struct item *m = create_data_item_from_int(i);
//@ assert item(m, ?data, dummy_pub);
//@ close dummy_pub(data);
//@ leak dummy_pub(data);
network_send(net_stat, m);
item_free(m);
network_disconnect(net_stat);
}
void network_send(int32 fd, netbuf buf){
register SESSION *s = &g_Session[fd];
#ifdef PARANOID_CHECKS
if(fd >= MAXCONN){
ShowError("network_send: tried to attach buffer to connection idientifer #%u which is out of bounds.\n", fd);
_network_free_netbuf_async(buf);
return;
}
#endif
if(s->type == NST_FREE)
return;
// Check Max Outstanding buffers limit.
if( (s->write.max_outstanding > 0) &&
(s->write.n_outstanding >= s->write.max_outstanding) ){
ShowWarning("network_send: fd #%u max Outstanding buffers exceeded. - disconnecting.\n", fd);
network_disconnect(fd);
//
_network_free_netbuf_async(buf);
return;
}
// Attach to the end:
buf->next = NULL;
if(s->write.buf_last != NULL){
s->write.buf_last->next = buf;
s->write.buf_last = buf;
}else{
// currently no buffer attached.
s->write.buf = s->write.buf_last = buf;
// register @ evdp for writable notification.
evdp_writable_add(fd, &s->evdp_data); //
}
//
s->write.n_outstanding++;
}//end: network_send()
void* ntp_connect(
const char* server,
int server_port,
void (*ntp_func)(uint32_t, uint32_t, uint32_t, uint32_t))
{
ntp_handle* handle;
if((handle = (ntp_handle*)malloc(sizeof(ntp_handle))) == NULL)
return NULL;
handle->receive_func = ntp_func;
handle->last_sec_sent = 0;
handle->last_nsec_sent = 0;
if((handle->sock = network_connect_udp(
server,
server_port,
NULL,
NULL)) == INVALID_SOCKET)
{
free(handle);
return NULL;
}
//printf("Unable to reach '%s:%d'\n", server, server_port);
if((handle->listener = network_listen_udp_from(
handle->sock,
ntp_listen,
handle->receive_packet,
NTP_PACKET_SIZE,
(void*)handle)) == NULL)
{
network_disconnect(handle->sock);
free(handle);
return NULL;
}
return (void*)handle;
}
void symbolic_attacker(int attacker_id, struct keypair* keypair)
/*@ requires [?f]world(?pub, ?key_clsfy) &*&
true == bad(attacker_id) &*&
principal(attacker_id, ?count) &*&
keypair(keypair, attacker_id, ?id, ?info, pub); @*/
//@ ensures false;
{
//@ retreive_proof_obligations();
for (;;)
/*@ invariant [f]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
principal(attacker_id, _) &*&
keypair(keypair, attacker_id, id, info, pub); @*/
{
struct network_status *net_stat = 0;
int net_choise = random_int_();
int port = random_int_();
if (net_choise % 2 == 0)
net_stat = network_bind_and_accept(port % 65536);
else
net_stat = network_connect("localhost", port % 65536);
{
int action = random_int_();
int *counter;
switch (action % 13)
{
case 0:
//@ open [f]world(pub, key_clsfy);
//@ assert [_]is_key_classifier(_, pub, key_clsfy);
//@ retreive_public_invariant_constraints(key_clsfy);
//@ duplicate_lemma_function_pointer_chunk(key_classifier);
/*@ {
lemma void public_key_classifier(cryptogram key, int p, int c,
bool symmetric)
requires polarssl_proof_pred(pub, key_clsfy)() &*&
[_]polarssl_pub(pub)(key) &*&
symmetric ?
key == cg_symmetric_key(p, c)
:
key == cg_private_key(p, c);
ensures polarssl_proof_pred(pub, key_clsfy)() &*&
col || true == key_clsfy(p, c, symmetric);
{
open [_]polarssl_pub(pub)(key);
item k;
if (symmetric)
k = symmetric_key_item(p, c);
else
k = private_key_item(p, c);
open polarssl_proof_pred(pub, key_clsfy)();
assert is_key_classifier(?proof, pub, key_clsfy);
proof(k, p, c, symmetric);
close polarssl_proof_pred(pub, key_clsfy)();
}
produce_lemma_function_pointer_chunk(public_key_classifier) :
public_key_classifier(polarssl_pub(pub), key_clsfy,
polarssl_proof_pred(pub, key_clsfy))
(key__, p__, c__, sym__)
{ call(); }
{duplicate_lemma_function_pointer_chunk(public_key_classifier);};
}
@*/
//@ close polarssl_proof_pred(pub, key_clsfy)();
attacker();
//@ open polarssl_proof_pred(pub, key_clsfy)();
//@ close [f]world(pub, key_clsfy);
//@ leak public_invariant_constraints(_, _);
//@ leak is_public_key_classifier(_, _, _, _);
//@ leak is_key_classifier(_, _, _);
break;
case 1:
// Anyone can publish arbitrary data items...
send_data(net_stat);
break;
case 2:
// Anyone can create pairs of public items...
send_pair_composed(net_stat);
break;
case 3:
// Anyone can deconstruct a public pair...
send_pair_decomposed(net_stat);
break;
case 4:
// Bad principals can publish generated nonce items...
send_nonce(net_stat);
break;
case 5:
// Bad principals can increment public nonces...
increment_and_send_nonce(net_stat);
break;
case 6:
// Bad principals can leak their keys...
send_keys(net_stat, keypair);
break;
case 7:
// Anyone can hmac public payload with public key
send_hmac(net_stat, keypair);
break;
case 8:
// Anyone can symmteric encrypt public payload with public key
send_symmetric_encrypted(net_stat, keypair);
break;
case 9:
// Anyone can symmteric decrypt message with public key
send_symmetric_decrypted(net_stat, keypair);
break;
case 10:
// Anyone can asymmteric encrypt public payload with public key
send_asymmetric_encrypted(net_stat, keypair);
break;
case 11:
// Anyone can asymmteric decrypt message with public key
send_asymmetric_decrypted(net_stat, keypair);
break;
case 12:
// Anyone can asymmteric sign public payload with public key
send_asymmetric_signature(net_stat, keypair);
}
}
network_disconnect(net_stat);
}
//@ leak proof_obligations(pub);
}
void telnet_disconnect(DESC * client)
{
network_disconnect(client);
}
static UI_CALLBACK(ui_netplay_disconnect)
{
network_disconnect();
}
struct item *client(char server, struct item *key, struct item *request)
/*@ requires [?f0]world(rpc_pub, rpc_key_clsfy) &*&
principal(?client, ?count) &*&
item(key, symmetric_key_item(?creator, ?id), rpc_pub) &*&
item(request, ?req, rpc_pub) &*& [_]rpc_pub(req) &*&
true == request(creator, server, req) &*&
shared_with(creator, id) == server;
@*/
/*@ ensures [f0]world(rpc_pub, rpc_key_clsfy) &*&
principal(client, count) &*&
item(key, symmetric_key_item(creator, id), rpc_pub) &*&
item(request, req, rpc_pub) &*& item(result, ?resp, rpc_pub) &*&
(
col || bad(creator) || bad(server) ||
response(creator, server, req, resp)
);
@*/
{
struct network_status *net_stat = network_connect("localhost", SERVER_PORT);
{
struct item *tag = create_data_item_from_int(0);
//@ item d = data_item(chars_of_int(0));
//@ assert item(tag, d, rpc_pub);
//@ close rpc_pub(d);
//@ leak rpc_pub(d);
struct item *payload = create_pair(tag, request);
//@ item p = pair_item(d, req);
//@ assert item(payload, p, rpc_pub);
//@ close rpc_pub(p);
//@ leak rpc_pub(p);
item_free(tag);
struct item *hash = create_hmac(key, payload);
//@ item h = hmac_item(creator, id, some(p));
//@ if (!col) assert item(hash, h, rpc_pub);
//@ close rpc_pub(h);
//@ leak rpc_pub(h);
struct item *m = create_pair(hash, payload);
//@ assert item(m, ?msg, rpc_pub);
//@ item msg0 = pair_item(h, p);
//@ if (!col) msg == msg0;
//@ close rpc_pub(msg);
//@ leak rpc_pub(msg);
item_free(hash);
item_free(payload);
network_send(net_stat, m);
item_free(m);
}
struct item *response;
{
struct item *r = network_receive(net_stat);
check_is_pair(r);
//@ assert item(r, pair_item(?h0, ?p0), rpc_pub);
struct item *hmac1 = pair_get_first(r);
//@ assert item(hmac1, ?h, rpc_pub);
struct item *payload = pair_get_second(r);
//@ assert item(payload, ?p, rpc_pub);
/*@ if (!col)
{
assert h0 == h;
assert p0 == p;
open [_]rpc_pub(pair_item(h, p));
open [_]rpc_pub(h);
open [_]rpc_pub(p);
}
@*/
struct item *hmac2 = create_hmac(key, payload);
item_check_equal(hmac1, hmac2);
item_free(hmac1);
item_free(hmac2);
item_free(r);
//@ assert col || h == hmac_item(creator, id, some(p));
struct item *tag = pair_get_first(payload);
check_is_data(tag);
int tagValue = item_get_data_as_int(tag);
if (tagValue != 1) abort();
//@ item d = data_item(chars_of_int(1));
//@ assert item(tag, ?d0, rpc_pub);
//@ assert col || d == d0;
item_free(tag);
struct item *reqresp = pair_get_second(payload);
struct item *request1 = pair_get_first(reqresp);
response = pair_get_second(reqresp);
//@ assert item(request1, ?req1, rpc_pub);
//@ assert item(response, ?resp, rpc_pub);
//@ if (!col) assert p == pair_item(d, pair_item(req1, resp));
item_free(payload);
item_free(reqresp);
item_check_equal(request, request1);
//@ assert col || req1 == req;
item_free(request1);
}
network_disconnect(net_stat);
return response;
}
void server(char server, struct item *key)
/*@ requires [?f0]world(rpc_pub, rpc_key_clsfy) &*&
principal(server, ?count) &*&
item(key, symmetric_key_item(?creator, ?id), rpc_pub) &*&
shared_with(creator, id) == server;
@*/
/*@ ensures [f0]world(rpc_pub, rpc_key_clsfy) &*&
principal(server, count + 1) &*&
item(key, symmetric_key_item(creator, id), rpc_pub);
@*/
{
struct network_status *net_stat = network_bind_and_accept(SERVER_PORT);
struct item *request = 0;
{
struct item *r = network_receive(net_stat);
check_is_pair(r);
//@ assert item(r, pair_item(?h0, ?p0), rpc_pub);
struct item *hmac1 = pair_get_first(r);
//@ assert item(hmac1, ?h, rpc_pub);
struct item *payload = pair_get_second(r);
//@ assert item(payload, ?p, rpc_pub);
/*@ if (!col)
{
assert h0 == h;
assert p0 == p;
open [_]rpc_pub(pair_item(h, p));
open [_]rpc_pub(h);
open [_]rpc_pub(p);
}
@*/
struct item *hmac2 = create_hmac(key, payload);
item_check_equal(hmac1, hmac2);
item_free(hmac1);
item_free(hmac2);
item_free(r);
//@ assert col || h == hmac_item(creator, id, some(p));
struct item *tag = pair_get_first(payload);
check_is_data(tag);
int tagValue = item_get_data_as_int(tag);
if (tagValue != 0) abort();
//@ item d = data_item(chars_of_int(0));
request = pair_get_second(payload);
/*@ if (!col)
{
assert item(tag, d, rpc_pub);
assert item(request, ?req, rpc_pub);
assert p == pair_item(d, req);
}
@*/
item_free(tag);
item_free(payload);
}
//@ assert item(request, ?req, rpc_pub);
struct item *response = compute_response(server, request);
//@ assert item(response, ?resp, rpc_pub);
{
struct item *reqresp = create_pair(request, response);
//@ item p = pair_item(req, resp);
//@ assert item(reqresp, p, rpc_pub);
//@ close rpc_pub(p);
//@ leak rpc_pub(p);
item_free(response);
item_free(request);
struct item *tag = create_data_item_from_int(1);
struct item *payload = create_pair(tag, reqresp);
//@ item d = data_item(chars_of_int(1));
//@ close rpc_pub(d);
//@ leak rpc_pub(d);
//@ assert item(payload, pair_item(d, p), rpc_pub);
//@ close rpc_pub(pair_item(d, p));
//@ leak rpc_pub(pair_item(d, p));
item_free(tag);
item_free(reqresp);
struct item *hash = create_hmac(key, payload);
//@ item h = hmac_item(creator, id, some(pair_item(d, p)));
//@ if (!col) assert item(hash, h, rpc_pub);
//@ close rpc_pub(h);
//@ leak rpc_pub(h);
struct item *m = create_pair(hash, payload);
//@ assert item(m, ?msg, rpc_pub);
//@ if (!col) msg == pair_item(h, pair_item(d, p));
//@ if (!col) assert item(m, msg, rpc_pub);
//@ close rpc_pub(msg);
//@ leak rpc_pub(msg);
item_free(hash);
item_free(payload);
network_send(net_stat, m);
item_free(m);
}
network_disconnect(net_stat);
}
int main(int argc, char* argv[])
{
//declare variables
int ret;
// poll client stuff
int i, j, maxi, connfd, sockfd;
int maxfd;
struct sockaddr_in cliaddr;
struct timeval clienttimeout;
int nready;
socklen_t clilen;
//
int client[MAX_CLIENTS];
fd_set master_set, readset, clientset;
VERBOSE = 0;
printf("ps4sh version %s\n",PS4SH_VERSION);
//call read config if exist we need redefine syntax and variables
read_config();
//if we call ps4sh with parameter it is the ps4 ip copy it to proper variable
if (argc == 2) {
strcpy(dst_ip, argv[1]);
dst_ip[strlen(argv[1])] = '\0';
}
clienttimeout.tv_sec = 0;
clienttimeout.tv_usec = USEC;
// create request socket connected to ps4link fio service
printf("Connecting to fio ps4link ip %s ", dst_ip);
request_socket = ps4link_fio_listener(dst_ip, SRV_PORT, 60);
if (request_socket < 0) {
printf(", failed\n");
return 1;
}
//udp socket to send commands to ps4
command_socket = network_connect(dst_ip, 0x4712, SOCK_DGRAM);
if (command_socket < 0) {
printf(", failed\n");
return 1;
}
// client stuff
for(i = 0; i < MAX_CLIENTS; i++) {
client[i] = -1;
}
FD_ZERO(&clientset);
// end client stuff
printf("\n");
//create console log udp socket bind to 0.0.0.0
console_socket = ps4link_log_listener(src_ip, LOG_PORT);
if ( console_socket < 0 ) {
perror("");
printf("Unable to start log service!\n");
//if i can't create local udp socket listening in LOG_PORT exit
return 1;
}
//create ps4sh listener to let tools from third parties connect to ps4sh
ps4sh_socket = ps4link_srv_setup(src_ip, SRV_PORT);
if ( ps4sh_socket < 0 ) {
perror("");
printf("Unable to start command server!\n");
//if i can't create local tcp socket listening in SRV_PORT exit
return 1;
}
//populate set standard output, command listener connected to ps4, udp logs listener, local command listener
FD_ZERO(&master_set);
//standard output
FD_SET(0, &master_set);
//ps4link fio channel
FD_SET(request_socket, &master_set);
//udp log channel
FD_SET(console_socket, &master_set);
//ps4sh channel
FD_SET(ps4sh_socket, &master_set);
client[0] = 0;
client[1] = request_socket;
client[2] = console_socket;
client[3] = ps4sh_socket;
maxfd = ps4sh_socket;
maxi = 3;
//initilize readline
initialize_readline();
debugNetPrintf(INFO,"Ready\n");
//mail loop
while(doloop) {
readset = master_set;
ret = select(maxfd+1, &readset, NULL, NULL, NULL);
if ( ret < 0 )
{
if ( FD_ISSET(0, &readset) ) {
continue;
}
debugNetPrintf(ERROR,"In select %s\n",strerror(errno));
break;
}
else if (ret == 0)
{
/* no file desc are ready, lets move on in life */
}
else
{
for(i = 0; i <= maxi; i++)
{
if ( (sockfd = client[i]) < 0)
{
continue;
}
if ( !FD_ISSET(sockfd, &readset) )
{
continue;
}
//if we have udp log messages from ps4 debugnet
if ( sockfd == console_socket) {
ps4sh_log_read(console_socket);
}
//if we have local standard messages
else if (sockfd == 0)
{
rl_callback_read_char();
}
//if we have messages related to ps4link fio service
else if(sockfd == request_socket)
{
ps4sh_srv_read(request_socket);
}
//if we have pending connection related to ps4sh server listener
else if (sockfd == ps4sh_socket)
{
clilen = sizeof(cliaddr);
connfd = accept(ps4sh_socket, (struct sockaddr *)&cliaddr, &clilen);
//search empty space
for(j = 0; i<FD_SETSIZE; j++)
{
if(client[j] < 0)
{
client[j] = connfd;
break;
}
}
//populate in the set
FD_SET(connfd, &master_set);
//sanity checks
if(connfd > maxfd)
{
maxfd = connfd;
}
if ( j > maxi )
{
maxi = j;
}
if (--nready <= 0)
{
continue;
}
}
else
{
if ( ps4sh_srv_read(sockfd) < 0 ) {
close(sockfd);
FD_CLR(sockfd, &master_set);
client[i] = -1;
maxi--;
}
}
}
}
}
rl_callback_handler_remove();
if ( (ret = network_disconnect(request_socket)) == -1 ) {
debugNetPrintf(ERROR,"From request_socket network_disconect %s\n",strerror(errno));
}
if ( (ret = network_disconnect(console_socket)) == -1 ) {
debugNetPrintf(ERROR,"From console_socket network_disconect %s\n",strerror(errno));
}
if ( log_to_file ) {
if ((ret = close(log_f_fd)) == -1)
debugNetPrintf(ERROR,"From file log closing %s\n",strerror(errno));
}
if (strcmp(ps4sh_history, "") != 0 ) {
if ( (ret = write_history(ps4sh_history)) != 0)
debugNetPrintf(ERROR,"From ps4sh_history %s\n",strerror(errno));
}
printf("\n");
return(0);
}
static void network_hook_connected_receive(void)
{
BYTE *remote_event_buf = NULL;
unsigned int recv_len;
BYTE recv_len4[4];
event_list_state_t *remote_event_list;
event_list_state_t *client_event_list, *server_event_list;
suspended = 0;
if (current_frame == frame_delta - 1)
frame_buffer_full = 1;
if (frame_buffer_full) {
do {
if (network_recv_buffer(network_socket, recv_len4, 4) < 0) {
ui_display_statustext(translate_text(IDGS_REMOTE_HOST_DISCONNECTED), 1);
network_disconnect();
return;
}
recv_len = util_le_buf4_to_int(recv_len4);
if (recv_len == 0 && suspended == 0) {
/* remote host suspended emulation */
ui_display_statustext(translate_text(IDGS_REMOTE_HOST_SUSPENDING), 0);
suspended = 1;
vsync_suspend_speed_eval();
}
} while (recv_len == 0);
if (suspended == 1)
ui_display_statustext("", 0);
remote_event_buf = lib_malloc(recv_len);
if (network_recv_buffer(network_socket, remote_event_buf,
recv_len) < 0) {
lib_free(remote_event_buf);
return;
}
#ifdef NETWORK_DEBUG
t3 = vsyncarch_gettime();
#endif
remote_event_list = network_create_event_list(remote_event_buf);
lib_free(remote_event_buf);
if (network_mode == NETWORK_SERVER_CONNECTED) {
client_event_list = remote_event_list;
server_event_list = &(frame_event_list[frame_to_play]);
} else {
server_event_list = remote_event_list;
client_event_list = &(frame_event_list[frame_to_play]);
}
/* test for sync */
if (client_event_list->base->type == EVENT_SYNC_TEST
&& server_event_list->base->type == EVENT_SYNC_TEST) {
int i;
for (i = 0; i < 5; i++) {
if (((DWORD *)client_event_list->base->data)[i]
!= ((DWORD *)server_event_list->base->data)[i]) {
ui_error(translate_text(IDGS_NETWORK_OUT_OF_SYNC));
network_disconnect();
/* shouldn't happen but resyncing would be nicer */
break;
}
}
}
/* replay the event_lists; server first, then client */
event_playback_event_list(server_event_list);
event_playback_event_list(client_event_list);
event_clear_list(remote_event_list);
lib_free(remote_event_list);
}
network_prepare_next_frame();
#ifdef NETWORK_DEBUG
t4 = vsyncarch_gettime();
#endif
}
