void send_keys(struct network_status *net_stat, struct keypair *keypair)
/*@ requires [?f0]world(?pub, ?key_clsfy) &*&
keypair(keypair, ?attacker_id, ?id, ?info, pub) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(attacker_id, ?count1) &*&
true == bad(attacker_id); @*/
/*@ ensures [f0]world(pub, key_clsfy) &*&
keypair(keypair, attacker_id, id, info, pub) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(attacker_id, ?count2); @*/
{
//@ close key_request(attacker_id, 0);
struct item *key_sym = create_symmetric_key();
struct item *key_priv = keypair_get_private_key(keypair);
struct item *key_pub = keypair_get_public_key(keypair);
//@ assert item(key_sym, ?k_sym, pub);
//@ assert item(key_pub, ?k_pub, pub);
//@ assert item(key_priv, ?k_priv, pub);
//@ open proof_obligations(pub);
//@ assert is_public_symmetric_key(?proof_sym, pub);
//@ assert is_public_public_key(?proof_pub, pub);
//@ assert is_public_private_key(?proof_priv, pub);
//@ proof_sym(k_sym);
//@ proof_pub(k_pub);
//@ proof_priv(k_priv);
//@ close proof_obligations(pub);
network_send(net_stat, key_sym);
network_send(net_stat, key_pub);
network_send(net_stat, key_priv);
item_free(key_sym);
item_free(key_pub);
item_free(key_priv);
}
void send_pair_decomposed(struct network_status *net_stat)
/*@ requires [?f0]world(?pub, ?key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(?principal, ?count1) &*&
true == bad(principal); @*/
/*@ ensures [f0]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(principal, ?count2); @*/
{
struct item *pair = network_receive(net_stat);
//@ assert item(pair, ?p, pub);
if (is_pair(pair))
{
struct item *first = pair_get_first(pair);
struct item *second = pair_get_second(pair);
//@ open proof_obligations(pub);
//@ assert is_public_pair_decompose(?proof1, pub);
//@ assert is_public_collision(?proof2, pub);
//@ proof1(p);
//@ assert item(first, ?f, pub);
//@ if (col) proof2(f);
//@ assert item(second, ?s, pub);
//@ if (col) proof2(s);
//@ close proof_obligations(pub);
network_send(net_stat, first);
network_send(net_stat, second);
item_free(first);
item_free(second);
}
item_free(pair);
}
/* ***************************************************
* Function: send_syn_ack
* ***************************************************
* Passive node calls this to send SYN_ACK and wait for
* the final ACK packet. It tries a total of 6 times before
* giving up.
*/
static bool send_syn_ack(mysocket_t sd, context_t *ctx, struct tcphdr* syn_packet)
{
struct tcphdr* ack_packet = (struct tcphdr *)calloc(1,(TH_MAX_OFFSET*sizeof(uint32_t))+STCP_MSS);
unsigned int event;
bool success = false;
int num_tries = 1;
struct timeval tstart;
gettimeofday(&tstart, NULL); /*Start the timer */
network_send(sd, syn_packet, (TH_MIN_OFFSET*sizeof(uint32_t)));
while((num_tries < MAX_RT_TRIES) && !success){
event = wait_for_event(sd, NETWORK_DATA, ctx, tstart);
if (event & NETWORK_DATA) {
network_recv(sd, ack_packet);
our_dprintf("Passive (ACK waiting): Ack: %d, Seq:%d, Next Seq:%d, Last Ack Sent: %d\n",
ack_packet->th_ack, ack_packet->th_seq, ctx->nxt_seq_num, ctx->last_ack_sent);
success = ((ack_packet->th_flags == TH_ACK) &&
(ack_packet->th_ack == ctx->nxt_seq_num));
}
else if (event==TIMEOUT){
our_dprintf("Passive Final INIT ACK not Received TIMEOUT!\n");
num_tries+=1;
gettimeofday(&tstart, NULL);
our_dprintf("PASSIVE - SEND SYN_ACK Packet with seq: %d and ack: %d \n",
syn_packet->th_seq, syn_packet->th_ack);
network_send(sd, syn_packet, (TH_MIN_OFFSET*sizeof(uint32_t)));
}
}
if (success){
our_dprintf("PASSIVE - RCVD Last Ack Packet has seq: %d and ack: %d \n",
ack_packet->th_seq, ack_packet->th_ack);
ctx->recv_win = MIN(syn_packet->th_win, CWIN);
}
free(ack_packet);
return success;
}
int ps4link_request_read(void *packet)
{
struct { unsigned int number; unsigned short length; int fd; int size; } PACKED *request = packet;
int result = -1, size = -1;
char buffer[65536], *bigbuffer;
// If a big read is requested...
if (ntohl(request->size) > sizeof(buffer))
{
// Allocate the bigbuffer.
bigbuffer = malloc(ntohl(request->size));
// Perform the request.
result = size = read(ntohl(request->fd), bigbuffer, ntohl(request->size));
// Send the response.
ps4link_response_read(result, size);
// Send the response data.
network_send(request_socket, bigbuffer, size);
// Free the bigbuffer.
free(bigbuffer);
// Else, a normal read is requested...
}
else
{
// Perform the request.
size = read(ntohl(request->fd), buffer, ntohl(request->size));
//int error=errno ;
//debugNetPrintf(DEBUG,"Error reading file: %s %s\n", strerror( error ),buffer);
result=size;
debugNetPrintf(DEBUG,"read %d bytes of file descritor %d\n",result,ntohl(request->fd));
// Send the response.
ps4link_response_read(result, size);
// Send the response data.
network_send(request_socket, buffer, size);
}
// End function.
return 0;
}
void TCPIP_GotNewPacket(void)
{
uip_input(); // Call the TCP/IP stack with the new packet
if (uip_len > 0) // If the above function invocation resulted in data that should be sent out
network_send(IP); // on the network, the global variable uip_len is set to a value > 0.
}
/* ***************************************************
* Function: handle_app_data
* ***************************************************
* The application has new data to be sent out. First make sure that
* there is some space in the window. Get maximum amount of data from
* the application, added it to the sender's buffer, and send it across
* the network.
*/
static void handle_app_data(mysocket_t sd, context_t *ctx)
{
size_t bytes_in_transit = ctx->nxt_seq_num - ctx->seq_base;
size_t win_space = ctx->recv_win - bytes_in_transit;
if (win_space>0){
char *pkt = (char *)calloc(1,(TH_MIN_OFFSET*sizeof(uint32_t)) + STCP_MSS);
struct tcphdr* hdr = (struct tcphdr*)pkt;
hdr->th_off = TH_MIN_OFFSET;
hdr->th_seq = ctx->nxt_seq_num;
hdr->th_flags = 0;
hdr->th_win = RWIN;
/* Pick the minimum between space in the window and MSS */
size_t data_max = MIN(STCP_MSS, win_space);
size_t len = stcp_app_recv(sd, pkt + TCP_DATA_START(hdr), data_max);
ctx->nxt_seq_num += len; /*add len to obtain nxt_seq_num to be used */
add_to_send_buffer(ctx, pkt, (TH_MIN_OFFSET*sizeof(uint32_t)) + len);
our_dprintf("Sending packet with seq: %d of size: %d\n",
hdr->th_seq,(TH_MIN_OFFSET*sizeof(uint32_t)) + len);
network_send(sd, pkt, (TH_MIN_OFFSET*sizeof(uint32_t)) + len);
free(pkt);
}
else {
our_dprintf(".");
}
}
void udp_send(uint16_t length) {
uint16_t tmp;
// IP protocol packet length
tmp = IP_LEN_HEADER + UDP_LEN_HEADER + length;
buffer_out[IP_PTR_LENGTH_H] = tmp >> 8;
buffer_out[IP_PTR_LENGTH_L] = tmp & 0xFF;
// UDP protocol packet length
tmp = UDP_LEN_HEADER + length;
buffer_out[UDP_PTR_LENGTH_H] = tmp >> 8;
buffer_out[UDP_PTR_LENGTH_L] = tmp & 0xFF;
// Calculate checksum IP header
tmp = checksum(&buffer_out[IP_PTR], IP_LEN_HEADER, CHK_IP);
buffer_out[IP_PTR_CHECKSUM_H] = tmp >> 8;
buffer_out[IP_PTR_CHECKSUM_L] = tmp & 0xFF;
// Calculate checksum UDP data
tmp = checksum(&buffer_out[IP_PTR_SRC], 16 + length, CHK_UDP);
buffer_out[UDP_PTR_CHECKSUM_H] = tmp >> 8;
buffer_out[UDP_PTR_CHECKSUM_L] = tmp & 0xFF;
#ifdef UTILS_WERKTI_MORE
// Update werkti udp out
werkti_udp_out += ETH_LEN_HEADER + IP_LEN_HEADER + UDP_LEN_HEADER + length;
#endif // UTILS_WERKTI_MORE
// Send packet to chip
network_send(ETH_LEN_HEADER + IP_LEN_HEADER + UDP_LEN_HEADER + length);
}
/* ***************************************************
* Function: handle_timeout
* ***************************************************
* This function is called whenever there is a timeout. Unless we
* are in the TIME_WAIT state, I retransmit all the packets starting
* from the beginning of the window.
* The RTO is also doubled when there is a retransmission as described
* in K&R.
*/
static void handle_timeout(mysocket_t sd, context_t *ctx)
{
if (ctx->connection_state==CSTATE_TIME_WAIT){
ctx->connection_state = CSTATE_CLOSED;
ctx->done = true;
return;
}
our_dprintf("TIMEOUT waiting for seq:%d\n", ctx->seq_base);
assert(ctx->sbuffer.num_entries>0 || !DEBUG);
assert(ctx->sbuffer.start->next!=NULL || !DEBUG);
struct p_entry *curr = ctx->sbuffer.start->next;
ctx->rto= MIN(ctx->rto*2, MAX_RTO);
/* Retransmit all packets */
while (curr){
struct tcphdr *hdr = (struct tcphdr*)curr->packet;
if (curr->num_transmits>=MAX_RT_TRIES){
our_dprintf("MAX NUMBER OF TRIES REACHED KILLING CONNECTION !!!!\n\n");
ctx->done = true;
errno = ETIMEDOUT;
return;
}
hdr->th_ack = ctx->last_ack_sent;
curr->num_transmits+=1; /* increase counter */
gettimeofday(&(curr->tstart),NULL);
network_send(sd, hdr, curr->packet_size);
curr = curr->next;
our_dprintf("Retransmitting Seq:%d with Len:%d New RTO:%f\n",
hdr->th_seq, ctx->sbuffer.start->next->packet_size, ctx->rto);
}
}
void send_data(struct network_status *net_stat)
/*@ requires [?f0]world(?pub, ?key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(?principal, ?count1) &*&
true == bad(principal); @*/
/*@ ensures [f0]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(principal, ?count2); @*/
{
int data_size = random_int_();
if (data_size > MIN_RANDOM_SIZE)
{
char* data = malloc((int) data_size);
if (data == 0) abort_crypto_lib("malloc failed");
random_buffer_(data, data_size);
struct item *item = create_data_item(data, data_size);
//@ assert item(item, ?i, pub) &*& i == data_item(?d);
free(data);
//@ open proof_obligations(pub);
//@ assert is_public_data(?proof, pub);
//@ proof(i);
//@ close proof_obligations(pub);
network_send(net_stat, item);
item_free(item);
}
}
void send_pair_composed(struct network_status *net_stat)
/*@ requires [?f0]world(?pub, ?key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(?principal, ?count1) &*&
true == bad(principal); @*/
/*@ ensures [f0]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(principal, ?count2); @*/
{
struct item *first = network_receive(net_stat);
struct item *second = network_receive(net_stat);
struct item * pair = create_pair(first, second);
//@ assert item(first, ?f, pub);
//@ assert item(second, ?s, pub);
//@ assert item(pair, pair_item(f, s), pub);
//@ open proof_obligations(pub);
//@ assert is_public_pair_compose(?proof, pub);
//@ proof(f, s);
//@ close proof_obligations(pub);
network_send(net_stat, pair);
item_free(pair);
item_free(first);
item_free(second);
}
void increment_and_send_nonce(struct network_status *net_stat)
/*@ requires [?f0]world(?pub, ?key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(?principal, ?count1) &*&
true == bad(principal); @*/
/*@ ensures [f0]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
network_status(net_stat) &*&
principal(principal, ?count2); @*/
{
struct item *nonce = network_receive(net_stat);
//@ assert item(nonce, ?n, pub);
if (is_nonce(nonce))
{
increment_nonce(nonce);
//@ assert item(nonce, ?n_inc, pub);
//@ open proof_obligations(pub);
/*@ if (col)
{
assert is_public_collision(?proof, pub);
proof(n_inc);
}
else
{
assert is_public_incremented_nonce(?proof, pub);
proof(n, n_inc);
}
@*/
//@ close proof_obligations(pub);
network_send(net_stat, nonce);
}
item_free(nonce);
}
void sample_device(FILE *f, FILE *m, int test)
{
struct buffer b;
size_t read = 0;
char *packet = NULL;
char count[24] = {0}; // Never gonna fill up
int i = 0;
size_t sent = 0;
while (!feof(f)) {
size_t rc = fread(&b, sizeof(struct buffer), 1, f);
char* rcc = fgets(&count[0], 23, m);
missed_count = atoi(&count[0]) - initial_missed;
if (!test && network_send(b, missed_count, &sent)) {
fprintf(stderr, "error: Could not send batch from buffer: %s\n", strerror(errno));
break;
}
if (debug)
debug_out(b);
if (test)
break;
outbytes += sent;
if (kbytes > 0 && outbytes / 1000 > kbytes) {
fprintf(stdout, "%zu kb requested, %zu bytes sent.\n", kbytes, outbytes);
break;
}
}
}
/* ***************************************************
* Function: active_init
* ***************************************************
* Initiate the active side connection. Send the SYN packet,
* wait for the SYN_ACK and then send the final SYN.
*/
static bool active_init(mysocket_t sd, context_t *ctx)
{
struct tcphdr* syn_packet = (struct tcphdr *)calloc(1,(TH_MAX_OFFSET*sizeof(uint32_t)) + STCP_MSS);
if (!sendrcv_syn(sd, ctx, syn_packet)) {
return false; /* Timeout waiting for SYN_ACK*/
}
ctx->connection_state = CSTATE_SYN_SENT;
our_dprintf("Active - RVCD SYN_ACK Seq: %d, ACK: %d \n", syn_packet->th_seq, syn_packet->th_ack);
ctx->recv_win = MIN(syn_packet->th_win, CWIN);
/* Send final ACK ---- Prepare Headers */
syn_packet->th_ack = syn_packet->th_seq + 1;
syn_packet->th_seq = ctx->nxt_seq_num;
syn_packet->th_flags = TH_ACK;
syn_packet->th_off = TH_MIN_OFFSET;
syn_packet->th_win = RWIN;
our_dprintf("Active - Sending Final ACK Seq: %d, ACK: %d \n", syn_packet->th_seq, syn_packet->th_ack);
network_send(sd, syn_packet, (TH_MIN_OFFSET*sizeof(uint32_t)));
/* Update connection state variables */
ctx->seq_base = ctx->nxt_seq_num;
ctx->last_ack_sent = syn_packet->th_ack;
free(syn_packet);
return true;
}
void lobby_host_loop() {
struct proto_join_packet packet;
static int tick = 0;
DARNIT_KEYS keys;
keys = d_keys_get();
d_keys_set(keys);
d_render_tile_blit(config.menu_background, 0, 0, 0);
if(!tick) {
packet.type = PROTO_TYPE_JOIN;
packet.player_id = -1;
strcpy(packet.player_name, config.player_name);
network_send(config.server.addr, &packet, sizeof(struct proto_join_packet));
update_player_list(lobby_join.list_players, config.player.player);
}
server_loop();
if(keys.select) {
game_state(GAME_STATE_LOBBY);
}
if(keys.start) {
game_state(GAME_STATE_GAME);
}
d_text_surface_draw(lobby_join.list_players);
d_text_surface_draw(lobby_host.start_game);
tick++;
tick %= 3;
}
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);
}
// -----[ _net_iface_ptmp_send ]-------------------------------------
static net_error_t _net_iface_ptmp_send(net_iface_t * self,
net_addr_t l2_addr,
net_msg_t * msg)
{
net_subnet_t * subnet;
net_iface_t * dst_iface;
net_error_t error;
int reached= 0;
assert(self->type == NET_IFACE_PTMP);
subnet= self->dest.subnet;
error= ip_opt_hook_msg_subnet(subnet, msg, &reached);
if (error != ESUCCESS)
return error;
if (reached) {
message_destroy(&msg);
return ESUCCESS;
}
// Find destination node (based on "physical address")
dst_iface= net_subnet_find_link(subnet, l2_addr);
if (dst_iface == NULL)
return ENET_HOST_UNREACH;
// Forward along link from subnet -> node ...
if (!net_iface_is_enabled(dst_iface))
return ENET_LINK_DOWN;
network_send(dst_iface, msg);
return ESUCCESS;
}
// -----[ _net_iface_ptp_send ]--------------------------------------
static int _net_iface_ptp_send(net_iface_t * self,
net_addr_t l2_addr,
net_msg_t * msg)
{
assert(self->type == NET_IFACE_PTP);
network_send(self->dest.iface, msg);
return ESUCCESS;
}
/**
* @brief Process Network
* @param None
* @retval None
*/
void Network_Process(void)
{
static uint8_t arp_counter = 0;
int i;
for (i = 0; i < UIP_CONNS; i++)
{
uip_periodic(i);
if (uip_len > 0)
{
uip_arp_out();
enc28j60_send_packet((uint8_t *)uip_buf, uip_len);
}
}
#if UIP_UDP
for (i = 0; i < UIP_UDP_CONNS; i++)
{
uip_udp_periodic(i);
if (uip_len > 0)
{
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if (++arp_counter >= 50)
{
arp_counter = 0;
uip_arp_timer();
}
uip_len = enc28j60_recv_packet((uint8_t *)uip_buf, UIP_BUFSIZE);
if (uip_len > 0)
{
if (((struct uip_eth_hdr *)&uip_buf[0])->type == htons(UIP_ETHTYPE_IP))
{
uip_arp_ipin();
uip_input();
if (uip_len > 0)
{
uip_arp_out();
enc28j60_send_packet((uint8_t *)uip_buf, uip_len);
}
}
else if (((struct uip_eth_hdr *)&uip_buf[0])->type == htons(UIP_ETHTYPE_ARP))
{
uip_arp_arpin();
if (uip_len > 0)
{
enc28j60_send_packet((uint8_t *)uip_buf, uip_len);
}
}
}
}
void ethernet_process(void) {
if(linkstate == 0) {
Dm9161 *pDm = &gDm9161;
if( DM9161_GetLinkSpeed(pDm, 1) != 0 ) {
TRACE_INFO("P: Link detected\n\r");
linkstate=1;
LED2_ON();
// Auto Negotiate
if (!DM9161_AutoNegotiate(pDm)) {
TRACE_INFO("P: Auto Negotiate ERROR!\n\r");
return;
}
}
} else {
uip_len = network_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)){
uip_arp_ipin();
uip_input();
if(uip_len > 0) {
uip_arp_out();
network_send();
}
} else if(BUF->type == htons(UIP_ETHTYPE_ARP)){
uip_arp_arpin();
if(uip_len > 0){
network_send();
}
}
}
}
}
static ssize_t write_all(const void *src, size_t len, int fd)
{
uintptr_t ptr = (uintptr_t) src;
while (len) {
ssize_t ret = network_send(fd, (const void *) ptr, len, 0);
ptr += ret;
len -= ret;
}
return (ssize_t)(ptr - (uintptr_t) src);
}
int l_disconnect(lua_State *l)
{
if (network_is_connected(main_window->network)) {
network_send(main_window->network, "BYE");
} else {
g_warning("tetris.client.disconnect: Already disconnected");
}
return 0;
}
static void push_message(MSG msg, size_t msgLength){
if(queue_nitems(msg_queue) < MAX_MSG_QUEUE_SIZE){
//printf("Pushing a message for %d with length %d\n", msg.dest, msgLength);
queue_add(msg_queue, &msg, msgLength);
}
if(queue_nitems(msg_queue) == MAX_MSG_QUEUE_SIZE){
CNET_disable_application(nodeinfo.address);
}
network_send();
}
void nethandler_periodic()
{
int i;
times(UIP_CONNS, i) {
uip_periodic(i);
if (uip_len > 0) {
uip_arp_out();
network_send();
}
}
int l_send(lua_State *l)
{
gchar *str;
luaL_checktype(l, 1, LUA_TSTRING);
str = g_strdup(lua_tostring(l, 1));
network_send(NETWORK(main_window->network), str);
g_free(str);
return 0;
}
int ps4link_response_rmdir(int result)
{
struct { unsigned int number; unsigned short length; int result; } PACKED response;
// Build the response packet.
response.number = htonl(PS4LINK_RMDIR_RLY);
response.length = htons(sizeof(response));
response.result = htonl(result);
// Send the response packet.
return network_send(request_socket, &response, sizeof(response));
}
/* ***************************************************
* Function: send_ack
* ***************************************************
* Small helper function for preparing an ACK packet and sending
* it to the network.
*/
static void send_ack(mysocket_t sd, context_t* ctx)
{
struct tcphdr *ack_pkt = (struct tcphdr *)calloc(1, (TH_MIN_OFFSET*sizeof(uint32_t)));
ack_pkt->th_flags = TH_ACK;
ack_pkt->th_ack = ctx->last_ack_sent;
ack_pkt->th_seq = ctx->nxt_seq_num;
our_dprintf("Sending ack: %d with seq: %d\n", ack_pkt->th_ack, ack_pkt->th_seq);
ack_pkt->th_win = RWIN;
ack_pkt->th_off = TH_MIN_OFFSET;
network_send(sd, ack_pkt, TH_MIN_OFFSET*sizeof(uint32_t));
free(ack_pkt);
}
void ntp_update(void* h)
{
ntp_handle* handle = (ntp_handle*)h;
char packet[NTP_PACKET_SIZE];
int sec, nsec;
uint32_t* time = (uint32_t*)packet;
//printf("Sending...\n");
#define LI 0
#define VN 3
#define MODE 3
#define STRATUM 0
#define POLL 4
#define PREC -6
timer_get(
&sec,
&nsec);
memset(
packet,
'\0',
NTP_PACKET_SIZE);
time[0] = htonl(
(LI << 30) | (VN << 27) | (MODE << 24) |
(STRATUM << 16) | (POLL << 8) | (PREC & 0xff));
time[1] = htonl(1<<16);
time[2] = htonl(1<<16);
//
// We need to set the 'Transmit Timestamp' to the server. When
// the message comes back, this value it moved to the 'Origin Timestamp'
// field (time[6] and time[7]).
//
// For more details on thy these constants are used, see ntpserver.c.
//
time[10] = htonl((uint32_t)(sec + 2208988800ULL));
time[11] = htonl((uint32_t)(((uint64_t)nsec << 32) / 1000000000ULL));
// Store the last time we sent.
handle->last_sec_sent = time[10];
handle->last_nsec_sent = time[11];
network_send(
handle->sock,
packet,
NTP_PACKET_SIZE);
}
void nethandler_rx()
{
uip_len = network_read();
if (uip_len > 0) {
switch (ntohs(BUF->type)) {
case UIP_ETHTYPE_IP:
uip_arp_ipin();
uip_input();
if (uip_len > 0) {
uip_arp_out();
network_send();
}
break;
case UIP_ETHTYPE_ARP:
uip_arp_arpin();
if (uip_len > 0)
network_send();
break;
}
}
}
/* ***************************************************
* Function: sendrcv_syn
* ***************************************************
* Helper function for active-side network initiation.
* It sends the SYN packet and waits for the right SYN_ACK
*/
static bool sendrcv_syn(mysocket_t sd, context_t *ctx, struct tcphdr* in_packet)
{
/* Set SYN Headers */
struct tcphdr* out_packet = (struct tcphdr *)calloc(1,(TH_MIN_OFFSET*sizeof(uint32_t)));
out_packet->th_ack = 0;
out_packet->th_seq = ctx->initial_sequence_num;
out_packet->th_flags = TH_SYN;
out_packet->th_off = TH_MIN_OFFSET;
out_packet->th_win = RWIN;
ctx->nxt_seq_num = ctx->initial_sequence_num + 1; /* SYN Packet = 1 byte */
our_dprintf("Active Sending SYN. Seq:%d\n", out_packet->th_seq);
unsigned int event;
bool success = false;
int num_tries = 1;
struct timeval tstart;
gettimeofday(&tstart,NULL); /*start the timer */
network_send(sd, out_packet, (TH_MIN_OFFSET*sizeof(uint32_t)));
/* Try sending the SYN a total of 6 times before giving up */
while ((num_tries < MAX_RT_TRIES) && !success){
event = wait_for_event(sd, NETWORK_DATA, ctx, tstart);
if (event & NETWORK_DATA) {
network_recv(sd, in_packet);
/* Check to see if we got the right SYN_ACK */
success = ((in_packet->th_flags & (TH_SYN | TH_ACK)) &&
(in_packet->th_ack == ctx->nxt_seq_num));
}
else if (event==TIMEOUT){
our_dprintf("Active - SYN TIMEOUT!, no SYN_ACK!\n");
gettimeofday(&tstart,NULL);
num_tries+=1;
our_dprintf("Active Resending SYN. Seq:%d\n", out_packet->th_seq);
network_send(sd, out_packet, (TH_MIN_OFFSET*sizeof(uint32_t)));
}
}
free(out_packet);
return success;
}
void
Ethernet_Task(void) {
int i;
ethernet_process();
if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
interface_periodic();
}
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
