sdndriver.cpp

// sdndriver.cpp
// Phohanh Tran, CSS 432, Assignment 3
// Date of Last Modification: 02/28/2026
// Purpose: SDN driver, creates TCP and UDP packets to be sent to the SDN switch
#include <iostream>
#include <cstring>
#include "packet.h"
#include "sdnswitch.h"

// PacketValues: struct containing all packet header values that are
// modified in driver test cases, used to reset values between test cases
struct PacketValues
{
    uint8_t destMAC[6];
    uint8_t srcIP[16];
    uint8_t destIP[16];
    uint16_t srcPort;
    uint16_t destPort;
    bool isTCP;
};

// fillTCPHeader: fills the passed in TCP header struct w/ the passed in values
// Preconditions: TCPHeader udp is valid, and values are valid
// Postconditions: returns TCPHeader udp with filled values.
// Values other than srcPort and destPort are arbitrary
void fillTCPHeader(TCPHeader &tcp, uint16_t srcPort, uint16_t destPort)
{
    tcp.srcPort = srcPort;
    tcp.destPort = destPort;
    tcp.seqNumber = 1;
    tcp.ackNumber = 0;
    tcp.flags = 0;
    tcp.window = 1024;
    tcp.checksum = 0xFFFF;
    tcp.urgentPtr = 0;
}

// fillUDPHeader: fills the passed in UDP header struct w/ the passed in values
// Preconditions: UDPHeader udp is valid, and values are valid
// Postconditions: returns UDPHeader udp with filled values
// Values other than srcPort and destPort are arbitrary
void fillUDPHeader(UDPHeader &udp, uint16_t srcPort, uint16_t destPort)
{
    udp.srcPort = srcPort;
    udp.destPort = destPort;
    udp.length = 8 + PAYLOAD_LEN;
    udp.checksum = 0xFFFF;
}

// createPacket: creates an Ethernet packet containing a IPv6 packet, containing either a
// TCP or UDP packet
// Preconditions: valid MAC addr, src and destination IP and port values
// and isTCP is valid
// Postconditions: returns a Ethernet packet with filled out header values
Packet createPacket(uint8_t destMAC[6], uint8_t srcIP[16], uint8_t destIP[16],
                    uint16_t srcPort, uint16_t destPort, bool isTCP)
{
    Packet p{};

    // Ethernet header
    uint8_t srcMAC[6] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

    memcpy(p.eth.destMAC, destMAC, 6);
    memcpy(p.eth.srcMAC, srcMAC, 6);
    p.eth.etherType = ETHER_TYPE;

    // IPv6 Header
    p.ip.version = 6;       // IPv6
    p.ip.trafficClass = 0;  // arbitrary value
    p.ip.flowLabel = 12345; // arbitrary value
    p.ip.hopLimit = 64;

    memcpy(p.ip.srcIP, srcIP, 16);
    memcpy(p.ip.destIP, destIP, 16);

    // TCP/UDP Header
    p.isTCP = isTCP;
    if (isTCP)
    {
        p.ip.payloadLength = sizeof(TCPHeader) + PAYLOAD_LEN;
        p.ip.nextHeader = 6; // TCP
        fillTCPHeader(p.tcp, srcPort, destPort);
    }
    else
    {
        p.ip.payloadLength = sizeof(UDPHeader) + PAYLOAD_LEN;
        p.ip.nextHeader = 17; // UDP
        fillUDPHeader(p.udp, srcPort, destPort);
    }

    // Payload
    for (int i = 0; i < PAYLOAD_LEN; i++)
        p.payload[i] = i;

    return p;
}

