Пример #1
0
        public string UpdateContact(IMORZEContact cnt)
        {
            string       err = null;
            MORZEContact c   = m_contacts.Where(x => x.GetAddress() == cnt.GetAddress()).FirstOrDefault();

            if (c != null)
            {
                c.DisplayName = cnt.ToString();
            }

            return(err);
        }
Пример #2
0
        public string AddContact(string Name, string address)
        {
            string err = null;

            Monitor.Enter(m_contacts);
            if (GetContact(address, false) == null)
            {
                try
                {
                    MORZEContact cnt = new MORZEContact(Name, address);
                    m_contacts.Add(cnt);
                }
                catch (Exception exp)
                {
                    err = exp.Message;
                }
            }
            Monitor.Exit(m_contacts);
            return(err);
        }
Пример #3
0
        /// <summary>
        /// добавить контакт в адресную книгу
        /// </summary>
        /// <param name="address">адрес контакта</param>
        /// <param name="isaddIfnotExist">добавить контакт если не сущесвует</param>
        /// <returns></returns>
        public IMORZEContact GetContact(string address, bool addIfnotExist)
        {
            IMORZEContact cnt   = null;
            bool          isnew = false;

            Monitor.Enter(m_contacts);

            var cnts = m_contacts.Where(x => x.GetAddress() == address);

            if (cnts.Any() == true)
            {
                cnt = cnts.First();
            }
            else
            {
                if (addIfnotExist == true)
                {
                    try
                    {
                        MORZEContact _cnt;
                        _cnt = new MORZEContact(null, address);
                        m_contacts.Add(_cnt);
                        cnt   = _cnt;
                        isnew = true;
                    }
                    catch (Exception exp)
                    {
                        cnt = null;
                    }
                }
            }

            Monitor.Exit(m_contacts);
            if (cnt != null && OnNewAccountRecive != null && isnew == true)
            {
                OnNewAccountRecive(cnt);
            }
            return(cnt);
        }
        public MORZERecvMessages(IMORZEAccount acc, byte[] data) : base(data)
        {
            int off = 0;

            byte[] msg;

            byte[] hash;
            byte[] ext;

            m_responses = null;
            byte[] addascii = Encoding.ASCII.GetBytes(acc.GetMyAccount());

            m_acc = acc;
            bool    err     = false;
            SMSHash mrzhash = SMSHash.None;

            while (off < data.Length && err == false)
            {
                msg  = null;
                hash = null;
                ext  = null;

                off++;             //ttl
                ushort msglen = 0;
                switch (data[off]) //hash
                {
                case 0x01:         //md5
                    hash    = new byte[0x10];
                    mrzhash = SMSHash.MD5;
                    break;

                case 0x81:
                    hash    = new byte[0x10];
                    mrzhash = SMSHash.MD5;
                    ext     = new byte[0x10];
                    break;

                default:
                    err = true;
                    break;
                }
                if (err == false)
                {
                    off++;
                    Array.Copy(data, off, hash, 0, hash.Length);
                    off += hash.Length;
                    if (ext != null)
                    {
                        Array.Copy(data, off, ext, 0, ext.Length);
                        off += ext.Length;
                    }
                    msglen = BitConverter.ToUInt16(data, off);
                    off   += 2;
                    if (msglen + off <= data.Length)
                    {
                        msg = new byte[msglen];
                        Array.Copy(data, off, msg, 0, msg.Length);
                        off += msg.Length;
                    }
                    else
                    {
                        err = true;
                    }
                }
                if (err == false)
                {
                    bool add = false;
                    if (checkHash(mrzhash, hash, msg) == true)
                    {
                        if (ext == null)
                        {//данные зашифрованные открытым ключем
                            byte   asynclen = 0;
                            byte[] smsg     = null;
                            byte[] async    = null;
                            asynclen = (byte)((int)addascii[0x10] ^ (int)msg[0]);
                            if (asynclen > 0)
                            {
                                async = new byte[asynclen];
                                Array.Copy(msg, 1, async, 0, async.Length);
                                if ((int)asynclen < msg.Length)
                                {
                                    smsg = new byte[msg.Length - (1 + asynclen)];
                                    Array.Copy(msg, 1 + asynclen, smsg, 0, smsg.Length);
                                }
                                else
                                {
                                    if (msg.Length < asynclen)
                                    {
                                        err = true;
                                    }
                                }
                                if (err == false)
                                {
                                    byte[] dec;
                                    byte[] tail       = null;
                                    int    taillength = msg.Length - asynclen - 1;
                                    if (taillength < 0)
                                    {
                                        err = true;
                                    }
                                    else
                                    {
                                        tail = new byte[taillength];
                                        Array.Copy(msg, async.Length + 1, tail, 0, taillength);
                                        if (acc.decodeAsync(async, out dec) == true)
                                        {
                                            err = !operateAsync(dec, tail);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                err = true;
                            }
                        }
                        else
                        {
                            add = true;
                        }

                        if (add == true)
                        {
                            if (m_msgData == null)
                            {
                                m_msgData = new List <byte[]>();
                            }
                            if (m_msgHash == null)
                            {
                                m_msgHash = new List <byte[]>();
                            }
                            if (m_msgExt == null)
                            {
                                m_msgExt = new List <byte[]>();
                            }
                            m_msgData.Add(msg);
                            m_msgHash.Add(hash);
                            m_msgExt.Add(ext);

                            IMORZEContact mc = m_acc.GetAddressBook().GetContact(ext);

                            if (mc != null)
                            {
                                if (mc.PutReciveMessage(msg, hash, mrzhash, ext) == true)
                                {
                                    MORZEContact cc = mc as MORZEContact;
                                    if (cc != null)
                                    {
                                        List <byte[]> r = cc.Responses;
                                        if (r != null)
                                        {
                                            foreach (byte[] i in r)
                                            {
                                                MORZESendMessage cmdMsgTyp2 = new MORZESendMessage();
                                                cmdMsgTyp2.AddMessageBody(i, mrzhash, ext);
                                                if (m_responses == null)
                                                {
                                                    m_responses = new List <SMSSendCommand>();
                                                }
                                                m_responses.Add(cmdMsgTyp2);
                                            }
                                            cc.Responses.Clear();
                                        }
                                    }
                                }
                            }
                        }
                    } //if (checkHash(mrzhash, hash, msg) == true)
                }
            }         //while (off<data.Length && err==false)
            if (err == true || off != data.Length)
            {
                m_msgData = null;
                m_msgHash = null;
                m_msgExt  = null;
            }
        }