[C++]send() entre win et linux

int SelectServerThread::protectedRun ( )
{
	while ( !bClose )
	{
		ID_IP.clear ( );
		
		//Verouille le mutex
		pthread_mutex_unlock ( &myMutex );

		//Recuperation des donn?es des utilisateurs connect?s
		((ServerMultiThreadLinux*)TheServer)->Get_myID_Ip_User ( ID_IP );

		//Lock le mutex
		pthread_mutex_lock ( &myMutex );

		if ( !ID_IP.empty ( ) )
		{
			//Creation d'un iterateur au debut de la map
			kstl::map < int, CONNEXION* >::iterator It = ID_IP.begin ( );

			fd_set Set_Read;
			fd_set Set_Exept;
			fd_set Set_Write;
			struct timeval tv;

			tv.tv_sec = 0;
			tv.tv_usec = 10000;

			//Parcour de la map
			while ( It != ID_IP.end ( ) )
			{

				//Initialisation des valeurs
				myReader.clear ( );
				myWriter.clear ( );
				myExept.clear ( );

				FD_ZERO ( &Set_Read );
				FD_ZERO ( &Set_Exept );
				FD_ZERO ( &Set_Write );

				FD_SET ( ( *It ).second->Socket, &Set_Read );
				FD_SET ( ( *It ).second->Socket, &Set_Write );
				FD_SET ( ( *It ).second->Socket, &Set_Exept );

				It++;
			}
			
			//Select
			int iValue = select ( 0, &Set_Read, &Set_Write, &Set_Exept, &tv );

			if ( iValue )
			{
				kstl::map < int, CONNEXION* >::iterator It = ID_IP.begin ( );

				while ( It != ID_IP.end ( ) )
				{
					if ( FD_ISSET ( ( *It ).second->Socket, &Set_Read ) )
					{
						myReader.push_back  ( ( *It ).second->Socket );
					}
					if ( FD_ISSET ( ( *It ).second->Socket, &Set_Write ) )
					{
						myWriter.push_back  ( ( *It ).second->Socket );
					}
					if ( FD_ISSET ( ( *It ).second->Socket, &Set_Exept ) )
					{
						myExept.push_back  ( ( *It ).second->Socket );
					}

					It ++;
				}
			}
			
			
			
			//Iterateur reader
			kstl::vector <int>::iterator ItReader = myReader.begin ( );

			//Parcour du vecteur
			while ( ItReader != myReader.end ( ) )
			{
				//erase buffer
				for ( int i = 0; i < 200; i++ )
				{
					myMessage [i] = 0;
				}

				//reception du message
				int iReceiveLenght = recv ( ( *ItReader ), myMessage,  200, 0 );
						
				if ( iReceiveLenght > 0 )
				{
					printf ( "Paquet recu\n");

					//Sauvegarde du message dans le buffer du serveur
					TheServer->AddMessage ( myMessage, iReceiveLenght );

                                        //Renvoi d'un r?ponse
					kstl::string Message;
					Message = "Reponse";

					//Recuperation de la taille du message
					int MessageLenght = Message.size ( );

					//envois le message
					send ( ( *ItReader ), Message.c_str ( ) , MessageLenght, 0 );
				}
				else
				{
					printf ( "Paquet non recu\n" );
				}

				//incr?mentation de l'iterateur
				ItReader++;
			}
		}
	}

	return 0;
}

bool ClientMultiThreadLinux::ConnectToAdress ( kstl::string strIP )
{
	if ( !mybIsConnect )
	{

		//Address de destination
		struct sockaddr_in DestAddr;
		DestAddr.sin_family = AF_INET;
		DestAddr.sin_port = htons ( ulRemotePort );
		
		DestAddr.sin_addr.s_addr = inet_addr( strIP.c_str () );
		
		// z?ro pour le reste de la struct
		memset ( &DestAddr.sin_zero, 0 , sizeof ( DestAddr.sin_zero ) );

		//Initialisation du socket en TCP
		myConnectedSocket = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP );

		//Connexion au serveur distant
		int TryToConnect = 0;
		int iValue = -1;
		
		//Fait 10 test de connexion en cas d'echec
		while ( ( iValue < 0 ) && ( TryToConnect <= 10 ) )
		{
			//Connexion
			iValue = connect ( myConnectedSocket, ( struct sockaddr * ) &DestAddr, sizeof ( struct sockaddr ) );
			
			if ( iValue >= 0 )
			{
				//Connexion reussi
				mybIsConnect = true;
			}
			
			TryToConnect ++;
		}

		//Connexion echouer

		if ( iValue < 0 )
		{
			printf ( "Not connection found\n" );
			
			//Fermeture du socket
			close ( myConnectedSocket );
			return false;
		}

		//Connexion reussi
		else
		{
			printf ( "Connexion succes\n" );

                        //Lancement du Thread d'ecoute de message
                        if ( myReceiveClientThread == NULL )
                        {
                                myReceiveClientThread = ( ReceiveClientThread* ) ( Core::GetInstanceOf ( "myReceiveClientThread", _S_2_ID ( "ReceiveClientThread" ) ) );
                                myReceiveClientThread->setValue ( "mySocket", myConnectedSocket );
                                myReceiveClientThread->Init ( );
                        }

                        while ( 1 )
                        {
                                kstl::string Message;
                                Message = "test 2.h";

                                //Recuperation de la taille du message
                                int MessageLenght = Message.size ( );

                                send ( myConnectedSocket, Message.c_str ( ), MessageLenght, 0 );

                                sleep ( 5 );
                        }

                        return true;
		}	
	}
}