1

Voilà, je souhaiterai developper une apps en C/C++ sous linux/unix qui permet de communiquer entre 2 pc. En gros je voudrai surtout de l'aide pour programmer une lib permettant d'envoyer et recevoir des données par RJ45.
Si vous avez des informations, ou encore mieux si vous connaissez deja une lib permettant de faire ca, je suis preneur. mercitongue

2

tcp/ip et les socket ? neutral

3

je connais pas grand chose malheureusementsad

4

c'est vraiment pas très dure à apprendre, il y a des bons tuto sur le net pour utiliser les socket en C,C++, tout ce que tu veux.
Ca devrait répondre à toutes tes attentes.

5

ok je vais regarder catongue merci

6

tu vas dans un biblio proche de chez toi et tu prends:
les reseaux [ de pujolle ] pour te donner une idée (je dis ça à cause du rj45/rj45 qui me dit que tu n'as aucune notion de reseau)
un bouquin sur tcp/ip
un bouquin sur les sockets unix
avatar
fabetal_ > Hier, je me suis fait monter par un pote
redangel > et en chevals, ça donne quoi?
Nil> OMG I think I'm gay

7

par exemple aussi, mais un bon tuto sur le net ca suffit a priori largement pour tout comprendre smile

8

-

9

http://www.salemioche.com/ y a des explications et des exemples de source en C, des modèles clients / serveurs.

il y a tout sur le net, la difficulté est de trouver l'information interessante au milieu de la masse de merde qui se disent tutoriaux pour ceci ou cela :/

10

Il est top ton sitetongue
maintenant il faut que je configure un 'reseau' entre 2 pc sous linux.
thx!

11

y a d'autres sites pour ça cheeky

12

Bon finalement je pense que je vais utiliser SDL_Net qui est une legere surcouche de cette gestion des sockets, et apparement je vais utiliser de l'UDP pour une plus grande vitesse, enfin si j'y parvient puisque je dois transmettre une image de webcam et que si il y a des pertes:/

13

UDP: t'as pas de controle d'erreur

14

oui, c le probleme:/
mais pour de l'imagerie c pas focement un probleme
faut que je reflechisse :/

15

effectivement pour un flux webcam, udp c'est le mieux, mais bon t'as pas regarde s'il existait des trucs tous faits?
(en fait si il en existe meme par dizaines)
avatar
fabetal_ > Hier, je me suis fait monter par un pote
redangel > et en chevals, ça donne quoi?
Nil> OMG I think I'm gay

16

en fait j'ai des données sensibles à transmettre et en supplement une img de webcam.
C'est pour controller le fonctionnement d'un robot.

17

pour les données sensibles, l'UDP est pas le mieux smile
tu n'auras jamais la certitude que c'est arrivé sauf si tu mets en place une surcouche dans ton programme qui valide.

18

je peux creer un processe gerant un socket UDP et un process gérnat un process TCPtongue
bn pour le moment j'ai ca:
	CNetwork yEp;
	Datas yOp;
	strcpy(yOp,"Essai de texte à envoyer....");
	yEp.Connection("192.168.1.101",9999);
	TCPsocket Socket= yEp.OpenTCPSocket();
	yEp.SendDatas(&yOp,Socket);



ca fait plaisirtongue

19

Erf j'ai des problemes entre receive et send.
j'explique: j'arrive a envoyé un message facilement.
je peux en envoyer plusieur si je recrée a chaque fois le socket sans probleme (mais je pense pas que ce soit une bonne sollution de creer a chaque fois le soket?)
si j'en envoi plusieurs avec plusieur send à la suite , et bien je revois soit des doublons,soit il m'en manque. je suis en TCP/IP, je ne comprend pas.
il faudrai un instruction comme receive, mais qui distingue les envois:
si je fais Evois 1 2 3
je recois:
1 2 2
comment faire dans ma boucle pour qu'il attende le prochain envois?

20

Tu es en tcp, tu n'envoies et ne reçois pas des paquets, mais un flux continue. L'ordre est garanti, ainsi que la présence de toutes les données à l'arrivée, sans doublon. Le problème vient de ton code. Tu peux montrer comment tu appelles read et write ?

Microbug> Pour des données sensibles (question temps surtout) le problème commence dès Ethernet, qui ne garantit pas que les trames seront transmises en un temps fini.

21

C'est a partir d'un site que j'ai vu sur le net:

alors pour le server:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


int main(int argc, char** argv )
{ 
	int    sockfd,newsockfd,clilen,chilpid,ok,nleft,nbwriten;
	char c;
	char pixels[320*240];
	struct sockaddr_in cli_addr,serv_addr;
	
	
	if (argc!=2) {printf ("usage: socket_srv port_number\n");exit(0);}
	
	printf ("server starting...\n");  
	
	/* ouvertture du socket */
	sockfd = socket (AF_INET,SOCK_STREAM,0);
	if (sockfd<0) {printf ("impossible d'ouvrir le socket\n");exit(0);}
	
	/* initialisation des parametres */
	bzero((char*) &serv_addr, sizeof(serv_addr));
	serv_addr.sin_family       = AF_INET;
	serv_addr.sin_addr.s_addr  = htonl(INADDR_ANY);
	serv_addr.sin_port         = htons(atoi(argv[1]));
	
	/* effecture le bind */
	if (bind(sockfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr))<0)
	{printf ("impossible de faire le bind\n");exit(0);}
	
	/* petit initialisation */
	listen(sockfd,1);
	
	/* attend la connection d'un client */
	clilen = sizeof (cli_addr);
	newsockfd = accept (sockfd,(struct sockaddr*) &cli_addr, &clilen);
	if (newsockfd<0) {printf ("accept error\n"); exit(0);}
	printf ("connection accepted\n");
	printf("Attente de Q pour quitter\n");
	
	
	while (1)
	{ 
		char c;
		while (read(newsockfd,&c,1)!=1);
		printf("%c",c);
		if (c=='Q')
			break;
	}

	close(sockfd);
	printf("\n");
	return 0;
}

