Lan shutdown program2

Kode 

//test.cpp
#include "Net.h"
#include "Exception.h"
#include "NetException.h"
#include "TimerException.h"
#include "IPAddress.h"
#include "Types.h"
#include "UDPSocket.h"
#include <cstdlib>

using namespace std;

void runServer(int argc, char ** argv)
{
  //Default adresse at binde til
  //NULL betyder alle
  IPAddress * bindAddr = NULL;
  //Default port at binde til
  UInt16 port = 5555;
  SInt32 i,bytesRead;
  //Buffer til indkommende data
  char buffer[1024];
  //Så længe denne er true venter vi på data
  bool again = true;
  for(i = 2; i < argc; i++)
  {
    if(string(argv[ i ]) == string("-a"))
    {
      i++;
      if(i == argc)
      {
        cout << "Parametren '-a' skal have et argument." << endl;
        return;
      }
      if(bindAddr != NULL)
        delete bindAddr;
      string adr(argv[ i ]);
      bindAddr = new IPAddress(adr);
    }
    else if(string(argv[ i ]) == string("-p"))
    {
      i++;
      if(i == argc)
      {
        cout << "Parametren '-p' skal have et argument." << endl;
        return;
      }
      port = atoi(argv[ i ]);
    }
  }

  //Tjek om vi skal binde til et bestemt interface
  if(bindAddr != NULL)
  {
    cout << "Binder til: " << bindAddr->getAddressString(0) << endl;
  }
  else
  {
    cout << "Binder til alle adresser" << endl;
  }
  cout << "Port: " << port << endl;

  //Opret socket
  UDPSocket * sock;
  if(bindAddr == NULL)
  {
    sock = new UDPSocket(port);
  }
  else
  {
    sock = new UDPSocket(*bindAddr, port);
    delete bindAddr;
    bindAddr = NULL;
  }
  while(again)
  {
    cout << "Venter på data." << endl;
    IPAddress * adr = NULL;
    UInt16 port;
    //Blokér til der er data
    bytesRead = sock->read(buffer,1024,&adr,&port);
    //Se hvem det er fra
    cout << "Modtog data fra " << (string)(*adr) << endl;
    string message(buffer,0,bytesRead);
    if(message == string("CLOSEDOWN"))
    {
      again = false;
    }
    //Skriv dataene ud
    cout << message << endl << endl;
    //Send dataene tilbage:
    sock->write(buffer,bytesRead,adr,port);
    delete adr;
    adr = NULL;
  }
  //Frigiv vores socket
  delete sock;
}

void runClient(int argc, char ** argv)
{
  //Adresse på server
  IPAddress * serverAddr = NULL;
  //Servers port
  UInt16 port = 5555;
  SInt32 i,bytesRead;
  //Buffer til indkommende data
  char buffer[1024];
  //Besked som vi sender
  char * message = NULL;
  //Læs parametre
  for(i = 1; i < argc; i++)
  {
    if(string(argv[ i ]) == string("-a"))
    {
      i++;
      if(i == argc)
      {
        cout << "Parametren '-a' skal have et argument." << endl;
        return;
      }
      if(serverAddr != NULL)
        delete serverAddr;
      string adr(argv[ i ]);
      serverAddr = new IPAddress(adr);
    }
    else if(string(argv[ i ]) == string("-p"))
    {
      i++;
      if(i == argc)
      {
        cout << "Parametren '-p' skal have et argument." << endl;
        return;
      }
      port = atoi(argv[ i ]);
    }
    else
    {
      message = argv[ i ];
    }
  }

  //Tjek om der blev specificeret en adresse
  if(serverAddr == NULL)
  {
    cout << "Du har ikke skervet en adresse." << endl;
    return;
  }

  //Tjeck om der blev specificeret en besked
  if(message == NULL)
  {
    cout << "Du har ikke skrevet en besked." << endl;
    return;
  }

  //Opret socket
  UDPSocket sock;
  try
  {
    sock.enableBroadcast(true);//Vi vil gerne kunne broadcaste
  } catch (NetException & ne)
  {
    //Men hvis vi ikke kan så er det ok
  }
  sock.setTimeOut(5000);//Vi vil højst vente 5 sekunder på, at serveren svarer

  //Send besked
  sock.write(message,strlen(message),serverAddr,port);
  delete serverAddr;
  serverAddr = NULL;

  try
  {
    bytesRead = sock.read(buffer,1024,&serverAddr,&port);
    cout << "Modtog data fra " << (string)(*serverAddr) << endl;
    cout.write(buffer,bytesRead);
    cout << endl;
    delete serverAddr;
    serverAddr = NULL;
  } catch (TimerException & te)
  {
    cout << "Vi fik intet i 5 sekunder." << endl;
  }
}