// setDefaultValues: helper function to reset values used to create Ethernet packets
// Preconditions: all values have already been declared
// Postconditions: values are reset
void setDefaultValues(PacketValues &values)
{
    uint8_t destMAC[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // arbitrary MAC addr
    memcpy(values.destMAC, destMAC, 6);

    // Default IPs
    memset(values.srcIP, 0, 16);
    memset(values.destIP, 0, 16);

    // Default ports
    values.srcPort = 1000;
    values.destPort = 80;

    // Default protocol
    values.isTCP = true;
}

// printPacketInfo: prints packet p info
// Preconditions: Packet p is a valid packet
// Postconditions: Makes no changes to packet, prints info for debugging
void printPacketInfo(Packet &p)
{
    std::cout << "Destination MAC: ";
    for (int i = 0; i < 6; i++)
        std::cout << (int)p.eth.destMAC[i] << " ";
    std::cout << std::endl;

    std::cout << "Source IP (last byte): "
              << (int)p.ip.srcIP[15] << std::endl;

    std::cout << "Destination IP (last byte): "
              << (int)p.ip.destIP[15] << std::endl;

    if (p.isTCP)
    {
        std::cout << "TCP Destination Port: "
                  << p.tcp.destPort << std::endl;
    }
    else
    {
        std::cout << "UDP Destination Port: "
                  << p.udp.destPort << std::endl;
    }
    std::cout << "Payload size: " << p.ip.payloadLength << std::endl;
    std::cout << "Next Header: " << (int)p.ip.nextHeader << std::endl;
    std::cout << "Hop limit: " << (int)p.ip.hopLimit << std::endl;
}

int main()
{
    PacketValues v;
    setDefaultValues(v);

    SDNSwitch sdn;

    /** Switch Test Case */
    // choose an output port based on mac address

    std::cout << "Test 1: Switch (choose an output port based on mac address)" << std::endl;
    Packet switchPkt = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, v.isTCP);
    // printPacketInfo(switchPkt);
    sdn.processPacket(switchPkt);

    std::cout << "Test 1.5: Switch UDP (choose an output port based on mac address)" << std::endl;
    Packet switchPktUDP = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, !v.isTCP);
    sdn.processPacket(switchPktUDP);

    /** Router Test Case */
    // choose an output port based on IP
    v.srcIP[15] = 1;  // ::1
    v.destIP[15] = 2; // ::2

    std::cout << std::endl;

    std::cout << "Test 2: Router (choose an output port based on IP)" << std::endl;
    Packet routerPkt = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, v.isTCP);
    // printPacketInfo(routerPkt);
    sdn.processPacket(routerPkt);

    std::cout << "Test 2.5: Router UDP (choose an output port based on IP)" << std::endl;
    Packet routerPktUDP = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, !v.isTCP);
    sdn.processPacket(routerPktUDP);

    // reset
    setDefaultValues(v);

    /** NAT Test Case */
    // rewrite the packet headers
    v.srcIP[15] = 10; // ::10 triggers NAT rule
    v.srcPort = 1234;

    std::cout << std::endl;

    std::cout << "Test 3: NAT (rewrite the packet headers)" << std::endl;
    Packet natPkt = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, v.isTCP);
    sdn.processPacket(natPkt);

    std::cout << "Test 3.5: NAT (rewrite the packet headers)" << std::endl;
    Packet natPktUDP = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, !v.isTCP);
    sdn.processPacket(natPktUDP);

    // reset
    setDefaultValues(v);

    /** Firewall Test Case */
    // eg, drop packets on port 22 to certain IP addresses
    v.destIP[15] = 5; // Blocked IP
    v.destPort = 22;

    std::cout << std::endl;

    std::cout << "Test 4: Firewall (drop packets on port 22 to certain IP addresses)" << std::endl;
    Packet frwllPkt = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, v.isTCP);
    // printPacketInfo(frwllPkt);
    sdn.processPacket(frwllPkt);

    std::cout << "Test 4.5: Firewall UDP (drop packets on port 22 to certain IP addresses)" << std::endl;
    Packet frwllPktUDP = createPacket(v.destMAC, v.srcIP, v.destIP, v.srcPort, v.destPort, v.isTCP);
    sdn.processPacket(frwllPktUDP);

    // reset
    setDefaultValues(v);

    return 0;
}