Discussion :

[Edouard Kaiser]

Oui j'ai lu mais je comprends pas, je dois vraiment etre fatigué en fin de semaine...
Voila mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
SOCKET dsocket;
 
dsocket = socket(AF_INET, SOCK_STREAM, 0);
 
if (dsocket == -1) 
{
	/* Erreur lors de la création de la socket... */
	printf("Impossible d'initialiser la connexion\n");
	exit(0);
}

dsocket a beau etre différent de -1 (je le vois en mode debug), ça rentre quand meme dans la condition

[Yabo]

tu peux paster l'intégralité de ton code stp ?

[Edouard Kaiser]

Aucun problem

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
#include <stdio.h>     // E/S habituelles
#include <winsock2.h>  // Les Socket
 
#pragma comment(lib, "ws2_32.lib")
 
 
/* --------------------------------------------------- */
/*         P R O G R A M M E   P R I N C I P A L       */
/*         =====================================       */
/*---------------------------------------------------- */
int main(int argc, char *argv[])
{
	char Adresse_Serveur[20];             // Contiendra l'adresse du serveur SMTP
	SOCKET dsocket;                          // Descripteur de fichier
	struct sockaddr_in Addresse_Distante; // Socket
	struct hostent *Adresse_Resolue;      // structure pour résoudre l'adresse
 
	// on demande l'adresse du serveur sur lequel on souhaite se connecter
    printf("Serveur SMTP : ");
	scanf("%s", &Adresse_Serveur);
 
	dsocket = socket(AF_INET, SOCK_STREAM, 0);
 
	// Création de la socket 
	if (dsocket == -1) 
	{
		// Erreur lors de la création de la socket... 
		printf("Impossible d'initialiser la connexion\n");
		exit(0);
	}
	else
	{
		// Type de famille : IPV4 
		Addresse_Distante.sin_family = AF_INET;
 
		// Port sur lequel on veut se connecter (25 : SMTP) 
		Addresse_Distante.sin_port = htons(25);
 
		// Adresse IP du destinataire 
		Addresse_Distante.sin_addr.s_addr = inet_addr(Addresse_Distante);
 
		// Remplie de 0 l'élément sin_zero de la strucuture sockaddr_in 
		memset(&(Addresse_Distante.sin_zero), '\0', 8);
	}
 
	Adresse_Resolue = gethostbyname(Adresse_Serveur);
 
	// Tentavie de connexion au serveur 
	if (connect(dsocket, (struct sockaddr *)&Addresse_Distante, sizeof(struct sockaddr)) == -1) 
	{
		// Erreur lors de la connexion...
		printf("Echec de la connexion : ");
		printf("%s\n",inet_ntoa(Addresse_Distante.sin_addr));
	}
	else
	{
		// On va essayer de se connecter au serveur
		printf("Connexion au serveur.....");
		printf("%s\n",inet_ntoa(Addresse_Distante.sin_addr));
	}
 
	return 0;
}

ce programme ne fait rien concretemenr, j'apprends à utiliser les sockets...

[Yabo]

Si je t'ai demandé si tu avais lu le tutorial c'est parce'que ton erreur est assez grosse.
Peut-être que le relire attentivement ne fera pas de mal

Le tutorial commence en ces termes :

Créer un socket en C/C++ est relativement simple, contrairement à ce que la majorité du monde pensent. La création d'un socket est faite par une chaîne de commandes. Pour commencer, il faut initialiser WSAStartup(). Un groupe de variables seront aussi nécéssaire pour faire cela. Bon, assez de bavardage et passons au code lui-même.
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
void main()
{
WSADATA WSAData;
WSAStartup(MAKEWORD(2,0), &WSAData);
}
WSADATA WSAData, l'initialisation d'une variable WSADATA. La variable va être utilisée pour le démarrage de WSAStartup(). Elle n'aura pas d'autre utilisation, généralement. WSAStartup(MAKEWORD(2,0), &WSAData), ce qui dis à votre ordinateur que vous allez utiliser des sockets.

Allez parce'que je suis gentil je te donne le lien vers le tutorial :
http://c.developpez.com/WalrusSock/

Bon courage pour la suite

[Edouard Kaiser]

Pfff je suis vraiment désolés de t'avoir déranger pour ça
C'était gros comme comme une mongolfière....
Promis je réfléchis encore plus avant de poster la prochaine fois.

