/*
* Function that sends cumulative ACK.
*/
void send_ack()
{
int len;
udp_pack ack_packet;
initialize_packet(&ack_packet, port, sequence_num, 1);
ack_packet.ack_num = ordered_count + 1;
strcpy(ack_packet.data, NODATA);
char *ackpack = (char *)malloc(MTU*sizeof(char));
bzero(ackpack, MTU);
strcpy(ackpack, serialize_packet(ack_packet));
len = sendto(client_sfd, ackpack, strlen(ackpack), 0, (struct sockaddr *) &server_addr, clen);
if (n < 0)
{
printf("\nError while sending ACK at current count = %d\n", ordered_count);
report_error("ERROR: Sending ACK");
}
sequence_num++;
printf("\nACK: %d Sent\n", ack_packet.ack_num);
}
/*
* Function to establish handshake.
*/
int establish_handshake(char *req_file)
{
int success = 0, n;
udp_pack syn, synack, ack;
fd_set fds; // fd set declare
struct timeval time_out; // Struct for Timeout value
initialize_packet(&syn, 2222, sequence_num, 0);
char *synreq = (char *)malloc(MTU*sizeof(char));
bzero(synreq, MTU);
strcpy(synreq, serialize_packet(syn));
// SYN
//printf("\nSYN to send: %s", synreq);
n = sendto(client_sfd, synreq, strlen(synreq), 0, (struct sockaddr *) &server_addr, clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: writing to socket for SYN");
}
sequence_num++;
printf("\nHANDSHAKE SYN Sent\n");
//gettimeofday(&start_timev,NULL);
printf("\a");
char *buffer = (char *)malloc(MTU*sizeof(char));
bzero(buffer, MTU);
// SYN-ACK
FD_ZERO(&fds); // Clear the fd set
FD_SET(client_sfd, &fds); // Set the client fd for select
time_out.tv_sec = 0;
time_out.tv_usec = timeout;
// Waiting until timeout for SYNACK
if ( select(32, &fds, NULL, NULL, &time_out) == 0 )
{
printf("SYNACK receiving timed out...\n");
}
else
{
bzero(buffer, MTU);
n = recvfrom(client_sfd, buffer, MTU, 0, (struct sockaddr *) &server_addr, &clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: reading from socket for SYNACK");
}
//printf("\nSYNACK response: %s", buffer);
synack = deserialize_data(buffer);
if(synack.is_ack != 1)
{
report_error("HANDSHAKE ERR: SYNACK not received from server during handshake");
}
printf("\nHANDSHAKE SYNACK received\n");
ack = synack;
ack.seq_num = sequence_num;
ack.ack_num = ack.seq_num + 1;
ack.is_ack = 1;
memset(ack.data, 0, DATALEN);
strcpy(ack.data, req_file);
char *ackpack = (char *)malloc(MTU*sizeof(char));
bzero(ackpack, MTU);
strcpy(ackpack, serialize_packet(ack));
//printf("Filename sent : %s", ackpack);
// ACK
//printf("\nACK to send: %s", ackpack);
n = sendto(client_sfd, ackpack, strlen(ackpack), 0, (struct sockaddr *) &server_addr, clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: writing to socket Handshake ACK");
}
printf("\nHANDSHAKE ACK Sent\n");
sequence_num++;
success = 1;
printf("\n-------- Handshake Successful --------\n");
}
return success;
}
static void
start_threads(struct glob_arg *g)
{
int i;
targs = calloc(g->nthreads, sizeof(*targs));
/*
* Now create the desired number of threads, each one
* using a single descriptor.
*/
for (i = 0; i < g->nthreads; i++) {
bzero(&targs[i], sizeof(targs[i]));
targs[i].fd = -1; /* default, with pcap */
targs[i].g = g;
if (g->dev_type == DEV_NETMAP) {
struct nmreq tifreq;
int tfd;
/* register interface. */
tfd = open("/dev/netmap", O_RDWR);
if (tfd == -1) {
D("Unable to open /dev/netmap: %s", strerror(errno));
continue;
}
targs[i].fd = tfd;
bzero(&tifreq, sizeof(tifreq));
strncpy(tifreq.nr_name, g->ifname, sizeof(tifreq.nr_name));
tifreq.nr_version = NETMAP_API;
if (g->host_ring) {
tifreq.nr_ringid = NETMAP_SW_RING;
} else {
tifreq.nr_ringid = (g->nthreads > 1) ? (i | NETMAP_HW_RING) : 0;
}
parse_nmr_config(g->nmr_config, &tifreq);
/*
* if we are acting as a receiver only, do not touch the transmit ring.
* This is not the default because many apps may use the interface
* in both directions, but a pure receiver does not.
*/
if (g->td_body == receiver_body) {
tifreq.nr_ringid |= NETMAP_NO_TX_POLL;
}
if ((ioctl(tfd, NIOCREGIF, &tifreq)) == -1) {
D("Unable to register %s: %s", g->ifname, strerror(errno));
continue;
}
D("memsize is %d MB", tifreq.nr_memsize >> 20);
targs[i].nmr = tifreq;
targs[i].nifp = NETMAP_IF(g->mmap_addr, tifreq.nr_offset);
D("nifp flags 0x%x", targs[i].nifp->ni_flags);
/* start threads. */
if (g->host_ring) {
targs[i].qfirst = (g->td_body == receiver_body ? tifreq.nr_rx_rings : tifreq.nr_tx_rings);
targs[i].qlast = targs[i].qfirst + 1;
} else {
targs[i].qfirst = (g->nthreads > 1) ? i : 0;
targs[i].qlast = (g->nthreads > 1) ? i+1 :
(g->td_body == receiver_body ? tifreq.nr_rx_rings : tifreq.nr_tx_rings);
}
} else {
targs[i].fd = g->main_fd;
}
targs[i].used = 1;
targs[i].me = i;
if (g->affinity >= 0) {
if (g->affinity < g->cpus)
targs[i].affinity = g->affinity;
else
targs[i].affinity = i % g->cpus;
} else
targs[i].affinity = -1;
/* default, init packets */
initialize_packet(&targs[i]);
if (pthread_create(&targs[i].thread, NULL, g->td_body,
&targs[i]) == -1) {
D("Unable to create thread %d: %s", i, strerror(errno));
targs[i].used = 0;
}
}
static void
start_threads(struct glob_arg *g)
{
int i;
targs = calloc(g->nthreads, sizeof(*targs));
/*
* Now create the desired number of threads, each one
* using a single descriptor.
*/
for (i = 0; i < g->nthreads; i++) {
struct targ *t = &targs[i];
bzero(t, sizeof(*t));
t->fd = -1; /* default, with pcap */
t->g = g;
if (g->dev_type == DEV_NETMAP) {
struct nm_desc nmd = *g->nmd; /* copy, we overwrite ringid */
uint64_t nmd_flags = 0;
nmd.self = &nmd;
if (g->nthreads > 1) {
if (nmd.req.nr_flags != NR_REG_ALL_NIC) {
D("invalid nthreads mode %d", nmd.req.nr_flags);
continue;
}
nmd.req.nr_flags = NR_REG_ONE_NIC;
nmd.req.nr_ringid = i;
}
/* Only touch one of the rings (rx is already ok) */
if (g->td_body == receiver_body)
nmd_flags |= NETMAP_NO_TX_POLL;
/* register interface. Override ifname and ringid etc. */
if (g->options & OPT_MONITOR_TX)
nmd.req.nr_flags |= NR_MONITOR_TX;
if (g->options & OPT_MONITOR_RX)
nmd.req.nr_flags |= NR_MONITOR_RX;
t->nmd = nm_open(t->g->ifname, NULL, nmd_flags |
NM_OPEN_IFNAME | NM_OPEN_NO_MMAP, &nmd);
if (t->nmd == NULL) {
D("Unable to open %s: %s",
t->g->ifname, strerror(errno));
continue;
}
t->fd = t->nmd->fd;
set_vnet_hdr_len(t);
} else {
targs[i].fd = g->main_fd;
}
t->used = 1;
t->me = i;
if (g->affinity >= 0) {
if (g->affinity < g->cpus)
t->affinity = g->affinity;
else
t->affinity = i % g->cpus;
} else {
t->affinity = -1;
}
/* default, init packets */
initialize_packet(t);
if (pthread_create(&t->thread, NULL, g->td_body, t) == -1) {
D("Unable to create thread %d: %s", i, strerror(errno));
t->used = 0;
}
}
}
void main(TCommandLine cmd)
{
fshutdown=-1;
agent_state = 3;
vccID = cmd.argv(0);
agentID = cmd.argv(1);
passwd = cmd.argv(2);
var TInteger FSM;
FSM = getfsmid();
CorrelationKey = sprintf('%04d', FSM);
print(sprintf('***The SL %s starts ,vccID:%s agentID:%s passwd:%s ***\n', CorrelationKey,vccID,agentID,passwd));
initialize_packet();
initial();
while(fshutdown==-1)
{
print(sprintf('***The SL %s is alive', CorrelationKey));
sleep(2);
}
on(serviceEvent, TCommandLine backevent)
{
print(sprintf('***The SL %s got message is %s***\n', CorrelationKey, backevent.argv()));
var TString xmlstr = strstr(backevent.argv(),'<acp');
var TXMLTree root = hxmlparse(xmlstr);
var TString type, name;
type = hxmlgetattr(root, 'acpMessage/body/type' , 'null');
if(type!='null')
{
name = hxmlgetattr(root, 'acpMessage/body/name', 'null');
switch(type)
{
case 'response':
if(name == 'Initial')
{
var TString ip = hxmlgetattr(root,'acpMessage/body/parameter/ip', 'null');
var TInteger port = atoi(hxmlgetattr(root,'acpMessage/body/parameter/port','0'));
sign_in(ip, port);
}
else if(name == 'SignIn')
{
agent_state=2;
timeStamp = hxml(root,'acpMessage/header/timeStamp', 'null');
send_state_msg();
set_idle();
}
else if(name == 'SetIdle')
{
agent_state=0;
var TString temp = hxmlgetattr(root, 'acpMessage/header/timeStamp', 'null');
if(timeStamp == '')
{
if(temp != 'null')
timeStamp = temp;
}
send_state_msg();
}
break;
case 'event':
if(name == 'OnAnswerRequest')
answer_request();
else if(name == 'OnForceOut')
{
agent_state=3;
send_state_msg();
force_out();
}
else if(name == 'OnAnswerSuccess')
answer_success();
break;
default:
print(sprintf('***The SL %s got unknown cmd***\n', CorrelationKey));
}
