1

/* 

     2

   Socket.cpp

     3

     4

   Copyright (C) 2002-2004 René Nyffenegger

     5

     6

   This source code is provided 'as-is', without any express or implied

     7

   warranty. In no event will the author be held liable for any damages

     8

   arising from the use of this software.

     9

    10

   Permission is granted to anyone to use this software for any purpose,

    11

   including commercial applications, and to alter it and redistribute it

    12

   freely, subject to the following restrictions:

    13

    14

   1. The origin of this source code must not be misrepresented; you must not

    15

      claim that you wrote the original source code. If you use this source code

    16

      in a product, an acknowledgment in the product documentation would be

    17

      appreciated but is not required.

    18

    19

   2. Altered source versions must be plainly marked as such, and must not be

    20

      misrepresented as being the original source code.

    21

    22

   3. This notice may not be removed or altered from any source distribution.

    23

    24

   René Nyffenegger rene.nyffenegger@adp-gmbh.ch

    25

*/

    26

    27

    28

#include "Socket.h"

    29

#include <iostream>

    30

    31

using namespace std;

    32

    33

int Socket::nofSockets_= 0;

    34

    35

void Socket::Start() {

    36

  if (!nofSockets_) {

    37

    WSADATA info;

    38

    if (WSAStartup(MAKEWORD(2,0), &info)) {

    39

      throw "Could not start WSA";

    40

    }

    41

  }

    42

  ++nofSockets_;

    43

}

    44

    45

void Socket::End() {

    46

  WSACleanup();

    47

}

    48

    49

Socket::Socket() : s_(0) {

    50

  Start();

    51

  // UDP: use SOCK_DGRAM instead of SOCK_STREAM

    52

  s_ = socket(AF_INET,SOCK_STREAM,0);

    53

    54

  if (s_ == INVALID_SOCKET) {

    55

    throw "INVALID_SOCKET";

    56

  }

    57

    58

  refCounter_ = new int(1);

    59

}

    60

    61

Socket::Socket(SOCKET s) : s_(s) {

    62

  Start();

    63

  refCounter_ = new int(1);

    64

};

    65

    66

Socket::~Socket() {

    67

  if (! --(*refCounter_)) {

    68

    Close();

    69

    delete refCounter_;

    70

  }

    71

    72

  --nofSockets_;

    73

  if (!nofSockets_) End();

    74

}

    75

    76

Socket::Socket(const Socket& o) {

    77

  refCounter_=o.refCounter_;

    78

  (*refCounter_)++;

    79

  s_         =o.s_;

    80

    81

  nofSockets_++;

    82

}

    83

    84

Socket& Socket::operator=(Socket& o) {

    85

  (*o.refCounter_)++;

    86

    87

  refCounter_=o.refCounter_;

    88

  s_         =o.s_;

    89

    90

  nofSockets_++;

    91

    92

  return *this;

    93

}

    94

    95

void Socket::Close() {

    96

  closesocket(s_);

    97

}

    98

    99

std::string Socket::ReceiveBytes() {

   100

  std::string ret;

   101

  char buf[1024];

   102

   103

  while (1) {

   104

    u_long arg = 0;

   105

    if (ioctlsocket(s_, FIONREAD, &arg) != 0)

   106

      break;

   107

   108

    if (arg == 0)

   109

      break;

   110

   111

    if (arg > 1024) arg = 1024;

   112

   113

    int rv = recv (s_, buf, arg, 0);

   114

    if (rv <= 0) break;

   115

   116

    std::string t;

   117

   118

    t.assign (buf, rv);

   119

    ret += t;

   120

  }

   121

   122

  return ret;

   123

}

   124

   125

std::string Socket::ReceiveLine() {

   126

  std::string ret;

   127

  while (1) {

   128

    char r;

   129

   130

    switch(recv(s_, &r, 1, 0)) {

   131

      case 0: // not connected anymore;

   132

              // ... but last line sent

   133

              // might not end in \n,

   134

              // so return ret anyway.

   135

        return ret;

   136

      case -1:

   137

        return "";

   138

//      if (errno == EAGAIN) {

   139

//        return ret;

   140

//      } else {

   141

//      // not connected anymore

   142

//      return "";

   143

//      }

   144

    }

   145

   146

    if (r == '\n')  return ret;

   147

    ret += r;

   148

  }

   149

}

   150

   151

