Discussion :

[jowo]

J'ai testé en démarrant l'application en mode admin.
Ça ne change rien.

TCP OK

UDP KO

[Spellbinder]

Les 2 en admins ? Bon, est-ce que la version de Java est la même sur S2 que sur S1 ? Est-ce que dans le code, y a moyen d'avoir des logs ou debug sur l'appli serveur surtout, notamment après l'instruction d'écoute, comme ca on peut voir si l'appli serveur (voire aussi l'appli client) ne rencontre pas en réalité des problèmes

Sinon, tu utilises la méthode bind de la classe DatagramSocket pour la partie serveur ? Tu peux tester avec cet outil pour voir s'il y a une différence http://sockettest.sourceforge.net/ C'est comme ton appli client serveur, c'est juste pour voir si ca le fait avec un autre programme

[jowo]

Bonjour Spellbinder,

D'abord merci pour ton aide.

Les applications ne sont écrites en Java mais en C#. Si Java est installé sur S2, je ferai des tests avec ton programme.

J'ai installé une version TRACE sur S2 mais pas de message d'erreur ni pour le client ni pour le serveur. C'est comme si la connexion UDP n'était pas établie.
J'ai utilisé l'outil TCPView de Sysinternal. Je vois le port utilisé par mon serveur UDP.

Le client

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
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
using System;
using System.Net;
using System.Net.Sockets;
using NetTcpClient = System.Net.Sockets.TcpClient;
using NetUdpClient = System.Net.Sockets.UdpClient;
using System.Text;
using System.Threading;

namespace UdpClientTest
{
  static class Program
  {
    private static readonly Barrier barrierSendComplete = new Barrier(2);

    static void Main(string[] args)
    {
      // Command Line
      // 1: [UDP | TCP] Default UDP
      // 2: Adresse IP
      // 3: Port
      // 4: Nom machine
      // 5: Message
      if (args.Length >= 4)
      {
        IClient client;
        string protocole = "UDP";
        int argIndx = 0;
        if ("UDP".Equals(args[argIndx], StringComparison.OrdinalIgnoreCase) ||
            "TCP".Equals(args[argIndx], StringComparison.OrdinalIgnoreCase))
        {
          protocole = args[argIndx++];
        }

        IPAddress ipAddr;
        int port;

        if (IPAddress.TryParse(args[argIndx++], out ipAddr) && int.TryParse(args[argIndx++], out port))
        {
          string machineName = args[argIndx++];
          string message = string.Join(" ", args, argIndx, args.Length - argIndx);
          if ("TCP".Equals(protocole, StringComparison.OrdinalIgnoreCase))
          {
            client = new TcpClient();
          }
          else
          {
            client = new UdpClient();
          }

          byte[] dgram = Encoding.Default.GetBytes($"${machineName}:{message}$");
          // Affiche les bytes envoyés en HEX
          Console.WriteLine($"HEX DataGramm: {BitConverter.ToString(dgram)} ");
          client.Connect(ipAddr, port);
          client.Send(dgram, dgram.Length, SendComplete);
          barrierSendComplete.SignalAndWait();
        }
      }
      else
      {
        Console.WriteLine("USAGE: [UDP|TCP] AdresseIP Port NomMachine Message");
      }
    }

    private static void SendComplete(IAsyncResult ar)
    {
      Socket socket = ar.AsyncState as Socket;
      if (socket != null)
      {
        Console.WriteLine($"{DateTime.Now} Connected: {socket.Connected} Completed: {ar.IsCompleted} TTL: {socket.Ttl}");
        IPEndPoint ipEP = socket.RemoteEndPoint as IPEndPoint;
        if (ipEP != null)
        {
          Console.WriteLine($"{DateTime.Now} Connected to: {ipEP.Address} on port nbr: {ipEP.Port}");
        }
        socket.Close();
        Console.WriteLine($"{DateTime.Now} Close");
        barrierSendComplete.SignalAndWait();
      }
    }
  }

  internal interface IClient
  {
    void Connect(IPAddress ipAddress, int port);

    IAsyncResult Send(byte[] data, int dataLength, AsyncCallback requestCallback);
  }

  internal class UdpClient : IClient, IDisposable
  {
    private readonly NetUdpClient udpClient;

    public UdpClient()
    {
      udpClient = new NetUdpClient();
    }

    public void Connect(IPAddress ipAddress, int port)
    {
      udpClient.Connect(ipAddress, port);
    }

