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

Windows Discussion :

Quel sera l'état d'un créateur de pipe après déconnexion du client qui s'y connecté ?


Sujet :

Windows

  1. #1
    Membre du Club Avatar de masterx_goldman
    Inscrit en
    Mai 2008
    Messages
    164
    Détails du profil
    Informations forums :
    Inscription : Mai 2008
    Messages : 164
    Points : 51
    Points
    51
    Par défaut Quel sera l'état d'un créateur de pipe après déconnexion du client qui s'y est connecté ?
    Bonjour tout le monde,

    J'ai deux processus que je veux faire communiquer infinimenent à travers un pipe: P1 crée le pipe et P2 est supposé s'y connecter après quelques instants et après ils restent en communication inifiniment.

    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
    //création du pipe
    HANDLE hPipe;
    	hPipe = CreateNamedPipe( 
              g_szPipeName,             // pipe name 
              PIPE_ACCESS_DUPLEX,       // read/write access 
              PIPE_TYPE_MESSAGE |       // message type pipe 
              PIPE_READMODE_MESSAGE |   // message-read mode 
              PIPE_WAIT,                // blocking mode 
              PIPE_UNLIMITED_INSTANCES, // max. instances  
              BUFFER_SIZE,              // output buffer size 
              BUFFER_SIZE,              // input buffer size 
              NMPWAIT_USE_DEFAULT_WAIT, // client time-out 
              NULL);                    // default security attribute 
    
    //Attente de connexion d'un client
    BOOL bClientConnected = ConnectNamedPipe(hPipe, NULL);
         
         if (FALSE == bClientConnected)
         {
              printf("\nError occurred while connecting to the client: %d", GetLastError()); 
              CloseHandle(hPipe);
              return 1;  //Error
         }
         else
         {
              printf("\nConnectNamedPipe() was successful.");
         }
    La fonction ConnectNamedPipe met le processus P1 dans un état d'attente infinie (la durée d'attente,dans mon cas, est inifinie puisque je précise pas de timeout dans la création du pipe). Maintenant une fois P2 se connecte, la fonction va retourner true et le processus P1 passe à l'instruction qui suit.
    Ma question est, si P2 se déconnecte(par exemple il s'arrête pour une raison inconnue et que je dois le relancer automatiquement par un processus de controle d'activité par exemple), quel sera l'état de P1?
    a) Toujours connecté ( donc la boucle infinie de communication que je dois faire doit être faite dans le writefile )
    b) Déconnecté ( donc ma boucle infinie doit être recommencée à partir de la fonction
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    //Attente de connexion d'un client
    BOOL bClientConnected = ConnectNamedPipe(hPipe, NULL);
    Merci pour vos réponses

  2. #2
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 074
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 074
    Points : 12 120
    Points
    12 120
    Par défaut
    Quand un processus tombe, tous les handlers qu'il possède sont fermés.
    Donc le server va avoir une erreur lors de la prochaine lecture ou écriture sur le handler "siamois" de celui du client.
    C'est à lui (le server) de recréer un handler d'écoute (après avoir fermer le handler "siamois"). Donc CloseHandler -> CreateNamedPipe -> ConnectNamedPipe.

  3. #3
    Membre du Club Avatar de masterx_goldman
    Inscrit en
    Mai 2008
    Messages
    164
    Détails du profil
    Informations forums :
    Inscription : Mai 2008
    Messages : 164
    Points : 51
    Points
    51
    Par défaut
    Citation Envoyé par bacelar Voir le message
    Quand un processus tombe, tous les handlers qu'il possède sont fermés.
    Donc le server va avoir une erreur lors de la prochaine lecture ou écriture sur le handler "siamois" de celui du client.
    C'est à lui (le server) de recréer un handler d'écoute (après avoir fermer le handler "siamois"). Donc CloseHandler -> CreateNamedPipe -> ConnectNamedPipe.
    Tu veux dire que le processus qui se ferme (dans mon cas P2 ) va fermer les handlers de P1 !! j'ai pas compris.

    Bon, je vais essayer de donner plus de détails sur "celui qui crée le pipe" ,"celui qui essai de l'écouter" , etc ..

    P1 ( server ) crée le pipe :
    #define g_szPipeName "\\\\.\\Pipe\\MyNamedPipe" //Name given to the pipe
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    hPipe = CreateNamedPipe( 
              g_szPipeName,             // pipe name 
              PIPE_ACCESS_DUPLEX,       // read/write access 
              PIPE_TYPE_MESSAGE |       // message type pipe 
              PIPE_READMODE_MESSAGE |   // message-read mode 
              PIPE_WAIT,                // blocking mode 
              PIPE_UNLIMITED_INSTANCES, // max. instances  
              BUFFER_SIZE,              // output buffer size 
              BUFFER_SIZE,              // input buffer size 
              NMPWAIT_USE_DEFAULT_WAIT, // client time-out 
              NULL);                    // default security attribute 
    BOOL bClientConnected = ConnectNamedPipe(hPipe, NULL);
    P2( client) essai d'ouvrir le pipe
    #define g_szPipeName "\\\\.\\Pipe\\MyNamedPipe" //Name given to the pipe
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    hPipe = CreateFile( 
              g_szPipeName,   // pipe name 
              GENERIC_READ |  // read and write access 
              GENERIC_WRITE, 
              0,              // no sharing 
              NULL,           // default security attributes
              OPEN_EXISTING,  // opens existing pipe 
              0,              // default attributes 
              NULL);          // no template file
    Les deux processus sont sur le même pc.
    Dans ce cas, permettez moi de reposer la même question encore une fois:
    Est ce que le hPipe du client est lui même que le serveur ?
    Si oui, ok ( Dans ce cas la fermeture de P2 va engendrer la fermeture dun handler de P2 qui est le même hander chez P1 et dans ce cas le handler de P1 va être fermé et puis la solution ==> faire comme a cité bacelar )
    Sinon, je vois pas le lien entre les handler de P2 et ceux de P1 donc pourquoi recréer le Pipe de la part du serveur ?!

  4. #4
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 074
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 074
    Points : 12 120
    Points
    12 120
    Par défaut
    Chaque process a ses handler.
    Donc le process P1 doit fermer son handler quand il détecte, via une erreur lors d'un Read ou d'un Write.
    Le handler de P1 est couplé (d’où mon terme de "siamois") au handler de P2 qui lui à été fermé.
    Le handler de P1 est "grillé" car est lié à un autre handler, qui lui est fermé, c'est pour cela qu'il faut en créer un autre via CreateNamedPipe.

    P.S.: n'oubliez pas de faire un CloseHandle sur celui de P1 car il est grillé mais pas fermé.

  5. #5
    Membre du Club Avatar de masterx_goldman
    Inscrit en
    Mai 2008
    Messages
    164
    Détails du profil
    Informations forums :
    Inscription : Mai 2008
    Messages : 164
    Points : 51
    Points
    51
    Par défaut
    Citation Envoyé par bacelar Voir le message
    Chaque process a ses handler.
    Donc le process P1 doit fermer son handler quand il détecte, via une erreur lors d'un Read ou d'un Write.
    Le handler de P1 est couplé (d’où mon terme de "siamois") au handler de P2 qui lui à été fermé.
    Le handler de P1 est "grillé" car est lié à un autre handler, qui lui est fermé, c'est pour cela qu'il faut en créer un autre via CreateNamedPipe.

    P.S.: n'oubliez pas de faire un CloseHandle sur celui de P1 car il est grillé mais pas fermé.
    Merci pour l'expplication

    Je ferai attention à ça

Discussions similaires

  1. Quel générateur d'états utilisez-vous le plus souvent?
    Par Fleur-Anne.Blain dans le forum Outils de restitution et d'analyse
    Réponses: 61
    Dernier message: 04/01/2010, 12h32
  2. Réponses: 5
    Dernier message: 13/09/2007, 16h42
  3. Déterminer quel générateur d'état est utilisé
    Par pi_hellz dans le forum Autres outils décisionnels
    Réponses: 3
    Dernier message: 22/08/2007, 17h20
  4. Vous qui êtes sous une "vieille" version de Windows, quel sera votre prochain OS?
    Par NicolasJolet dans le forum Windows 2000/Me/98/95
    Réponses: 7
    Dernier message: 23/05/2007, 14h43
  5. Dernier ID > quel sera l'index autoincremet ?
    Par Never dans le forum Requêtes
    Réponses: 2
    Dernier message: 24/01/2007, 11h26

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