C:/knet/include/kNet/Socket.h

Go to the documentation of this file.

/* Copyright 2010 Jukka Jylänki

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */
#pragma once

#ifdef WIN32

#include "win32/WS2Include.h"
#define KNET_EWOULDBLOCK WSAEWOULDBLOCK
#define KNET_SOCKET_ERROR SOCKET_ERROR
#define KNET_ACCEPT_FAILURE SOCKET_ERROR

namespace kNet
{
typedef int socklen_t;
}

#else

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#define INVALID_SOCKET (0)
#define KNET_SOCKET_ERROR (-1)
#define KNET_ACCEPT_FAILURE (-1)
#define KNET_EWOULDBLOCK EWOULDBLOCK
#define closesocket close
#define TIMEVAL timeval
#define SD_SEND SHUT_WR
#define SD_BOTH SHUT_RDWR

namespace kNet
{
typedef unsigned int SOCKET;
}
#endif

#include <vector>
#include <list>

#include "SharedPtr.h"
#include "EndPoint.h"
#include "WaitFreeQueue.h"
#include "Event.h"

namespace kNet
{

enum SocketTransportLayer
{
   InvalidTransportLayer = 0, 
   SocketOverUDP,
   SocketOverTCP
};

std::string SocketTransportLayerToString(SocketTransportLayer transport);

enum SocketType
{
   InvalidSocketType = 0, 
   ServerListenSocket, 
   ServerClientSocket, 
   ClientSocket 
};

std::string SocketTypeToString(SocketType type);

typedef int OverlappedTransferTag;

#ifdef WIN32
typedef WSABUF kNetBuffer;
#else
struct kNetBuffer
{
   unsigned long len;

   char *buf;
};
#endif

struct OverlappedTransferBuffer
{
   kNetBuffer buffer;
#ifdef WIN32
   WSAOVERLAPPED overlapped;
#endif

   int bytesContains;

   sockaddr_in from;
   socklen_t fromLen;
};

class Socket : public RefCountable
{
public:
   Socket();

   Socket(SOCKET connection, const EndPoint &localEndPoint, const char *localHostName,
      const EndPoint &remoteEndPoint, const char *remoteHostName, 
      SocketTransportLayer transport, SocketType type, size_t maxSendSize);

   Socket(const Socket &);
   ~Socket();

   Socket &operator=(const Socket &);

   void SetSendBufferSize(int bytes);
   void SetReceiveBufferSize(int bytes);

   int SendBufferSize() const;
   int ReceiveBufferSize() const;

   bool Connected() const;
   bool IsReadOpen() const { return IsOverlappedReceiveReady() || readOpen; }
   bool IsWriteOpen() const { return writeOpen; }
   void MarkReadClosed() { readOpen = false; }
   void MarkWriteClosed() { writeOpen = false; }

   bool IsUDPServerSocket() const { return transport == SocketOverUDP && type == ServerListenSocket; }
   bool IsUDPSlaveSocket() const { return transport == SocketOverUDP && type == ServerClientSocket; }

   void Disconnect();
   void Close();

   bool Send(const char *data, size_t numBytes);

   OverlappedTransferBuffer *BeginSend();
   bool EndSend(OverlappedTransferBuffer *send);
   void AbortSend(OverlappedTransferBuffer *send);

#ifdef WIN32

   int NumOverlappedSendsInProgress() const { return queuedSendBuffers.Size(); }
   int MaxOverlappedSendsInProgress() const { return queuedSendBuffers.Capacity(); }
#endif

   bool IsOverlappedSendReady();
   Event GetOverlappedSendEvent();

// bool WaitForData(int msecs); // this will be removed completely.

   size_t Receive(char *dst, size_t maxBytes, EndPoint *endPoint = 0);

   OverlappedTransferBuffer *BeginReceive();
   void EndReceive(OverlappedTransferBuffer *buffer);
#ifdef WIN32

   int NumOverlappedReceivesInProgress() const { return queuedReceiveBuffers.Size(); }
   int MaxOverlappedReceivesInProgress() const { return queuedReceiveBuffers.Capacity(); }
#endif

   bool IsOverlappedReceiveReady() const;
   Event GetOverlappedReceiveEvent(); // [worker thread]

   SocketTransportLayer TransportLayer() const { return transport; }

   SocketType Type() const { return type; }

   size_t MaxSendSize() const { return maxSendSize; }

   const EndPoint &LocalEndPoint() const { return localEndPoint; }
   const char *LocalAddress() const { return localHostName.c_str(); }
   unsigned short LocalPort() const { return localEndPoint.port; }

   const EndPoint &RemoteEndPoint() const { return remoteEndPoint; }
   const char *DestinationAddress() const { return remoteHostName.c_str(); }
   unsigned short DestinationPort() const { return remoteEndPoint.port; }

   std::string ToString() const;

   void SetBlocking(bool isBlocking);

   SOCKET &GetSocketHandle() { return connectSocket; }

   void SetNaglesAlgorithmEnabled(bool enabled);

private:
   SOCKET connectSocket;

   EndPoint localEndPoint;

   std::string localHostName;
   
   EndPoint remoteEndPoint;

   sockaddr_in udpPeerAddress;

   std::string remoteHostName;

   SocketTransportLayer transport;

   SocketType type;

   size_t maxSendSize;

   bool writeOpen;

   bool readOpen;

#ifdef WIN32
   WaitFreeQueue<OverlappedTransferBuffer*> queuedReceiveBuffers;
   WaitFreeQueue<OverlappedTransferBuffer*> queuedSendBuffers;

   void FreeOverlappedTransferBuffers();

   void EnqueueNewReceiveBuffer(OverlappedTransferBuffer *buffer = 0);
#endif
};

} // ~kNet