udpraw.h

Go to the documentation of this file.

/* This file is part of Udpraw - A library for UDP transmission.
 *
 * Copyright (C) 2011 Trevor Dodds <@gmail.com trev.dodds>
 *
 * Udpraw is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * Udpraw is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * Udpraw.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef UDPRAW_H
#define UDPRAW_H

#include "udpraw_api.h"
#include <string>
#include <vector>
#ifdef _MSC_VER
  // link to ws2_32.lib, ws2_32.dll, see WSAStartup docs.
  #include <winsock2.h>
#else
  #include <netinet/in.h>
#endif

class UDPRAW_API Udpraw {
  private:

  protected:

#ifdef _MSC_VER
    WSADATA wsaData;          
    SOCKET recvSocket,        
           sendSocket;        
    bool initWSA;             
#else
    int recvSocket, 
        sendSocket; 
#endif

    bool createdRecv, 
         createdSend; 
    fd_set readSocks;                   
    fd_set writeSocks;                  
    fd_set exceptionSocks;              
    int numSocksReadable;               
    sockaddr_in recvAddr, 
                sendAddr, 
                fromAddr; 
    std::vector <std::string> sendIp;                 
    std::vector<int>::iterator recv_port_iterator;    
    std::vector <int> sendPort;                       
    // generate some basic stats
    int statSent;   
    int statRecvd;  
    int lastError;  
    std::string errorPrepend; 
    struct {
      float send;
      float recv;
    } simulateLoss; 
    void init(); 
    bool simulatePacketLoss(float prob); 
  public:

    enum UdprawError {
      UDPRAW_NO_ERROR,      
      UDPRAW_BIND,          
      UDPRAW_MSGSIZE,       
      UDPRAW_NOINIT,        
      UDPRAW_NOIP,          
      UDPRAW_NOPORT,        
      UDPRAW_RECV,          
      UDPRAW_SELECT,        
      UDPRAW_SEND,          
      UDPRAW_SOCKEXCEPTION, 
      UDPRAW_UNMATCHED      
    };


    Udpraw(); 
    ~Udpraw(); 
    int getError(); 
    std::string getErrorStr(); 
    std::string getErrorStr(int error); 
    void writeError(); 
    void writeError(std::string prependMsg); 
    void writeError(int error); 
    // Call either initReceiver or initSender.
    // For the receiver, you must specify a port, because it binds in the init.
    // For the sender, you can specify a port/ip straight away, or later with the
    // methods below, because it's only used when the data is actually sent.
    // The ip/ports for sending can be changed at any time, see below for details.

    int initReceiver(int port); 
    void initSender(int port = 0); 
    void initSender(const char* ip, int port = 0); 
    void initSender(std::vector <std::string> ip_list, int port = 0); 
    void initSender(std::vector <std::string> ip_list, std::vector <int> port_list); 
    // set/change IPs and ports
    // Can be either one IP and list of ports,
    // one port and list of IPs,
    // or equal size list of IPs and corresponding ports.
    // If they are not equal size then sendRaw will return an error.

    void setSendIp(const char* ip); 
    void setSendIp(std::vector <std::string> ip_list); 
    void setSendPort(int port); 
    void setSendPort(std::vector <int> port_list); 
    int doSelect();

    int recvRaw(char* buf, int len, bool select = true);

    int sendRaw(const char* buf, int len, bool select = true);


    int getStatSent(); 
    int getStatRecvd(); 
    void setStatSent(int bytes); 
    void setStatRecvd(int bytes); 
    void setSimulateLossSend(float probabilityofloss); 
    void setSimulateLossRecv(float probabilityofloss); 
    float getSimulateLossSend(); 
    float getSimulateLossRecv(); 
    int closeAndCleanup(); 
};

#endif