void
antialias_style_type::
attach
( QRadioButton * p_radio_best
, QRadioButton * p_radio_fastest
, QRadioButton * p_radio_none
, bool init_value_from_holder
)
{
d_assert( p_radio_best );
d_assert( p_radio_fastest);
d_assert( p_radio_none );
d_assert( p_radio_best != p_radio_fastest);
d_assert( p_radio_best != p_radio_none );
d_assert( p_radio_fastest != p_radio_none );
if ( init_value_from_holder ) {
// Set the init state of the radio buttons from this folder.
p_radio_best ->setChecked( is_best( ));
p_radio_fastest->setChecked( is_fastest( ));
p_radio_none ->setChecked( is_none( ));
} else {
// Set the init value of this holder from the radio buttons.
if ( p_radio_best->isChecked( ) ) {
d_assert( ! p_radio_fastest->isChecked( ));
d_assert( ! p_radio_none ->isChecked( ));
set_best( );
} else
if ( p_radio_fastest->isChecked( ) ) {
d_assert( ! p_radio_best->isChecked( ));
d_assert( ! p_radio_none->isChecked( ));
set_fastest( );
} else
if ( p_radio_none->isChecked( ) ) {
d_assert( ! p_radio_best ->isChecked( ));
d_assert( ! p_radio_fastest->isChecked( ));
set_none( );
} else {
// None of the radio buttons are on! Choose arbitrarily.
d_assert( false);
set_none( ); /* set the holder value */
p_radio_none->setChecked( true); /* check the radio button */
}
}
// Tell the radio buttons to update the values here.
d_verify( connect( p_radio_best , SIGNAL( toggled( bool)), this, SLOT( set_best( bool)) ));
d_verify( connect( p_radio_fastest, SIGNAL( toggled( bool)), this, SLOT( set_fastest( bool)) ));
d_verify( connect( p_radio_none , SIGNAL( toggled( bool)), this, SLOT( set_none( bool)) ));
// Propagate changes here back to the radio buttons.
d_verify( connect( this, SIGNAL( has_changed__best( bool)), p_radio_best , SLOT( setChecked( bool)) ));
d_verify( connect( this, SIGNAL( has_changed__fastest( bool)), p_radio_fastest, SLOT( setChecked( bool)) ));
d_verify( connect( this, SIGNAL( has_changed__none( bool)), p_radio_none , SLOT( setChecked( bool)) ));
}
int main(int argc, char *argv[])
{
int cwnd;
cwnd = 4000; // default cwnd
timeout = 0;
int WINDOW_SIZE;
double p_loss, p_corrupt;
p_loss = 0.0;
p_corrupt = 0.0;
struct sockaddr_in serv_si, cli_si;
struct packet snd_pkt, rcv_pkt;
FILE *file;
struct stat file_stat;
int n_packets;
int readlength;
int portno, sockfd, i, recv_len, send_len;
int slen = sizeof(cli_si);
if (argc < 2)
{
fprintf(stderr, "Usage: %s port [cwnd] [loss ratio] [corrupt ratio]\n", argv[0]);
exit(0);
}
switch (argc)
{
case 5:
p_corrupt = atof(argv[4]);
case 4:
p_loss = atof(argv[3]);
case 3:
cwnd = atoi(argv[2]);
default:
portno = atoi(argv[1]);
break;
}
WINDOW_SIZE = cwnd / PACKET_SIZE;
//create a UDP socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
die("socketfd error", sockfd);
}
// zero out the structure
memset((char *) &serv_si, 0, sizeof(serv_si));
serv_si.sin_family = AF_INET;
serv_si.sin_port = htons(portno);
serv_si.sin_addr.s_addr = htonl(INADDR_ANY);
//bind socket to port
if(bind(sockfd , (struct sockaddr*)&serv_si, sizeof(serv_si)) == -1)
{
die("error in bind\n", sockfd);
}
rcv_pkt = make_packet();
msg("Waiting for file request...\n");
if ((recv_len = recvfrom(sockfd, &rcv_pkt, sizeof(rcv_pkt), 0, (struct sockaddr *) &cli_si, (socklen_t*)&slen)) == -1)
{
die("error receive syn", sockfd);
}
snd_pkt = make_packet();
if (check_syn(&rcv_pkt)) {
msg("Received file request for %s\n", rcv_pkt.data);
file = fopen(rcv_pkt.data, "rb");
if (file == NULL) // no file exists
{
msg("No such file, sending NONE packet...\n");
set_none(&snd_pkt);
if ((send_len = sendto(sockfd, &snd_pkt, sizeof(snd_pkt), 0, (struct sockaddr*)&cli_si, slen)) == -1)
{
die("Error sending NONE", sockfd);
}
teardown(file, sockfd);
}
}
stat(rcv_pkt.data, &file_stat);
n_packets = file_stat.st_size / DATA_SIZE;
if (file_stat.st_size % DATA_SIZE)
{
n_packets++;
}
int base, next_seq, last_ack = 1;
base = 1;
next_seq = 1;
last_ack = 0;
int pktindex;
struct packet pkt_win[WINDOW_SIZE];
char buf[PACKET_SIZE];
struct sigaction act;
memset (&act, '\0', sizeof(act));
act.sa_sigaction = &handle_sigalrm;
act.sa_flags = 0;
sigaction(SIGALRM, &act, NULL); //sets timeout handler
// Send initial packets
for (i = 0; i < min(WINDOW_SIZE, n_packets); i++) {
memset(buf, 0, PACKET_SIZE);
snd_pkt = make_packet();
snd_pkt.seq_num = i + 1;
readlength = fread(buf, sizeof(char), DATA_SIZE, file);
set_data(&snd_pkt, buf, readlength);
pkt_win[i] = snd_pkt;
msg("<- DATA: SEQNUM %d ...\n", snd_pkt.seq_num);
if (sendto(sockfd, &snd_pkt, sizeof(snd_pkt), 0, (struct sockaddr *)&cli_si, slen) < 0)
{
error("ERROR on sending");
}
next_seq++;
}
while (base <= n_packets) {
if (timeout) {
int n_char;
int resend_base = base;
msg("TIMEOUT: resending packets %d - %d\n", resend_base, min(resend_base + WINDOW_SIZE - 1, n_packets));
while (resend_base < next_seq) {
pktindex = (resend_base - 1) % WINDOW_SIZE;
send_len = sendto(sockfd, &pkt_win[pktindex], sizeof(pkt_win[pktindex]), 0, (struct sockaddr*)&cli_si, slen);
if (send_len < 0)
{
die("Error sending packet during timeout", sockfd);
}
msg("Retransmitting DATA with SEQNUM %d ...\n", resend_base);
resend_base++;
}
timeout = 0;
alarm(TO_SEC);
}
rcv_pkt = make_packet();
if ((recv_len = recvfrom(sockfd, &rcv_pkt, sizeof(rcv_pkt), 0, (struct sockaddr *) &cli_si, (socklen_t*)&slen)) == -1)
{
// Timed out, recvfrom unblocked.
// Continue, let loop hit timeout block above
continue;
}
else if (chance() < p_loss)
{
msg("Packet from receiver LOST\n");
}
else if (chance() < p_corrupt)
{
msg("Packet from receiver CORRUPT\n");
}
else if (check_fin(&rcv_pkt)) {
msg("-> FIN-ACK\n");
teardown(file, sockfd);
}
else if (rcv_pkt.seq_num == base) {
// Correct ACK received, stop timer
alarm(0);
msg("-> ACK: SEQNUM %d\n", rcv_pkt.seq_num);
last_ack = rcv_pkt.seq_num;
base = rcv_pkt.seq_num + 1;
// Send packets
if (next_seq <= min(base + WINDOW_SIZE, n_packets + 1)) {
memset(buf, 0, PACKET_SIZE);
if ((readlength = fread(buf, sizeof(char), DATA_SIZE, file)) == 0) {
// struct packet fin_pkt = make_packet();
// set_fin(fin_pkt);
// fin_pkt.seq_num = next_seq;
// if ((send_len = sendto(sockfd, &finpkt, sizeof(finpkt), 0, (struct sockaddr*)&cli_si, slen)) < 0) {
// die("Error sending packet during fin", sockfd);
// }
// else {
// msg("<- FIN ...\n");
// alarm(TO_SEC);
// }
alarm(TO_SEC);
}
else {
snd_pkt = make_packet();
set_data(&snd_pkt, buf, readlength);
snd_pkt.seq_num = next_seq;
pktindex = (next_seq - 1) % WINDOW_SIZE;
pkt_win[pktindex] = snd_pkt;
msg("<- DATA: SEQNUM %d ...\n", next_seq);
if ((send_len = sendto(sockfd, &pkt_win[pktindex], sizeof(pkt_win[pktindex]), 0, (struct sockaddr*)&cli_si, slen)) < 0) {
die("Error sending packet during data", sockfd);
}
if (next_seq == base) {
alarm(TO_SEC);
}
if (next_seq <= n_packets)
{
next_seq++;
}
}
}
}
else {
// Incorrect ACK received, restart timer
alarm(TO_SEC);
}
}
// Send FIN
snd_pkt = make_packet();
set_fin(&snd_pkt);
msg("<- FIN ...\n");
if ((send_len = sendto(sockfd, &snd_pkt, sizeof(snd_pkt), 0, (struct sockaddr*)&cli_si, slen)) < 0) {
die("Error sending packet during teardown", sockfd);
}
rcv_pkt = make_packet();
if ((recv_len = recvfrom(sockfd, &rcv_pkt, sizeof(rcv_pkt), 0, (struct sockaddr *) &cli_si, (socklen_t*)&slen)) > 0)
{
if (check_fin(&rcv_pkt)) {
msg("-> FIN-ACK\n");
teardown(file, sockfd);
}
}
teardown(file, sockfd);
return 0;
}
