コード例 #1
0
        /// <summary>
        /// Stores MIME entity body to the specified stream.
        /// </summary>
        /// <param name="stream">Stream where to store body data.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
        protected internal override void ToStream(Stream stream,
                                                  MIME_Encoding_EncodedWord headerWordEncoder,
                                                  Encoding headerParmetersCharset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            m_pMessage.ToStream(stream, headerWordEncoder, headerParmetersCharset);
        }
コード例 #2
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
 /// <returns>Returns header field as string.</returns>
 public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
 {
     if (m_ParseValue != null)
     {
         return(m_ParseValue);
     }
     else
     {
         if (wordEncoder != null)
         {
             return(m_Name + ": " + wordEncoder.Encode(m_Value) + "\r\n");
         }
         else
         {
             return(m_Name + ": " + m_Value + "\r\n");
         }
     }
 }
コード例 #3
0
ファイル: MIME_Entity.cs プロジェクト: ztcyun/CommunityServer
        /// <summary>
        /// Stores MIME entity to the specified file.
        /// </summary>
        /// <param name="file">File name with path where to store MIME entity.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>file</b> is null.</exception>
        /// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
        public void ToFile(string file,
                           MIME_Encoding_EncodedWord headerWordEncoder,
                           Encoding headerParmetersCharset)
        {
            if (file == null)
            {
                throw new ArgumentNullException("file");
            }
            if (file == "")
            {
                throw new ArgumentException("Argument 'file' value must be specified.");
            }

            using (FileStream fs = File.Create(file))
            {
                ToStream(fs, headerWordEncoder, headerParmetersCharset);
            }
        }
コード例 #4
0
        /// <summary>
        /// Parses header field from the specified value.
        /// </summary>
        /// <param name="value">Header field value. Header field name must be included. For example: 'Content-Type: text/plain'.</param>
        /// <returns>Returns parsed header field.</returns>
        /// <exception cref="ArgumentNullException">Is raised when <b>value</b> is null reference.</exception>
        /// <exception cref="ParseException">Is raised when header field parsing errors.</exception>
        public static MIME_h_Unstructured Parse(string value)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            MIME_h_Unstructured retVal = new MIME_h_Unstructured();

            string[] name_value = value.Split(new[] { ':' }, 2);
            if (name_value[0].Trim() == string.Empty)
            {
                throw new ParseException("Invalid header field '" + value + "' syntax.");
            }

            retVal.m_Name  = name_value[0];
            retVal.m_Value = MIME_Encoding_EncodedWord.DecodeAll(
                MIME_Utils.UnfoldHeader(name_value.Length == 2 ? name_value[1].TrimStart() : ""));

            retVal.m_ParseValue = value;

            return(retVal);
        }
コード例 #5
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
 /// <returns>Returns header field as string.</returns>
 public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
 {
     return m_ParseValue;
 }
コード例 #6
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.
 /// If encoding needed, UTF-8 is strongly reccomended if not sure.</param>
 /// <returns>Returns header field as string.</returns>
 public abstract string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset);
コード例 #7
0
        /// <summary>
        /// Stores header to the specified file.
        /// </summary>
        /// <param name="fileName">File name with optional path.</param>
        /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="parmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>fileName</b> is null reference.</exception>
        public void ToFile(string fileName, MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException("fileName");
            }

            using (FileStream fs = File.Create(fileName))
            {
                ToStream(fs, wordEncoder, parmetersCharset);
            }
        }
