Working IPv6 Neighbor Discovery

assignment3.c

#include <arpa/inet.h>
#include <asm/byteorder.h>
#include <assert.h>
#include <errno.h>
#include <net/ethernet.h>
#include <netinet/ether.h>
#include <netinet/icmp6.h>
#include <netinet/ip6.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <ctype.h>

#include "arguments.h"
#include "checksums.h"
#include "hexdump.h"
#include "raw.h"

#define ICMPv6_NEXT_HEADER 0x3A
#define IPv6_ETHER_TYPE htons(0x86DD)
#define IPv6_VERSION 0x06
#define ICMPv6_ND_CODE 0x00
#define ICMPv6_ND_SOLICIT_TYPE ND_NEIGHBOR_SOLICIT
#define ICMPv6_ND_ADVERT_TYPE ND_NEIGHBOR_ADVERT
#define ND_OPTION_LENGTH 0x01
#define ND_HOP_LIMIT 0xFF
#define IPv6_ADDR_LEN 16
#define RECEIVE_BUFFER_LENGTH 1514

#define IPv6_ADDR_LENGTH sizeof(struct in6_addr)
#define MIN_PACKET_LENGTH sizeof(struct icmp6_neighbor_solicit)
#define MIN_ICMPv6_PAYLOAD_LENGTH sizeof(struct neighbor_solicit_payload)
#define MIN_IPv6_TOTAL_LENGTH \
	sizeof(struct ipv6_hdr) + sizeof(struct neighbor_solicit_payload)

#define ROUTER_FLAG 0x80
#define SOLICITED_FLAG 0x40
#define OVERRIDE_FLAG 0x20

typedef enum { false, true } bool;
typedef uint8_t *ether_addr;

#define FAILURE false
#define SUCCESS true

/* Extracted from /usr/include/linux/if_ethernet.h (just for reference):
 * #define ETH_ALEN 6			 Octets in one ethernet addr
 *
 * Extracted from /usr/include/net/ethernet.h (just for reference):
 * struct ether_header
 * {
 *  u_int8_t  ether_dhost[ETH_ALEN];	destination eth addr
 *  u_int8_t  ether_shost[ETH_ALEN];	source ether addr
 *  u_int16_t ether_type;		packet type ID field
 * }
 */

/* Extracted from /usr/include/netinet/in.h (just for reference):
 * struct in6_addr
 *   {
 *     union
 *       {
 * 	uint8_t	__u6_addr8[16];
 * #ifdef __USE_MISC
 * 	uint16_t __u6_addr16[8];
 * 	uint32_t __u6_addr32[4];
 * #endif
 *       } __in6_u;
 * #define s6_addr		__in6_u.__u6_addr8
 * #ifdef __USE_MISC
 * # define s6_addr16		__in6_u.__u6_addr16
 * # define s6_addr32		__in6_u.__u6_addr32
 * #endif
 *   };
 *
 * "hdr->s6_addr" will  work as access.
 */


/*
 * We do not use the kernel's definition of the IPv6 header (struct ipv6hdr)
 * because the definition there is slightly different from what we would
 * expect
 * (the problem is the 20bit flow label - 20bit is brain-damaged).
 *
 * Instead, we provide you struct that directly maps to the RFCs and lecture
 * slides below.
 */

struct ipv6_hdr {
#if defined(__LITTLE_ENDIAN_BITFIELD)
	uint32_t tc1 : 4, version : 4, flow_label1 : 4, tc2 : 4, flow_label2 : 16;
#elif defined(__BIG_ENDIAN_BITFIELD)
	uint32_t version : 4, tc1 : 4, tc2 : 4, flow_label1 : 4, flow_label2 : 16;
#else
#error "You did something wrong"
#endif
	uint16_t plen;
	uint8_t nxt;
	uint8_t hlim;
	struct in6_addr src;
	struct in6_addr dst;
} __attribute__((packed));


/*====================================TODO===================================*/

/* First, declare struct useful for package dissection, i.e., a struct
 * containing pointers to the various headers and header fields that will be
 * set by your dissector (the function that tests whether or not a received
 * frame/packet is valid).
 */


/*
 * It is very useful to look into the files at /usr/include/netinet for
 * existing structs that may help to create these. Also have a look at
 * assignment2.c, e.g. 'struct wol'.
 */

