client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <time.h>
#include "sham.h"
#include <stdarg.h>

long get_time_ms();

#define BUFFER_SIZE 1040 // 1024 (payload) + 16 (header)
#define PAYLOAD_SIZE 1024
#define WINDOW_SIZE 4 
#define RTO_MS 500 // Retransmission Timeout in milliseconds

// Packet structure for sender's window
typedef struct {
    char buffer[BUFFER_SIZE];
    int sent;
    struct timeval sent_time;
    uint32_t seq_num;
    size_t payload_len;
} SentPacket;

SentPacket window[WINDOW_SIZE];
int window_start = 0;
int window_end = 0;
uint32_t next_seq_to_send = 1;
uint32_t base_seq_num = 1;
uint32_t receiver_window = WINDOW_SIZE * PAYLOAD_SIZE;

FILE *log_file = NULL;

void log_event(const char *format, ...) {
    if (!log_file) {
        return;
    }

    char time_buffer[30];
    struct timeval tv;
    time_t curtime;
    gettimeofday(&tv, NULL);
    curtime = tv.tv_sec;

    strftime(time_buffer, 30, "%Y-%m-%d %H:%M:%S", localtime(&curtime));

    fprintf(log_file, "[%s.%06d] [LOG] ", time_buffer, tv.tv_usec);

    va_list args;
    va_start(args, format);
    vfprintf(log_file, format, args);
    va_end(args);

    fprintf(log_file, "\n");
    fflush(log_file);
}

// Function to simulate packet loss
int simulate_packet_loss(double loss_rate) {
    if (loss_rate > 0.0 && ((double)rand() / RAND_MAX) < loss_rate) {
        return 1; // Drop the packet
    }
    return 0; // Send the packet
}

long get_time_ms() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (long)tv.tv_sec * 1000 + (long)tv.tv_usec / 1000;
}

// Function to perform four-way handshake termination
int perform_four_way_handshake(int sockfd, struct sockaddr_in *server_addr, double loss_rate) {
    char buffer[BUFFER_SIZE];
    struct sham_header *header = (struct sham_header *)buffer;
    
    printf("\nInitiating four-way handshake...\n");
    
    // Send FIN
    memset(buffer, 0, sizeof(struct sham_header));
    header->seq_num = next_seq_to_send;
    header->ack_num = 0;
    header->flags = FIN_FLAG;
    header->window_size = 0;
    
    int fin_retransmissions = 0;
    int ack_received = 0;
    
    while(fin_retransmissions < 5 && !ack_received) {
        if (!simulate_packet_loss(loss_rate)) {
            sham_header_to_network(header);
            sendto(sockfd, buffer, sizeof(struct sham_header), 0, (const struct sockaddr *)server_addr, sizeof(*server_addr));
            sham_header_to_host(header);
            printf("Sent FIN to server.\n");
            log_event("SND FIN SEQ=%u", header->seq_num);
        } else {
            log_event("DROP FIN SEQ=%u", header->seq_num);
            printf("[Packet Dropped] FIN packet dropped\n");
        }

        fd_set read_fds;
        struct timeval timeout;
        timeout.tv_sec = 2;
        timeout.tv_usec = 0;
        FD_ZERO(&read_fds);
        FD_SET(sockfd, &read_fds);

        if (select(sockfd + 1, &read_fds, NULL, NULL, &timeout) > 0) {
            recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
            sham_header_to_host(header);
            if (header->flags & ACK_FLAG) {
                printf("Received ACK from server.\n");
                log_event("RCV ACK FOR FIN ACK=%u", header->ack_num);
                ack_received = 1;
                break;
            }
        }
        fin_retransmissions++;
    }
    
    if (!ack_received) {
        printf("Failed to receive ACK for FIN after retries.\n");
        return -1;
    }

    // Wait for server's FIN
    printf("Waiting for server to send FIN...\n");
    fd_set read_fds;
    struct timeval timeout;
    timeout.tv_sec = 10; // Increased timeout
    timeout.tv_usec = 0;
    FD_ZERO(&read_fds);
    FD_SET(sockfd, &read_fds);

    if (select(sockfd + 1, &read_fds, NULL, NULL, &timeout) > 0) {
        recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
        sham_header_to_host(header);
        if (header->flags & FIN_FLAG) {
            printf("Received FIN from server.\n");
            log_event("RCV FIN SEQ=%u", header->seq_num);
            
            // Send final ACK
            memset(buffer, 0, sizeof(struct sham_header));
            header->seq_num = next_seq_to_send + 1;
            header->ack_num = header->seq_num + 1;
            header->flags = ACK_FLAG;
            header->window_size = 1024;
            
            if (!simulate_packet_loss(loss_rate)) {
                sham_header_to_network(header);
                sendto(sockfd, buffer, sizeof(struct sham_header), 0, (const struct sockaddr *)server_addr, sizeof(*server_addr));
                printf("Sent final ACK to server.\n");
                log_event("SND ACK FOR FIN ACK=%u", header->ack_num);
            }
            printf("Connection terminated.\n");
            return 0;
        }
    } else {
        printf("Timeout waiting for server's FIN. Connection will be closed anyway.\n");
        return -1;
    }
    
    return 0;
}

