Point::Point( const POINT_MATRIX& matrix )
: Matrix<point_t>(matrix)
{
if(isCorrupt()){
throw(0);
}
}
Point& Point::operator=(const Point& cpy){
if(!isCorrupt()){
set(cpy.x(), 0, 0);
set(cpy.y(), 1, 0);
set(cpy.z(), 2, 0);
}
return *this;
}
inline void Point::debug_output() const
{
std::cout << "p{ " << x() << ", " << y() << ", " << z() << ", " << w() << " }";
if(isCorrupt()){
std::cout << " WARNING: Point is corrupt!";
}
std::cout << std::endl;
}
bool ExtentRect::isValid()
{
bool retval = !isCorrupt();
if (retval)
{
retval = (left <= right) && (bottom <= top);
}
return retval;
}
bool ReadWriteArchiveInterface::isReadOnly() const
{
// We set corrupt archives to read-only to avoid add/delete actions, that
// are likely to fail anyway.
if (isCorrupt()) {
return true;
}
QFileInfo fileInfo(filename());
if (fileInfo.exists()) {
return !fileInfo.isWritable();
} else {
return !fileInfo.dir().exists(); // TODO: Should also check if we can create a file in that directory
}
}
int main(int argc, char *argv[])
{
int n = 0, i = 0, len = 0, reuseaddr;
int ch;
struct sockaddr_in serv_addr, clnt_addr;
struct protocol1 header;
int protocol = 0;
struct protocol2_2 proto2_2;
struct protocol2_1 proto2_1;
int listenfd, clntaddrlen, connfd;
pid_t pid;
struct sigaction sa;
//FILE *stdIn = freopen(NULL, "rb", stdin);
//FILE *stdOut = freopen(NULL, "wb", stdout);
if(argc != 5)
{
printf("usage : %s -h <ip of server> -p <port>", argv[0]);
return 1;
}
if((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
{
bail("socket", -1);
return 1;
}
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) {
bail("setsockopt", listenfd);
return 1;
}
bzero((char *)&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
inet_pton(AF_INET, argv[2], &serv_addr.sin_addr);
serv_addr.sin_port = htons(atoi(argv[4]));
if(bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
bail("bind", listenfd);
return 1;
}
if(listen(listenfd, 5) < 0)
{
bail("listen", listenfd);
return 1;
}
/* Set up the signal handler */
sa.sa_handler = wait_for_child;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
bail("sigaction", listenfd);
return 1;
}
srand(time(NULL));
while(1)
{
clntaddrlen = sizeof(clnt_addr);
if((connfd = accept(listenfd, (struct sockaddr *)&clnt_addr, &clntaddrlen)) < 0)
{
bail("accept", listenfd);
continue;
}
// for a new server process to service this client
pid = fork();
if(pid==-1) {
bail("fork", connfd);
continue;
} else if(pid > 0) {
close(connfd);
continue;
}
// send phase1 msg
header.op = 0;
header.proto = 0;
header.trans_id = rand();
header.checksum = calChecksum(header);
header.trans_id = htonl(header.trans_id);
header.checksum = htons(header.checksum);
n = write(connfd, (char *)&header, sizeof(header));
if(n < 0) {bail("write phase 1", connfd); continue;}
// receive phase1 msg
memset(&header, '0', sizeof(header));
n = read(connfd,(char *)&header, sizeof(header));
if(n < 0) {bail("read phase 1", connfd); continue;}
header.checksum = ntohs(header.checksum);
header.trans_id = ntohl(header.trans_id);
protocol = header.proto;
if(isCorrupt(header, connfd)==1) {bail("corrupt", connfd); continue;}
//receive phase2 msg and send handled msg
if(protocol==PROTOCOL2_1) {
unsigned size = 0;
unsigned totalback = 0;
unsigned lastch = '\0';
char recvBuff[SIZE+3];
memset(recvBuff, '\0', SIZE+3);
memset(proto2_1.string, '\0', SIZE+3);
while((n = read(connfd, recvBuff, SIZE+3)) > 0) {
//printf("%s\n", recvBuff);
i = 0, size = 0;
//printf("here0\n");
while(i < n) {
ch = recvBuff[i++];
//printf("%c", ch);
if(ch == '\\') {
totalback++;
//printf("%d\n", totalback);
if(ch!=lastch && totalback%2==0) {
proto2_1.string[size++] = ch;
proto2_1.string[size++] = ch;
lastch = ch;
//printf("%d ", size);
}
//printf("here1\n");
} else if(ch =='0' && (totalback%2)==1){
proto2_1.string[size++] = '\\';
proto2_1.string[size++] = '0';
totalback--;
//printf("here\n");
//printf("here2 %d\n", totalback);
break;
} else if(ch != lastch) {
proto2_1.string[size++] = ch;
lastch = ch;
//printf("%d ", size);
//printf("here3\n");
}
}
//printf("here4\n");
//printf("%d\n")
//printf("\n%d",size);
//proto2_1.string[size++] = '\\';
//proto2_1.string[size++] = '0';
n = write(connfd, proto2_1.string, size);
if(n < 0) {bail("wirte phase 2", connfd); continue;}
memset(recvBuff, '\0', SIZE+3);
memset(proto2_1.string, '\0', SIZE+3);
}
} else if(protocol==PROTOCOL2_2) {
memset(proto2_2.string, '\0', SIZE);
char recvBuff[SIZE+3];
memset(recvBuff , '\0' , SIZE);
int recvSize = 0;// = proto2_2.length;
int sendSize = 0;
int counter = 0;
char lastch='\0', ch;
while((n = read(connfd, (char *)&proto2_2, 4)) > 0){
proto2_2.length = ntohl(proto2_2.length);
recvSize = proto2_2.length;
while(recvSize > 0)
{
n = read(connfd, recvBuff, SIZE);
while(counter < n){
ch = recvBuff[counter++];
if(ch != lastch){
proto2_2.string[sendSize++] = ch;
lastch = ch;
}
}
memset(recvBuff, '\0', SIZE);
recvSize = recvSize - counter;
counter = 0;
}
proto2_2.length = htonl(sendSize);
n = write(connfd, &proto2_2, sendSize+4);
sendSize = 0;
memset(proto2_2.string, '\0', SIZE);
}
} else {
bail("wrong protocol",connfd);
continue;
}
//h = gethostbyaddr((const char *)&clnt_addr.sin_addr.s_addr, sizeof(clnt_addr.sin_addr.s_addr), AF_INET);
//printf("server connected to %s (%s) \n", h->h_name, inet_ntoa(clnt_addr.sin_addr));
//printf("connection terminated.\n");
close(listenfd);
exit(0);
}
//fclose(stdIn);
//fclose(stdOut);
return 0;
}
int main(int argc, char**argv)
{
int sockfd, n, fp;
struct sockaddr_in servaddr, cliaddr;
socklen_t len = sizeof(servaddr);
char mesg[PACKET_SIZE];
int size;
double p_loss = .05;
double p_corrupt = .05;
if (argc != 2)
{
printf("usage: ./sender <PortNumber>");
exit(1);
}
/* Set up Socket Stuff */
sockfd=socket(AF_INET,SOCK_DGRAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(atoi(argv[1]));
bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
/* Set socket to nonbinding */
int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
/* these will hold file */
int filesize;
char* filebuffer;
/* Go-Back-N Protocol to transmit file */
int base = 0;
int nextSeqNum = 1;
int N = 5;
struct packet_stream ps = make_packet_stream(N);
time_t timer = 0;
int ftp_done = 0;
int handshake_done = 0;
int last_packet = -1;
// printf("FileSize: %d, PACKET_SIZE - HEADER_SIZE: %d\n", filesize, PACKET_SIZE-HEADER_SIZE);
printf("(%f) Server now running...\n", timestamp());
for (;;)
{
bzero(mesg, sizeof(mesg));
n = recvfrom(sockfd, mesg, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, &len);
if (n > 0)
{
struct packet ack = extract_packet(mesg);
// printf("ACK NUM: %d ", ack.ackNum);
if (!isCorrupt(ack))
{
printf("(%f) Receiving pkt w/ACK: %d. Base: %d => %d: ", timestamp(), ack.ackNum, base, base+1);
base = ack.ackNum + 1;
if (base == nextSeqNum)
timer = 0; //stop timer
else
timer = time(NULL);
if (ack.type == 0) //syn
{
//send out SYNACK
printf(" SYN, sending out SYNACK...\n");
struct packet synack = create_packet(1, 0, nextSeqNum, 0, NULL);
sendto(sockfd, synack.data, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
addPacketToStream(&ps, synack);
nextSeqNum++;
}
else if (ack.type == 2) //handshake ack
{
printf("Request for %s, opening file...\n", getData(ack));
char* filename = getData(ack);
filename[ack.size] = 0;
fp = open(filename, O_RDONLY);
if (fp < 0)
{
printf("Could not find file.\n");
exit(1);
}
struct stat st;
stat(filename, &st);
filesize = st.st_size;
filebuffer = (char *)malloc(filesize * sizeof(char));
read(fp, filebuffer, filesize);
handshake_done = 1;
}
else if (last_packet == ack.ackNum && ftp_done)
{
printf("Done transfering file. Sending FIN...\n");
struct packet fin = create_packet(5, 0, 0, 0, 0);
sendto(sockfd, fin.data, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
addPacketToStream(&ps, fin);
printf("Waiting for FIN-ACK..\n");
for (;;)
{
bzero(mesg, sizeof(mesg));
n = recvfrom(sockfd, mesg, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, &len);
if (n > 0)
{
struct packet finack = extract_packet(mesg);
if (finack.type == 6)
{
printf("(%f) FIN-ACK received. Goodbye!\n", timestamp());
return 0;
}
}
}
}
else
{
printf("\n");
}
}
}
//lets see if we can send any packets
if (!ftp_done && handshake_done && nextSeqNum < base + N)
{
printf("(%f) Sending out packet: SequenceNumber: %d...", timestamp(), nextSeqNum);
if (filesize > PACKET_SIZE - HEADER_SIZE)
{
printf("\n");
struct packet pkt = create_packet(3, PACKET_SIZE - HEADER_SIZE, nextSeqNum, 0, filebuffer);
if (!corruptedFile(p_loss, p_corrupt))
sendto(sockfd, pkt.data, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
else
printf("Packet lost!...\n");
timer = time(NULL);
addPacketToStream(&ps, pkt);
filesize -= (PACKET_SIZE - HEADER_SIZE);
filebuffer += (PACKET_SIZE - HEADER_SIZE);
// printf("\n\n DATA: %s\n\n", getData(pkt));
}
else
{
printf("(last packet)\n");
struct packet pkt = create_packet(3, filesize, nextSeqNum, 0, filebuffer);
sendto(sockfd, pkt.data, PACKET_SIZE, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
addPacketToStream(&ps, pkt);
ftp_done = 1;
last_packet = nextSeqNum + 1;
// printf("\n\n DATA: %s\n\n", getData(pkt));
}
nextSeqNum++;
}
int endtimer = time(NULL);
if (endtimer - timer >= 5 && timer != 0)
{
printf("(%f) Timeout: Resending all packets from %d to %d...\n", timestamp(), base, nextSeqNum -1);
resendAll(sockfd, cliaddr, &ps, base, nextSeqNum - 1);
timer = time(NULL);
}
}
free_packet_stream(&ps);
//wait for fin-ack
return 0;
}