struct icmp6_header {
	uint8_t type;
	uint8_t code;
	uint16_t checksum;
} __attribute__((packed));;

struct icmp_option_header {
  uint8_t type;
  uint8_t length;
} __attribute__((packed));;

struct nd_option {
  struct icmp_option_header header;
  uint8_t link_address[ETH_ALEN];
} __attribute__((packed));;

/* This struct should contain the icmp part of your message (ip-payload) */
struct neighbor_solicit_payload {
	struct icmp6_header icmp6;
	uint32_t reserved;
	struct in6_addr target_address;
	struct nd_option option;
} __attribute__((packed));

/* This struct should reserve enough space for the complete packet */
struct icmp6_neighbor_solicit {
	struct ether_header ether;
	struct ipv6_hdr ip;
	struct neighbor_solicit_payload payload;
} __attribute__((packed));

/* This struct should contain the icmp part of the advertisement (ip-payload) */
struct neighbor_advertise_payload {
  struct icmp6_header icmp6;
  uint8_t flags;
  uint8_t reserved [3];
  struct in6_addr target_address;
  uint8_t options [];
} __attribute__((packed));

/* This struct should reserve enough space for the complete packet */
struct icmp6_neighbor_advertise {
	struct ether_header ether;
	struct ipv6_hdr ip;
	struct neighbor_advertise_payload payload;
} __attribute__((packed));

/**
 * Checks a flag in the ICMPv6 payload's flag set.
 *
 * @param payload The NDP advertisement payload.
 * @param flag The flag to check.
 *
 * @return The boolean value of the flag.
 *
 */
bool is_set(const struct neighbor_advertise_payload* payload, int flag) {
  return payload->flags & flag;
}

/**
 * Determines the number of neighbor discovery options in an IMCPv6 Payload.
 *
 * @param packet The neighbor advertisement packet.
 *
 * @return The number of NDP options.
 *
 */
int get_nd_option_bytes(struct icmp6_neighbor_advertise* packet) {
  // Note that the sizeof operator evaluated on a struct with a flexible
  // array member (empty []) gives the size of the struct *up to the array*
  // i.e. the offset of the array pointer. This is precisely what we want here,
  // since plen is the whole size of the payload.
  return ntohs(packet->ip.plen) - sizeof(struct neighbor_advertise_payload);
}

/**
 * Tests whether a character is one of the allowed
 * hexadecimal alphabetic characters ([a-f]).
 *
 * @param character The character to check.
 *
 * @return true if the character is in [a-f], else false.
 */
bool ishexalpha(char character) {
	return character >= 'a' && character <= 'z';
}

/**
 * Checks if a character is part of the hexadecimal alphabet ([0-9a-f]).
 *
 * @param character The character to check.
 *
 * @return true if the character is hexadecimal, else false.
 */
bool ishex(char character) {
	return isdigit(character) || ishexalpha(character);
}


/**
 * Lowers both characters of an octet.
 *
 * @param A pointer to an array of two characters to lower.
 */
void make_octet_lower(char *chars) {
	chars[0] = tolower(chars[0]);
	chars[1] = tolower(chars[1]);
}

/**
 * Parses a hexadecimal ASCII digit into the
 * corresponding hexadecimal number.
 *
 * E.g. 'a' => 10, '5' => 5
 *
 * @param character The ASCII character to parse.
 *
 * @return The numeric value of the hexadecimal value
 *         represented by the character.
 */
uint8_t parse_hex_digit(char character) {
	if (isdigit(character)) {
		return character - '0';
	} else {
		return character - 'a' + 10;
	}
}

/**
 * Parses the two hex digits (as ASCII characters) pointed
 * to by octet into a singe byte value.
 *
 * @param octet The two hex digits to conver to a byte.
 *
 * @return The corresponding byte.
 */
int parse_octet(char *octet) {
	uint8_t result;

	make_octet_lower(octet);

	if (!ishex(octet[0]) || !ishex(octet[1])) return -1;

	// Grab lower nibble
	result = parse_hex_digit(octet[1]);
	// Grab upper nibble
	result |= parse_hex_digit(octet[0]) << 4;

	return result;
}

