sipcmessage.cs

破解的飞信源代码

namespace Imps.Base.Sipc
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Text;

    public abstract class SipcMessage
    {
        private string _body = string.Empty;
        private byte[] _bodyBuffer;
        private ArrayList _headers = new ArrayList();

        protected SipcMessage()
        {
        }

        public void AddHeader(SipcHeader header)
        {
            this._headers.Add(header);
        }

        protected abstract string GetFirstLine();
        public SipcHeader[] GetHeaders(string name)
        {
            name = name.ToUpper();
            List<SipcHeader> list = new List<SipcHeader>();
            foreach (SipcHeader header in this._headers)
            {
                if (header.Name == name)
                {
                    list.Add(header);
                }
            }
            return list.ToArray();
        }

        public virtual byte[] ToBinary()
        {
            string s = this.ToString();
            return Encoding.UTF8.GetBytes(s);
        }

        public override string ToString()
        {
            return this.ToString(ToStringMode.Default);
        }

        public string ToString(ToStringMode mode)
        {
            StringBuilder builder = new StringBuilder();
            builder.AppendFormat("{0}\r\n", this.GetFirstLine());
            foreach (SipcHeader header in this._headers)
            {
                if (header.Name != "L")
                {
                    builder.AppendFormat("{0}\r\n", header.ToString());
                }
            }
            string s = this.Body;
            if (s.Length > 0)
            {
                builder.AppendFormat("{0}: {1}\r\n\r\n", "L", Encoding.UTF8.GetByteCount(s));
                if (mode == ToStringMode.Default)
                {
                    builder.Append(s);
                }
                else if (mode == ToStringMode.NoMessageBody)
                {
                    if ("M".Equals(this.CSeq.Method))
                    {
                        builder.Append('*', s.Length);
                    }
                    else
                    {
                        builder.Append(s);
                    }
                }
            }
            else
            {
                builder.Append("\r\n");
            }
            return builder.ToString();
        }

        public SipcAuthorizationHeader Authorization
        {
            get
            {
                return (this["A"] as SipcAuthorizationHeader);
            }
        }

        public string Body
        {
            get
            {
                if (string.IsNullOrEmpty(this._body))
                {
                    if (this.BodyBuffer == null)
                    {
                        return string.Empty;
                    }
                    this._body = Encoding.UTF8.GetString(this.BodyBuffer);
                }
                return this._body;
            }
            set
            {
                this._body = (value == null) ? string.Empty : value;
            }
        }

        public byte[] BodyBuffer
        {
            get
            {
                return this._bodyBuffer;
            }
            internal set
            {
                this._bodyBuffer = value;
                this._body = null;
            }
        }

        public SipcCallIdHeader CallId
        {
            get
            {
                return (this["I"] as SipcCallIdHeader);
            }
        }

        public SipcContentLengthHeader ContentLength
        {
            get
            {
                return (this["L"] as SipcContentLengthHeader);
            }
        }

        public SipcContentTypeHeader ContentType
        {
            get
            {
                return (this["C"] as SipcContentTypeHeader);
            }
        }

        public SipcCSeqHeader CSeq
        {
            get
            {
                return (this["Q"] as SipcCSeqHeader);
            }
        }

        public SipcDateHeader DateHeader
        {
            get
            {
                return (this["D"] as SipcDateHeader);
            }
        }

        public SipcEndPointsHeader EndPoints
        {
            get
            {
                return (this["EP"] as SipcEndPointsHeader);
            }
        }

        public SipcEventHeader Event
        {
            get
            {
                return (this["N"] as SipcEventHeader);
            }
        }

        public SipcExpiresHeader Expires
        {
            get
            {
                return (this["X"] as SipcExpiresHeader);
            }
        }

        public SipcFromHeader From
        {
            get
            {
                return (this["F"] as SipcFromHeader);
            }
        }

        public ArrayList Headers
        {
            get
            {
                return this._headers;
            }
        }

        private SipcHeader this[string name]
        {
            get
            {
                name = name.ToUpper();
                foreach (SipcHeader header in this._headers)
                {
                    if (header.Name == name)
                    {
                        return header;
                    }
                }
                return null;
            }
        }

        public SipcMessageIDHeader MessageIDHeader
        {
            get
            {
                return (this["XI"] as SipcMessageIDHeader);
            }
        }

        public SipcReferredByHeader ReferredBy
        {
            get
            {
                return (this["RB"] as SipcReferredByHeader);
            }
        }

        public SipcReferToHeader ReferTo
        {
            get
            {
                return (this["RT"] as SipcReferToHeader);
            }
        }

        public SipcRequireHeader RequireHeader
        {
            get
            {
                return (this["RQ"] as SipcRequireHeader);
            }
        }

        public SipcRosterManagerHeader RosterManager
        {
            get
            {
                return (this["RM"] as SipcRosterManagerHeader);
            }
        }

        public SipcSourceHeader SourceHeader
        {
            get
            {
                return (this["SO"] as SipcSourceHeader);
            }
        }

        public SipcSupportedHeader SupportedHeader
        {
            get
            {
                return (this["K"] as SipcSupportedHeader);
            }
        }

        public SipcToHeader To
        {
            get
            {
                return (this["T"] as SipcToHeader);
            }
        }

        public SipcWWWAuthenticateHeader WWWAuthenticate
        {
            get
            {
                return (this["W"] as SipcWWWAuthenticateHeader);
            }
        }
    }
}