int main()
{
   char *arg[] = {"", "-p" "1234", "-a" "123.321.123.321", "Some message to the world"};
    //Initialisér netværk
    netInit();
      //Kør i server mode
    runServer(6, arg);
    //Frigiv netværk
    netRelease();

  return 0;
}

Kode 

//ConnectionLostException.h
#if !defined(CONNECTIONLOSTEXCEPTION_H)
#define      CONNECTIONLOSTEXCEPTION_H
#include "NetException.h"

class ConnectionLostException : public NetException
{
  public:
    ConnectionLostException(string description);
};

#endif

Kode 

//Exception.h
#if !defined(EXCEPTION_H)
#define      EXCEPTION_H

#include <iostream>
#include <string>

using namespace std;

class Exception
{
    //Denne funktion gør at vi kan skrive en
    //exception til en strøm som f.eks. cout
    friend ostream & operator<<(ostream & out, Exception & e);

    public:
        //Denne funktion gør at vi kan caste en
        //exception til et string objekt
        operator string ();

    protected:
        Exception(string description);

    private:
        string m_description;
};

#endif

Kode 

//IPAddress.h
#if !defined(IPADDRESS_H)
#define      IPADDRESS_H

#include <string>
#include <vector>
#include "Types.h"
#if defined(_WIN32)
#include <winsock2.h>
#elif defined(__linux__)
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif

using namespace std;

class IPAddress
{
    public:
        //Opretter et IPAddress objekt ud fra en streng
        //som enten indeholder en IP adresse i dotted notation
        //eller et host navn.
        IPAddress(string & adr);
        //Ipretter et IPAddress objekt ud fra en in_addr struktur.
        //Dette bliver nødvendigt i en senere artikel om server programmering.
        IPAddress(struct in_addr adr);

        //Fortæller hvor mange adresser, der er tilknyttet denne adresse
        UInt32 numAdresses();
        //Returnerer adressen med det givne nummer som in_addr struktur
        struct in_addr getAddress(UInt32 index);
        //Returnerer adressen med det givne nummer som streng
        string getAddressString(UInt32 index);

        //Fortæller hvor mange aliaser, der findes for denne adresse
        UInt32 numAliases();
        //Returnerer aliaset med det givne nummer
        string getAlias(UInt32 index);
        //Returnerer det officielle navn for denne adresse
        string getOfficialName();
        //Konverterer denne adresse til en streng
        operator string();

    private:
        //Laver opslaget fra en in_addr struktur
        void fromInAddr(struct in_addr adr);
        //Definerer en vector indeholdende strenge
        typedef vector<string> StringVector;
        //Definerer en vector indeholdende in_addr strukturer
        typedef vector<struct in_addr> InAddrVector;

        //Vores liste af aliaser
        StringVector m_aliases;
        //Vores liste af adresser
        InAddrVector m_adresses;
        //Det officielle navn
        string m_officialName;
};

#endif

Kode 

//mutex.h
#if !defined(MUTEX_H)
#define      MUTEX_H

#if defined(__linux__)
#include <pthread.h>
#elif defined(_WIN32)
#include <windows.h>
#endif

class Mutex
{
  private:
#if defined(__linux__)
    //Linux mutex objekt
    pthread_mutex_t m_mutex;
    #elif defined(_WIN32)
    //Windows mutex objekt
    CRITICAL_SECTION m_mutex;
#endif
  public:
    //Initialiserer mutex objektet
    Mutex();
    //Frigiver mutex objektet
    ~Mutex();
    //Låser mutex objektet. Blokerer til mutexen kan låses.
    void enter();
    //Låser mutex objektet medmindre det allerede er låst.
    //Returnerer true hvis mutexen blev låst. Ellers returneres false.
    bool tryEnter();
    //Låser mutex objektet op
    void leave();
};

#endif

Kode 

//Net.h
#if !defined(NET_H)
#define      NET_H

#if defined(__linux__)
#define netInit()
#define netRelease()
#elif defined _WIN32
void NetInit();
void NetRelease();
#define netInit() NetInit()
#define netRelease() NetRelease()
#endif

#endif

Kode 

//NetException.h
#if !defined(NETEXCEPTION_H)
#define      NETEXCEPTION_H
#include "Exception.h"

class NetException : public Exception
{
    public:
        NetException(string description);
};

#endif

Kode 

//TCPServerSocket.h
#if !defined(TCPSERVERSOCKET_H)
#define      TCPSERVERSOCKET_H