/*
 * Counts the number of empty groups in an IPv6 address.
 * E.g. in a::b the number of empty groups would be six.
 *
 * @param ip The IP address to count the number of empty groups in.
 *
 * @return The number of empty groups in the IP address.
 */
int count_groups(const char* ip) {
  int count = 0;
  bool has_empty_groups = false;

  for (; *ip != '\0'; ++ip) {
    if(*ip == ':') {
      if (*(ip + 1) == ':') {
	// Should only come here once
	if (has_empty_groups) return -1;
	has_empty_groups = true;
      }
      ++count;
    }
  }

  // If we didn't count any empty groups, we expect 7
  if (!has_empty_groups && count != 7) return -1;

  // For 8 groups we can have at most 7 delimiters
  if (count > 7) return -1;
  
  return count;
}

/*
 * This function parses the ip address from a string into an network byte order
 * representation
 *
 * @param dst_ip A pointer to a struct in6_addr where the ip will be written to
 * @param ipaddr The ip address as null terminated string
 *
 * @return  1 on success
 *          0 on error    (NOTE: I changed this to have a uniform FAILURE code)
 */
bool parse_ip(const char *original_ip_addr, struct in6_addr *dst_ip) {
        size_t index = 0;
	char ip[INET6_ADDRSTRLEN];
	char* token = ip;
	char* colon;
	int number_of_groups;
	
	if (original_ip_addr == NULL || dst_ip == NULL) return -1;
	
	// strok will modify our IP address
	strcpy(ip, original_ip_addr);
	
	// Set all to zero first so we only have
	// to fill in the non-empty groups
	memset(dst_ip->s6_addr, 0, IPv6_ADDR_LEN);

	if ((number_of_groups = count_groups(original_ip_addr)) == -1) {
	  fprintf(stderr, "'%s' is not a valid IPv6 address!\n", original_ip_addr);
	}

	for (colon = strchr(ip, ':'); true; colon = strchr(colon, ':')) {
		char group[4];
		int octet;
		int length;

		// If we just found an empty group and are not at the start
		// then this is the empty group in the middle, i.e. the ::
		if (token == colon && token != ip) {
		  // Skip all the empty groups (note we set everything to zero
		  // first so this is OK). It even deals well with the invalid
		  // case of compressing a single 0 field, i.e. a:b:c::e:f:g:h,
		  // which is actually invalid. That group would simply be skipped.
		  index += (7 - number_of_groups + 1) * 2;
		  
		} else {
		  if (colon) *colon = '\0';

		// Pad with zero (characters!) first
		memset(group, '0', 4);

		// Copy the rest of the group into the upper chars of
		// the group string (so that lower zeros are taken into account)
		// E.g. ff => 00ff
		length = strlen(token);
		strncpy(group + (4 - length), token, length);

		// Parse each group of two hex digits into one octet
		if ((octet = parse_octet(group)) == -1) {
			return FAILURE;
		} else {
		  dst_ip->s6_addr[index++] = (uint8_t)octet;
		}

		// Next octet in the group
		if ((octet = parse_octet(group + 2)) == -1) {
			return FAILURE;
		} else {
			dst_ip->s6_addr[index++] = (uint8_t)octet;
		}
		}

		// colon was at the : (now the \0), so set
		// it one passed that for the next token
		// (only if colon is not null, then we break now)
		if (colon) token = ++colon;
		else break;
	}

	return SUCCESS;
}

/*
 * This function initializes an ethernet header
 *
 * @param hdr A pointer to the ethernet header
 * @param dst_mac A pointer to a buffer that contains the destination mac
 * @param src_mac A pointer to a buffer that contains the mac of this host
 * @param ethertype The ethernet type in host byte order
 */
void init_ether_header(struct ether_header *hdr,
											 const ether_addr dst_mac,
											 const ether_addr src_mac,
										 uint16_t ethertype) {
  memcpy(hdr->ether_dhost, dst_mac, ETH_ALEN);
  memcpy(hdr->ether_shost, src_mac, ETH_ALEN);
  hdr->ether_type = ethertype;
}

