The Labs \ Source Viewer \ SSCLI \ System.Net \ EmptyStream

  1. // ------------------------------------------------------------------------------
  2. // <copyright file="FtpWebResponse.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 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. // </copyright>
  14. // ------------------------------------------------------------------------------
  15. //
  16. namespace System.Net
  17. {
  18.    
  19.     using System.Collections;
  20.     using System.IO;
  21.     using System.Net.Sockets;
  22.     using System.Threading;
  23.     using System.Security.Cryptography.X509Certificates;
  24.     using System.Security.Permissions;
  25.    
  26.     /// <summary>
  27.     /// <para>The FtpWebResponse class contains the result of the FTP request
  28.     /// interface.</para>
  29.     /// </summary>
  30.     public class FtpWebResponse : WebResponse, IDisposable
  31.     {
  32.        
  33.         internal Stream m_ResponseStream;
  34.         private long m_ContentLength;
  35.         private Uri m_ResponseUri;
  36.         private FtpStatusCode m_StatusCode;
  37.         private string m_StatusLine;
  38.         private WebHeaderCollection m_FtpRequestHeaders;
  39.         private HttpWebResponse m_HttpWebResponse;
  40.         private DateTime m_LastModified;
  41.         private string m_BannerMessage;
  42.         private string m_WelcomeMessage;
  43.         private string m_ExitMessage;
  44.        
  45.        
  46.         internal FtpWebResponse(Stream responseStream, long contentLength, Uri responseUri, FtpStatusCode statusCode, string statusLine, DateTime lastModified, string bannerMessage, string welcomeMessage, string exitMessage)
  47.         {
  48.             GlobalLog.Print("FtpWebResponse#" + ValidationHelper.HashString(this) + "::.ctor(" + contentLength.ToString() + "," + statusLine + ")");
  49.             m_ResponseStream = responseStream;
  50.             if (responseStream == null && contentLength < 0) {
  51.                 contentLength = 0;
  52.             }
  53.             m_ContentLength = contentLength;
  54.             m_ResponseUri = responseUri;
  55.             m_StatusCode = statusCode;
  56.             m_StatusLine = statusLine;
  57.             m_LastModified = lastModified;
  58.             m_BannerMessage = bannerMessage;
  59.             m_WelcomeMessage = welcomeMessage;
  60.             m_ExitMessage = exitMessage;
  61.         }
  62.        
  63.         internal FtpWebResponse(HttpWebResponse httpWebResponse)
  64.         {
  65.             m_HttpWebResponse = httpWebResponse;
  66.             InternalSetFromCache = m_HttpWebResponse.IsFromCache;
  67.             InternalSetIsCacheFresh = m_HttpWebResponse.IsCacheFresh;
  68.         }
  69.        
  70.         internal void UpdateStatus(FtpStatusCode statusCode, string statusLine, string exitMessage)
  71.         {
  72.             m_StatusCode = statusCode;
  73.             m_StatusLine = statusLine;
  74.             m_ExitMessage = exitMessage;
  75.         }
  76.        
  77.        
  78.         /// <summary>
  79.         /// <para>Returns a data stream for FTP</para>
  80.         /// </summary>
  81.         public override Stream GetResponseStream()
  82.         {
  83.             Stream responseStream = null;
  84.             if (HttpProxyMode) {
  85.                 responseStream = m_HttpWebResponse.GetResponseStream();
  86.             }
  87.             else if (m_ResponseStream != null) {
  88.                 responseStream = m_ResponseStream;
  89.             }
  90.             else {
  91.                 responseStream = m_ResponseStream = new EmptyStream();
  92.             }
  93.             return responseStream;
  94.         }
  95.         //
  96.         internal class EmptyStream : MemoryStream
  97.         {
  98.             internal EmptyStream() : base(new byte[0], false)
  99.             {
  100.             }
  101.         }
  102.         //
  103.         // Only used when combining cached and live responses
  104.         //
  105.         internal void SetResponseStream(Stream stream)
  106.         {
  107.             if (stream == null || stream == Stream.Null || stream is EmptyStream)
  108.                 return;
  109.             m_ResponseStream = stream;
  110.         }
  111.        
  112.        
  113.         /// <summary>
  114.         /// <para>Closes the underlying FTP response stream, but does not close control connection</para>
  115.         /// </summary>
  116.         public override void Close()
  117.         {
  118.             if (Logging.On)
  119.                 Logging.Enter(Logging.Web, this, "Close", "");
  120.             if (HttpProxyMode) {
  121.                 m_HttpWebResponse.Close();
  122.             }
  123.             else {
  124.                 Stream stream = m_ResponseStream;
  125.                 if (stream != null) {
  126.                     stream.Close();
  127.                 }
  128.             }
  129.             if (Logging.On)
  130.                 Logging.Exit(Logging.Web, this, "Close", "");
  131.         }
  132.        
  133.         /// <summary>
  134.         /// <para>Queries the length of the response</para>
  135.         /// </summary>
  136.         public override long ContentLength {
  137.             get {
  138.                 if (HttpProxyMode) {
  139.                     return m_HttpWebResponse.ContentLength;
  140.                 }
  141.                 return m_ContentLength;
  142.             }
  143.         }
  144.         internal void SetContentLength(long value)
  145.         {
  146.             if (HttpProxyMode)
  147.                 return;
  148.             //m_HttpWebResponse.ContentLength = value;
  149.             m_ContentLength = value;
  150.         }
  151.        
  152.        
  153.         /// <devdoc>
  154.         /// <para>
  155.         /// A collection of headers, currently nothing is return except an empty collection
  156.         /// </para>
  157.         /// </devdoc>
  158.         public override WebHeaderCollection Headers {
  159.             get {
  160.                 if (HttpProxyMode) {
  161.                     return m_HttpWebResponse.Headers;
  162.                 }
  163.                
  164.                 if (m_FtpRequestHeaders == null) {
  165.                     lock (this) {
  166.                         if (m_FtpRequestHeaders == null) {
  167.                             m_FtpRequestHeaders = new WebHeaderCollection(WebHeaderCollectionType.FtpWebResponse);
  168.                         }
  169.                     }
  170.                 }
  171.                 return m_FtpRequestHeaders;
  172.             }
  173.         }
  174.        
  175.         /// <summary>
  176.         /// <para>Shows the final Uri that the FTP request ended up on</para>
  177.         /// </summary>
  178.         public override Uri ResponseUri {
  179.             get {
  180.                 if (HttpProxyMode) {
  181.                     return m_HttpWebResponse.ResponseUri;
  182.                 }
  183.                 return m_ResponseUri;
  184.             }
  185.         }
  186.        
  187.        
  188.         /// <summary>
  189.         /// <para>Last status code retrived</para>
  190.         /// </summary>
  191.         public FtpStatusCode StatusCode {
  192.             get {
  193.                 if (HttpProxyMode) {
  194.                     return ((FtpStatusCode)((int)m_HttpWebResponse.StatusCode));
  195.                 }
  196.                 return m_StatusCode;
  197.             }
  198.         }
  199.        
  200.         /// <summary>
  201.         /// <para>Last status line retrived</para>
  202.         /// </summary>
  203.         public string StatusDescription {
  204.             get {
  205.                 if (HttpProxyMode) {
  206.                     return m_HttpWebResponse.StatusDescription;
  207.                 }
  208.                 return m_StatusLine;
  209.             }
  210.         }
  211.        
  212.         /// <summary>
  213.         /// <para>Returns last modified date time for given file (null if not relavant/avail)</para>
  214.         /// </summary>
  215.         public DateTime LastModified {
  216.             get {
  217.                 if (HttpProxyMode) {
  218.                     return m_HttpWebResponse.LastModified;
  219.                 }
  220.                 return m_LastModified;
  221.             }
  222.         }
  223.        
  224.         /// <summary>
  225.         /// <para>Returns the server message sent before user credentials are sent</para>
  226.         /// </summary>
  227.         public string BannerMessage {
  228.             get { return m_BannerMessage; }
  229.         }
  230.        
  231.         /// <summary>
  232.         /// <para>Returns the server message sent after user credentials are sent</para>
  233.         /// </summary>
  234.         public string WelcomeMessage {
  235.             get { return m_WelcomeMessage; }
  236.         }
  237.        
  238.         /// <summary>
  239.         /// <para>Returns the exit sent message on shutdown</para>
  240.         /// </summary>
  241.         public string ExitMessage {
  242.             get { return m_ExitMessage; }
  243.         }
  244.        
  245.        
  246.         /// <summary>
  247.         /// <para>True if request is just wrapping HttpWebRequest</para>
  248.         /// </summary>
  249.         private bool HttpProxyMode {
  250.             get { return (m_HttpWebResponse != null); }
  251.         }
  252.     }
  253. }

Developer Fusion