void Socket::SendLine(std::string s) {

   152

  s += '\n';

   153

  send(s_,s.c_str(),s.length(),0);

   154

}

   155

   156

void Socket::SendBytes(const std::string& s) {

   157

  send(s_,s.c_str(),s.length(),0);

   158

}

   159

   160

SocketServer::SocketServer(int port, int connections, TypeSocket type) {

   161

  sockaddr_in sa;

   162

   163

  memset(&sa, 0, sizeof(sa));

   164

   165

  sa.sin_family = PF_INET;             

   166

  sa.sin_port = htons(port);          

   167

  s_ = socket(AF_INET, SOCK_STREAM, 0);

   168

  if (s_ == INVALID_SOCKET) {

   169

    throw "INVALID_SOCKET";

   170

  }

   171

   172

  if(type==NonBlockingSocket) {

   173

    u_long arg = 1;

   174

    ioctlsocket(s_, FIONBIO, &arg);

   175

  }

   176

   177

  /* bind the socket to the internet address */

   178

  if (bind(s_, (sockaddr *)&sa, sizeof(sockaddr_in)) == SOCKET_ERROR) {

   179

    closesocket(s_);

   180

    throw "INVALID_SOCKET";

   181

  }

   182

   183

  listen(s_, connections);                               

   184

}

   185

   186

Socket* SocketServer::Accept() {

   187

  SOCKET new_sock = accept(s_, 0, 0);

   188

  if (new_sock == INVALID_SOCKET) {

   189

    int rc = WSAGetLastError();

   190

    if(rc==WSAEWOULDBLOCK) {

   191

      return 0; // non-blocking call, no request pending

   192

    }

   193

    else {

   194

      throw "Invalid Socket";

   195

    }

   196

  }

   197

   198

  Socket* r = new Socket(new_sock);

   199

  return r;

   200

}

   201

   202

SocketClient::SocketClient(const std::string& host, int port) : Socket() {

   203

  std::string error;

   204

   205

  hostent *he;

   206

  if ((he = gethostbyname(host.c_str())) == 0) {

   207

    error = strerror(errno);

   208

    throw error;

   209

  }

   210

   211

  sockaddr_in addr;

   212

  addr.sin_family = AF_INET;

   213

  addr.sin_port = htons(port);

   214

  addr.sin_addr = *((in_addr *)he->h_addr);

   215

  memset(&(addr.sin_zero), 0, 8); 

   216

   217

  if (::connect(s_, (sockaddr *) &addr, sizeof(sockaddr))) {

   218

    error = strerror(WSAGetLastError());

   219

    throw error;

   220

  }

   221

}

   222

   223

SocketSelect::SocketSelect(Socket const * const s1, Socket const * const s2, TypeSocket type) {

   224

  FD_ZERO(&fds_);

   225

  FD_SET(const_cast<Socket*>(s1)->s_,&fds_);

   226

  if(s2) {

   227

    FD_SET(const_cast<Socket*>(s2)->s_,&fds_);

   228

  }     

   229

   230

  TIMEVAL tval;

   231

  tval.tv_sec  = 0;

   232

  tval.tv_usec = 1;

   233

   234

  TIMEVAL *ptval;

   235

  if(type==NonBlockingSocket) {

   236

    ptval = &tval;

   237

  }

   238

  else { 

   239

    ptval = 0;

   240

  }

   241

   242

  if (select (0, &fds_, (fd_set*) 0, (fd_set*) 0, ptval) == SOCKET_ERROR) 

   243

    throw "Error in select";

   244

}

   245

   246

bool SocketSelect::Readable(Socket const* const s) {

   247

  if (FD_ISSET(s->s_,&fds_)) return true;

   248

  return false;

   249

}