TcpClientSocketManager.cs

1. // ==++==
2. // 
3. //   
4. //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.
5. //   
6. //    The use and distribution terms for this software are contained in the file
7. //    named license.txt, which can be found in the root of this distribution.
8. //    By using this software in any fashion, you are agreeing to be bound by the
9. //    terms of this license.
10. //   
11. //    You must not remove this notice, or any other, from this software.
12. //   
13. // 
14. // ==--==
15. //==========================================================================
16. //  File:       TcpClientSocketManager.cs
17. //
18. //  Summary:    Class for managing a socket connection.
19. //
20. //==========================================================================
23. using System;
24. using System.Collections;
25. using System.IO;
26. using System.Net;
27. using System.Net.Sockets;
28. using System.Runtime.Remoting.Messaging;
29. using System.Text;
30. using System.Threading;
33. namespace System.Runtime.Remoting.Channels.Tcp
34. {
36.     // A client socket manager instance should encapsulate the socket
37.     //   for the purpose of reading a response
38.     internal class TcpClientSocketHandler : TcpSocketHandler
39.     {    
40.         // prebaked bytes
41.         private static byte[] s_endOfLineBytes = Encoding.ASCII.GetBytes("/r/n");
42.         
43.     
44.         private String _machineAndPort; // "machineName:port"                     
45.     
46.         // connection state information
47.         private bool _bOneWayRequest = false;  // was the request made OneWay?
48.         private bool _bChunked;    
49.         private int  _contentLength;
51.         private Stream _requestStream; // the request stream that we return from GetRequestStream()
52.         private TcpReadingStream _responseStream; // the stream that we returned from GetResponseStream()
53.         
55.         public TcpClientSocketHandler(Socket socket, String machineAndPort) :
56.             base(socket)            
57.         {          
58.             _machineAndPort = machineAndPort;
59.         } // TcpClientSocketHandler
61.         
63.         // Prepare for reading a new request off of the same socket
64.         protected override void PrepareForNewMessage()
65.         {
66.             _requestStream = null;
67.             _responseStream = null;
68.         } // PrepareForNewRequest
71.         public override void OnInputStreamClosed()
72.         {       
73.             // make sure we read to the end of the response stream
74.             if (_responseStream != null)
75.             {
76.                 _responseStream.ReadToEnd();
77.                 _responseStream = null;                
78.             }
79.         
80.             // return socket to the cache
81.             ReturnToCache();
82.         } // OnInputStreamClosed
86.         public BaseTransportHeaders ReadHeaders()
87.         {           
88.             BaseTransportHeaders headers = new BaseTransportHeaders();
90.             UInt16 operation;
91.             ReadVersionAndOperation(out operation);
93.             // At this point, we're always expecting a Reply, so check for that.
94.             if (operation != TcpOperations.Reply)
95.             {
96.                 throw new RemotingException(
97.                     String.Format(
98.                         CoreChannel.GetResourceString("Remoting_Tcp_ExpectingReplyOp"),
99.                         operation.ToString()));
100.             }                        
101.                    
102.             // content length must come next (may be chunked or a specific length)
103.             ReadContentLength(out _bChunked, out _contentLength);
104.             
105.             // read to end of headers  
106.             ReadToEndOfHeaders(headers); 
107.                                
108.             return headers;
109.         } // ReadHeaders  
112.         public Stream GetRequestStream(IMessage msg, int contentLength,
113.                                        ITransportHeaders headers)
114.         {
115.             IMethodCallMessage mcm = (IMethodCallMessage)msg;        
116.             String uri = mcm.Uri;
117.             _bOneWayRequest = RemotingServices.IsOneWay(mcm.MethodBase);
119.             ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
121.             // output preamble and version
122.             WritePreambleAndVersion(headerStream);
123.             // output opcode 
124.             if (!_bOneWayRequest)
125.                 WriteUInt16(TcpOperations.Request, headerStream);
126.             else
127.                 WriteUInt16(TcpOperations.OneWayRequest, headerStream);            
128.             // output content delimiter style
129.             WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
130.             WriteInt32(contentLength, headerStream);
131.             
132.             // output request uri
133.             WriteUInt16(TcpHeaders.RequestUri, headerStream);
134.             WriteByte(TcpHeaderFormat.CountedString, headerStream);
135.             WriteCountedString(uri, headerStream);         
137.             // output rest of headers
138.             WriteHeaders(headers, headerStream);   
139.             
140.             headerStream.WriteTo(NetStream);
141.             headerStream.Close();
143.             _requestStream = NetStream;
145.             return _requestStream;
146.         } // GetRequestStream
148.         public void SendRequest(IMessage msg, ITransportHeaders headers, Stream contentStream)
149.         {
150.             int requestLength = (int)contentStream.Length;
151.             GetRequestStream(msg, requestLength, headers);
153.             StreamHelper.CopyStream(contentStream, NetStream);           
155.             contentStream.Close();
156.         } // SendRequest
159.         public Stream GetResponseStream()
160.         {
161.             if (!_bChunked)
162.                 _responseStream = new TcpFixedLengthReadingStream(this, _contentLength);
163.             else
164.                 _responseStream = new TcpChunkedReadingStream(this);
165.             
166.             return _responseStream;
167.         } // GetResponseStream
170.         public bool OneWayRequest
171.         {
172.             get { return _bOneWayRequest; }
173.         }
175.         public void ReturnToCache()
176.         {
177.             TcpClientTransportSink.ClientSocketCache.ReleaseSocket(
178.                 _machineAndPort, this);
179.         }
180.     
181.     } // TcpClientSocketHandler
183. } // namespace System.Runtime.Remoting.Channels