// --- Chat Mode Logic ---
void run_chat_mode(int sockfd, struct sockaddr_in *server_addr, double loss_rate) {
    char buffer[BUFFER_SIZE];
    struct sham_header *header = (struct sham_header *)buffer;
    fd_set read_fds;
    
    printf("Entering Chat Mode. Type messages and press Enter to send. Type '/quit' to exit.\n");
    
    while(1) {
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);
        FD_SET(sockfd, &read_fds);
        
        int max_fd = (STDIN_FILENO > sockfd) ? STDIN_FILENO : sockfd;
        
        if (select(max_fd + 1, &read_fds, NULL, NULL, NULL) == -1) {
            perror("select");
            break;
        }

        // Handle input from standard input
        if (FD_ISSET(STDIN_FILENO, &read_fds)) {
            char chat_msg[PAYLOAD_SIZE];
            if (fgets(chat_msg, PAYLOAD_SIZE, stdin) != NULL) {
                chat_msg[strcspn(chat_msg, "\n")] = 0;
                
                // Check for the /quit command
                if (strcmp(chat_msg, "/quit") == 0) {
                    printf("Quitting chat mode.\n");
                    return; // Just return, don't call handshake here
                }
                
                // Prepare chat message packet
                memset(buffer, 0, BUFFER_SIZE);
                header->seq_num = next_seq_to_send;
                header->ack_num = 0;
                header->flags = 0;
                header->window_size = 1024;
                memcpy(buffer + sizeof(struct sham_header), chat_msg, strlen(chat_msg) + 1);
                
                if (!simulate_packet_loss(loss_rate)) {
                    sham_header_to_network(header);
                    sendto(sockfd, buffer, sizeof(struct sham_header) + strlen(chat_msg) + 1, 0, (const struct sockaddr *)server_addr, sizeof(*server_addr));
                    sham_header_to_host(header);
                    log_event("SND DATA SEQ=%u LEN=%zu", header->seq_num, strlen(chat_msg) + 1);
                    printf("You: %s\n", chat_msg);
                } else {
                    log_event("DROP DATA SEQ=%u", next_seq_to_send);
                    printf("[Packet Dropped] You tried to send: %s\n", chat_msg);
                }
                next_seq_to_send += strlen(chat_msg) + 1;
            }
        }
        
        // Handle incoming data from the socket
        if (FD_ISSET(sockfd, &read_fds)) {
            ssize_t bytes_received = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
            if (bytes_received > (ssize_t)sizeof(struct sham_header)) {
                sham_header_to_host(header);
                
                if (header->flags & FIN_FLAG) {
                    printf("Server is closing the connection.\n");
                    log_event("RCV FIN SEQ=%u", header->seq_num);
                    // Send ACK for server's FIN
                    memset(buffer, 0, sizeof(struct sham_header));
                    header->seq_num = next_seq_to_send;
                    header->ack_num = header->seq_num + 1;
                    header->flags = ACK_FLAG;
                    header->window_size = 1024;
                    
                    if (!simulate_packet_loss(loss_rate)) {
                        sham_header_to_network(header);
                        sendto(sockfd, buffer, sizeof(struct sham_header), 0, (const struct sockaddr *)server_addr, sizeof(*server_addr));
                        printf("Sent ACK for server's FIN.\n");
                        log_event("SND ACK FOR FIN ACK=%u", header->ack_num);
                    }
                    return;
                }
                
                printf("Server: %s\n", buffer + sizeof(struct sham_header));
            }
        }
    }
}