/*
 * This function initializes an ipv6 header
 * This encompasses the version and everything given as parameter
 *
 * @param hdr A pointer to the ip header
 * @param dst_ip A pointer to a buffer that contains the destination ip
 * @param src_ip A pointer to a buffer that contains the ip of this host
 * @param next The next hop field for this header
 * @param plen The size of the ip payload in host byte order
 * @param hoplimit The hoplimit for the ip packet
 */
void init_ip6_header(struct ipv6_hdr *hdr,
		     const struct in6_addr *dst_ip,
		     const struct in6_addr *src_ip,
		     uint8_t next,
		     uint16_t plen,
		     uint8_t hoplimit) {
	hdr->version = IPv6_VERSION;
	hdr->tc1 = hdr->tc2 = 0x00;
	hdr->flow_label1 = hdr->flow_label2 = 0x00;
	hdr->plen = plen;
	hdr->nxt = next;
	hdr->hlim = hoplimit;

	hdr->src = *src_ip;
	hdr->dst = *dst_ip;
}

void init_icmp6_header(struct icmp6_header *header) {
	// ND_NEIGHBOR_SOLICIT =  0x87 (from netinet/icmp6.h)
        header->type = ICMPv6_ND_SOLICIT_TYPE;
	header->code = ICMPv6_ND_CODE;
}

void init_icmp6_checksum(struct ipv6_hdr *ip_header,
			 struct neighbor_solicit_payload* payload) {
  payload->icmp6.checksum = icmp6_checksum((struct ip6_hdr*)ip_header,
					   (uint8_t*)payload,
					   sizeof(struct neighbor_solicit_payload));
}

void init_nd_option(struct nd_option *option,
		    const ether_addr source_link_address) {
  // ND_OPT_SOURCE_LINKADDR = 0x01 (from netinet/icmp6.h)
  option->header.type = ND_OPT_SOURCE_LINKADDR;
  // Length is set to 0x01, but measured in 8 bytes
  option->header.length = ND_OPTION_LENGTH;
  // The 48-bit/6-byte source link (MAC) address
  memcpy(option->link_address, source_link_address, ETH_ALEN);
}

/*
 * This function initializes the icmpv6 header and the neighbor discovery
 * payload
 *
 * @param payload A pointer to the buffer in which to initialize
 * @param dst_ip A pointer to a buffer that contains the destination ip
 * @param src_mac A pointer to a buffer that contains the mac of this host
 */
void init_icmp6_ndisc(struct neighbor_solicit_payload *payload,
											const struct in6_addr *dst_ip,
		      const ether_addr src_mac) {
  init_icmp6_header(&payload->icmp6);
	
  payload->reserved = 0x00;
  payload->target_address = *dst_ip;
	
  init_nd_option(&payload->option, src_mac);
}

void init_packet(struct icmp6_neighbor_solicit *packet,
		 const ether_addr dst_mac,
		 const ether_addr src_mac,
		 const struct in6_addr *solicited_dst_ip,
		 const struct in6_addr *dst_ip,
		 const struct in6_addr *src_ip) {
  memset(packet, 0, sizeof(*packet));
  init_ether_header(&packet->ether, dst_mac, src_mac, IPv6_ETHER_TYPE);
  
  init_ip6_header(&packet->ip,
		  solicited_dst_ip,
		  src_ip,
		  ICMPv6_NEXT_HEADER,
		  htons(MIN_ICMPv6_PAYLOAD_LENGTH),
		  ND_HOP_LIMIT);
	
  init_icmp6_ndisc(&packet->payload, dst_ip, src_mac);
  init_icmp6_checksum(&packet->ip, &packet->payload);	
}

/*
 * This function checks whether the ethernet header may be for a neighbor
 * advertisement which is sent as response to our neighbor discovery
 *
 * @param hdr A pointer to the header
 * @param len The length of the packet reported by read
 * @param mymac A pointer to a buffer which contains the mac of this host
 *
 * @return 0 on fail
 *	       1 on success
 */
int is_my_ether_header(struct ether_header *hdr,
		       size_t len,
		       const ether_addr mymac) {
	if (len < MIN_PACKET_LENGTH) return FAILURE;

	// Should be an IPv6 ethertype
	if (hdr->ether_type != IPv6_ETHER_TYPE) return FAILURE;

	// Destination should be our MAC Address
	if (memcmp(hdr->ether_dhost, mymac, ETH_ALEN) != 0) return FAILURE;

	return SUCCESS;
}