コード例 #8
0
        /// <summary>
        /// Reads RFC 822 'quoted-string' from source stream.
        /// </summary>
        /// <returns>Returns RFC 822 'quoted-string' or null if end of stream reached.</returns>
        /// <exception cref="InvalidOperationException">Is raised when source stream has no quoted-string at current position.</exception>
        /// <exception cref="ArgumentException">Is raised when not valid 'quoted-string'.</exception>
        public string QuotedString()
        {
            /* RFC 2822 3.2.5.
             *  qtext         = NO-WS-CTL /     ; Non white space controls
             *                  %d33 /          ; The rest of the US-ASCII
             *                  %d35-91 /       ;  characters not including "\"
             *                  %d93-126        ;  or the quote character
             *  qcontent      = qtext / quoted-pair
             *  quoted-string = [CFWS] DQUOTE *([FWS] qcontent) [FWS] DQUOTE [CFWS]
             */

            ToFirstChar();

            if (Peek(false) != '"')
            {
                throw new InvalidOperationException("No quoted-string available.");
            }

            // Read start DQUOTE.
            Char(false);

            string retVal = "";
            bool   escape = false;

            while (true)
            {
                int intC = Char(false);
                // We reached end of stream, invalid quoted string, end quote is missing.
                if (intC == -1)
                {
                    throw new ArgumentException("Invalid quoted-string, end quote is missing.");
                }
                // This char is escaped.
                else if (escape)
                {
                    escape = false;

                    retVal += (char)intC;
                }
                // Closing DQUOTE.
                else if (intC == '"')
                {
                    break;
                }
                // Next char is escaped.
                else if (intC == '\\')
                {
                    escape = true;
                }
                // Skip folding chars.
                else if (intC == '\r' || intC == '\n')
                {
                }
                // Normal char in quoted-string.
                else
                {
                    retVal += (char)intC;
                }
            }

            return(MIME_Encoding_EncodedWord.DecodeAll(retVal));
        }
コード例 #9
0
ファイル: MIME_b.cs プロジェクト: haoasqui/ONLYOFFICE-Server
 /// <summary>
 /// Stores MIME entity body to the specified stream.
 /// </summary>
 /// <param name="stream">Stream where to store body data.</param>
 /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
 /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
 protected internal abstract void ToStream(Stream stream,
                                           MIME_Encoding_EncodedWord headerWordEncoder,
                                           Encoding headerParmetersCharset);
コード例 #10
0
        /// <summary>
        /// Stores MIME entity body to the specified stream.
        /// </summary>
        /// <param name="stream">Stream where to store body data.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
        protected internal override void ToStream(Stream stream,
                                                  MIME_Encoding_EncodedWord headerWordEncoder,
                                                  Encoding headerParmetersCharset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            Net_Utils.StreamCopy(GetEncodedDataStream(), stream, Workaround.Definitions.MaxStreamLineLength);
        }
コード例 #11
0
 public byte[] ToByteArray(MIME_Encoding_EncodedWord headerWordEncoder,
                      Encoding headerParmetersCharset)
 {
     using (MemoryStream ms = new MemoryStream())
     {
         ToStream(ms, headerWordEncoder, headerParmetersCharset);
         return ms.GetBuffer();
     }
 }
コード例 #12
0
        /// <summary>
        /// Store MIME enity to the specified stream.
        /// </summary>
        /// <param name="stream">Stream where to store MIME entity. Storing starts form stream current position.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null.</exception>
        public void ToStream(Stream stream,
                             MIME_Encoding_EncodedWord headerWordEncoder,
                             Encoding headerParmetersCharset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            m_pHeader.ToStream(stream, headerWordEncoder, headerParmetersCharset);
            stream.Write(new byte[] {(int) '\r', (int) '\n'}, 0, 2);
            m_pBody.ToStream(stream, headerWordEncoder, headerParmetersCharset);
        }
コード例 #13
0
        /// <summary>
        /// Stores MIME entity to the specified file.
        /// </summary>
        /// <param name="file">File name with path where to store MIME entity.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>file</b> is null.</exception>
        /// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
        public void ToFile(string file,
                           MIME_Encoding_EncodedWord headerWordEncoder,
                           Encoding headerParmetersCharset)
        {
            if (file == null)
            {
                throw new ArgumentNullException("file");
            }
            if (file == "")
            {
                throw new ArgumentException("Argument 'file' value must be specified.");
            }

            using (FileStream fs = File.Create(file))
            {
                ToStream(fs, headerWordEncoder, headerParmetersCharset);
            }
        }
コード例 #14
0
        /// <summary>
        /// Returns MIME header as string.
        /// </summary>
        /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="parmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <returns>Returns MIME header as string.</returns>
        public string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
        {
            StringBuilder retVal = new StringBuilder();
            foreach (MIME_h field in m_pFields)
            {
                retVal.Append(field.ToString(wordEncoder, parmetersCharset));
            }

            return retVal.ToString();
        }
コード例 #15
0
        /// <summary>
        /// Stores header to the specified stream.
        /// </summary>
        /// <param name="stream">Stream where to store header.</param>
        /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="parmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
        public void ToStream(Stream stream, MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            byte[] header = Encoding.UTF8.GetBytes(ToString(wordEncoder, parmetersCharset));
            stream.Write(header, 0, header.Length);
        }