22

Pour le client:
#include <stdio.h>

#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>  
// atoi

#include <string.h>
// bzero

#include <unistd.h>
#include <SDL/SDL.h>


void SetPxl(int x, int y, Uint8 color, SDL_Surface *pScreen)
{
	Uint8 *bufp;
	bufp = (Uint8 *)pScreen->pixels + y*pScreen->pitch + x;
        *bufp = color;
	SDL_UpdateRect(pScreen, x, y, 1, 1);
}


int main(int argc, char** argv )
{ 
  int    sockfd,newsockfd,clilen,chilpid,ok,nleft,nbwriten;
  char c;
  struct sockaddr_in cli_addr,serv_addr;

/*
SDL_Init(SDL_INIT_VIDEO);
SDL_Surface *pScreen = SDL_SetVideoMode(320,240,8,SDL_SWSURFACE);

for (int y=0;y<240;y++)
for (int x=0;x<320;x++)
	SetPxl(x,y,(Uint8)x+y,pScreen);

char *pDatas = (char*)pScreen->pixels;
for (int y=0;y<240;y++)
for (int x=0;x<320;x++)
	SetPxl(x,y,*++pDatas,pScreen);


printf("Taille de la SDL_Surface : %uo, %uko\n",320*240,320*240/1024);
*/
  if (argc!=3) {printf ("usage  socket_clt adresse_serveur numero_de_por\n");exit(0);}
 
  printf ("client starting\n");  

  /* initialise la structure de donnee */
  bzero((char*) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family       = AF_INET;
  serv_addr.sin_addr.s_addr  = inet_addr(argv[1]);
  serv_addr.sin_port         = htons(atoi(argv[2]));
  
  /* ouvre le socket */
  if ((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
    {printf("socket error\n");exit(0);}
  
  /* effectue la connection */
  if (connect(sockfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr))<0)
    {printf("socket error\n");exit(0);}
//  SDL_Quit();  
  
  /* repete dans le socket tout ce qu'il entend */
  while (1) 
  {
	c=getchar();
	write (sockfd,&c,1);
	if (c=='Q')
		break;
  }
	printf("\n");
  
  
  /*  attention il s'agit d'une boucle infinie 
   *  le socket n'est jamais ferme !
   */
  return 0;
}

23

Bon la je suis retourné a qqc de stable, qui marche bien, mais j'avais essayé d'envoyer pDatas, et la ca marchait plus :/

24

tu faisais comment pour envoyer pDatas ?

25

int done = 0;
while (done < 320*240) {
	int n = write(sockfd, (char*)pDatas+done, 320*240 -done);
	if (n < 0) break; /* erreur */
	done += n;
}
C'est quelque chose dans ce genre là qu'il faut faire pour être sûr que tout est écrit correctement

26

write (sockfd,pData,320*240);
et pour recevoir:
while (read(newsockfd,pixel,sizeof(pixel))!=sizeof(pixel));

27

Ué pour envoyer c'est pas bon, tu as de fortes chances qu'une partie seulement soit envoyée (les buffers d'émission sont assez petits).

Pour la lecture ta fonction est fausse, tous les pixels seont écrits au même endroit. Sans compter que read peut retourner une valeur inférieure à sizeof(pixel), tu n'as pas de garantie d'atomicité. C'est à dire que si tu écris :
abc def
L'autre en face peut parfaitement lire
ab cd e f

28

Euh au fait dans le ./25, y'a pas de condition d'arrêt à la boucle triso. Faut remplacer le while(1) par while(done < 320*240). Je vais éditer ça.

Note que pour la lecture c'est exactement la même fonction, mais avec read au lieu de write.

29

Heu si j'ai bien compris pour résumer (je peux pas tester là):

Le server:
int done = 0; 
char pDatas[320*240];
printf("Reception de l'image en cours\n");
while (done!=320*240) 
{ 
	int n = read(sockfd, (char*)pDatas+done, 320*240 -done); 
	if (n < 0) break; /* erreur */ 
	done += n; 
} 
if (n!=320*240)
 printf("L'image n'a pas ete recue correctement\n");
else
 printf("Image recu.\n");
close(sockfd);


Le client:
printf("Envois de l'image en cours\n");
int done = 0; 
while (done!=320*240) { 
	int n = write(sockfd, (char*)pDatas+done, 320*240 -done); 
	if (n < 0) break; /* erreur */ 
	done += n; 
} 
if (done!=320*240)
 printf("Echec de l'envois\n");
else
 printf("Envois reussit\n");
close(sockfd);


ce devrait etre bon?

30

Je n'y vois pas d'erreur a priori. Faudra tester, évidemment.