/*
 * This function checks whether the ip header is a valid ipv6 header and if
 * it might be a neighbor advertisement sent in response to our neighbor
 * discovery
 *
 * @param hdr A pointer to the ethernet payload
 * @param len The length of the *packet* reported by read
 * @param myip A pointer to a buffer containing the ip address of this host
 * @param dst_ip A pointer to a buffer containing the ip address of our target
 *
 * @return 0 on fail
 *    	   1 on success
 */
int is_my_ip6_header(struct ipv6_hdr *hdr,
		     size_t len,
		     const struct in6_addr *myip,
		     const struct in6_addr *dst_ip) {
  // Length of the whole IPv6 packet should match
  if (len < MIN_IPv6_TOTAL_LENGTH) return FAILURE;
  
  if (hdr->version != IPv6_VERSION) return FAILURE;
  if (hdr->nxt != ICMPv6_NEXT_HEADER) return FAILURE;
  
  // The payload length should match for an ICMPv6 + ND Option packet
  if (ntohs(hdr->plen) < MIN_ICMPv6_PAYLOAD_LENGTH) return FAILURE;
  // The icmp6 payload can have more than one option, but then
  // the payload length minus all the non-option stuff (e.g. icmp6 header)
  // should be in multiples of 8 byte. Note that sizeof() the advertise
  // message does not measure the options, because they are a flexible array
  if (ntohs(hdr->plen) - sizeof(struct neighbor_advertise_payload) % 8 != 0)
	
  // Hop Limit is fixed as 0xFF for neighbor discovery
  if (hdr->hlim != ND_HOP_LIMIT) return FAILURE;
  
  // Check the IPv6 addresses
  // Source should be the address of the host we wanted the MAC address for
  if ((memcmp(&hdr->src, dst_ip, sizeof(struct in6_addr))) != 0) return FAILURE;
  // Destination should be our address
  if ((memcmp(&hdr->dst, myip, sizeof(struct in6_addr))) != 0) return FAILURE;

  return SUCCESS;
}

/*
 * Checks the ICMPv6 header of the packet's payload, taking care of
 * the type, code and especially the checksum of the header.
 *
 * @param packet The ND advertisement packet.
 * @param payload The advertisement payload (header + nd option).
 * @param len The length of the *payload*.
 *
 * @return 0 on fail
 *    	   1 on success
 */
int is_my_icmp6_header(struct icmp6_neighbor_advertise* packet,
		       struct neighbor_advertise_payload* payload,
		       size_t len) {
  int checksum;
  int expected_checksum;

  // Length of the ICMPv6 payload should be at least this
  if (len < MIN_ICMPv6_PAYLOAD_LENGTH) return FAILURE;

  // Type should be for an ND Advertisement
  // ND_NEIGHBOR_ADVERT = 0x88 (from netinet/icmp6.h)
  if (payload->icmp6.type != ICMPv6_ND_ADVERT_TYPE) return FAILURE;
  if (payload->icmp6.code != ICMPv6_ND_CODE) return FAILURE;

  // Need to store the checksum first, then set to null, then recompute it
  checksum = payload->icmp6.checksum;
  payload->icmp6.checksum = 0;
  expected_checksum = icmp6_checksum((struct ip6_hdr*)&packet->ip,
				     (uint8_t*)payload,
				     len);
  if (checksum != expected_checksum) return FAILURE;

  return SUCCESS;
}

/**
 * 
 * Checks the options of a received ICMPv6 payload.
 *
 * @param packet The ND advertisement packet.
 * @param option An output pointer for the correct option (if there are many options).
 *
 */
