IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Network Socket en C


Sujet :

C

  1. #1
    Candidat au Club
    Homme Profil pro
    Sans Emploi
    Inscrit en
    avril 2021
    Messages
    12
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Sans Emploi

    Informations forums :
    Inscription : avril 2021
    Messages : 12
    Points : 4
    Points
    4
    Par défaut Network Socket en C
    Salut à tous.

    Je commence à découvrir le langage C et je souhaite modifier le code de deux logiciels pour qu'ils puisse communiquer via un port.

    j'ai découvert sur Wikipédia un code qui me parait vraiment trop simple pour que ça fonctionne :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Socket mysocket = getSocket(type = "TCP")
    connect(mysocket, address = "1.2.3.4", port = "80")
    send(mysocket, "Hello, world!")
    close(mysocket)
    source (partie 6 exemple) : https://en.wikipedia.org/wiki/Network_socket#Example

    J'ai essayé de le faire fonctionner sur l'ip 127.0.0.1 car les deux applications sont sur mon pc mais cela ne fonctionne pas.

    Pensez-vous que ce code peut fonctionner ou c'est vraiment trop fantaisiste ?

    Merci.

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    25 797
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 25 797
    Points : 201 091
    Points
    201 091
    Billets dans le blog
    82
    Par défaut
    Bonjour,

    Ce n'est pas simpliste, c'est juste que ce n'est pas en C.
    D'autre part, je n'ai pas très bien compris ce que vous souhaitez faire.
    Sinon, sous Windows, ce cours pourrait vous aider : https://melem.developpez.com/tutorie...ndows/winsock/
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Candidat au Club
    Homme Profil pro
    Sans Emploi
    Inscrit en
    avril 2021
    Messages
    12
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Sans Emploi

    Informations forums :
    Inscription : avril 2021
    Messages : 12
    Points : 4
    Points
    4
    Par défaut
    Merci beaucoup.

    Savez-vous c'est qu'elle langage ?

    J'étais persuadé que c'est du C.

  4. #4
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    juin 2010
    Messages
    6 716
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : juin 2010
    Messages : 6 716
    Points : 30 648
    Points
    30 648
    Billets dans le blog
    4
    Par défaut
    La syntaxe ressemble à du Python, mais c'est possiblement du pseudo-code.
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  5. #5
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 078
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 078
    Points : 24 805
    Points
    24 805
    Billets dans le blog
    1
    Par défaut
    Bonjour

    Citation Envoyé par card15nod2 Voir le message
    J'ai essayé de le faire fonctionner sur l'ip 127.0.0.1 car les deux applications sont sur mon pc mais cela ne fonctionne pas.

    Pensez-vous que ce code peut fonctionner ou c'est vraiment trop fantaisiste ?
    Il n'est pas fantaisiste car il envoie "Hello" sur un serveur web (le port 80). Donc à priori le serveur (si la machine "1.2.3.4" possède un serveur web en écoute) devrait le recevoir et en ce sens, le code est déjà fonctionnel. Mais en aucune façon ce code ne te permettra de "dialoguer" avec ledit serveur car nulle part il ne lit ce que le serveur retourne.
    Et effectivement ce n'est pas du C car le Cn'accepte pas d'appel de fonction avec paramètre nommé (port=80 par exemple).

    Citation Envoyé par card15nod2 Voir le message
    Je commence à découvrir le langage C
    Ben... t'es pas sorti du sable.

    A titre de TP, j'avais codé un "petit" exemple de client/serveur en C. Le serveur écoute en boucle infinie et chaque fois qu'un client arrive, il génère un fils chargé de répéter ce que le client lui dit (donc sans lui répondre).

    Voici le code complet
    socket_tcp.h
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //
    // Header commun aux programmes de communication via tcp
    //
     
    #ifndef _SOCKET_TCP_H_
    #define _SOCKET_TCP_H_
     
    #define SZ_BUF				(256)			// Taille buffer
     
    #endif //_SOCKET_TCP_H_

    Le client "client.c"
    Code c : 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
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    //
    // Client réseau mode tcp
    // Programme destiné à écrire des chaines dans une connexion mode tcp
    // Usage: prog port [nom serveur | adresse serveur]
    //
     
    #include <sys/types.h>						// Types prédéfinis "c"
    #include <sys/socket.h>						// Généralités sockets
    #include <sys/param.h>						// Paramètres et limites système
    #include <stdio.h>							// I/O fichiers classiques
    #include <string.h>							// Gestion chaines de caractères
    #include <netdb.h>							// Gestion network database
    #include <stdlib.h>							// Librairie standard Unix
    #include <unistd.h>							// Standards Unix
    #include <errno.h>							// Erreurs système
    #include "socket_tcp.h"						// Outils communs client et serveur
     
    #define SERVEUR_DEFAULT		("localhost")	// Nom serveur utilisé par défaut
     
    typedef struct {
    	char *host;								// Adresse serveur
    	unsigned short port;					// Port serveur
    } t_param;									// Type créé
     
    // Fonctions diverses
    int init_socket(t_param*);					// Initialisation socket
     
    // Programme principal
    int main(
    	int argc,								// Nbre arg.
    	char *argv[])							// Ptr arguments
    {
    	// Déclaration des variables
    	int sock;								// Socket
    	t_param param;							// Paramètres de connexion
     
    	char hostname[MAXHOSTNAMELEN + 1];		// Nom machine locale
    	char buf[SZ_BUF];						// Buffer texte
    	char *pt;								// Ptr de chaine
     
    	// Récuperation nom machine locale (juste pour l'exemple)
    	if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    		fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, strerror(errno));
    	printf("gethostname='%s'\n", hostname);
     
    	// Si le port n'est pas fourni
    	if (argc <= 1) {
    		fprintf(stderr, "ligne %u - Pas de port\n", __LINE__);
    		return -1;
    	}
     
    	// Initialisation socket sur le serveur demandé en paramètre (ou le serveur par défaut)
    	param.port=atoi(argv[1]);
    	if (argc > 2) {
    		param.host=argv[2];
    	}
    	else {
    		param.host=SERVEUR_DEFAULT;
    	}
    	if ((sock=init_socket(&param)) < 0) {
    		fprintf(stderr, "ligne %u - init_socket(%s) - %s\n", __LINE__, param.host, strerror(errno));
    		exit(errno);
    	}
    	printf("Initialisation socket (serveur=%s, port=%hu, socket=%d)\n", param.host, param.port, sock);
     
    	// Saisie et envoi de la chaîne en boucle
    	do {
    		// Saisie de la chaîne
    		fputs("Entrer chaine (EOT pour finir) :", stdout); fflush(stdout);
    		fgets(buf, SZ_BUF, stdin);
     
    		// Suppression du caractère '\n' éventuel
    		if ((pt=strchr(buf, '\n')) != NULL) *pt='\0';
     
    		// Envoi de la chaîne sur la socket (ne pas oublier le '\0')
    		if (write(sock, buf, strlen(buf) + 1) < 0)
    			fprintf(stderr, "ligne %u - write(%s) - %s\n", __LINE__, buf, strerror(errno));
    	} while (strcmp(buf, "EOT") != 0);
     
    	// Fermeture socket et fin du programme
    	close(sock);
    	return 0;
    }
     
    // Initialisation socket
    int init_socket(
    	t_param *param)							// Paramètres de connexion
    {
    	// Déclaration des variables
    	ushort i;								// Indice de boucle
    	ushort j;								// Indice de boucle
     
    	struct sockaddr_in adr_serveur;			// Adresse socket serveur
    	struct hostent *host_info;				// Info. host
    	int sock;								// Socket
     
    	// Récuperation informations serveur
    	if ((host_info=gethostbyname(param->host)) == NULL) {
    		fprintf(stderr, "ligne %u - gethostbyname(%s) - %s\n", __LINE__, param->host, strerror(errno));
    		return -1;
    	}
    	fputc('\n', stdout);
    	printf("host_info.h_name='%s'\n", host_info->h_name);
    	for (i=0; host_info->h_aliases[i] != NULL; i++)
    		printf("host_info.h_aliase[%hu]='%s'\n", i, host_info->h_aliases[i]);
    	printf("host_info.h_addrtype=%u\n", host_info->h_addrtype);
    	printf("host_info.h_length=%u\n", host_info->h_length);
    	for (i=0; host_info->h_addr_list[i] != NULL; i++) {
    		printf("host_info.h_addr_list[%hu]=", i);
    		for (j=0; j < host_info->h_length; j++)
    			printf("%hu ", (unsigned char)host_info->h_addr_list[i][j]);
    		fputc('\n', stdout);
    	}
    	printf("port demandé=%hu\n", param->port);
     
    	// Remplissage adresse socket
    	memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    	adr_serveur.sin_family=AF_INET;
    	adr_serveur.sin_port=htons(param->port);
    	memcpy(&adr_serveur.sin_addr.s_addr, host_info->h_addr, host_info->h_length);
     
    	// Création socket
    	if ((sock=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
    		fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
    		return -3;
    	}
    	printf("Socket (%d) créée\n", sock);
     
    	// Tentative de connexion en boucle permanente
    	fputc('\n', stdout);
    	while (1) {
    		// Connexion au serveur
    		if (connect(sock, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in)) == 0)
    			break;
     
    		fprintf(stderr, "ligne %u - connect() - %s\n", __LINE__, strerror(errno));
    		sleep(5);
    	}
    	printf("Connexion réussie (socket=%d)\n", sock);
     
    	// Fin fonction
    	return sock;
    }

    Le serveur "serveur.c"
    Code c : 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
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    //
    // Serveur réseau mode tcp
    // Programme destiné à écouter un client via une connexion mode tcp
    // Usage: prog port
    //
     
    #include <sys/types.h>						// Types prédéfinis "c"
    #include <sys/socket.h>						// Généralités sockets
    #include <sys/param.h>						// Paramètres et limites système
    #include <arpa/inet.h>						// Adresses format "arpanet"
    #include <signal.h>							// Signaux de communication
    #include <netdb.h>							// Gestion network database
    #include <stdio.h>							// I/O fichiers classiques
    #include <string.h>							// Gestion chaines de caractères
    #include <stdlib.h>							// Librairie standard Unix
    #include <unistd.h>							// Standards Unix
    #include <errno.h>							// Erreurs système
    #include "socket_tcp.h"						// Outils communs client et serveur
     
    // Structure de travail socket
    typedef struct {
    	int sk_connect;							// Socket de connexion
    	int sk_dialog;							// Socket de dialogue
    } t_socket;									// Type créé
     
    // Fonctions diverses
    int init_socket(unsigned short);			// Initialisation socket
    int client(t_socket*);						// Gestion client
    int dialogue(int);							// Dialogue avec le client
    int nslookup(struct sockaddr_in *, char*);	// Conversion adresse en nom
     
    // Programme principal
    int main(
    	int argc,								// Nbre arguments
    	char *argv[])							// Ptr arguments
    {
    	// Déclaration des variables
    	char hostname[MAXHOSTNAMELEN + 1];		// Nom machine locale
    	t_socket sock;							// Socket
     
    	// Si le port n'est pas fourni
    	if (argc <= 1) {
    		fprintf(stderr, "ligne %u - Pas de port\n", __LINE__);
    		return -1;
    	}
     
     
    	// Récuperation nom machine locale (juste pour l'exemple)
    	if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    		fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, strerror(errno));
    	printf("gethostname='%s'\n", hostname);
     
    	// Détournement du signal émis à la mort du fils (il ne reste pas zombie)
    	signal(SIGCHLD, SIG_IGN);
     
    	// Initialisation socket de connexion
    	if ((sock.sk_connect=init_socket(argc > 1 ?atoi(argv[1]) :0)) < 0) {
    		fprintf(stderr, "ligne %u - init_socket() - %s\n", __LINE__, strerror(errno));
    		return errno;
    	}
    	printf("Socket de connexion (%d) initialisée\n", sock.sk_connect);
     
    	// Ecoute de la ligne
    	if (listen(sock.sk_connect, 1) < 0) {
    		fprintf(stderr, "ligne %u - listen() - %s\n", __LINE__, strerror(errno));
    		return errno;
    	}
    	printf("Socket de connexion (%d) en écoute\n", sock.sk_connect);
     
    	// Attente permanente
    	fputc('\n', stdout);
    	while (1) {
    		printf("ppid=%u, pid=%u, socket=%d, attente entrée...\n", getppid(), getpid(), sock.sk_connect);
     
    		// Attente connexion client
    		if (client(&sock) < 0) {
    			fprintf(stderr, "ligne %u - client() - %s\n", __LINE__, strerror(errno));
    			continue;
    		}
    	}
    	// Pas de sortie de programme - Boucle infinie
     
    	// Fermeture socket et fin théorique du programme (pour être propre)
    	close(sock.sk_connect);
    	return 0;
    }
     
    // Initialisation socket
    int init_socket(
    	unsigned short port)					// Port (éventuel)
    {
    	// Déclaration des variables
    	struct sockaddr_in adr_serveur;			// Adresse socket serveur
    	int sock;								// Socket de connexion
     
    	// Création socket
    	printf("port demandé=%hu\n", port);
    	if ((sock=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
    		fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
    		return -2;
    	}
    	printf("Socket de connexion (%d) créée\n", sock);
     
    	// Remplissage adresse socket
    	memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    	adr_serveur.sin_family=AF_INET;
    	adr_serveur.sin_port=htons(port);
    	adr_serveur.sin_addr.s_addr=INADDR_ANY;
     
    	// Identification socket/réseau
    	if (bind(sock, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in)) < 0) {
    		fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, strerror(errno));
    		return -3;
    	}
    	printf("Socket de connexion (%d) identifiée sur le réseau\n", sock);
     
    	// Renvoi socket créée
    	return sock;
    }
     
    // Gestion du client
    int client(
    	t_socket *sock)							// Socket de communication
    {
    	// Déclaration des variables
    	int pid;								// Process créé
     
    	struct sockaddr_in adr_client;			// Adresse socket client
    	socklen_t len_adr;						// Taille adresse
    	char lookup[MAXHOSTNAMELEN + 1024 + 1];	// Correspondance adresse/nom
     
    	// Attente connexion client
    	len_adr=sizeof(struct sockaddr_in);
    	if ((sock->sk_dialog=accept(sock->sk_connect, (struct sockaddr*)&adr_client, &len_adr)) < 0) {
    		fprintf(stderr, "ligne %u - accept() - %s\n", __LINE__, strerror(errno));
    		return -1;
    	}
     
    	// Client connecté
    	if (nslookup(&adr_client, lookup) < 0)
    		fprintf(stderr, "ligne %u - nslookup() - %s\n", __LINE__, strerror(errno));
    	printf("ppid=%d, pid=%d, socket=%d - Entrée émise (dialogue=%d, adr=%s)\n", getppid(), getpid(), sock->sk_connect, sock->sk_dialog, lookup);
     
    	// Duplication du process (ne pas oublier de fflusher les flux standards)
    	fflush(stdout);
    	fflush(stderr);
    	switch (pid=fork()) {
    		case -1: // Erreur de fork
    			close(sock->sk_connect);
    			close(sock->sk_dialog);
    			fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, strerror(errno)); 
    			return -2;
     
    		case 0: // Fils
    			// Fermeture socket de connexion (inutilisée)
    			close(sock->sk_connect);
     
    			// Dialogue avec le client
    			if (dialogue(sock->sk_dialog) < 0) {
    				fprintf(stderr, "ligne %u - dialogue() - %s\n", __LINE__, strerror(errno));
    				exit(errno);
    			}
     
    			// Fin du fils
    			close(sock->sk_dialog);
    			printf("\tppid=%d, pid=%d, socket=%d - Entrée raccrochée\n", getppid(), getpid(), sock->sk_dialog);
    			exit(0);
     
    		default: // Père
    			close(sock->sk_dialog);
    	}
     
    	// Fin fonction
    	return 0;
    }
     
    // Dialogue avec le client
    int dialogue(
    	int sock)								// Socket de communication
    {
    	// Déclaration des variables
    	int sz_read;							// Nbre octets lus
     
    	char buf[SZ_BUF];						// Buffer texte
    	char *pt;								// Pointeur chaine
     
    	// Lecture en boucle sur la socket
    	while ((sz_read=read(sock, buf, SZ_BUF)) > 0) {
    		// Par précaution, le buffer reçu est transformé en chaine
    		buf[sz_read]='\0';
     
    		// Suppression du caractère '\n' éventuel
    		if ((pt=strchr(buf, '\n')) != NULL) *pt='\0';
     
    		// Mémorisation chaine contient "EOT" (optimisation)
    		pt=strcmp(buf, "EOT") != 0 ?buf :NULL;
     
    		// Affichage chaine reçue
    		printf("\tppid=%u, pid=%u, socket=%d - Le serveur a lu %d [%s]%s\n", getppid(), getpid(), sock, sz_read, buf, pt != NULL ?"" :" => Fin de communication");
     
    		// Si la chaine contient "EOT"
    		if (pt == NULL) break;
    	}
     
    	// Si l'arrêt de la lecture est dû à une erreur
    	if (sz_read < 0) {
    		fprintf(stderr, "ligne %u - read() - %s\n", __LINE__, strerror(errno));
    		return -1;
    	}
     
    	// Fin fonction
    	printf("\tppid=%u, pid=%u, socket=%d - Client terminé\n", getppid(), getpid(), sock);
    	return 0;
    }
     
    // Conversion adresse en nom
    int nslookup(
    	struct sockaddr_in *adr,				// Adresse à convertir
    	char *lookup)							// Correspondance adresse/nom
    {
    	// Déclaration des variables
    	char *adr_ascii;						// Adresse client mode ascii
    	struct hostent *host_info;				// Informations host
     
    	// Transformation adresse net en ascii
    	if ((adr_ascii=inet_ntoa(adr->sin_addr)) == NULL) {
    		fprintf(stderr, "ligne %u - inet_ntoa() - %s\n", __LINE__, strerror(errno));
    		strcpy(lookup, "?");
    		return -1;
    	}
     
    	// Récupération informations sur host par son adresse
    	if ((host_info=gethostbyaddr(&adr->sin_addr.s_addr, sizeof(struct in_addr), AF_INET)) == NULL) {
    		fprintf(stderr, "ligne %u - gethostbyaddr() - %s\n", __LINE__, strerror(errno));
    		sprintf(lookup, "%s (?)", adr_ascii);
    		return -2;
    	}
    	sprintf(lookup, "%s (%s)", adr_ascii, host_info->h_name);
    	return 0;
    }

    Tu peux les compiler (sous Linux). Ensuite d'un côté tu lances le serveur en lui donnant un numéro de port (ex ./serveur 5000) et de l'autre tu lances le client en lui mettant le même numéro de port. Et tu peux éventuellement rajouter le nom ou l'ip du serveur en second paramètre (ex ./client 5000 localhost) ce qui est utile si tu veux tester sur deux machines distinctes.

    Ensuite le client te demande de saisir des lignes de texte et tout ce que tu tapes est affiché par le serveur.

    Et leur équivalent en Python
    Le client
    Code python : 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
    #!/usr/bin/env python3
    # coding: utf-8
     
    import socket
    import sys
     
    class cSocket(object):
    	def __init__(self, port, host="localhost"):
    		self.__dialog=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    		self.__dialog.connect((host, port))
    		print("socket %s connectée avec %s sur le port %d" % (self.__dialog, host, port))
    	# __init__()
     
    	def dialogue(self):
    		while True:
    			msg=input("Tapez votre message (EOT pour quitter): ")
    			self.__dialog.send(msg.encode("utf-8"))
    			if msg == "EOT":
    				print("Client teminé")
    				break
    			# if
    		# while
    	# dialogue()
    # class cSocket
     
    if __name__ == "__main__":
    	sock=cSocket(int(sys.argv[1]), sys.argv[2] if len(sys.argv) > 2 else "localhost")
    	sock.dialogue()
    # if

    Et le serveur
    Code python : 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
    65
    #!/usr/bin/env python3
    # coding: utf-8
     
    import socket
    import sys
    import os
     
    class cSocket(object):
    	def __init__(self, port):
    		self.__connect=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    		self.__connect.bind(("", port))
    		self.__dialog=None
    		print("socket %s prête à écouter sur le port %d" % (self.__connect, port))
    	# __init__()
     
    	# Ecoute
    	def listen(self):
    		self.__connect.listen(1)
    		while True:
    			(self.__dialog, infos)=self.__connect.accept()
    			pid=os.fork()
    			if pid == 0:
    				self.__client(infos)
    				exit(0)
    			# if
    		# while
    	# listen()
     
    	# Gestion du client connecté
    	def __client(self, infos):
    		try:
    			host=socket.gethostbyaddr(infos[0])[0]
    		except socket.herror as e:
    			host="?"
    		# try
    		print(
    			"client pid=%d - Entrée émise [adr=%s]" % (
    				os.getpid(),
    				host,
    			)
    		)
    		data=None
    		while data != "EOT":
    			data=self.__dialog.recv(1024).decode("utf-8")
    			print(
    				"client pid=%d: Message: [%s]%s" % (
    					os.getpid(),
    					data,
    					" => Arrêt du client" if data == "EOT" else "",
    				)
    			)
    		# while
    		print(
    			"client pid=%d - Entrée raccrochée [adr=%s]" % (
    				os.getpid(),
    				host,
    			)
    		)
    	# __client()
    # class cSocket
     
    if __name__ == "__main__":
    	sock=cSocket(int(sys.argv[1]))
    	sock.listen()
    # if
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  6. #6
    Candidat au Club
    Homme Profil pro
    Sans Emploi
    Inscrit en
    avril 2021
    Messages
    12
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Sans Emploi

    Informations forums :
    Inscription : avril 2021
    Messages : 12
    Points : 4
    Points
    4
    Par défaut
    Merci beaucoup.

    C'est super impressionnant et passionnant.

    Encore merci pour votre aide complète.

    Je vais prendre le temps avec les bases, j'imaginais pouvoir sauter des chapitres et apprendre seulement ce dont j'ai besoin.

    Petites questions supplémentaires si vous avez encore un peu de temps pour moi.

    En fait, apprendre le langage C est une base super solide pour ensuite apprendre n'importe quel langage ? J'ai l'impression de voir du C de partout.

    J'hésite beaucoup entre le C et Java. Je commence a survoler les deux langage, apprendre les deux en même temps c'est faire n'importe quoi ?

  7. #7
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    3 926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 3 926
    Points : 8 781
    Points
    8 781
    Par défaut
    Je précise, que le choix du port n'est pas forcément du hasard

    1 certains nombre de logiciels utilisent des ports spécifiques. Voici la liste des ports logiciels, page wikipedia


    Citation Envoyé par card15nod2 Voir le message
    En fait, apprendre le langage C est une base super solide pour ensuite apprendre n'importe quel langage ? J'ai l'impression de voir du C de partout.
    Étant donné que le monde du travail veut des développeurs qui empilent les briques logicielles, non par vraiment


    Citation Envoyé par card15nod2 Voir le message
    J'hésite beaucoup entre le C et Java. Je commence a survoler les deux langage, apprendre les deux en même temps c'est faire n'importe quoi ?
    Oui c'est 1 peu n'importe quoi.
    Selon moi, il faut apprendre 1 langage procédural pour l'aspect procédure/ fonction (comme le langage C) puis on peut passer à l'objet (d'abord objet pur comme le Java, puis au C++ est son objet/ générique et au Javascript pour son objet par prototypes) ou au fonctionnel (comme le langage Lisp)
    Et il y a d'autres langages comme Prolog et SML pour les moteurs d'inférence, le génie logiciel, ...

  8. #8
    Candidat au Club
    Homme Profil pro
    Sans Emploi
    Inscrit en
    avril 2021
    Messages
    12
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Sans Emploi

    Informations forums :
    Inscription : avril 2021
    Messages : 12
    Points : 4
    Points
    4
    Par défaut
    Oui c'est 1 peu n'importe quoi.
    Selon moi, il faut apprendre 1 langage procédural pour l'aspect procédure/ fonction (comme le langage C) puis on peut passer à l'objet (d'abord objet pur comme le Java, puis au C++ est son objet/ générique et au Javascript pour son objet par prototypes) ou au fonctionnel (comme le langage Lisp)
    Et il y a d'autres langages comme le Prolog et le SML/ Scheme pour les moteurs d'inférence, le génie logiciel, ...
    Merci beaucoup, je vais rester sur le C pour le moment, en plus c'est le langage qui m'attire le plus.

    Je voulais savoir également.

    Si je veux ajouter un socket dans une fonction main déjà existante, comment ça se passe pour ne pas perturber le fonctionnement du programme ?

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 1
    Dernier message: 09/09/2019, 20h54
  2. Réponses: 1
    Dernier message: 07/02/2012, 09h02
  3. Réponses: 0
    Dernier message: 06/10/2011, 21h41
  4. executer une application a distance : Sockets ? RPC ? CORBA?
    Par a_hic dans le forum Développement
    Réponses: 5
    Dernier message: 30/05/2006, 13h02
  5. transfert d'un fichier bitmap en socket tcp
    Par localhost dans le forum C++Builder
    Réponses: 5
    Dernier message: 29/07/2002, 00h40

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo