Пример #1
0
        public static async Task <bool> AcceptConfirm(string mail, string pass)
        {
            return(await Task.Run(async() =>
            {
                try
                {
                    using (var client = new Pop3Client())
                    {
                        await client.ConnectAsync("pop.mail.yahoo.com", 995, true);

                        // Note: since we don't have an OAuth2 token, disable
                        // the XOAUTH2 authentication mechanism.
                        client.AuthenticationMechanisms.Remove("XOAUTH2");
                        await client.AuthenticateAsync(mail, pass);

                        var msgs = await client.GetMessagesAsync(0, client.Count);
                        var confMess = msgs.First(x => x.Subject.Contains("Quora Account Confirmation"));

                        if (confMess == null)
                        {
                            return false;
                        }

                        var link = Regex.Match(confMess.HtmlBody, @"(?=https).+(?=\"")").Value;
                        Utils.GetRequest.Get(link).None();

                        await client.DeleteAllMessagesAsync();
                        client.Disconnect(true);
                        return true;
                    }
                }
                catch (Exception ex)
                {
                    //Informer.RaiseOnResultReceived(ex.Message);
                    return false;
                }
            }));
        }
Пример #2
0
        public async void TestGMailPop3Client()
        {
            var commands = new List <Pop3ReplayCommand> ();

            commands.Add(new Pop3ReplayCommand("", "gmail.greeting.txt"));
            commands.Add(new Pop3ReplayCommand("CAPA\r\n", "gmail.capa1.txt"));
            commands.Add(new Pop3ReplayCommand("AUTH PLAIN\r\n", "gmail.plus.txt"));
            commands.Add(new Pop3ReplayCommand("AHVzZXJuYW1lAHBhc3N3b3Jk\r\n", "gmail.auth.txt"));
            commands.Add(new Pop3ReplayCommand("CAPA\r\n", "gmail.capa2.txt"));
            commands.Add(new Pop3ReplayCommand("STAT\r\n", "gmail.stat.txt"));
            commands.Add(new Pop3ReplayCommand("UIDL\r\n", "gmail.uidl.txt"));
            commands.Add(new Pop3ReplayCommand("UIDL 1\r\n", "gmail.uidl1.txt"));
            commands.Add(new Pop3ReplayCommand("UIDL 2\r\n", "gmail.uidl2.txt"));
            commands.Add(new Pop3ReplayCommand("UIDL 3\r\n", "gmail.uidl3.txt"));
            commands.Add(new Pop3ReplayCommand("LIST\r\n", "gmail.list.txt"));
            commands.Add(new Pop3ReplayCommand("LIST 1\r\n", "gmail.list1.txt"));
            commands.Add(new Pop3ReplayCommand("LIST 2\r\n", "gmail.list2.txt"));
            commands.Add(new Pop3ReplayCommand("LIST 3\r\n", "gmail.list3.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\n", "gmail.retr1.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\nRETR 2\r\nRETR 3\r\n", "gmail.retr123.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\nRETR 2\r\nRETR 3\r\n", "gmail.retr123.txt"));
            commands.Add(new Pop3ReplayCommand("TOP 1 0\r\n", "gmail.top.txt"));
            commands.Add(new Pop3ReplayCommand("TOP 1 0\r\nTOP 2 0\r\nTOP 3 0\r\n", "gmail.top123.txt"));
            commands.Add(new Pop3ReplayCommand("TOP 1 0\r\nTOP 2 0\r\nTOP 3 0\r\n", "gmail.top123.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\n", "gmail.retr1.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\nRETR 2\r\nRETR 3\r\n", "gmail.retr123.txt"));
            commands.Add(new Pop3ReplayCommand("RETR 1\r\nRETR 2\r\nRETR 3\r\n", "gmail.retr123.txt"));
            commands.Add(new Pop3ReplayCommand("NOOP\r\n", "gmail.noop.txt"));
            commands.Add(new Pop3ReplayCommand("DELE 1\r\n", "gmail.dele.txt"));
            commands.Add(new Pop3ReplayCommand("RSET\r\n", "gmail.rset.txt"));
            commands.Add(new Pop3ReplayCommand("DELE 1\r\nDELE 2\r\nDELE 3\r\n", "gmail.dele123.txt"));
            commands.Add(new Pop3ReplayCommand("RSET\r\n", "gmail.rset.txt"));
            commands.Add(new Pop3ReplayCommand("DELE 1\r\nDELE 2\r\nDELE 3\r\n", "gmail.dele123.txt"));
            commands.Add(new Pop3ReplayCommand("RSET\r\n", "gmail.rset.txt"));
            commands.Add(new Pop3ReplayCommand("DELE 1\r\nDELE 2\r\nDELE 3\r\n", "gmail.dele123.txt"));
            commands.Add(new Pop3ReplayCommand("RSET\r\n", "gmail.rset.txt"));
            commands.Add(new Pop3ReplayCommand("QUIT\r\n", "gmail.quit.txt"));

            using (var client = new Pop3Client()) {
                try {
                    client.ReplayConnect("localhost", new Pop3ReplayStream(commands, false));
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Connect: {0}", ex);
                }

                Assert.IsTrue(client.IsConnected, "Client failed to connect.");

                Assert.AreEqual(GMailCapa1, client.Capabilities);
                Assert.AreEqual(2, client.AuthenticationMechanisms.Count);
                Assert.IsTrue(client.AuthenticationMechanisms.Contains("XOAUTH2"), "Expected SASL XOAUTH2 auth mechanism");
                Assert.IsTrue(client.AuthenticationMechanisms.Contains("PLAIN"), "Expected SASL PLAIN auth mechanism");

                // Note: remove the XOAUTH2 auth mechanism to force PLAIN auth
                client.AuthenticationMechanisms.Remove("XOAUTH2");

                try {
                    await client.AuthenticateAsync("username", "password");
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Authenticate: {0}", ex);
                }

                Assert.AreEqual(GMailCapa2, client.Capabilities);
                Assert.AreEqual(0, client.AuthenticationMechanisms.Count);

                Assert.AreEqual(3, client.Count, "Expected 3 messages");

                var uids = await client.GetMessageUidsAsync();

                Assert.AreEqual(3, uids.Count);
                Assert.AreEqual("101", uids[0]);
                Assert.AreEqual("102", uids[1]);
                Assert.AreEqual("103", uids[2]);

                for (int i = 0; i < 3; i++)
                {
                    var uid = await client.GetMessageUidAsync(i);

                    Assert.AreEqual(uids[i], uid);
                }

                var sizes = await client.GetMessageSizesAsync();

                Assert.AreEqual(3, sizes.Count);
                Assert.AreEqual(1024, sizes[0]);
                Assert.AreEqual(1025, sizes[1]);
                Assert.AreEqual(1026, sizes[2]);

                for (int i = 0; i < 3; i++)
                {
                    var size = await client.GetMessageSizeAsync(i);

                    Assert.AreEqual(sizes[i], size);
                }

                try {
                    var message = await client.GetMessageAsync(0);

                    using (var jpeg = new MemoryStream()) {
                        var attachment = message.Attachments.OfType <MimePart> ().FirstOrDefault();

                        attachment.ContentObject.DecodeTo(jpeg);
                        jpeg.Position = 0;

                        using (var md5 = new MD5CryptoServiceProvider()) {
                            var md5sum = HexEncode(md5.ComputeHash(jpeg));

                            Assert.AreEqual("5b1b8b2c9300c9cd01099f44e1155e2b", md5sum, "MD5 checksums do not match.");
                        }
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessage: {0}", ex);
                }

                try {
                    var messages = await client.GetMessagesAsync(0, 3);

                    foreach (var message in messages)
                    {
                        using (var jpeg = new MemoryStream()) {
                            var attachment = message.Attachments.OfType <MimePart> ().FirstOrDefault();

                            attachment.ContentObject.DecodeTo(jpeg);
                            jpeg.Position = 0;

                            using (var md5 = new MD5CryptoServiceProvider()) {
                                var md5sum = HexEncode(md5.ComputeHash(jpeg));

                                Assert.AreEqual("5b1b8b2c9300c9cd01099f44e1155e2b", md5sum, "MD5 checksums do not match.");
                            }
                        }
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessages: {0}", ex);
                }

                try {
                    var messages = await client.GetMessagesAsync(new [] { 0, 1, 2 });

                    foreach (var message in messages)
                    {
                        using (var jpeg = new MemoryStream()) {
                            var attachment = message.Attachments.OfType <MimePart> ().FirstOrDefault();

                            attachment.ContentObject.DecodeTo(jpeg);
                            jpeg.Position = 0;

                            using (var md5 = new MD5CryptoServiceProvider()) {
                                var md5sum = HexEncode(md5.ComputeHash(jpeg));

                                Assert.AreEqual("5b1b8b2c9300c9cd01099f44e1155e2b", md5sum, "MD5 checksums do not match.");
                            }
                        }
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessages: {0}", ex);
                }

                try {
                    var header = await client.GetMessageHeadersAsync(0);

                    Assert.AreEqual("Test inline image", header[HeaderId.Subject]);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessageHeaders: {0}", ex);
                }

                try {
                    var headers = await client.GetMessageHeadersAsync(0, 3);

                    Assert.AreEqual(3, headers.Count);
                    for (int i = 0; i < headers.Count; i++)
                    {
                        Assert.AreEqual("Test inline image", headers[i][HeaderId.Subject]);
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessageHeaders: {0}", ex);
                }

                try {
                    var headers = await client.GetMessageHeadersAsync(new [] { 0, 1, 2 });

                    Assert.AreEqual(3, headers.Count);
                    for (int i = 0; i < headers.Count; i++)
                    {
                        Assert.AreEqual("Test inline image", headers[i][HeaderId.Subject]);
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetMessageHeaders: {0}", ex);
                }

                try {
                    using (var stream = await client.GetStreamAsync(0)) {
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetStream: {0}", ex);
                }

                try {
                    var streams = await client.GetStreamsAsync(0, 3);

                    Assert.AreEqual(3, streams.Count);
                    for (int i = 0; i < 3; i++)
                    {
                        streams[i].Dispose();
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetStreams: {0}", ex);
                }

                try {
                    var streams = await client.GetStreamsAsync(new int[] { 0, 1, 2 });

                    Assert.AreEqual(3, streams.Count);
                    for (int i = 0; i < 3; i++)
                    {
                        streams[i].Dispose();
                    }
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in GetStreams: {0}", ex);
                }

                try {
                    await client.NoOpAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in NoOp: {0}", ex);
                }

                try {
                    await client.DeleteMessageAsync(0);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in DeleteMessage: {0}", ex);
                }

                try {
                    await client.ResetAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Reset: {0}", ex);
                }

                try {
                    await client.DeleteMessagesAsync(new [] { 0, 1, 2 });
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in DeleteMessages: {0}", ex);
                }

                try {
                    await client.ResetAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Reset: {0}", ex);
                }

                try {
                    await client.DeleteMessagesAsync(0, 3);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in DeleteMessages: {0}", ex);
                }

                try {
                    await client.ResetAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Reset: {0}", ex);
                }

                try {
                    await client.DeleteAllMessagesAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in DeleteAllMessages: {0}", ex);
                }

                try {
                    await client.ResetAsync();
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Reset: {0}", ex);
                }

                try {
                    await client.DisconnectAsync(true);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Disconnect: {0}", ex);
                }

                Assert.IsFalse(client.IsConnected, "Failed to disconnect");
            }
        }