int is_my_nd_option(struct icmp6_neighbor_advertise* packet,
		    struct nd_option** option) {
  uint8_t* iterator;
  uint8_t* end;
  int option_bytes;

  option_bytes = get_nd_option_bytes(packet);

  // Should be multiples of 8
  if (option_bytes % 8 != 0) return FAILURE;

  iterator = packet->payload.options;
  end = iterator + option_bytes;

  while (iterator < end) {
    struct icmp_option_header* header = (struct icmp_option_header*)iterator;

    // Won't be able to parse the other options if we don't
    // know where they start because we don't know when this
    // option ends
    if ((header->length * 8) > option_bytes) return FAILURE;
    
    // ND_OPT_TARGET_LINKADDR = 0x02 (from netinet/icmp6.h)
    if (header->type == ND_OPT_TARGET_LINKADDR) {
      // Length should 1, measured in 8 bytes.
      if (header->length == ND_OPTION_LENGTH) {
	// The advertised MAC address and the source MAC
	// of the ethernet header should match
        uint8_t* first = iterator + sizeof(struct icmp_option_header);
	uint8_t* second = packet->ether.ether_shost;
	if (memcmp(first, second, ETH_ALEN) == 0) {
	  *option = (struct nd_option*)iterator;
	  return SUCCESS;
	}
      }
    }

    iterator += (header->length * 8);
  }

  // No suitable option found
  return FAILURE;
}

/**
 * This function checks whether the ip payload is a
 * neighbor advertisement sent to us.
 *
 * @param payload A pointer to the icmp payload
 * @param len The length of the icmp payload
 * @param dstip A pointer to a buffer containing the target ip
 * @param option An output pointer for the correct option (if there are many options).
 *
 * @return 0 on fail
 *	   1 on success
 */
int is_my_neighbor_advertisement(struct icmp6_neighbor_advertise* packet,
				 size_t len,
				 const struct in6_addr *dstip,
				 struct nd_option** option) {
  struct neighbor_advertise_payload* payload = &packet->payload;

  if (!is_my_icmp6_header(packet, payload, len)) return FAILURE;

  // Ensure the advertisement is a response to our solicitation
  if (!is_set(payload, SOLICITED_FLAG)) return FAILURE;

  // Ensure the target IP Address is the one who's solicited node
  // multicast group we sent the packet to.
  if (memcmp(&payload->target_address, dstip, IPv6_ADDR_LENGTH) != 0) {
    return FAILURE;
  }

  if (!is_my_nd_option(packet, option)) return FAILURE;

  return SUCCESS;
}

/*
 * This function checks if the frame received is a neighbor advertisement sent
 *as
 * response to our neighbor discovery. If it is, it returns a pointer to the mac
 * address in the frame.
 * It calls the more specialized functions in succession to check their parts
 * and does tests that have to be with access to multiple layers
 * (i.e. checksum, matching macs)
 *
 * @param buffer A pointer to the received frame
 * @param len The size of the received packet
 * @param mymac A pointer to a buffer which contains the mac of this host
 * @param myip6 A pointer to a buffer which contains the ip of this host
 * @param dstip A pointer to a buffer which contains the destination ip
 *
 * @return null on fail
 *	   A pointer to the destination mac address sent with the neighbor
 *	   advertisement
 */
ether_addr retrieve_mac(uint8_t *buffer,
			ssize_t len,
			const ether_addr mymac,
			const struct in6_addr *myip6,
			const struct in6_addr *dstip) {
  struct nd_option* option;
  struct icmp6_neighbor_advertise *packet =
    (struct icmp6_neighbor_advertise *)buffer;

  if (!is_my_ether_header(&packet->ether, len, mymac)) {
    return NULL;
  }

  len -= sizeof(struct ether_header);
  if (!is_my_ip6_header(&packet->ip, len, myip6, dstip)) {
    return NULL;
  }
  
  len -= sizeof(struct ipv6_hdr);
  // Note that we pass the option as an output parameter, it will
  // then store the option that contains the requested link address
  // for the case that there are many options (and if the advertisement
  // is valid at all).
  if (!is_my_neighbor_advertisement(packet, len, dstip, &option)) {
    return NULL;
  }

  // Wooh!
  return option->link_address;
}

void get_solicited_ip(const struct in6_addr *ip, struct in6_addr *solicited) {
	size_t index = 0;

	// ff02:
	solicited->s6_addr[index++] = 0xff;
	solicited->s6_addr[index++] = 0x02;

	// 8 bytes (4 groups) for the ::
	memset(solicited->s6_addr + index, 0, 8);
	index += 8;

	// :0001
	solicited->s6_addr[index++] = 0x00;
	solicited->s6_addr[index++] = 0x01;

	// :ff
	solicited->s6_addr[index++] = 0xff;

	// Lower 24 bits (3 bytes) of the IPv6 Address
	memcpy(solicited->s6_addr + index, ip->s6_addr + index, 3);
}

