sr_router.h

Go to the documentation of this file.

/*-----------------------------------------------------------------------------
 * File: sr_router.h
 * Date: ?
 * Authors: Guido Apenzeller, Martin Casado, Virkam V.
 * Contact: casado@stanford.edu
 *---------------------------------------------------------------------------*/

/** \file
 * The set of functions which routes packets
 */

#ifndef SR_ROUTER_H
#define SR_ROUTER_H

#include <netinet/in.h>
#include <sys/time.h>
#include <stdio.h>

#include "sr_protocol.h"
#include "sr_arpcache.h"


#define min(a,b) ( (a) < (b) ? (a) : (b) )

/* we dont like this debug , but what to do for varargs ? */
#ifdef _DEBUG_
#define Debug(x, args...) printf(x, ## args)
#define DebugMAC(x) \
  do { int ivyl; for(ivyl=0; ivyl<5; ivyl++) printf("%02x:", \
  (unsigned char)(x[ivyl])); printf("%02x",(unsigned char)(x[5])); } while (0)
#else
#define Debug(x, args...) do{}while(0)
#define DebugMAC(x) do{}while(0)
#endif

#define INIT_TTL 255
#define PACKET_DUMP_SIZE 1024

/** number of uint8_ts in the Ethernet header (dst MAC + src MAC + type) */
#define ETH_HEADER_LEN 14

/** max uint8_ts in the payload (usually 1500B, but jumbo may be larger */
#define ETH_MAX_DATA_LEN 2048

/** max uint8_ts in the Ethernet frame (header + data uint8_ts) */
#define ETH_MAX_LEN (ETH_HEADER_LEN + ETH_MAX_DATA_LEN)

/** min uint8_ts in the Ethernet frame */
#define ETH_MIN_LEN 60

/** number of uint8_ts in an IPv4 header without options. */
#define IPV4_HEADER_LEN 20

/* forward declare */
struct sr_if;
struct sr_rt;

/** Struct which encapsulates all the state of a single router */
struct sr_instance
{
    int  sockfd;   /* socket to server */
    char user[32]; /* user name */
    char host[32]; /* host name */
    char template[30]; /* template name if any */
    unsigned short topo_id;
    struct sockaddr_in sr_addr; /* address to server */
    struct sr_if* if_list; /** list of interfaces */
    struct sr_rt* routing_table; /** routing table */
    struct sr_arpcache cache;   /** ARP cache */
    pthread_attr_t attr;
    FILE* logfile;
};

/* -- sr_main.c -- */
int sr_verify_routing_table(struct sr_instance* sr);

/* -- sr_vns_comm.c -- */
int sr_send_packet(struct sr_instance* , uint8_t* , unsigned int , const char*);
int sr_connect_to_server(struct sr_instance* ,unsigned short , char* );
int sr_read_from_server(struct sr_instance* );

/* -- sr_router.c -- */
/** Initializes router state */
void sr_init(struct sr_instance* );

/** Called whenever an incoming packet is received; You are
 * responsible for writing this.  
 * This function checks that a received packet is well
 * structured, decapsulates it, and then calls another handler based on the
 * packet type.  */
void sr_handlepacket(struct sr_instance* , uint8_t * , unsigned int , char* );

/** Determine if an ethernet frame is addressed to a given interface's MAC
 * address.
 * @param my_address the router interface's MAC address
 * @param addr_s the MAC address we would like to check against
 * @return Nonzero (true) if the addresses match, or the second argument is the
 * broadcast address. Zero (false) otherwise.
 */
int ether_to_me(unsigned char* my_address, unsigned char* addr_s);

/** Handles all incoming packets with an ARP header; You are responsible
 * for writing this.
 * @param sr: the router instance
 * @param packet: the raw ARP packet
 * @param len: the size of the raw ARP packet
 * @param interface: the name of the interface which the packet arrived on
 * */
int handle_arp(struct sr_instance * sr, uint8_t * packet, unsigned int len, char * interface);

/** Handles all incoming packets with an IP header; You are responsible for writing this.
 * @param sr: the router instance
 * @param packet: the raw IP packet
 * @param len: the size of the raw IP packet
 * @param interface: the name of the interface which the packet arrived on
 * */
int handle_ip(struct sr_instance *sr, uint8_t * packet,unsigned int len,char * interface);

/** Helper function which computes and sets the checksum on an IP header.
 * */
uint16_t checksum_ip( struct sr_ip_hdr * hdr );

/** Helper function which computes the checksum over the specified length of
 * the given buffer.
 * */