P.S : faut pas trop m'en vouloir c est la fin de la semaine et Delphi me lobotomise le cerveau au boulot

[Nasky]

Hors Sujet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

scanf("%s", &Adresse_Serveur);

C'est plutot sans le & ou bien &Adresse_Serveur[0].
C'est bon je vais dormir

Nas'

[Edouard Kaiser]

Merci pour la correction

[gl]

ah oui ce code marche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void mafonction(char *unechaine)
{
        printf("%s", unechaine);
}
 
int main()
{
        mafonction("chaine");
        return 0;
}

mais je comprend pas pourquoi, la je donne pas l'adresse du premier caractère de la chaine en argument de mafonction...

Si tu donne bien l'adresse du premier caractere, "chaine" est une chaine (au sens C du terme) constante donc un tableau constant de char, ce qui fait qu'en argument de fonction ca corrspond a un pointeur sur le debut de la chaine.

Sur les OS récents l'adressage ce fait sur 32 bit (la taille d'un int). Donc on peut avoir autant d'octet en mémoire qu'on peut addresser. Mais avant ca se faisait sur 16 bit (donc on ne pouvait addresser que moitié-moins de mémoire) et en C lorsqu'on voulait addresser sur 32 bit on utilisait le mot FAR.
Encore une fois c'était y a longtemps et ce sont des souvenirs sur ce que j'avais lu dans un article. Si je me trompe corrigez moi

C'est bien lie a l'adresage de la memoire. En gros un pointeur NEAR designait quelquechose se trouvant dans la meme page de 64ko (le pointeur ne devait donc contenir que l'adresse dans la page) et un pinteur FAR permettait de designer quelquechose se trouvant potentiellement dans une autre page (il faut alors l'adresse dans la page et la reference de la page). Sur les systemes du types Windows 9.X, Windows NT, etc... c'est totalement inutile.

[Emmanuel Delahaye]

Le FAR est une vieille notation des pointeurs des pointeurs en C. Il me semble que c'était lorsque l'adressage se faisait sur 16 bit et qu'on voulait un pointeur 32 bit on utilisait void FAR * ptr;.

Enfin je parle de choses que je n'ai pas connue, Emmanuel pour peut-être confirmer (ou infirmer) mes dires

En fait, FAR (ou far) est une extension des compilateurs pour x86 en mode réel (16-bits).

Ce mode supporte plusieurs modèles de mémoire (tiny, small, medium, compact, large, huge). Dans certains modèles, les adresses sont 'near' par défaut (codées en 16 bit) et d'autres 'far' par défaut (codées sur 32-bit[1]),

Souvent, une bibliothèque est compilée en mode 'large', car les adresses ont besoin d'être longues. Si on utilise une telle bibliothèque avec une application compilée en mode small, les adresses seront codée en 16-bits, ce qui n'est pas compatible avec le format attendu par la bibliothèque. C'est pourquoi les implémenteurs du langage C sur x86 mode réel ont inventé les mots clés 'near' et 'far' (_far, FAR...) pour préciser les intentions.

Si une bibliothèque prévue pour fonctionner en mode large doit accepter n'importe quel modèle de mémoire, il suffit de qualifier les pointeurs avec le mot far dans l'interface (le prototype qui est dans le fichier d'entête de la bibliothèque):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   int function (char far *s);

Mais comme ce mot clé n'est pas connu de tous les compilateurs, voire ignoré dans les mode 'plats' (32-bit), on a généralement défini une macro FAR dont la valeur dépend du contexte:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#ifdef 0
#elif defined (__BORLANDC__)
#define FAR far
#elif defined (_MSCV)
#define FAR _far
#elif defined (_DIAB)
#define FAR 
#else
#error FAR is undefined for this platform
#endif

que l'on utilise ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   int function (char FAR *s);

selon le contexte, et sans qu'on ait à modifier le code, on obtient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   int function (char far *s);

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   int function (char _far *s);

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   int function (char *s);

-------------------------
[1] mais ne couvrant en fait que 20 bits physiques, soit 1 Mbyte. Les processeurs Intel en mode réel ont rendu fous plus d'un programmeur...

[Willand]

merci pour les explications

[Yabo]

J'étais pas si loin que ca de al solution Merci Emmanuel