#include "TCPSocket.h"
#include "IPAddress.h"
#include "Types.h"
#include <string>

using namespace std;

class TCPServerSocket
{
  public:
    //Opretter et TCPServerSocket som kan lytte på alle adresser
    //og på den angivne port og med det givne timeout
    TCPServerSocket(UInt16 port, UInt32 timeOut = 0);
    //Opretter et TCPServerSocket som kun lytter på adressen
    //angivet som en streng og på den angivne port og med det givne timeout
    TCPServerSocket(string adr, UInt16 port, UInt32 timeOut = 0);
    //Opretter et TCPServerSocket som kun lytter på adressen
    //angivet som en IPAddress og på den angivne port og med det givne timeout
    TCPServerSocket(IPAddress adr, UInt16 port, UInt32 timeOut = 0);
    //Deallokerer og lukker evt. serveren
    ~TCPServerSocket();
    //Lukker serveren. En lukket server kan ikke sættes til at lytte igen.
    void close();
    //Sætter serveren til at lytte
    void listen();
    //Returnerer en dynamisk allokeret TCPSocket til en klient som har forbundet.
    //Hvis 'm_timeOut' er større end 0 ventes dette antal
    //millisekunder eller til der er en klient. Udløber
    //tiden kastes en TimerException.
    TCPSocket * accept();
    //Sætter et nyt timeout som virker fra næste gang vi kalder 'accept()'
    //Der ventes 'timeOut' millisekunder hvis 'timeOut' > 0. Ellers ventes
    //til der er en klient
    void setTimeOut(UInt32 timeOut);
    //Returnerer timeout
    UInt32 getTimeOut();
    //Returnerer porten, der lyttes på
    UInt16 getPort();

  private:
    //Opretter vores server socket og binder den til den angivne adresse og port
    void makeAndBind(struct in_addr address);
    //Denne funktion blokerer i 'm_timeOut' millisekunder, eller til
    //der er en klient
    void waitForClient();
    //Porten som vi lytter på
    UInt16      m_port;
    //Antallet af millisekunder vi skal vente på blokerende kald.
    //Hvis denne er 0, venter vi evigt.
    UInt32      m_timeOut;
    //Vores server socket
    int         m_serverSocket;
};

#endif

Kode 

//TCPSocket.h
#if !defined(TCPSOCKET_H)
#define      TCPSOCKET_H

#include "IPAddress.h"

class TCPSocket
{
  //Dette gør, at TCPServerSocket, som vi laver i næste artikel, kan bruge vores
  //private constructor
  friend class TCPServerSocket;
  public:
    //Opretter en socket som forbinder til en adresse
    //baseret på IPAddress klassen og en port
    TCPSocket(IPAddress & adr, UInt16 port, UInt32 timeOut = 0);
    //Opretter en socket som forbinder til en adresse
    //baseret på string klassen og en port
    TCPSocket(string & adr, UInt16 port, UInt32 timeOut = 0);
    //Deallokerer socket objektet, lukker evt. forbindelsen
    ~TCPSocket();
    //Sætter et nyt timeout som virker fra næste gang vi kalder 'read()'
    //Der ventes 'timeOut' millisekunder hvis 'timeOut' > 0. Ellers ventes
    //til der er data
    void setTimeOut(UInt32 timeOut);
    //Opretter en socket og forbinder til den angivne adresse og port
    void connect();
    //Læser op til 'size' bytes og placerer dem i 'buffer'.
    //Returnerer antallet af bytes, som blev læst.
    //Hvis 'm_timeOut' er større end 0 ventes dette antal
    //millisekunder eller til der er data at læst. Udløber
    //tiden kastes en TimerException.
    SInt32 read(void * buffer, SInt32 size);
    //Skriver 'size' bytes fra 'buffer'.
    //Returnerer antallet af bytes, som blev skrevet.
    SInt32 write(const void * buffer, SInt32 size);
    //Lukker forbindelsen og frigiver vores socket
    void close();
    //Returnerer en pointer til adressen
    IPAddress * getAddress();
    //Returnerer porten
    UInt16 getPort();
    //Returnerer timeout
    UInt32 getTimeOut();

  private:
    //Denne constructor opretter et TCPSocket objekt ud fra en eksisterende
    //socket. Det bliver nødvendigt i næste artikel, hvor vi programmerer
    //servere. Den vil blive brugt af TCPServerSocket klassen
    TCPSocket(int socket, struct sockaddr_in sock_addr, UInt32 timeOut = 0);
    //Denne funktion blokerer i 'm_timeOut' millisekunder, eller til
    //der er data at læse.
    void waitForData();