    public IAsyncResult Send(byte[] data, int dataLength, AsyncCallback requestCallback)
    {
      Console.WriteLine($"{DateTime.Now} DontFragment: {udpClient.DontFragment}");
      udpClient.DontFragment = true;
      return udpClient.BeginSend(data, dataLength, requestCallback, udpClient.Client);
    }

    #region IDisposable Support
    private bool disposedValue = false; // Pour détecter les appels redondants

    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        if (disposing)
        {
          udpClient.Close();
        }
        disposedValue = true;
      }
    }


    // Ce code est ajouté pour implémenter correctement le modèle supprimable.
    public void Dispose()
    {
      // Ne modifiez pas ce code. Placez le code de nettoyage dans Dispose(bool disposing) ci-dessus.
      Dispose(true);
    }
    #endregion
  }

  internal class TcpClient : IClient, IDisposable
  {
    private readonly NetTcpClient tcpClient;

    public TcpClient()
    {
      tcpClient = new NetTcpClient();
    }

    public void Connect(IPAddress ipAddress, int port)
    {
      tcpClient.Connect(ipAddress, port);
    }

    public IAsyncResult Send(byte[] data, int dataLength, AsyncCallback requestCallback)
    {
      Socket socket = tcpClient.Client;
      return socket.BeginSend(data, 0, dataLength, SocketFlags.None, requestCallback, socket);
    }

    #region IDisposable Support
    private bool disposedValue = false; // Pour détecter les appels redondants

    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        if (disposing)
        {
          // TODO: supprimer l'état managé (objets managés).
          tcpClient.Close();
        }

        // TODO: libérer les ressources non managées (objets non managés) et remplacer un finaliseur ci-dessous.
        // TODO: définir les champs de grande taille avec la valeur Null.

        disposedValue = true;
      }
    }

    // Ce code est ajouté pour implémenter correctement le modèle supprimable.
    public void Dispose()
    {
      // Ne modifiez pas ce code. Placez le code de nettoyage dans Dispose(bool disposing) ci-dessus.
      Dispose(true);
    }
    #endregion
  }

}

Le serveur

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
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
using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
using TcpServerNet = System.Net.Sockets.TcpListener;


namespace UdpServer
{
  static class Program
  {
    static void Main(string[] args)
    {
      int port = 2564;
      IPAddress ipAddress = IPAddress.Any;
      string protocole = "UDP";

      if (args.Length > 0)
      {
        int argIndx = 0;
        if ("UDP".Equals(args[argIndx],StringComparison.OrdinalIgnoreCase) ||
            "TCP".Equals(args[argIndx], StringComparison.OrdinalIgnoreCase))
        {
          protocole = args[argIndx];
          argIndx++;
        }
        if (args.Length > argIndx)
        {
          if (!int.TryParse(args[argIndx], out port))
          {
            Console.WriteLine($"Invalid port. Set port to default port value : {port}:");
            return;
          }
          argIndx++;
        }
        if (args.Length > argIndx)
        {
          if (args[argIndx].Equals("IPV6", StringComparison.OrdinalIgnoreCase))
          {
            ipAddress = IPAddress.IPv6Any;
          }
        }
      }
      IPEndPoint ipep = new IPEndPoint(ipAddress, port);
      IServer server = GetServer(protocole,ipep);

      Console.WriteLine($"{protocole} server started. Listen on {ipep.Address} and port {ipep.Port}.");
      Console.WriteLine("Waiting for a client...");
      IPEndPoint sender = new IPEndPoint(ipAddress, port);

      try
      {
        while (true)
        {
          byte[] data = server.Receive(ref sender);
          Console.WriteLine($"HEX DataGramm: {BitConverter.ToString(data)} ");
          string msg = Encoding.Default.GetString(data, 0, data.Length);
          Console.WriteLine(msg);
        }
      }
      finally
      {
        server.Close();
      }
    }

    private static IServer GetServer(string protocole, IPEndPoint localEP)
    {
      IServer server;
      if ("TCP".Equals(protocole, StringComparison.OrdinalIgnoreCase))
      {
        server = new TcpServer(localEP);
      }
      else
      {
        server = new UdpServer(localEP);
      }
      return server;
    }
  }

  internal interface IServer
  {
    byte[] Receive(ref IPEndPoint remoteEP);

    void Close();
  }

  internal class TcpServer : IServer, IDisposable
  {
    private readonly TcpListener tcpListener;
    public TcpServer(IPEndPoint localEP)
    {
      tcpListener = new TcpListener(localEP);
      tcpListener.Start();
    }

    public byte[] Receive(ref IPEndPoint remoteEP)
    {
      Socket client = tcpListener.AcceptSocket();
      byte[] buffer = new byte[1024];
      int size = client.Receive(buffer);
      Array.Resize(ref buffer, size);
      client.Close();
      return buffer;
    }