int main(int argc, char *argv[]) {
    srand(time(NULL));

    // Check for logging environment variable
    if (getenv("RUDP_LOG") != NULL && strcmp(getenv("RUDP_LOG"), "1") == 0) {
        log_file = fopen("client_log.txt", "a");
        if (log_file == NULL) {
            perror("Failed to open client_log.txt");
        }
    }

    char *server_ip;
    int server_port;
    char *input_file_path = NULL;
    char *output_file_name = NULL;
    double loss_rate = 0.0;
    int chat_mode = 0;

    if (argc >= 4 && strcmp(argv[3], "--chat") == 0) {
        chat_mode = 1;
        server_ip = argv[1];
        server_port = atoi(argv[2]);
        if (argc == 5) {
            loss_rate = atof(argv[4]);
        }
    } else {
        if (argc < 5) {
            fprintf(stderr, "Usage: ./client <server_ip> <server_port> <input_file> <output_file> [loss_rate]\n");
            fprintf(stderr, "Or:    ./client <server_ip> <server_port> --chat [loss_rate]\n");
            if (log_file) fclose(log_file);
            exit(EXIT_FAILURE);
        }
        server_ip = argv[1];
        server_port = atoi(argv[2]);
        input_file_path = argv[3];
        output_file_name = argv[4];
        if (argc == 6) {
            loss_rate = atof(argv[5]);
        }
    }
    
    if (loss_rate < 0.0 || loss_rate > 1.0) {
        fprintf(stderr, "Error: loss_rate must be between 0.0 and 1.0\n");
        if (log_file) fclose(log_file);
        exit(EXIT_FAILURE);
    }
    
    int sockfd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    struct sham_header *header = (struct sham_header *)buffer;

    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        if (log_file) fclose(log_file);
        exit(EXIT_FAILURE);
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    server_addr.sin_addr.s_addr = inet_addr(server_ip);

    printf("Client connecting to server at %s:%d...\n", server_ip, server_port);
    
    // --- Three-Way Handshake (Client Side) ---
    printf("Initiating three-way handshake...\n");
    uint32_t client_isn = 1000;
    
    memset(buffer, 0, BUFFER_SIZE);
    header->seq_num = client_isn;
    header->ack_num = 0;
    header->flags = SYN_FLAG;
    header->window_size = 1024;
    
    if (!simulate_packet_loss(loss_rate)) {
        sham_header_to_network(header);
        sendto(sockfd, buffer, sizeof(struct sham_header), 0, (const struct sockaddr *)&server_addr, sizeof(server_addr));
        sham_header_to_host(header);
        log_event("SND SYN SEQ=%u", header->seq_num);
        printf("Sent SYN to server. Seq: %u\n", header->seq_num);
    } else {
        log_event("DROP SYN SEQ=%u", header->seq_num);
        printf("[Packet Dropped] SYN packet dropped\n");
    }
    
    // Receive SYN-ACK
    recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
    sham_header_to_host(header);
    
    if ((header->flags & SYN_FLAG) && (header->flags & ACK_FLAG) && (header->ack_num == client_isn + 1)) {
        log_event("RCV SYN-ACK SEQ=%u ACK=%u", header->seq_num, header->ack_num);
        printf("Received SYN-ACK from server. Seq: %u, Ack: %u\n", header->seq_num, header->ack_num);
        uint32_t server_isn = header->seq_num;
        
        // Send final ACK
        memset(buffer, 0, BUFFER_SIZE);
        header->seq_num = client_isn + 1;
        header->ack_num = server_isn + 1;
        header->flags = ACK_FLAG;
        header->window_size = 1024;
        
        if (!simulate_packet_loss(loss_rate)) {
            sham_header_to_network(header);
            sendto(sockfd, buffer, sizeof(struct sham_header), 0, (const struct sockaddr *)&server_addr, sizeof(server_addr));
            sham_header_to_host(header);
            log_event("SND ACK FOR SYN");
            printf("Sent final ACK to server. Ack: %u\n", header->ack_num);
        } else {
            log_event("DROP ACK FOR SYN");
        }
        printf("Connection established.\n\n");
        
        next_seq_to_send = client_isn + 1;
        base_seq_num = client_isn + 1;
    } else {
        fprintf(stderr, "Handshake failed.\n");
        close(sockfd);
        if (log_file) fclose(log_file);
        exit(EXIT_FAILURE);
    }

    if (chat_mode) {
        run_chat_mode(sockfd, &server_addr, loss_rate);
        // Perform handshake only once, after chat mode ends
        perform_four_way_handshake(sockfd, &server_addr, loss_rate);
    } else {
        printf("Beginning file transfer for '%s'...\n", input_file_path);
        FILE *file = fopen(input_file_path, "rb"); 
        if (!file) {
            perror("Failed to open file");
            close(sockfd);
            if (log_file) fclose(log_file);
            exit(EXIT_FAILURE);
        }
        
        // Send filename to server
        memset(buffer, 0, BUFFER_SIZE);
        header->seq_num = next_seq_to_send;
        header->ack_num = 0;
        header->flags = 0;
        header->window_size = WINDOW_SIZE;
        memcpy(buffer + sizeof(struct sham_header), output_file_name, strlen(output_file_name) + 1);

        int filename_ack_received = 0;
        while (!filename_ack_received) {
            if (!simulate_packet_loss(loss_rate)) {
                sham_header_to_network(header);
                sendto(sockfd, buffer, sizeof(struct sham_header) + strlen(output_file_name) + 1, 0, (const struct sockaddr *)&server_addr, sizeof(server_addr));
                sham_header_to_host(header);
                log_event("SND DATA SEQ=%u LEN=%zu", header->seq_num, strlen(output_file_name) + 1);
                printf("Client sent filename. Seq: %u\n", header->seq_num);
            } else {
                log_event("DROP DATA SEQ=%u", header->seq_num);
                printf("[Packet Dropped] Client tried to send filename. Seq: %u\n", header->seq_num);
            }

            fd_set read_fds;
            struct timeval timeout;
            timeout.tv_sec = 2; // Timeout for ACK
            timeout.tv_usec = 0;
            FD_ZERO(&read_fds);
            FD_SET(sockfd, &read_fds);

            if (select(sockfd + 1, &read_fds, NULL, NULL, &timeout) > 0) {
                char ack_buffer[BUFFER_SIZE];
                ssize_t bytes_received = recvfrom(sockfd, ack_buffer, BUFFER_SIZE, 0, NULL, NULL);
                if (bytes_received > 0) {
                    struct sham_header *ack_header = (struct sham_header *)ack_buffer;
                    sham_header_to_host(ack_header);
                    if ((ack_header->flags & ACK_FLAG) && (ack_header->ack_num == header->seq_num + strlen(output_file_name) + 1)) {
                        log_event("RCV ACK=%u", ack_header->ack_num);
                        printf("Client received ACK for filename. Ack: %u\n", ack_header->ack_num);
                        next_seq_to_send += strlen(output_file_name) + 1;
                        base_seq_num += strlen(output_file_name) + 1;
                        filename_ack_received = 1;
                    }
                }
            } else {
                log_event("TIMEOUT SEQ=%u", header->seq_num);
                printf("Timeout waiting for filename ACK. Retransmitting...\n");
            }
        }
        
        int file_read_complete = 0;
        
        while (1) {
            while ((window_end - window_start) < WINDOW_SIZE && !file_read_complete) {
                uint32_t bytes_in_flight = next_seq_to_send - base_seq_num;
                if (bytes_in_flight >= receiver_window) {
                    printf("Flow control: Waiting for receiver to clear its buffer. Bytes in flight: %u, Receiver window: %u\n", bytes_in_flight, receiver_window);
                    log_event("FLOW WIN UPDATE=%u", receiver_window);
                    break;
                }
                
                char payload[PAYLOAD_SIZE];
                size_t bytes_read = fread(payload, 1, PAYLOAD_SIZE, file);
                if (bytes_read <= 0) {
                    file_read_complete = 1;
                    break;
                }

                struct sham_header *header_ptr = (struct sham_header *)window[window_end % WINDOW_SIZE].buffer;
                header_ptr->seq_num = next_seq_to_send;
                header_ptr->ack_num = 0;
                header_ptr->flags = 0;
                header_ptr->window_size = WINDOW_SIZE;
                memcpy(window[window_end % WINDOW_SIZE].buffer + sizeof(struct sham_header), payload, bytes_read);

                if (!simulate_packet_loss(loss_rate)) {
                    sham_header_to_network(header_ptr);
                    sendto(sockfd, window[window_end % WINDOW_SIZE].buffer, sizeof(struct sham_header) + bytes_read, 0, (const struct sockaddr *)&server_addr, sizeof(server_addr));
                    sham_header_to_host(header_ptr);
                    log_event("SND DATA SEQ=%u LEN=%zu", header_ptr->seq_num, bytes_read);
                    printf("Client sent packet. Seq: %u, Bytes: %zu\n", header_ptr->seq_num, bytes_read);
                } else {
                    log_event("DROP DATA SEQ=%u", next_seq_to_send);
                    printf("[Packet Dropped] Client tried to send packet. Seq: %u\n", next_seq_to_send);
                }

                window[window_end % WINDOW_SIZE].sent = 1;
                window[window_end % WINDOW_SIZE].seq_num = next_seq_to_send;
                window[window_end % WINDOW_SIZE].payload_len = bytes_read;
                gettimeofday(&window[window_end % WINDOW_SIZE].sent_time, NULL);
                next_seq_to_send += bytes_read;
                window_end++;
            }

            fd_set read_fds;
            struct timeval dynamic_timeout;
            
            struct timeval *select_timeout_ptr = NULL;
            if (window_end > window_start) {
                long oldest_packet_time_ms = (long)window[window_start % WINDOW_SIZE].sent_time.tv_sec * 1000 + (long)window[window_start % WINDOW_SIZE].sent_time.tv_usec / 1000;
                long time_elapsed_ms = get_time_ms() - oldest_packet_time_ms;
                long remaining_timeout_ms = RTO_MS - time_elapsed_ms;

                if (remaining_timeout_ms < 0) remaining_timeout_ms = 0;
                
                dynamic_timeout.tv_sec = remaining_timeout_ms / 1000;
                dynamic_timeout.tv_usec = (remaining_timeout_ms % 1000) * 1000;
                select_timeout_ptr = &dynamic_timeout;
            } else {
                select_timeout_ptr = NULL; 
            }

            FD_ZERO(&read_fds);
            FD_SET(sockfd, &read_fds);
            int ready = select(sockfd + 1, &read_fds, NULL, NULL, select_timeout_ptr);

            if (ready > 0) {
                char ack_buffer[BUFFER_SIZE];
                ssize_t bytes_received = recvfrom(sockfd, ack_buffer, BUFFER_SIZE, 0, NULL, NULL);
                if (bytes_received > 0) {
                    struct sham_header *ack_header = (struct sham_header *)ack_buffer;
                    sham_header_to_host(ack_header);

                    if (ack_header->flags & ACK_FLAG) {
                        if (ack_header->window_size != receiver_window) {
                           log_event("FLOW WIN UPDATE=%u", ack_header->window_size);
                        }
                        receiver_window = ack_header->window_size;
                        log_event("RCV ACK=%u", ack_header->ack_num);
                        printf("Client received ACK. Ack: %u, Receiver's Window: %u\n", ack_header->ack_num, receiver_window);
                        
                        if (ack_header->ack_num > base_seq_num) {
                            base_seq_num = ack_header->ack_num;
                            printf("Sliding window updated. New base: %u\n", base_seq_num);
                            
                            while (window_start < window_end) {
                                uint32_t current_packet_end_seq = window[window_start % WINDOW_SIZE].seq_num + window[window_start % WINDOW_SIZE].payload_len;
                                if (current_packet_end_seq <= base_seq_num) {
                                    window_start++;
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            
            long current_time_ms = get_time_ms();
            if (window_end > window_start) {
                long sent_time_ms = (long)window[window_start % WINDOW_SIZE].sent_time.tv_sec * 1000 + (long)window[window_start % WINDOW_SIZE].sent_time.tv_usec / 1000;
                if ((current_time_ms - sent_time_ms) > RTO_MS) {
                    log_event("TIMEOUT SEQ=%u", window[window_start % WINDOW_SIZE].seq_num);
                    printf("Timeout for packet. Retransmitting Seq: %u\n", window[window_start % WINDOW_SIZE].seq_num);
                    struct sham_header *header_to_retransmit = (struct sham_header *)window[window_start % WINDOW_SIZE].buffer;
                    if (!simulate_packet_loss(loss_rate)) {
                        sham_header_to_network(header_to_retransmit);
                        sendto(sockfd, window[window_start % WINDOW_SIZE].buffer, sizeof(struct sham_header) + window[window_start % WINDOW_SIZE].payload_len, 0, (const struct sockaddr *)&server_addr, sizeof(server_addr));
                        sham_header_to_host(header_to_retransmit);
                        log_event("RETX DATA SEQ=%u LEN=%zu", header_to_retransmit->seq_num, window[window_start % WINDOW_SIZE].payload_len);
                    } else {
                        log_event("DROP DATA SEQ=%u", window[window_start % WINDOW_SIZE].seq_num);
                        printf("[Packet Dropped] Client tried to retransmit packet. Seq: %u\n", window[window_start % WINDOW_SIZE].seq_num);
                    }
                    gettimeofday(&window[window_start % WINDOW_SIZE].sent_time, NULL);
                }
            }

            if (file_read_complete && window_start == window_end) {
                printf("File transfer complete. All packets acknowledged.\n");
                break;
            }
        }
        fclose(file);
        perform_four_way_handshake(sockfd, &server_addr, loss_rate);
    }
    
    close(sockfd);
    if (log_file) {
        fclose(log_file);
    }
    return 0;
}