#ifndef __FAKEIP__INCLUDED
#define __FAKEIP__INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <pthread.h>
#include <errno.h>
#include <string>

extern int errno;

typedef unsigned char byte;
typedef pthread_mutex_t semaphore;

struct ip_packet
{ byte source_addr[6];
  byte dest_addr[6];
  short int protocol;
  short int length;
  byte content[0]; };

ip_packet * create_ip_packet(int content_length);
void delete_ip_packet(ip_packet * p);
string ip_address_to_string(byte * addr);

struct ip_packet_link
{ ip_packet * item;
  ip_packet_link * next;
  ip_packet_link(ip_packet * i); };

class ip_packet_queue
{ protected:
    semaphore s;
    pthread_cond_t rready;
    ip_packet_link * first, * last;
    int number, maxnumber;

  public:
    ip_packet_queue(int maxlen = 100);
    ~ip_packet_queue();
    bool is_empty();
    bool is_full();
    int length();
    bool add(ip_packet * p);
    ip_packet * get();
    ip_packet * get_wait(int msec = -1); };

class ip_system
{ protected:
    bool started;
    int servesocket, tracing, reliability;
    ip_packet_queue * rcvq;
    byte address[6];
    pthread_t threadid;
    friend void * listening_process(void * a);
    void put_on_receive_queue(ip_packet * p);

  public:
    ip_system();
    ~ip_system();
    byte * start();
    bool ok();
    byte * get_address();
    void set_trace_level(int n);
    void set_reliability(double r);
    int receive_queue_length();
    int transmit_queue_length();
    ip_packet * receive();
    ip_packet * wait_to_receive(int msec = -1);
    bool transmit(ip_packet * p);
    void wait_until_dead(); };

void * listening_process(void * a);

#endif