    public void Close()
    {
      Dispose();
    }

    #region IDisposable Support
    private bool disposedValue = false; // Pour détecter les appels redondants

    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        if (disposing)
        {
          tcpListener.Stop();
        }
        disposedValue = true;
      }
    }

    // Ce code est ajouté pour implémenter correctement le modèle supprimable.
    public void Dispose()
    {
      // Ne modifiez pas ce code. Placez le code de nettoyage dans Dispose(bool disposing) ci-dessus.
      Dispose(true);
    }
    #endregion

  }

  internal class UdpServer : IServer, IDisposable
  {
    private readonly UdpClient udpClient;

    public UdpServer(IPEndPoint localEP)
    {
      udpClient = new UdpClient(localEP);
    }

    public byte[] Receive(ref IPEndPoint remoteEP)
    {
      return udpClient.Receive(ref remoteEP);
    }

    public void Close()
    {
      Dispose();
    }

    #region IDisposable Support
    private bool disposedValue = false; // Pour détecter les appels redondants

    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        if (disposing)
        {
          udpClient.Close();
        }

        disposedValue = true;
      }
    }

    // Ce code est ajouté pour implémenter correctement le modèle supprimable.
    public void Dispose()
    {
      // Ne modifiez pas ce code. Placez le code de nettoyage dans Dispose(bool disposing) ci-dessus.
      Dispose(true);
    }
    #endregion
  }
}

[Spellbinder]

Bonjour Jowo

Ah ok désolé j'ai cru qu'elles étaient en Java comme tu es développeur Java ^^

Est-ce que tu peux faire une capture avec Wireshark pour voir sur S2 ? Tu devrais normalement voir les paquets envoyés par le client même sur la même machine, à son IP externe privée. Bien que je ne sois pas développeur C#, ton code a l'air d’être ok, enfin y a rien d'anormal surtout qu'il fonctionne sur une autre machine, après peut-être ajouter quelques try catch à certains endroits pour voir s'il y a un problème ?

[jowo]

J'étais développeur Java...

Sur S2, Java n'est pas installé.

Pour Wireshark, je crois qu'il est nécessaire d'installer WinPCap pour analyser les paquets du réseau, dites-mois si je me trompe. WinPCAP s'installe comme un driver donc une possibilité que je doive redémarrer le serveur ou qu'il ne fonctionne plus après installation. Comme je l'ai écrit, S2 ne peut pas être stoppé.

J'ai demandé au département informatique qu'il analyse le réseau et les modifications faites sur S2. J'attends toujours leur réponse.

[Spellbinder]

Oui je comprends, bon on va faire autrement si tu ne peux pas installer Wireshark dessus.

Le département informatique doit capturer directement sur le serveur car les paquets ne quittent pas S2 en fait, maintenant si c'est une VM, il y a moyen de lancer une capture directement depuis l’hyperviseur, VMware?

Dans ton code serveur, je ne sais pas si ca va changer quelque chose, mais est-ce que tu peux créer un dump (dans un fichier texte) dès que tu crées la socket ? Comme ca tu enregistres tout ce que l'application recoit comme trafic Notamment quand tu essaies l'appli client

EDIT : je rajoute un test : comment tu effectues l'écoute sur la partie serveur ? Le programme écoute par défaut sur 0.0.0.0 c'est ca ? Est-ce que tu peux essayer stp avec l'IP externe de S2 plutôt pour voir s'il y a une différence ?

[jowo]

J'ai modifié mon programme de test pour avoir le choix de l'adresse d'écoute.

Toujours le même résultat :
UDP KO
TCP OK

J'attends le retour de l'IT.

Pour le dump, je n'ai pas compris.

J'ai utilisé l'utilitaire TCPView. Donc je vois bien ma connexion UDP sur le bon port mais je ne reçois aucune donnée.

[Spellbinder]

D'accord et tu es sûr que tout est identique au niveau des librairies sur S2 ? Je veux dire est-ce qu'il y a une différence de version du .NET framework par exemple entre S1 et S2, tu compiles sur S1 mais peut-être que quand tu lances le exe sur S2, il y a une différence même minime entre des fichiers/librairies, est-ce que c'est plausible ?

[jowo]

Je reviens pour dire que l'IT du client n'a pas trouvé d'où venez le problème.
On a modifier l'application pour qu'elle puisse communiquer sur une "adresse IP de secours". Pour ce cas, c'est l'adresse localhost.

Je marque le problème comme résolu même si ce n'est pas vraiment le cas.