Discussion :

[atmakefka]

Bonjour,
J'ai besoin d'un programme avec un unique socket où un thread écrit sur le socket et un deuxième thread lit depuis le socket, les deux fonctionnants en continu et de manière asynchrone.
Je souhaiterai savoir s'il faut mettre un mutex sur le socket, ou si le noyaux s'occupe déjà d'empêcher les accès concurrents.

Merci d'avance!

[LittleWhite]

Bonjour,

Je ne pense pas qu'il n'y ai de problème à faire comme vous faites.

[Vincent Rogier]

il faut tout de même sérialiser les opératons de lecture / écriture entre les deux threads..

[atmakefka]

D'accord merci.
Que signifie sérialiser ?

[spin0us]

Que signifie sérialiser ?

En gros enchainer les recv/send/recv/send

[keikoz]

Si t'utilises les threads, c'est bien pour avoir une lecture/écriture synchrone sur le socket non ?

J'avais utilisé les threads pour faire un truc dans le genre, je sais pas si ça correspond à ce que tu veux. Un truc que j'ai fais à mes débuts. Des doutes, des erreurs sans doute, mais en tout cas ça marchait: lecture et écriture sur la socket, via des threads séparés. Voilà l'essentiel du code :

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
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
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <netdb.h>
#include "commands.h"
#include "irc.h"
#include "kbot.h"
#include "files.h"
 
 
/* Initialisation des fonctions */
void *write_funct(void *arg);
void *read_funct(void *arg);
 
 
/* Variables globales. Est-ce mal ? Les buffers sont utilisés tout au long
 * de la connexion ... */
int Cli_Sock;
char wBuffer[MAX_BUFFER];
char rBuffer[MAX_BUFFER];
pthread_t read_thread, write_thread;
 
 
int main(int argc, char *argv[])
{
  int Serv_Port;
  struct sockaddr_in Serv_Addr;
  struct hostent *Server;
 
 
  /* On vérifie que la commande est utilisée correctement */
  if (argc != 3) {
    fprintf(stderr,"Usage: kbot hostname port\n");
    exit(1);
  }
  else {
    Serv_Port = atoi(argv[2]);
    if (Serv_Port < 1 || Serv_Port > 65355) {
      fprintf(stderr, "Invalid port\n");
      exit(1);
    }
  }
 
 
  /* Appel du fichier de configuration */
  conf_file_open();
 
 
  /* On créé l'adresse serveur avec les paramètres de connexion */
  Server = gethostbyname(argv[1]);
  Serv_Addr.sin_family = AF_INET;
  Serv_Addr.sin_port = htons(Serv_Port);
  memcpy(&Serv_Addr.sin_addr.s_addr, Server->h_addr, Server->h_length);
 
 
  /* On établi le socket (pourquoi AF_INET et pas PF_INET ?) */
  Cli_Sock = socket(AF_INET, SOCK_STREAM, 0);
  if (Cli_Sock < 0) {
    fprintf(stderr,"Erreur lors de la création du socket\n");
    exit(1);
  }
 
 
  /* On établit la connection sur le socket */
  if(connect(Cli_Sock, (struct sockaddr*) &Serv_Addr, sizeof(Serv_Addr))!= 0) {
    fprintf(stderr,"Erreur lors de la connection\n");
    exit(1);
  }
 
 
  /* Threads (écriture, lecture) */
  pthread_create(&write_thread, NULL, write_funct, NULL);
  pthread_create(&read_thread, NULL, read_funct, NULL);
 
 
  /* On rejoint les thread lors de leur fin d'exécution) */
  pthread_join(write_thread, NULL);
  pthread_join(read_thread, NULL);
 
  return 0;
}
 
 
/* fonctions d'écriture/lecture dans le socket */
void *write_funct (void *arg)
{
  /* Modules */
  auth();
 
  /* Boucle: Processus d'écriture */
  while (1) {
    memset(wBuffer, 0, MAX_BUFFER);
    fgets(wBuffer, MAX_BUFFER-1, stdin);
 
    commands();
 
    if (write(Cli_Sock, wBuffer, strlen(wBuffer)) < 0)
      fprintf(stderr,"Error writing to socket\n");
  }
  return(0);
}
 
void *read_funct (void *arg)
{
  while (1) {
    int n;
 
    memset(rBuffer,0, MAX_BUFFER);
    n = recv(Cli_Sock, rBuffer, MAX_BUFFER, 0);
 
    /* Situation d'écriture normale */
    if (n > 0) {
 
      /* Ecriture sur stdout */
      printf(">%s", rBuffer);
 
      /* Modules */
      on_ping();
 
    }
 
    /* Cas erreur */
    else if (n < 0) 
      fprintf(stderr,"Error reading from socket\n");
 
    /* Fermeture du socket distant */
    else if (n == 0) {
      if (close(Cli_Sock) != 0)
	fprintf(stderr, "Could not close the socket\n");
      printf("Fin de la connection\n");
      pthread_exit(&read_thread);
    }
 
  }
  return(0);
}