uint16_t checksum( uint16_t* buf, unsigned len );

/** Helper function to determine whether an IP packet is destined for any of the
 * router's interfaces' addresses.
 * @param sr_instance: the router instance
 * @param uint32_t: the destination address in question
 */
int ip_to_me(struct sr_instance * , uint32_t );

/** Creates an ICMP header and encapsulates the given buffer (if
 * any); You are responsible for writing this.
 * @param router: the router instance
 * @param dst: the destination address
 * @param src: the source address
 * @param ip_packet: the IP packet which triggered the creation of this ICMP packet, if any
 * @param len: the length of the IP packet, if any
 * @param type: type of ICMP packet to be created
 * @param code: code of ICMP packet to be created
 * @param id: id of the ICMP packet
 * @param seq: sequence number of the ICMP packet
 * */
void icmp_send(struct sr_instance * router,
                uint32_t dst,
                uint32_t src,
                uint8_t * ip_packet,
                unsigned len,
                uint8_t type,
                uint8_t code,
                uint16_t id,
                uint16_t seq);

/** Computes and sets the checksum on an ICMP header.
 * */
uint16_t checksum_icmp( sr_icmp_hdr_t* icmp_hdr, unsigned total_len );

/** Handles all incoming packets with an ICMP header; This is already
 * implemented for you */  
void icmp_handle_packet( struct sr_instance * router, uint8_t* ip_packet, unsigned len );

/** Creates an IP header and encapsulates the given buffer; You
 * are responsible for writing this.
 * @param sr_instance: the router instance
 * @param dst: the destination address
 * @param src: the source address
 * @param proto: the protocol of the encapsulated buffer
 * @param buf: buffer to encapsulate with IP header
 * @param len: size of the buffer
 */
int  ip_send_packet_from( struct sr_instance *,
                          uint32_t dst,
                          uint32_t src,
                          uint8_t proto,
                          uint8_t* buf,
                          unsigned len );

/** Wrapper function for \link ip_send_packet_from \endlink when the outbound
 * address & interface are not known; This is already implemented for you 
 * @param router: the router instance
 * @param dst: the destination address
 * @param proto: the protocol of the encapsulated buffer
 * @param payload: buffer to encapsulate with IP header
 * @param len: size of the buffer
 * */
int ip_send_packet(struct sr_instance * router,
                     uint32_t dst,
                     uint8_t proto,
                     uint8_t* payload,
                     unsigned len );

/** Searches the routing table to find the correct
 * interface on which to send the payload based on the destination IP, then
 * queues the packet; This is already implemented for you 
 * @param router: the router instance
 * @param dst_ip: the destination IP address
 * @param type: the type of ethernet traffic
 * @param payload: the packet to be encapsulated in an ethernet frame
 * @param len: the size of the payload
 * */
int router_send_ethernet_frame( struct sr_instance * router,
                                 uint32_t dst_ip,
                                 uint16_t type,
                                 uint8_t* payload,
                                 unsigned len );

/** Constructs an ethernet packet to the correct MAC address -
 * if this exists in the cache the packet can be sent immediately, otherwise it
 * must be queued while the ARP cache resolves the next hop IP address's MAC
 * address; You are responsible for writing this.
 * @param router: the router instance
 * @param rti: the routing table
 * @param intf: the outgoing interface
 * @param type: the type of ethernet traffic
 * @param payload: the packet to be encapsulated in an ethernet frame
 * @param payload_len: the size of the payload
 */
int  router_queue_ethernet_frame(struct sr_instance * router,
                                     struct sr_rt * rti,
                                     struct sr_if * intf,
                                     uint16_t type,
                                     uint8_t* payload,
                                     unsigned payload_len ) ;

/** Given a destination IP address, looks up the routing
 * table entry for the next hop; This is already implemented for you.
 */
struct sr_rt * rtable_find_route(struct sr_instance * sr, uint32_t ip);

/** Handles sending ARP requests to get IP/MAC mappings; You are
 * responsible for writing this.
 * @param sr: the router instance
 * @param req: the ARP request to be resolved
 */
int handle_arpreq(struct sr_instance * sr,struct sr_arpreq * req);

/* -- sr_if.c -- */
void sr_add_interface(struct sr_instance* , const char* );
void sr_set_ether_ip(struct sr_instance* , uint32_t );
void sr_set_ether_addr(struct sr_instance* , const unsigned char* );
void sr_print_if_list(struct sr_instance* );

#endif /* SR_ROUTER_H */