[C++] Sto sclerando... Problemino socket

[monelli]

socket.h

// Definition of the Socket class

#ifndef Socket_class
#define Socket_class


#include <sys/types.h>
//#include <sys/socket.h>
//#include <netinet/in.h>
//#include <netdb.h>
//#include <unistd.h>
#include <string>
#include <winsock2.h> 
#include <ws2tcpip.h> 
//#include <arpa/inet.h>


const int MAXHOSTNAME = 200;
const int MAXCONNECTIONS = 5;
const int MAXRECV = 500;
//const int MSG_NOSIGNAL = 0; // defined by dgame

class MySocket
{
 public:
  MySocket();
  virtual ~MySocket();

  // Server initialization
  bool create();
  bool bind ( const int port );
  bool listen() const;
  bool accept ( MySocket& ) const;

  // Client initialization
  bool connect ( const std::string host, const int port );

  // Data Transimission
  bool send ( const std::string ) const;
  int recv ( std::string& ) const;

  bool is_valid() const { return m_sock != -1; }

  bool getRemoteHostIP(std::string& s);

 private:

  int m_sock;
  sockaddr_in m_addr;


};
#endif

socket.cpp

// Implementation of the Socket class.


#include "Socket.h"
#include <iostream>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#define MSG_NOSIGNAL 0
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
#define EAFNOSUPPORT WSAEAFNOSUPPORT
#define EWOULDBLOCK WSAEWOULDBLOCK





MySocket::MySocket() :
  m_sock ( -1 )
{

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

}

MySocket::~MySocket()
{
  if ( is_valid() )
    ::closesocket ( m_sock );
}

bool MySocket::create()
{
  m_sock = socket ( AF_INET,
		    SOCK_STREAM,
		    0 );

  if ( ! is_valid() )
    return false;


  // TIME_WAIT - argh
  int on = 1;
  if ( setsockopt ( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 )
    return false;


  return true;

}



bool MySocket::bind ( const int port )
{

  if ( ! is_valid() )
    {
      return false;
    }



  m_addr.sin_family = AF_INET;
  m_addr.sin_addr.s_addr = INADDR_ANY;
  m_addr.sin_port = htons ( port );

  int bind_return = ::bind ( m_sock,
			     ( struct sockaddr * ) &m_addr,
			     sizeof ( m_addr ) );


  if ( bind_return == -1 )
    {
      return false;
    }

  return true;
}


bool MySocket::listen() const
{
  if ( ! is_valid() )
    {
      return false;
    }

  int listen_return = ::listen ( m_sock, MAXCONNECTIONS );


  if ( listen_return == -1 )
    {
      return false;
    }

  return true;
}


bool MySocket::accept ( MySocket& new_socket ) const
{
  int addr_length = sizeof ( m_addr );
  new_socket.m_sock = ::accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );

  if ( new_socket.m_sock <= 0 )
    return false;
  else
    return true;
}


bool MySocket::send ( const std::string s ) const
{
  int status = ::send ( m_sock, s.c_str(), s.size(), MSG_NOSIGNAL );
  if ( status == -1 )
    {
      return false;
    }
  else
    {
      return true;
    }
}


int MySocket::recv ( std::string& s ) const
{
  char buf [ MAXRECV + 1 ];

  s = "";

  memset ( buf, 0, MAXRECV + 1 );

  int status = ::recv ( m_sock, buf, MAXRECV, 0 );

  if ( status == -1 )
    {
      //std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
      return 0;
    }
  else if ( status == 0 )
    {
      return 0;
    }
  else
    {
      s = buf;
      return status;
    }
}



bool MySocket::connect ( const std::string host, const int port )
{
  if ( ! is_valid() ) return false;

  m_addr.sin_family = AF_INET;
  m_addr.sin_port = htons ( port );

  int status = inet_pton ( AF_INET, host.c_str(), &m_addr.sin_addr );

  if ( errno == EAFNOSUPPORT ) return false;

  status = ::connect ( m_sock, ( sockaddr * ) &m_addr, sizeof ( m_addr ) );

  if ( status == 0 )
    return true;
  else
    return false;
}



bool MySocket::getRemoteHostIP(std::string& s){

	struct sockaddr_in m_addr;
	socklen_t len;

	len = sizeof m_addr;
	getpeername(m_sock, (struct sockaddr*)&m_addr, &len);
	//printf("Peer IP address: %s\n", inet_ntoa(m_addr.sin_addr));
	s=inet_ntoa(m_addr.sin_addr);

	return true;

}

Ora... nel mio codice eseguo ciò:

socket.send("MESSAGGIO DI PROVA 1");


            fare->setData(zrtp_audio,socket);
	   socket.send("MESSAGGIO DI PROVA 2");

Ora perchè il primo messaggio viene inviato correttamente e il secondo no???

Dovrebbe essere colpa di ciò fare->setData(zrtp_audio,socket); giusto???

Ma setdata fa semplicemente ciò

void setData(zrtp_stream_t  *stream,MySocket ms){
        zrtp_audio=stream;
        s=ms;
	}

Bò... Sto sclerando non capisco dove sia il problema proprio... dove s è dichiarato MySocket s