Discussion :

[andromeda]

Bonjour,

j'ai ce message dans le code suivant

Int32 rBytes = IPsocket.Receive(RecvBytes, RecvBytes.Length, SocketFlags.None);

Savez vous d'ou cela peux provenir ?
Est ce cette connexion qui est fermee ?
car elle est bien ouverte, j'ai mis des log a chaque ligne, juste avant cette socket (IPSOcket) et elle est connectée.

voici le 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
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
 
using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
 
 
namespace WebProxy2
{
    class Program
    {
        static void Main(string[] args)
        {
            const int localport = 12000;
            const string localaddress = "127.0.0.1";
 
            IPAddress localAddr = IPAddress.Parse(localaddress);
            TcpListener tcplistener = new TcpListener(localAddr, localport);
            Console.WriteLine("Listening on port {0}", + localport);
            tcplistener.Start();
 
            while (true)
            {
                Socket socket = tcplistener.AcceptSocket();
                WebProxy2 webproxy = new WebProxy2(socket);
                Thread thread = new Thread(new ThreadStart(webproxy.run));
                thread.Start();
            }
        }
 
        class WebProxy2
        {
            const int remoteport = 12002;
            const string remoteaddr = "localhost";
            Socket clientSocket = null;
            Byte[] read = new byte[1024];
            Byte[] Buffer = null;
            Encoding ASCII = Encoding.ASCII;
            Byte[] RecvBytes = new Byte[4096];
 
            //Constructeur de la classe
            public WebProxy2(Socket socket)
            {
                this.clientSocket = socket;
            }
 
            public void run()
            {
                String clientmessage = " ";
 
                //Lecture des donnees recues de la connexion cliente du serveur
                int bytes = readmessage(read, ref clientSocket, ref clientmessage);
                if (bytes == 0)
                {
                    return;
                }
 
                Console.WriteLine("Connection from {0}", clientSocket.RemoteEndPoint);
                Console.WriteLine("< " + clientmessage);
 
                try
                {
                    IPAddress ip = IPAddress.Parse(GetAdr(remoteaddr));
                    IPEndPoint ipEnd = new IPEndPoint(ip, remoteport);
                    Socket IPsocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    IPsocket.Connect(ipEnd);
 
                    if (IPsocket.Connected)
                        Console.WriteLine("Socket connect OK");
 
                    if ((IPsocket.Connected) && clientmessage != " ")
                    {
                        //On renvoi les donnees recue de la connection initiale vers la remote socket
                        string GET = clientmessage;
                        Byte[] ByteGet = ASCII.GetBytes(GET);
                        IPsocket.Send(ByteGet, ByteGet.Length, 0);
                        clientmessage = " ";
                    }
 
                    //On receptionne les donnees de la connection distante (remote socket)
                    Int32 rBytes = IPsocket.Receive(RecvBytes, 0, SocketFlags.None);
                    Console.WriteLine("Recieved {0}", +rBytes);
 
                    //Formatage en byte des donnees recues du remote socket
                    String strRetPage = null;
                    strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, rBytes);
 
                    while (rBytes > 0) 
                    {
                        rBytes = IPsocket.Receive(RecvBytes, RecvBytes.Length, SocketFlags.None);
                        strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, rBytes);
                    }
 
                    IPsocket.Shutdown(SocketShutdown.Both);
                    IPsocket.Close();
 
                    if ((clientSocket.Connected) && (strRetPage != ""))
                        sendmessage(clientSocket, strRetPage);
 
                    Thread.Sleep(30);
                }
                catch (Exception exc2)
                {
                    Console.WriteLine(exc2.ToString());
                }
            }
 
            //Lecture socket
            private int readmessage(byte[] ByteArray, ref Socket s, ref String clientmessage)
            {
                int bytes = s.Receive(ByteArray, 1024, SocketFlags.None);
                string messagefromclient = Encoding.ASCII.GetString(ByteArray);
                clientmessage = (String)messagefromclient;
                return bytes;
            }
 
            //Ecriture socket
            private void sendmessage(Socket s, string message)
            {
                Buffer = new Byte[message.Length + 1];
                int length = ASCII.GetBytes(message, 0, message.Length, Buffer, 0);
                s.Send(Buffer, length, 0);
            }
 
            //Recupere l'addresse ip par rapport un nom de domaine
            private String GetAdr(string addr)
            {
                try
                {
                    IPHostEntry iphostentry = Dns.GetHostByName(addr);
                    String IPStr = "";
                    foreach (IPAddress ipaddress in iphostentry.AddressList)
                    {
                        IPStr = ipaddress.ToString();
                        return IPStr;
                    }
                }
                catch (SocketException E)
                {
                    Console.WriteLine(E.Message.ToString());
 
                }
                return "";
            }
 
            //Revoit les donnees a partir d'une socket (cette fonction ne sert pas pour l'instant)
            private void Receive(Socket socket, byte[] buffer, int offset, int size, int timeout)
            {
                int startTickCount = Environment.TickCount;
                int received = 0;  // how many bytes is already received
                do
                {
                    if (Environment.TickCount > startTickCount + timeout)
                        throw new Exception("Timeout.");
                    try
                    {
                        received += socket.Receive(buffer, offset + received, size - received, SocketFlags.None);
                    }
                    catch (SocketException ex)
                    {
                        if (ex.SocketErrorCode == SocketError.WouldBlock ||
                            ex.SocketErrorCode == SocketError.IOPending ||
                            ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
                        {
                            // socket buffer is probably empty, wait and try again
                            Thread.Sleep(30);
                        }
                        else
                            throw ex;  // any serious error occurr
                    }
                } while (received > 0);
            }
 
 
        }
 
    }
}

Pour les test j'ai un serveur sur une machine qui envoi des requetes sur le port 12000 sur ma machine dont le proxy est installe et dont le meme serveur tourne avec le port 12002, je redirige tout ce qui viens du serveur de l'autres machine avec le port 12000 vers mon serveur ayant le port 12002.

ce test fonctionne tres bien avec un proxy que j'avais developper sous delphi.

Merci de votre aide.

[tomlev]

la propriété Connected n'est pas vraiment un moyen fiable de savoir si tu es connecté... elle indique simplement si tu étais connecté lors du dernier Send ou Receive. Si le serveur a fermé la connexion entre temps, Connected peut valoir true malgré tout... welcome to socket hell

[andromeda]

j'ai refait la partie de reception pour le remote socket et je n'ai plus le probleme par contre un autre probleme est que je ne recois plus de donnees de la cible redirigee.