コード例 #16
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
 /// <returns>Returns header field as string.</returns>
 public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
 {
     if (m_ParseValue != null)
     {
         return m_ParseValue;
     }
     else
     {
         if (wordEncoder != null)
         {
             return m_Name + ": " + wordEncoder.Encode(m_Value) + "\r\n";
         }
         else
         {
             return m_Name + ": " + m_Value + "\r\n";
         }
     }
 }
コード例 #17
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
 /// <returns>Returns header field as string.</returns>
 public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
 {
     return(m_ParseValue);
 }
コード例 #18
0
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
 /// <returns>Returns header field as string.</returns>
 public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
 {
     if (IsModified)
     {
         return "Content-Disposition: " + m_DispositionType + m_pParameters.ToString(parmetersCharset) +
                "\r\n";
     }
     else
     {
         return m_ParseValue;
     }
 }
コード例 #19
0
        /// <summary>
        /// Stores MIME entity body to the specified stream.
        /// </summary>
        /// <param name="stream">Stream where to store body data.</param>
        /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
        protected internal override void ToStream(Stream stream,
                                                  MIME_Encoding_EncodedWord headerWordEncoder,
                                                  Encoding headerParmetersCharset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            // Set "preamble" text if any.
            if (!string.IsNullOrEmpty(m_TextPreamble))
            {
                byte[] preableBytes = null;
                if (m_TextPreamble.EndsWith("\r\n"))
                {
                    preableBytes = Encoding.UTF8.GetBytes(m_TextPreamble);
                }
                else
                {
                    preableBytes = Encoding.UTF8.GetBytes(m_TextPreamble + "\r\n");
                }
                stream.Write(preableBytes, 0, preableBytes.Length);
            }

            for (int i = 0; i < m_pBodyParts.Count; i++)
            {
                MIME_Entity bodyPart = m_pBodyParts[i];
                // Start new body part.
                byte[] bStart = Encoding.UTF8.GetBytes("--" + ContentType.Param_Boundary + "\r\n");
                stream.Write(bStart, 0, bStart.Length);

                bodyPart.ToStream(stream, headerWordEncoder, headerParmetersCharset);

                // Last body part, close boundary.
                if (i == (m_pBodyParts.Count - 1))
                {
                    byte[] bEnd = Encoding.UTF8.GetBytes("--" + ContentType.Param_Boundary + "--\r\n");
                    stream.Write(bEnd, 0, bEnd.Length);
                }
            }

            // Set "epilogoue" text if any.
            if (!string.IsNullOrEmpty(m_TextEpilogue))
            {
                byte[] epilogoueBytes = null;
                if (m_TextEpilogue.EndsWith("\r\n"))
                {
                    epilogoueBytes = Encoding.UTF8.GetBytes(m_TextEpilogue);
                }
                else
                {
                    epilogoueBytes = Encoding.UTF8.GetBytes(m_TextEpilogue + "\r\n");
                }
                stream.Write(epilogoueBytes, 0, epilogoueBytes.Length);
            }
        }
コード例 #20
0
        /// <summary>
        /// Returns header field as string.
        /// </summary>
        /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
        /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
        /// <returns>Returns header field as string.</returns>
        public override string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset)
        {
            if (!IsModified)
            {
                return m_ParseValue;
            }
            else
            {
                StringBuilder retVal = new StringBuilder();
                retVal.Append("Content-Type: " + m_Type + "/" + m_SubType);
                retVal.Append(m_pParameters.ToString(parmetersCharset));
                retVal.Append("\r\n");

                return retVal.ToString();
            }
        }
コード例 #21
0
ファイル: MIME_b.cs プロジェクト: yulifengwx/CommunityServer
 /// <summary>
 /// Stores MIME entity body to the specified stream.
 /// </summary>
 /// <param name="stream">Stream where to store body data.</param>
 /// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
 /// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
 protected internal abstract void ToStream(Stream stream,
                                           MIME_Encoding_EncodedWord headerWordEncoder,
                                           Encoding headerParmetersCharset);
コード例 #22
0
ファイル: MIME_h.cs プロジェクト: Inzaghi2012/teamlab.v7.5
 /// <summary>
 /// Returns header field as string.
 /// </summary>
 /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
 /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.
 /// If encoding needed, UTF-8 is strongly reccomended if not sure.</param>
 /// <returns>Returns header field as string.</returns>
 public abstract string ToString(MIME_Encoding_EncodedWord wordEncoder, Encoding parmetersCharset);