[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[linux] [OT] prog rzo C/C++



salut,

en jouant avec les socket (et les winsocks (berk)), j'arrive à un
résultat assez surprenant... je vous fait voir...

binny@typhus:~$ ./rzo_server 44444
SERVEUR> Le serveur ecoute le port 44444
192.168.0.2:32772 [1]   : d
192.168.0.2:32772 [2]   : ee
192.168.0.2:32772 [1]   : de
SERVEUR> Arret du serveur (signal 2)

et en meme temps
binny@storia:~/tauceti/tauceti/client/functions$ ./rzo_test 
ENVOI : d
REPONSE : d
ENVOI : ee
REPONSE : ee
ENVOI : d
REPONSE : de

d'ou peut venir ce problème des lettres qui restent ?

Le code du serveur est en C et celui du client en C++.

Je mets en attachement les fichiers sources...

merci de jeter un oeil

@+,
binny

ps: faites pas trop attention, je code comme un goret :)
ps2: si vous connaissez un bon tutorial/livre/autre sur les winsocks et
les sockets, je suis preneur... fr/en

-- 

Un coup de chaleur ? Passez sur La Banquise... 
http://www.labanquise.org

       Benjamin Michotte        <binny@baby-linux.net>
  °v°  web      : http://www.baby-linux.net
  _o_  homepage : http://www.baby-linux.net/binny
       slaktool : http://slaktool.sourceforge.net
       icq uin  : 99745024
#include "rzo.h"

int main(int argc, char **argv) {
	
	Rzo mon_rzo("typhus", 44444);
	
	string yop;

	while(1) {
		cout << "ENVOI : ";
		cin >> yop;
		mon_rzo.send(yop);
		cout << "REPONSE : " << mon_rzo.receive() << endl;
	}

}
/*
 *  This program 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *  Start: Fri Aug 24 16:34:46 CEST 2001
 *     Benjamin Michotte (binny) <binny@baby-linux.net>
 *  Filename: rzo.cxx
 *
 */

#include "rzo.h"

Rzo::Rzo(char *serveur, int port) {
	
	nom_serveur = new char[strlen(serveur)+1];
	strcpy(nom_serveur, serveur);
	numero_port_serveur = port;

#ifdef _WIN32
	int error;
	
	version = MAKEWORD( 2, 0 );
	error = WSAStartup( version, &wsaData );
	if(error != 0) {
		exit(1); // see later for something better
	}
	if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) {
    WSACleanup();
    exit(1); // see later for something better
	}
#endif
	
	fd = socket(AF_INET, SOCK_DGRAM, 0);
	if(fd < 0) {
		cout << "oops... fuck, can't create the socket";
		exit(1);
	}
	
	hote = gethostbyname(nom_serveur);

#ifdef _WIN32
	memset(&adresse_socket_serveur, 0, sizeof adresse_socket_serveur);
#endif

	adresse_socket_serveur.sin_family = AF_INET;
	adresse_socket_serveur.sin_port = htons(numero_port_serveur);

#ifdef LINUX
	adresse_socket_serveur.sin_addr = *(struct in_addr *)hote->h_addr;
#elif _WIN32    
	adresse_socket_serveur.sin_addr.s_addr = ((struct in_addr *)(hote->h_addr))->s_addr;
	if(connect(fd, &adresse_socket_serveur, sizeof adresse_socket_serveur) == SOCKET_ERROR)
		return FALSE;
#endif

	if(hote == NULL) {
		cout << "oops... can't find server :(";
		exit(1);
	}
	
	taille_adresse_socket_serveur = sizeof adresse_socket_serveur;
}

Rzo::~Rzo() {

#ifdef LINUX
	close(fd);
#elif _WIN32
	closesocket(fd);
	WSACleanup();
#endif
}

bool Rzo::send(string word) {
	
	int longueur_requete = word.size();
	char *sendmsg = new char[longueur_requete];
	strcpy(sendmsg, word.data());

	if(sendto(fd, sendmsg, longueur_requete, 0, 
					(struct sockaddr *)&adresse_socket_serveur, 
					taille_adresse_socket_serveur) < 0)
		return false;

	delete sendmsg;
	return true;
}