    //Adressen som vi skal forbinde til
    IPAddress   m_address;
    //Porten som vi forbinder til
    UInt16      m_port;
    //Vores socket
    int         m_socket;
    //Antallet af millisekunder vi skal vente på blokerende kald.
    //Hvis denne er 0, venter vi evigt.
    UInt32      m_timeOut;
};

#endif

Kode 

//Thread.h
#if !defined(THREAD_H)
#define      THREAD_H
#if defined(__linux__)
    #include <pthread.h>
#elif defined(_WIN32)
    #include <windows.h>
#endif

class Thread
{
    private:
#if defined(__linux__)
        //Funktionen som kaldes af Linux
        static void * thread_function(void * parameter);
        //Handle til tråden
        pthread_t   m_thread;
#elif defined(_WIN32)
        //Funktionen som kaldes af Windows
        static DWORD WINAPI thread_function(LPVOID parameter);
        //Handle til tråden
        HANDLE m_thread;
#endif
    protected:
        //Denne funktion skal overstyres af nedarvende klasser
        virtual void run() = 0;
    public:
        //Trådens constructor
        Thread();
        //Denne funktion får den kaldende tråd til at standse
        //til dette tråd objekt er færdig med at eksekvere
        void waitForThread();
        //Denne funktion vil starte tråden
        void start();
};

#endif

Kode 

//ThreadException.h
#if !defined(THREADEXCEPTION_H)
#define      THREADEXCEPTION_H

#include "Exception.h"

class ThreadException : public Exception
{
    public:
        ThreadException(string description);
};

#endif

Kode 

//TimerException.h
#if !defined(TIMEREXCEPTION_H)
#define      TIMEREXCEPTION_H
#include "Exception.h"

class TimerException : public Exception
{
  public:
    TimerException(string description);
};

#endif

Kode 

//Types.h
#if !defined(TYPES_H)
#define      TYPES_H

typedef signed char SInt8;
typedef unsigned char UInt8;
typedef signed short SInt16;
typedef unsigned short UInt16;
typedef signed int SInt32;
typedef unsigned int UInt32;

#endif

Kode 

//UDPSocket.h
#if !defined(UDPSOCKET_H)
#define      UDPSOCKET_H

#include "IPAddress.h"
#include "Mutex.h"

class UDPSocket
{
  public:
    //Opretter en UDP socket som ikke
    //er bundet til hverken port eller adresse
    //Denne socket SKAL sende den første pakke
    UDPSocket();
    //Opretter en UDP socket som binder
    //til den specificerede port og alle netkort
    UDPSocket(UInt16 port);
    //Opretter en UDP socket som binder
    //til den specificerede port og adresse
    UDPSocket(IPAddress adr, UInt16 port);
    //Frigiver den interne socket
    ~UDPSocket();
    //Sætter et nyt timeout som virker fra næste gang vi kalder 'read()'
    //Der ventes 'timeOut' millisekunder hvis 'timeOut' > 0. Ellers ventes
    //til der er data
    void setTimeOut(UInt32 timeOut);
    //Returnerer timeout
    UInt32 getTimeOut();
    //Skriver 'size' bytes fra 'buffer' til den angivne adresse og port
    //Returnerer antallet af bytes, som blev skrevet
    SInt32 write(const void * buffer, UInt32 size, IPAddress * adr, UInt16 port);
    //Læser højst 'size' bytes og placerer dem i 'buffer'
    //Hvis 'adr' ikke er NULL indeholder den efter dette kald afsenderens adresse
    //Adressen bliver dynamisk allokeret
    //Hvis 'port' ikke er NULL bliver den opdateret med afsenderens port
    SInt32 read(void * buffer, UInt32 size, IPAddress ** adr, UInt16 * port);
    //Returnerer 'true' hvis broadcasting er tilladt på denne UDP socket
    bool broadcastEnabled();
    //Slår broadcasting til eller fra på denne UDP socket
    void enableBroadcast(bool doEnable);
  private:
    //Denne funktion blokerer i 'm_timeOut' millisekunder, eller til
    //der er data at læse.
    void waitForData();
    //Vores socket
    int m_socket;
    //Antallet af millisekunder vi skal vente på blokerende kald.
    //Hvis denne er 0, venter vi evigt.
    UInt32 m_timeOut;
};

#endif

Kode 

//UnknownHostException.h
#if !defined(UNKNOWNHOSTEXCEPTION_H)
#define      UNKNOWNHOSTEXCEPTION_H
#include "NetException.h"

class UnknownHostException : public NetException
{
    public:
        UnknownHostException(string description);
};

#endif