void sender_tcpc(SOCKET s, uint16 port)
{
uint16 RSR_len;
uint8 DATA_BUFF_IN[INPUT_SIZE_BUF];
switch (getSn_SR(s))
{
case SOCK_ESTABLISHED: /* if connection is established */
if(ch_status[s]==1)
{
ch_status[s] = 2;
}
send(s, DATA_BUFF_IN, MAX_SIZE_BUF, (bool)WINDOWFULL_FLAG_OFF, FPGA);
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
if ((RSR_len = getSn_RX_RSR(s)) > 0) /* check Rx data */
{
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
if (RSR_len > TX_RX_MAX_BUF_SIZE) RSR_len = TX_RX_MAX_BUF_SIZE; /* the data size to read is MAX_BUF_SIZE. */
// received_len = recv(s, DATA_BUFF_A, RSR_len); /* read the received data */
}
disconnect(s);
ch_status[s] = 0;
break;
case SOCK_CLOSED: /* if a socket is closed */
if(!ch_status[s])
{
ch_status[s] = 1;
}
if(socket(s, Sn_MR_TCP, port, 0x00) == 0) /* reinitialize the socket */
{
ch_status[s] = 0;
}
break;
case SOCK_INIT: /* if a socket is initiated */
if(time_return() - presentTime >= (tick_second * 3)) /* For TCP client's connection request delay : 3 sec */
{
/* Try to connect to TCP server(Socket, DestIP, DestPort) */
connect(s, Config_Msg.destip, Config_Msg.port);
presentTime = time_return();
}
break;
default:
break;
}
}
static void
test_kdc_insert_lookaside_cache_expire(void **state)
{
struct entry *e;
krb5_context context = *state;
krb5_data req1 = string2data("I'm a test request");
krb5_data rep1 = string2data("I'm a test response");
size_t e1_size = entry_size(&req1, &rep1);
krb5_data req2 = string2data("I'm a different test request");
size_t e2_size = entry_size(&req2, NULL);
struct entry *hash1_ent, *hash2_ent, *exp_ent;
time_return(0, 0);
kdc_insert_lookaside(context, &req1, &rep1);
hash1_ent = k5_hashtab_get(hash_table, req1.data, req1.length);
assert_non_null(hash1_ent);
assert_true(data_eq(hash1_ent->req_packet, req1));
assert_true(data_eq(hash1_ent->reply_packet, rep1));
exp_ent = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_ent->req_packet, req1));
assert_true(data_eq(exp_ent->reply_packet, rep1));
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, e1_size);
/* Increase hits on entry */
e = k5_hashtab_get(hash_table, req1.data, req1.length);
assert_non_null(e);
e->num_hits = 5;
time_return(STALE_TIME + 1, 0);
kdc_insert_lookaside(context, &req2, NULL);
assert_null(k5_hashtab_get(hash_table, req1.data, req1.length));
assert_int_equal(max_hits_per_entry, 5);
hash2_ent = k5_hashtab_get(hash_table, req2.data, req2.length);
assert_non_null(hash2_ent);
assert_true(data_eq(hash2_ent->req_packet, req2));
assert_int_equal(hash2_ent-> reply_packet.length, 0);
exp_ent = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_ent->req_packet, req2));
assert_int_equal(exp_ent->reply_packet.length, 0);
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, e2_size);
}
static void
test_kdc_insert_lookaside_multiple(void **state)
{
krb5_context context = *state;
krb5_data req1 = string2data("I'm a test request");
krb5_data rep1 = string2data("I'm a test response");
size_t e1_size = entry_size(&req1, &rep1);
krb5_data req2 = string2data("I'm a different test request");
size_t e2_size = entry_size(&req2, NULL);
struct entry *hash1_ent, *hash2_ent, *exp_first, *exp_last;
time_return(0, 0);
kdc_insert_lookaside(context, &req1, &rep1);
hash1_ent = k5_hashtab_get(hash_table, req1.data, req1.length);
assert_non_null(hash1_ent);
assert_true(data_eq(hash1_ent->req_packet, req1));
assert_true(data_eq(hash1_ent->reply_packet, rep1));
exp_first = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_first->req_packet, req1));
assert_true(data_eq(exp_first->reply_packet, rep1));
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, e1_size);
time_return(0, 0);
kdc_insert_lookaside(context, &req2, NULL);
hash2_ent = k5_hashtab_get(hash_table, req2.data, req2.length);
assert_non_null(hash2_ent);
assert_true(data_eq(hash2_ent->req_packet, req2));
assert_int_equal(hash2_ent->reply_packet.length, 0);
exp_last = K5_TAILQ_LAST(&expiration_queue, entry_queue);
assert_true(data_eq(exp_last->req_packet, req2));
assert_int_equal(exp_last->reply_packet.length, 0);
assert_int_equal(num_entries, 2);
assert_int_equal(total_size, e1_size + e2_size);
}
static void
test_kdc_insert_lookaside_no_reply(void **state)
{
krb5_context context = *state;
krb5_data req = string2data("I'm a test request");
struct entry *hash_ent, *exp_ent;
time_return(0, 0);
kdc_insert_lookaside(context, &req, NULL);
hash_ent = k5_hashtab_get(hash_table, req.data, req.length);
assert_non_null(hash_ent);
assert_true(data_eq(hash_ent->req_packet, req));
assert_int_equal(hash_ent->reply_packet.length, 0);
exp_ent = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_ent->req_packet, req));
assert_int_equal(exp_ent->reply_packet.length, 0);
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, entry_size(&req, NULL));
}
/* ------------ TCP Client Routine ------------ */
void ProcessTcpClient(SOCKET mSocket) {
// if len is not volatile, it will overflow
// and causes 'cstack' overstack error
volatile uint16_t len;
getSn = getSn_SR(mSocket);
switch (getSn_SR(mSocket)) {
case SOCK_ESTABLISHED:
if(ch_status[mSocket]==1) {
printf("\r\n%d : Connected", mSocket);
ch_status[mSocket] = 2;
}
/* check Rx data */
if ((len = getSn_RX_RSR(mSocket)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
/* the data size to read is MAX_BUF_SIZE. */
if (len > TX_RX_MAX_BUF_SIZE) len = TX_RX_MAX_BUF_SIZE;
/* read the received data */
len = recv(mSocket, RX_BUF, len);
RSR_len = len;
/* sent the received data back */
//send(mSocket, RX_BUF, len, (bool)WINDOWFULL_FLAG_OFF);
}
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
E1Flag = false; // Reset E1 flag
E2Flag = false; // Reset E2 flag
printf("\r\n%d : CLOSE_WAIT", mSocket);
/* check Rx data */
if ((len = getSn_RX_RSR(mSocket)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
/* the data size to read is MAX_BUF_SIZE. */
if (len > TX_RX_MAX_BUF_SIZE) len = TX_RX_MAX_BUF_SIZE;
/* read the received data */
len = recv(mSocket, RX_BUF, len);
RSR_len = len;
}
disconnect(mSocket);
ch_status[mSocket] = 0;
break;
case SOCK_INIT: /* if a socket is initiated */
/* For TCP client's connection request delay : 3 sec */
if(time_return() - presentTime >= (tick_second * 3)) {
/* Try to connect to TCP server(Socket, DestIP, DestPort) */
printf("\r\n[ Attempt to connect on socket %d ]", mSocket);
connect(mSocket, Chconfig_Type_Def.destip, Chconfig_Type_Def.port);
presentTime = time_return();
}
break;
case SOCK_CLOSED: /* if a socket is closed */
if(!ch_status[mSocket]) {
printf("\r\n%d : Loop-Back TCP Client Started. port: %d", mSocket, Chconfig_Type_Def.port);
ch_status[mSocket] = 1;
}
/* reinitialize the socket */
if(socket(mSocket, Sn_MR_TCP, Chconfig_Type_Def.port, 0x00) == 0) {
printf("\a%d : Fail to create socket.", mSocket);
ch_status[mSocket] = 0;
}
break;
}
}
void loopback_tcpc(SOCKET s, uint16 port)
{
uint16 RSR_len;
uint16 received_len;
uint16 sent_data_len = 0;
uint8 tmp_retry_cnt = 0;
switch (getSn_SR(s))
{
case SOCK_ESTABLISHED: /* if connection is established */
if(ch_status[s]==1)
{
ch_status[s] = 2;
}
if ((RSR_len = getSn_RX_RSR(s)) > 0) /* check Rx data */
{
if (RSR_len > TX_RX_MAX_BUF_SIZE) RSR_len = TX_RX_MAX_BUF_SIZE;
received_len = recv(s, DATA_BUFF_A, RSR_len); /* read the received data */
/* sent the received data */
sent_data_len = send(s, DATA_BUFF_A, received_len, (bool)WINDOWFULL_FLAG_OFF,MCU);
if(sent_data_len != received_len) /* ohly assert when windowfull */
{
init_windowfull_retry_cnt(s);
while(sent_data_len != received_len)
{
tmp_retry_cnt = incr_windowfull_retry_cnt(s);
if(tmp_retry_cnt <= WINDOWFULL_MAX_RETRY_NUM)
{
sent_data_len += send(s, DATA_BUFF_A, received_len, (bool)WINDOWFULL_FLAG_ON,MCU);
Delay_ms(WINDOWFULL_WAIT_TIME);
}
else
{
close(s);
while(1);
}
}
}
}
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
if ((RSR_len = getSn_RX_RSR(s)) > 0) /* check Rx data */
{
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
if (RSR_len > TX_RX_MAX_BUF_SIZE) RSR_len = TX_RX_MAX_BUF_SIZE; /* the data size to read is MAX_BUF_SIZE. */
received_len = recv(s, DATA_BUFF_A, RSR_len); /* read the received data */
}
disconnect(s);
ch_status[s] = 0;
break;
case SOCK_CLOSED: /* if a socket is closed */
if(!ch_status[s])
{
ch_status[s] = 1;
}
if(socket(s, Sn_MR_TCP, port, 0x00) == 0) /* reinitialize the socket */
{
ch_status[s] = 0;
}
break;
case SOCK_INIT: /* if a socket is initiated */
if(time_return() - presentTime >= (tick_second * 3)) /* For TCP client's connection request delay : 3 sec */
{
/* Try to connect to TCP server(Socket, DestIP, DestPort) */
connect(s, Config_Msg.destip, Config_Msg.port);
presentTime = time_return();
}
break;
default:
break;
}
}