string Rzo::receive(void) {
	
	char *creponse;
	creponse = (char*)malloc(TAILLE_TAMPON);
	int longueur_reponse = recvfrom(fd, 
																creponse,
																TAILLE_TAMPON,
																0,
																NULL,
																0);

	string reponse(creponse);
	
	if(longueur_reponse < 0)
		return "oops... a fuckin' error";
	return reponse;

}
/*
 *  This program 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *  Start: Fri Aug 24 16:34:55 CEST 2001
 *     Benjamin Michotte (binny) <binny@baby-linux.net>
 *  Filename: rzo.h
 *
 */

#ifndef __RZO_H__
#define __RZO_H__

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>

#ifdef LINUX
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#elif _WIN32
// don't forget to add ws2_32.lib when compiling
#include <winsock2.h>
#endif

#ifndef EXIT_FAILURE
#define EXIT_FAILURE -1
#endif

#define TAILLE_TAMPON 1000

class Rzo {
	private:
		struct sockaddr_in adresse_socket_serveur;
#ifdef LINUX
		int fd;
#elif _WIN32
		SOCKET fd;
		WSADATA wsaData;
		WORD version;
#endif
		struct hostent *hote;
		int taille_adresse_socket_serveur;
		char *nom_serveur;
		int numero_port_serveur;

	public:
		Rzo(char*, int);
		~Rzo();
		bool send(string);
		string receive(void);
};

#endif /* __RZO_H__ */
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <ctype.h>

#define TAILLE_TAMPON 1000
static int fd;  

void ErreurFatale(char message[]) {
	printf("SERVEUR> Erreur fatale\n");
	perror(message); 
	exit(EXIT_FAILURE); 
}

void ArretServeur(int signal) {
	close(fd);
	printf("SERVEUR> Arret du serveur (signal %d)\n",signal);
	exit(EXIT_SUCCESS);
}

int main(int argc, char **argv) {
	struct sockaddr_in adresse_socket_serveur;
	size_t taille_adresse_socket_serveur;
	int numero_port_serveur;
	char *src, *dst;  
	struct sigaction a;
	
	if (argc != 2) {
		printf("usage: %s port\n",argv[0]);
		exit(1);
	};
	numero_port_serveur = atoi(argv[1]);
	
	a.sa_handler = ArretServeur;
	sigemptyset(&a.sa_mask); 
	a.sa_flags   = 0;
	sigaction(SIGINT,&a,NULL);
	
	fd = socket(AF_INET,SOCK_DGRAM,0);
	if(fd < 0) 
		ErreurFatale("socket");

	adresse_socket_serveur.sin_family      = AF_INET;    
	adresse_socket_serveur.sin_addr.s_addr = INADDR_ANY; 
	adresse_socket_serveur.sin_port        = htons(numero_port_serveur);
	
	taille_adresse_socket_serveur = sizeof adresse_socket_serveur;
	if(bind(fd, (struct sockaddr *)&adresse_socket_serveur, taille_adresse_socket_serveur) < 0) 
	   ErreurFatale("bind");
	
	printf("SERVEUR> Le serveur ecoute le port %d\n", numero_port_serveur);
	
	while(1) {
		struct sockaddr_in adresse_socket_client;
		int taille_adresse_socket_client;
		char *tampon_requete;
		int longueur_requete;
		
		longueur_requete = 0;
		
		tampon_requete = (char*)malloc(TAILLE_TAMPON);
				
		taille_adresse_socket_client = sizeof(adresse_socket_client);
		longueur_requete = recvfrom(fd,
										tampon_requete,
										TAILLE_TAMPON,
										0,
										(struct sockaddr *)&adresse_socket_client,
										(socklen_t *)&taille_adresse_socket_client);
		
		if(longueur_requete < 0) 
			ErreurFatale("recfrom");
		
		printf("%s:%d [%d]\t: %s\n",
						inet_ntoa(adresse_socket_client.sin_addr),
						ntohs(adresse_socket_client.sin_port),
						longueur_requete,
						tampon_requete);  
		
		if (sendto(fd,
					tampon_requete,
					longueur_requete,
					0,
					(struct sockaddr *)&adresse_socket_client,
					taille_adresse_socket_client) < 0) 
			ErreurFatale("Envoi de la reponse");
		
		free(tampon_requete);
	}
}