void get_solicited_mac(const struct in6_addr *ip, ether_addr mac) {
	// IPv6 multicast prefix
	mac[0] = mac[1] = 0x33;
	// The last 4 bytes of the solicited node IP address
	memcpy(mac + 2, ip->s6_addr + 12, 4);
}

void send_packet(int fd, const struct icmp6_neighbor_solicit *packet, size_t length) {
        hexdump(packet, sizeof(*packet));
	if (grnvs_write(fd, packet, length) < 0) {
		fprintf(stderr, "grnvs_write() failed: %s\n", strerror(errno));
	}
}

ether_addr
read_mac(int fd, uint8_t* recbuffer, const ether_addr mymac, const struct in6_addr *sip6, const struct in6_addr *dip6, unsigned int timeout) {
	ssize_t ret;
	ether_addr mac;

	while ((ret = grnvs_read(fd, recbuffer, RECEIVE_BUFFER_LENGTH, &timeout))) {
	  if ((mac = retrieve_mac(recbuffer, ret, mymac, sip6, dip6))) {
	    break;
	  }
	}
	if (ret == 0) {
		/*
		 * This should go to stdout because the tester uses this to
		 * determine a graceful shutdown. Do NOT change this
		 */
		fprintf(stdout, "Timeout\n");
		return NULL;
	}

	return mac;
}

/*====================================TODO===================================*/
/*
 *TODO: Print the retrieved mac address.
 * The format MUST strictly adhere to the following rule:
 *
 * <IP-Address> is at <mac>
 *
 * The IP-address MAY be shortened, the mac MUST be 2 characters for
 * each byte. The result MUST be printed on stdout. Don't forget the
 * newline!
 *
 * Example output:
 * ::1 is at 01:02:03:04:05:06
 */
/*===========================================================================*/

void print_mac(const char *ip, ether_addr mac) {
	printf("%s is at %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
	       ip,
	       (unsigned)mac[0],
	       (unsigned)mac[1],
	       (unsigned)mac[2],
	       (unsigned)mac[3],
	       (unsigned)mac[4],
	       (unsigned)mac[5]);
}

void assignment3(int fd, const char *ipaddr, const int timeoutval) {
        // Buffer for receiving packets
  	uint8_t recbuffer[RECEIVE_BUFFER_LENGTH];
	
	// Returned target MAC
	ether_addr mac;

	struct icmp6_neighbor_solicit packet;
	size_t length = sizeof(packet);

	struct in6_addr dip6;
	const struct in6_addr *sip6 = grnvs_get_ip6addr(fd);
	struct in6_addr solicited_dip6;

	// Buffer for solicited node multicast mac
	uint8_t dstmac[ETH_ALEN];
	const ether_addr mymac = (const ether_addr)grnvs_get_hwaddr(fd);

	if (parse_ip(ipaddr, &dip6) == FAILURE) {
		fprintf(stderr,
						"Wrong input format for destination address, "
						"input should be in format: a:b:c::1:2:3\n");
		return;
	}

	get_solicited_ip(&dip6, &solicited_dip6);
	get_solicited_mac(&solicited_dip6, dstmac);

	init_packet(&packet, dstmac, mymac, &solicited_dip6, &dip6, sip6);

		  send_packet(fd, &packet, length);

	mac = read_mac(fd, recbuffer, mymac, sip6, &dip6, timeoutval * 1000);
	
	if (mac) print_mac(ipaddr, mac);
}

int main(int argc, char **argv) {
	struct arguments args;
	int sock;

	if (parse_args(&args, argc, argv) < 0) {
		fprintf(stderr,
						"Failed to parse arguments, call with "
						"--help for more information\n");
		return -1;
	}

	if ((sock = grnvs_open(args.interface, SOCK_RAW)) < 0) {
		fprintf(stderr, "grnvs_open() failed: %s\n", strerror(errno));
		return -1;
	}

	assignment3(sock, args.dst, args.timeout);

	grnvs_close(sock);

	return 0;
}

Is there a possibility to make the remaining files available?