Example #1
0
 public void TestMethod1()
 {
     var web = new WebClient();
     var stream = web.OpenRead("http://" + Environment.GetEnvironmentVariable("APPNAME"));
     var result = new StreamReader(stream).ReadToEnd();
     Assert.IsTrue(result.Contains("ASP.NET MVC Website") && result.Contains("Home"));
 }
Example #2
0
        static void TestLoggingAndDelete(string path)
        {
            ILogger log = null;

            try
            {
                log = new LoggerConfiguration()
                    .WriteTo.File(path)
                    .CreateLogger();

                var message = Some.MessageTemplate();

                log.Write(new LogEvent(
                    DateTimeOffset.Now,
                    LogEventLevel.Information,
                    null,
                    message,
                    Enumerable.Empty<LogEventProperty>()));

                var refile = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                var content = new StreamReader(refile).ReadToEnd();
                refile.Dispose();

                Assert.That(content.Contains(message.Text));
            }
            finally
            {
                var disposable = (IDisposable) log;
                    if (disposable != null) disposable.Dispose();
                System.IO.File.Delete(path);
            }
        }
        public bool login(string username, string password) {
            var initialRequest = CyberghostRequest("https://account.cyberghostvpn.com/en_us/login");
            var initialResponse = (HttpWebResponse)initialRequest.GetResponse();

            var csrfToken = new StreamReader(initialResponse.GetResponseStream()).ReadToEnd();
            csrfToken = csrfToken.Substring(csrfToken.IndexOf("var CSRF", StringComparison.Ordinal) + 12, 64);


            var loginRequest = CyberghostRequest("https://account.cyberghostvpn.com/en_us/proxy/users/me?flags=17&csrf=" + csrfToken);
            var postData = "username="+ username + "&authentication=" + password + "&captcha=";
            var data = Encoding.ASCII.GetBytes(postData);

            loginRequest.Method = "POST";
            loginRequest.ContentType = "application/x-www-form-urlencoded";
            loginRequest.ContentLength = data.Length;

            using (var stream = loginRequest.GetRequestStream()) {
                stream.Write(data, 0, data.Length);
            }
            try {
                var loginResponse = (HttpWebResponse)loginRequest.GetResponse();
                var responded = new StreamReader(loginResponse.GetResponseStream()).ReadToEnd();
                return responded.Contains("user_name");
            } catch (Exception) {
                return false;
            }
            
        }
Example #4
0
        /// <summary>
        /// 指定されたメールアドレスとパスワードでニコニコ動画にログインする.<para/>
        /// アプリケーションの起動時に1回だけ呼ぶ.
        /// </summary>
        /// <param name="mail">メールアドレス</param>
        /// <param name="passwd">パスワード</param>
        public static void LoginToNicovideo(string mail, string passwd)
        {
            var req = (HttpWebRequest)HttpWebRequest.Create("https://secure.nicovideo.jp/secure/login?site=niconico");
            req.Method = "POST";

            var args = new Dictionary<string, string>
                           {
                               {"mail", mail},
                               {"password", passwd}
                           };

            var s = args.Select(x => x.Key + "=" + x.Value).Aggregate((x, y) => x + "&" + y);
            var bs = Encoding.UTF8.GetBytes(s);
            req.ContentLength = bs.Length;
            req.ContentType = "application/x-www-form-urlencoded";
            req.CookieContainer = LoginCookie;
            req.GetRequestStream().Write(bs, 0, bs.Length);

            string result;
            try {
                var resp = (HttpWebResponse) req.GetResponse();
                result = new StreamReader(resp.GetResponseStream()).ReadToEnd();
            }
            catch (Exception ex) {
                throw new Exception("Error during login proccess.", ex);
            }
            if (result.Contains("wrongPass")) {
                throw new Exception("Wrong ID or Password. Login Failed.");
            }
        }
Example #5
0
        static void TestLoggingAndDelete(string path)
        {
            ExecuteAndCleanUpFile(
                path,
                p => new LoggerConfiguration()
                    .WriteTo.File(p)
                    .CreateLogger(),
                log => 
                {
                    var message = Some.MessageTemplate();

                    log.Write(new LogEvent(
                        DateTimeOffset.Now,
                        LogEventLevel.Information,
                        null,
                        message,
                        Enumerable.Empty<LogEventProperty>()));

                    var refile = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    var content = new StreamReader(refile).ReadToEnd();
                    refile.Dispose();

                    Assert.That(content.Contains(message.Text));
                });
        }
        public bool TryExtract(string fullPath, Stream stream, string fileName, out ExtractionResult result)
        {
            result = null;
            if (IsExtractable(fileName))
            {
                var encoding = GetFileEncoding(stream);

                stream.Position = 0; //TODO: buscar una forma mas elegante de hacer esto

                var text = new StreamReader(stream, encoding).ReadToEnd();
                //TODO: mejorar este parche feo y caro para soportar a la vez ansi y utf sin bom
                if (text.Contains("Ã"))
                {
                    var bytes = encoding.GetBytes(text);
                    text = Encoding.UTF8.GetString(bytes);
                }

                result = new ExtractionResult()
                {
                    ContentType = "text/plain",
                    PlainContent = text
                };

                return true;
            }
            else
            {
                return false;
            }
        }
        public void WriterShouldNotIncludeTypeNameForCollectionOfDerivedType()
        {
            // JSON Light: writer doesn't include type name for collection of derived type
            // If I have a collection property declared in metadata as Collection(Edm.Geography), 
            // and at serialization type, it's clearly a Collection(Edm.GeographyPoint), 
            // we won't write the type name for that property by default (i.e., minimal metadata mode).

            var model = new EdmModel();
            var entityType = new EdmEntityType("Var1", "Type");
            entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
            entityType.AddProperty(new EdmStructuralProperty(entityType, "Geographies", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, false)))));
            model.AddElement(entityType);
            
            var writerSettings = new ODataMessageWriterSettings();
            writerSettings.SetContentType(ODataFormat.Json);
            writerSettings.DisableMessageStreamDisposal = true;

            var message = new InMemoryMessage { Stream = new MemoryStream() };
            using (ODataMessageWriter odataMessageWriter = new ODataMessageWriter((IODataRequestMessage)message, writerSettings, model))
            {
                ODataWriter odataWriter = odataMessageWriter.CreateODataEntryWriter();
                odataWriter.WriteStart(
                    new ODataEntry
                    {
                        TypeName = "Var1.Type",
                        Properties = new[] 
                        {
                            new ODataProperty() 
                            { 
                                Name = "Id", 
                                Value = 1 
                            }, 
                            new ODataProperty() 
                            { 
                                Name = "Geographies", 
                                Value = new ODataCollectionValue 
                                { 
                                    Items = new[] 
                                    { 
                                        GeographyPoint.Create(0,0),
                                        GeographyPoint.Create(1,1), 
                                        GeographyPoint.Create(2,2) 
                                    } 
                                } 
                            }, 
                        }
                    });
                odataWriter.WriteEnd();
                odataWriter.Flush();
            }
            
            message.Stream.Position = 0;
            var output = new StreamReader(message.Stream).ReadToEnd();
            Assert.IsFalse(output.Contains("Collection(Edm.GeographyPoint)"), @"output.Contains(""Collection(Edm.GeographyPoint)"" == false");
        }
Example #8
0
        public static void Init()
        {
            try
            {
                GetResponse(WebRequest.Create(UpdateMsgPath), response => { UpdateMsg = new StreamReader(response.GetResponseStream()).ReadToEnd().ToString(); });

                Core.DelayAction(
                    () =>
                        {
                            GetResponse(
                                WebRequest.Create(WebVersionPath),
                                response =>
                                    {
                                        var data = new StreamReader(response.GetResponseStream()).ReadToEnd().ToString();
                                        if (data.Contains(CurrentVersionPath.ToString()))
                                        {
                                            Console.ForegroundColor = ConsoleColor.Cyan;
                                            Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + "Info]" + " KappaAIO: Your version is Updated !");
                                            Console.ResetColor();
                                        }
                                        else
                                        {
                                            Console.ForegroundColor = ConsoleColor.Magenta;
                                            Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + "Warn] KappaAIO: There is a new Update Available for KappaAIO !");
                                            Console.ResetColor();
                                            Console.ForegroundColor = ConsoleColor.Cyan;
                                            Chat.Print("<b>KappaAIO: There is a new Update Available for KappaAIO !</b>");
                                            if (UpdateMsg != string.Empty)
                                            {
                                                Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + "Info] KappaAIO: " + UpdateMsg);
                                                Console.ResetColor();
                                                Chat.Print("<b>KappaAIO: " + UpdateMsg + "</b>");
                                                Common.ShowNotification("There is a new Update Available for KappaAIO !", 10000, UpdateMsg);
                                            }
                                            else
                                            {
                                                Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + "Info] KappaAIO: Failed to retrive update msg");
                                                Console.ResetColor();
                                                Chat.Print("<b>KappaAIO: Failed to Retrieve Update msg</b>");
                                                Common.ShowNotification("There is a new Update Available for KappaAIO !", 10000, "Failed to retrive update msg");
                                            }
                                        }
                                    });
                        },
                    500);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Magenta;
                Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + "Warn] KappaAIO: Failed To Check for Updates !");
                Console.WriteLine(DateTime.Now.ToString("[H:mm:ss - ") + ex);
                Console.ResetColor();
            }
        }
Example #9
0
        public void TestRequest()
        {
            var request = new RestRequest(BaseUrl + "TestPage.aspx");
            var response = request.Request("POST", "test=" + HttpUtility.UrlEncode("Bring the awesome."),
                "application/x-www-form-urlencoded");

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, response.StatusDescription);

            var responseBody = new StreamReader(response.GetResponseStream()).ReadToEnd();
            Assert.IsTrue(responseBody.Contains("Bring the awesome."), responseBody);
        }
        /// <summary>
        /// Allows OAuth applications to directly exchange Twitter usernames and passwords for OAuth access tokens and secrets.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="username">The username.</param>
        /// <param name="password">The password.</param>
        /// <returns>A <see cref="OAuthTokenResponse"/> instance.</returns>
        public static OAuthTokenResponse GetAccessTokens(string consumerKey, string consumerSecret, string username, string password)
        {
            if (string.IsNullOrEmpty(consumerKey))
            {
                throw new ArgumentNullException("consumerKey");
            }

            if (string.IsNullOrEmpty(consumerSecret))
            {
                throw new ArgumentNullException("consumerSecret");
            }

            if (string.IsNullOrEmpty(username))
            {
                throw new ArgumentNullException("username");
            }

            if (string.IsNullOrEmpty(password))
            {
                throw new ArgumentNullException("password");
            }

            OAuthTokenResponse response = new OAuthTokenResponse();

            try
            {
                WebRequestBuilder builder = new WebRequestBuilder(
                    new Uri("https://api.twitter.com/oauth/access_token"),
                    HTTPVerb.POST,
                    new OAuthTokens() { ConsumerKey = consumerKey, ConsumerSecret = consumerSecret },
                    "");

                builder.Parameters.Add("x_auth_username", username);
                builder.Parameters.Add("x_auth_password", password);
                builder.Parameters.Add("x_auth_mode", "client_auth");

                string responseBody = new StreamReader(builder.ExecuteRequest().GetResponseStream()).ReadToEnd();

                response.Token = Regex.Match(responseBody, @"oauth_token=([^&]+)").Groups[1].Value;
                response.TokenSecret = Regex.Match(responseBody, @"oauth_token_secret=([^&]+)").Groups[1].Value;
                if (responseBody.Contains("user_id="))
                    response.UserId = long.Parse(Regex.Match(responseBody, @"user_id=([^&]+)").Groups[1].Value, CultureInfo.CurrentCulture);
                response.ScreenName = Regex.Match(responseBody, @"screen_name=([^&]+)").Groups[1].Value;
            }
            catch (WebException wex)
            {
                throw new Exception(wex.Message, wex);
            }

            return response;
        }
        public void Serialize_message_without_typeinfo()
        {
            using (var stream = new MemoryStream())
            {
                Serializer.SkipArrayWrappingForSingleMessages = true;

                Serializer.Serialize(new object[] { new SimpleMessage() }, stream);

                stream.Position = 0;
                var result = new StreamReader(stream).ReadToEnd();

                Assert.That(!result.Contains("$type"), result);
            }
        }
        public void Should_be_able_to_serialize_and_deserialize_a_transport_message()
        {
            var original = new TransportMessage();

            var sut = SUT();

            var stream = sut.Serialize(original);

            var xml = new StreamReader(stream).ReadToEnd();

            Assert.IsTrue(xml.Contains(original.MessageId.ToString()));

            stream.Position = 0;

            Assert.AreEqual(original.MessageId, ((TransportMessage)sut.Deserialize(typeof(TransportMessage), stream)).MessageId);
        }
Example #13
0
        public static Tuple<bool, string> Login(string user, string hash)
        {
            if (user == null || hash == null)
            {
                return new Tuple<bool, string>(false, "Password or username is empty");
            }

            try
            {
                var uri = "username=" + WebUtility.UrlEncode(user) + "&password=" + hash;
                var dataBytes = Encoding.UTF8.GetBytes(uri);

                var wr = WebRequest.Create("http://" + AuthServer + "/forum/api.php?request=login");
                wr.Timeout = 2000;
                wr.ContentLength = dataBytes.Length;
                wr.Method = "POST";
                wr.ContentType = "application/x-www-form-urlencoded";

                var dataStream = wr.GetRequestStream();
                dataStream.Write(dataBytes, 0, dataBytes.Length);
                dataStream.Close();

                var response = wr.GetResponse();

                using (var stream = response.GetResponseStream())
                {
                    if (stream != null)
                    {
                        var responseString = new StreamReader(stream, Encoding.UTF8).ReadToEnd();

                        if (responseString.Contains("success"))
                        {
                            return new Tuple<bool, string>(true, "Success!");
                        }
                    }
                }

                return new Tuple<bool, string>(false, "Wrong password or username, register at http://" + AuthServer);
            }
            catch (Exception e)
            {
                return new Tuple<bool, string>(true, "Fallback T_T");
            }
        }
        public void ThenAllDataWillBeSent()
        {
            GivenKinesisClient();
            WhenLoggerCreated();

            var messages = Fixture.CreateMany<string>(100).ToList();
            foreach (var message in messages)
            {
                Logger.Information(message);
                Thread.Sleep(TimeSpan.FromMilliseconds(ThrottleTime.TotalMilliseconds / 30));
            }

            Thread.Sleep(ThrottleTime.Add(ThrottleTime));

            DataSent.Position = 0;
            var data = new StreamReader(DataSent).ReadToEnd();

            messages.ShouldAllBe(msg => data.Contains(msg));
        }
        public void Serialize_message_without_concrete_implementation()
        {
            var messageMapper = new MessageMapper();
            messageMapper.Initialize(new[]
            {
                typeof(ISuperMessageWithoutConcreteImpl)
            });
            var serializer = new JsonMessageSerializer(messageMapper);

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(messageMapper.CreateInstance<ISuperMessageWithoutConcreteImpl>(), stream);

                stream.Position = 0;
                var result = new StreamReader(stream).ReadToEnd();

                Assert.That(!result.Contains("$type"), result);
                Assert.That(result.Contains("SomeProperty"), result);
            }
        }
        public void Serialize_message_without_typeInfo()
        {
            var messageMapper = new MessageMapper();
            var serializer = new JsonMessageSerializer(messageMapper);
            using (var stream = new MemoryStream())
            {
                serializer.Serialize(new SimpleMessage(), stream);

                stream.Position = 0;
                var result = new StreamReader(stream).ReadToEnd();

                Assert.That(!result.Contains("$type"), result);
            }
        }
        public static void TestSimpleDecryptFileOnThreadWorker()
        {
            FileOperationsController controller = new FileOperationsController(_fileSystemState);
            controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                e.Passphrase = "a";
            };
            bool knownKeyWasAdded = false;
            controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
            {
                knownKeyWasAdded = e.Key == new Passphrase("a").DerivedPassphrase;
            };
            string destinationPath = String.Empty;
            FileOperationStatus status = FileOperationStatus.Unknown;
            controller.Completed += (object sender, FileOperationEventArgs e) =>
            {
                destinationPath = e.SaveFileFullName;
                status = e.Status;
            };
            using (ThreadWorker worker = new ThreadWorker(new ProgressContext()))
            {
                controller.DecryptFile(_helloWorldAxxPath, worker);
                worker.Join();
            }

            Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
            Assert.That(knownKeyWasAdded, "A new known key was used, so the KnownKeyAdded event should have been raised.");
            IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
            Assert.That(destinationInfo.Exists, "After decryption the destination file should be created.");

            string fileContent;
            using (Stream stream = destinationInfo.OpenRead())
            {
                fileContent = new StreamReader(stream).ReadToEnd();
            }
            Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
        }
Example #18
0
        void PlaceBetThread()
        {
            try
            {
                Parent.updateStatus(string.Format("Betting: {0:0.00000000} at {1:0.00000000} {2}", amount, this.chance, High ? "High" : "Low"));
                HttpWebRequest loginrequest = HttpWebRequest.Create("https://www.999dice.com/api/web.aspx") as HttpWebRequest;
                if (Prox != null)
                    loginrequest.Proxy = Prox;
                string post = string.Format("a=GetServerSeedHash&s={0}", sessionCookie);
                string sEmitResponse = "";
                double chance = (999999.0) * (this.chance / 100.0);
                HttpWebResponse EmitResponse;

                if (next == "" && next!=null)
                {

                    loginrequest = HttpWebRequest.Create("https://www.999dice.com/api/web.aspx") as HttpWebRequest;
                    if (Prox != null)
                        loginrequest.Proxy = Prox;
                    post = string.Format("a=GetServerSeedHash&s={0}", sessionCookie);
                    loginrequest.Method = "POST";

                    loginrequest.ContentLength = post.Length;
                    loginrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";

                    using (var writer = new StreamWriter(loginrequest.GetRequestStream()))
                    {

                        writer.Write(post);
                    }
                    EmitResponse = (HttpWebResponse)loginrequest.GetResponse();
                    sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd();
                    if (sEmitResponse.Contains("error"))
                    {
                        if (BetRetries++ < 3)
                        {

                            Thread.Sleep(200);
                            PlaceBetThread();
                            return;
                        }
                        else
                            throw new Exception();
                    }
                    string Hash = next =  json.JsonDeserialize<d999Hash>(sEmitResponse).Hash;
                }
                loginrequest = HttpWebRequest.Create("https://www.999dice.com/api/web.aspx") as HttpWebRequest;
                if (Prox != null)
                    loginrequest.Proxy = Prox;
                string ClientSeed = r.Next(0, int.MaxValue).ToString();

                post = string.Format("a=PlaceBet&s={0}&PayIn={1}&Low={2}&High={3}&ClientSeed={4}&Currency={5}&ProtocolVersion=2", sessionCookie, (long)Math.Ceiling(amount * 100000000.0), High ? 999999 - (int)chance : 0, High ? 999999 : (int)chance, ClientSeed, Currency);
                loginrequest.Method = "POST";

                loginrequest.ContentLength = post.Length;
                loginrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";

                using (var writer = new StreamWriter(loginrequest.GetRequestStream()))
                {

                    writer.Write(post);
                }
                EmitResponse = (HttpWebResponse)loginrequest.GetResponse();
                 sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd();

                d999Bet tmpBet = json.JsonDeserialize<d999Bet>(sEmitResponse);
                if (amount>=21)
                {

                }
                if (tmpBet.ChanceTooHigh==1 || tmpBet.ChanceTooLow==1| tmpBet.InsufficientFunds == 1|| tmpBet.MaxPayoutExceeded==1|| tmpBet.NoPossibleProfit==1)
                {
                    throw new Exception();
                }
                if (tmpBet.BetId==0)
                {

                }
                balance = (double)tmpBet.StartingBalance / 100000000.0 - (amount) + ((double)tmpBet.PayOut / 100000000.0);

                profit += -(amount ) + (double)(tmpBet.PayOut / 100000000m);
                Bet tmp = new Bet();
                tmp.Amount = (decimal)amount;
                tmp.BetDate = DateTime.Now.ToString(); ;
                tmp.Chance = ((decimal)chance * 100m) / 999999m;
                tmp.clientseed = ClientSeed;
                tmp.Currency = Currency;
                tmp.high = High;
                tmp.Id = tmpBet.BetId;
                tmp.nonce = 0;
                tmp.Profit = ((decimal)tmpBet.PayOut / 100000000m) - ((decimal)amount);
                tmp.Roll = tmpBet.Secret / 10000m;
                tmp.serverhash = next;
                tmp.serverseed = tmpBet.ServerSeed;
                tmp.uid = (int)uid;
                tmp.UserName = "";

                bool win = false;
                if ((tmp.Roll > 99.99m - tmp.Chance && High) || (tmp.Roll < tmp.Chance && !High))
                {
                    win = true;
                }
                if (win)
                    wins++;
                else
                    losses++;
                Wagered += tmp.Amount;
                bets++;
                BetRetries = 0;

                sqlite_helper.InsertSeed(tmp.serverhash, tmp.serverseed);
                next = tmpBet.Next;
                FinishedBet(tmp);

            }
            catch
            {
                System.Windows.Forms.MessageBox.Show("Something went wrong! betting stopped.");
            }
        }
        /// <summary>
        /// Обрабатывает очередь сообщений
        /// </summary>
        private void FlushQueue()
        {
            var notifications = Convert.ToBoolean(ConfigurationManager.AppSettings["Notifications"]);
            if (!notifications)
            {
                return;
            }
            using (var httpRequestScope = Locator.BeginNestedHttpRequestScope())
            {
                // Репозиторий
                var dc = Locator.GetService<LCDataContext>();
                var messages = dc.SMSNotificationMessages.Where(m => m.Sended == false).ToList();

                // Выходим если в очереди пусто
                if (messages.Count == 0)
                {
                    return;
                }

                // Обрабатываем очередь
                Logger.Info(string.Format("Обрабатываем очередь сообщений, в очереди {0} писем", messages.Count));

                // Корневой объект отправки
                var rootObject = new JObject(new JProperty("apikey", new JValue(System.Configuration.ConfigurationManager.AppSettings["SMSAPIKey"])));

                // Массив, содержащий отправляемые сообщения
                var sendArray = new JArray();

                // Формируем запрос на отправку
                foreach (var msg in messages)
                {
                    var number = StringUtils.NormalizePhoneNumber(msg.Recipient);
                    var sendObject = new JObject(
                        new JProperty("id", new JValue(msg.Id)),
                        new JProperty("from", new JValue("Fulgur.ru")),
                        new JProperty("to",new JValue(number)),
                        new JProperty("text",new JValue(msg.Message)));

                    sendArray.Add(sendObject);
                }
                rootObject.Add(new JProperty("send",sendArray));

                // Отправляем
                HttpWebResponse response = null;
                try
                {
                    HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(String.Format("http://smspilot.ru/api2.php?json={0}", HttpUtility.UrlEncode(rootObject.ToString())));
                    response = (HttpWebResponse) webRequest.GetResponse();
                }
                catch (Exception e)
                {
                    Logger.Error(string.Format("Ошибка в ходе обработки очереди СМС: {0}",e.Message));
                    throw;
                }

                // Обрабатываем результат
                bool sendSuccess = false;
                var responseStream = response.GetResponseStream();
                if (responseStream != null)
                {
                    // Анализируем ответ
                    var json = new StreamReader(responseStream).ReadToEnd();
                    if (json.Contains("\"send\""))
                    {
                        sendSuccess = true;
                    }
                }

                // Помечаем письма как отправленные
                if (sendSuccess)
                {
                    foreach (var msg in messages)
                    {
                        msg.Sended = true;
                        msg.DateSended = DateTime.Now;
                    }
                    dc.SubmitChanges();
                }
                Logger.Info(string.Format("Обработка очереди смс сообщений завершена."));
            }
        }
        // upload a file using the web form instead of the API (for old versions of WikiMedia which don't have the upload API)
        private void UploadFileThroughForm(LoginInfo loginInfo, string localFilePath, string remoteFilename)
        {
            UploadFile[] files = new UploadFile[] { new UploadFile(localFilePath, "wpUploadFile", "application/octet-stream") };

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(GetUrl("Special:Upload"));
            request.CookieContainer = loginInfo.Cookies;

            var parameters = new System.Collections.Specialized.NameValueCollection();
            parameters["wpSourceType"] = "file";
            parameters["wpDestFile"] = remoteFilename;
            parameters["wpUpload"] = "Upload file";

            var response = HttpUploadHelper.Upload(request, files, parameters);

            string strResponse = new StreamReader(response.GetResponseStream()).ReadToEnd();
            if (strResponse.Contains("A file with this name exists already"))
                throw new MediaWikiException("Image already exists on the wiki");
        }
        // implemented for a wiki that logs users through another form after a redirection
        private LoginInfo LoginRedirected(Uri uri)
        {
            // These parameter names may be specific. If the need arises, they could be made configurable.
            string postData = string.Format("submit=Login&username={0}&password={1}", Options.Account.Username, Options.Account.Password);

            ASCIIEncoding encoding = new ASCIIEncoding();
            byte[] postBytes = encoding.GetBytes(postData);

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
            request.Method = WebRequestMethods.Http.Post;
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = postBytes.Length;
            var cookieContainer = new CookieContainer();
            request.CookieContainer = cookieContainer;

            Stream postStream = request.GetRequestStream();
            postStream.Write(postBytes, 0, postBytes.Length);
            postStream.Close();

            var response = request.GetResponse();
            string strResponse = new StreamReader(response.GetResponseStream()).ReadToEnd();
            if (strResponse.Contains("Authentication Failed"))
                throw new MediaWikiException("Authentication failed");

            //var cookies = cookieContainer.GetCookies(uri);
            return new LoginInfo() { NeedToken = false, Cookies = cookieContainer };
        }
Example #22
0
        static void tt()
        {
            var lines = plist.Split(new[] { Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 25; i < lines.Length; i++)
            {
                var line = lines[i];
                Console.WriteLine(line);
                var ss = line.Split(':');
                var ip = ss[0];
                var port = int.Parse(ss[1]);

                Exception ex = null;
                var t = new Thread(() =>
                    {
                        try
                        {
                            var p1 = new Socks5(IPAddress.Parse(ip), port);
                            //var p1 = new HttpProxy(IPAddress.Parse("175.182.229.2"), 80);
                            var tcp = p1.CreateConnection(IPAddress.Parse("1111"), 80);
                            var bytes = Encoding.ASCII.GetBytes("GET / HTTP/1.0" + Environment.NewLine + "Host: qwe" + Environment.NewLine + Environment.NewLine);
                            tcp.GetStream().Write(bytes, 0, bytes.Length);
                            var response = new StreamReader(tcp.GetStream()).ReadToEnd();
                            if (response.Contains("508 Loop Detected"))
                                Console.WriteLine("Blacklisted");
                            else
                                Console.WriteLine(response);
                            tcp.Close();
                        }
                        catch (Exception e)
                        {
                            ex = e;
                        }
                    });
                t.Start();
                if (t.Join(10000))
                {
                    if (ex != null)
                        Console.WriteLine("error");
                }
                else
                {
                    t.Abort();
                    Console.WriteLine("timeout");
                }

                Console.WriteLine();
            }

            /*var p1 = new Socks5(IPAddress.Parse("98.191.62.242"), 16902);
            //var p1 = new HttpProxy(IPAddress.Parse("175.182.229.2"), 80);
            var tcp = p1.CreateConnection(IPAddress.Parse("1111"), 80);
            var bytes = Encoding.ASCII.GetBytes("GET / HTTP/1.0" + Environment.NewLine + "Host: qwe" + Environment.NewLine + Environment.NewLine);
            tcp.GetStream().Write(bytes, 0, bytes.Length);
            Console.WriteLine(new StreamReader(tcp.GetStream()).ReadToEnd());
            tcp.Close();*/
        }
Example #23
0
        private static void HandleWebException(WebException ex)
        {
            if (ex.Status == WebExceptionStatus.Timeout) throw new ClientTimeoutException();

            if (ex.Status == WebExceptionStatus.KeepAliveFailure) throw new KeepAliveFailureException();

            if (ex.Status == WebExceptionStatus.ProtocolError && ex.Response != null)
            {
                Stream responseStream = ex.Response.GetResponseStream();
                if (responseStream != null)
                {
                    string message = new StreamReader(responseStream).ReadToEnd();

                    if (message.Contains("quota exceeded"))
                        throw new ClientQuotaExceededException();

                    string symbol;
                    if (IsSymbolNotFound(ex, out symbol))
                        throw new SymbolNotFoundException(symbol);

                    if (message.Contains("Message") && message.Contains("StatusCode"))
                        throw new ClientBadRequestException(message);

                    if (ex.Message.Contains("(401) Unauthorized"))
                        throw new ClientAuthorizationException();

                    throw new ClientGenericProtocolException(message);

                }

            }

            throw ex;
        }
        public static void TestDecryptFileWithRepeatedPassphraseQueries()
        {
            FileOperationsController controller = new FileOperationsController(_fileSystemState);
            int passphraseTry = 0;
            controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                switch (++passphraseTry)
                {
                    case 1:
                        e.Passphrase = "b";
                        break;

                    case 2:
                        e.Passphrase = "d";
                        break;

                    case 3:
                        e.Passphrase = "a";
                        break;

                    case 4:
                        e.Passphrase = "e";
                        break;
                };
            };
            string destinationPath = String.Empty;
            controller.Completed += (object sender, FileOperationEventArgs e) =>
            {
                destinationPath = e.SaveFileFullName;
            };
            bool knownKeyWasAdded = false;
            controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
            {
                knownKeyWasAdded = e.Key == new Passphrase("a").DerivedPassphrase;
            };
            FileOperationStatus status = controller.DecryptFile(_helloWorldAxxPath);

            Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
            Assert.That(knownKeyWasAdded, "A new known key was used, so the KnownKeyAdded event should have been raised.");
            Assert.That(passphraseTry, Is.EqualTo(3), "The third key was the correct one.");
            IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
            Assert.That(destinationInfo.Exists, "After decryption the destination file should be created.");

            string fileContent;
            using (Stream stream = destinationInfo.OpenRead())
            {
                fileContent = new StreamReader(stream).ReadToEnd();
            }
            Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
        }
        private string GetOvalDefinitionsXml(string resourceFolder, string resouceName)
        {
            var resourcePath = String.Format("{0}.{1}", resourceFolder, resouceName);
            try
            {
                var ovalDefinitionsAsStream = new OvalDocumentLoader().GetStreamFrom(resourcePath);
                if (ovalDefinitionsAsStream == null)
                    Assert.Fail("A resource with name '{0}' could not be found.", resourcePath);

                var ovalDefinitionsAsXml = new StreamReader(ovalDefinitionsAsStream).ReadToEnd();
                Assert.IsNotNull(ovalDefinitionsAsXml, "Could not possible to get Oval Definitions Document from stream.");
                Assert.IsTrue(ovalDefinitionsAsXml.Contains("<oval_definitions "), "The document is not an Oval Definitions file. Missing <oval_definitions> begin tag.");
                Assert.IsTrue(ovalDefinitionsAsXml.Contains("</oval_definitions>"), "The document is not an Oval Definitions file. Missing </oval_definitions> closing tag.");

                return ovalDefinitionsAsXml;
            }
            catch (Exception ex)
            {
                Assert.Fail("An error occurred while trying to load resource '{0}': '{1}'.", resourcePath, ex.Message);
                return null;
            }
        }
        public static void TestDecryptWithAlternativeDestinationName()
        {
            IRuntimeFileInfo expectedDestinationInfo = OS.Current.FileInfo(Path.Combine(Path.GetDirectoryName(_helloWorldAxxPath), "HelloWorld-Key-a.txt"));
            using (Stream stream = expectedDestinationInfo.OpenWrite())
            {
            }

            FileOperationsController controller = new FileOperationsController(_fileSystemState);
            controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                e.Passphrase = "a";
            };
            controller.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
            {
                e.SaveFileFullName = Path.Combine(Path.GetDirectoryName(e.SaveFileFullName), "Other Hello World.txt");
            };
            string destinationPath = String.Empty;
            controller.Completed += (object sender, FileOperationEventArgs e) =>
            {
                destinationPath = e.SaveFileFullName;
            };
            FileOperationStatus status = controller.DecryptFile(_helloWorldAxxPath);

            Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");

            IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
            string fileContent;
            using (Stream stream = destinationInfo.OpenRead())
            {
                fileContent = new StreamReader(stream).ReadToEnd();
            }
            Assert.That(fileContent.Contains("Hello"), "A file named 'Other Hello World.txt' should contain that text when decrypted.");
        }
        public static void TestDecryptWithKnownKey()
        {
            FileOperationsController controller = new FileOperationsController(_fileSystemState);
            _fileSystemState.KnownKeys.Add(new Passphrase("b").DerivedPassphrase);
            _fileSystemState.KnownKeys.Add(new Passphrase("c").DerivedPassphrase);
            _fileSystemState.KnownKeys.Add(new Passphrase("a").DerivedPassphrase);
            _fileSystemState.KnownKeys.Add(new Passphrase("e").DerivedPassphrase);
            bool passphraseWasQueried = false;
            controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                passphraseWasQueried = true;
            };
            string destinationPath = String.Empty;
            controller.Completed += (object sender, FileOperationEventArgs e) =>
            {
                destinationPath = e.SaveFileFullName;
            };
            bool knownKeyWasAdded = false;
            controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
            {
                knownKeyWasAdded = true;
            };
            FileOperationStatus status = controller.DecryptFile(_helloWorldAxxPath);

            Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
            Assert.That(!knownKeyWasAdded, "An already known key was used, so the KnownKeyAdded event should not have been raised.");
            Assert.That(!passphraseWasQueried, "An already known key was used, so the there should be no need to query for a passphrase.");
            IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
            Assert.That(destinationInfo.Exists, "After decryption the destination file should be created.");

            string fileContent;
            using (Stream stream = destinationInfo.OpenRead())
            {
                fileContent = new StreamReader(stream).ReadToEnd();
            }
            Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
        }
Example #28
0
		/// <summary>
		/// Begins the async query.
		/// </summary>
		/// <param name="index">The index.</param>
		/// <param name="query">The query.</param>
		/// <param name="includes">The include paths</param>
		public Task<QueryResult> QueryAsync(string index, IndexQuery query, string[] includes)
		{
			EnsureIsNotNullOrEmpty(index, "index");
			var path = query.GetIndexQueryUrl(url, index, "indexes");
			if (includes != null && includes.Length > 0)
			{
				path += "&" + string.Join("&", includes.Select(x => "include=" + x).ToArray());
			}
			var request = jsonRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(this, path, "GET", credentials, convention));

			return request.ReadResponseJsonAsync()
				.ContinueWith(task =>
				{
					RavenJObject json;
					try
					{
						json = (RavenJObject) task.Result;
					}
					catch (AggregateException e)
					{
						var we = e.ExtractSingleInnerException() as WebException;
						if(we != null)
						{
							var httpWebResponse = we.Response as HttpWebResponse;
							if (httpWebResponse != null && httpWebResponse.StatusCode == HttpStatusCode.NotFound)
							{
								var text = new StreamReader(httpWebResponse.GetResponseStreamWithHttpDecompression()).ReadToEnd();
								if (text.Contains("maxQueryString"))
									throw new InvalidOperationException(text, e);
								throw new InvalidOperationException("There is no index named: " + index);
							}
						}
						throw;
					}

					return new QueryResult
					{
						IsStale = Convert.ToBoolean(json["IsStale"].ToString()),
						IndexTimestamp = json.Value<DateTime>("IndexTimestamp"),
						IndexEtag = new Guid(request.ResponseHeaders["ETag"]),
						Results = ((RavenJArray)json["Results"]).Cast<RavenJObject>().ToList(),
						TotalResults = Convert.ToInt32(json["TotalResults"].ToString()),
						IndexName = json.Value<string>("IndexName"),
						SkippedResults = Convert.ToInt32(json["SkippedResults"].ToString())
					};
				});

		}
        public static void TestSimpleDecryptAndLaunchOnThreadWorker()
        {
            FakeLauncher launcher = null;
            FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;
            environment.Launcher = ((string path) =>
            {
                launcher = new FakeLauncher(path);
                return launcher;
            });

            FileOperationsController controller = new FileOperationsController(_fileSystemState);
            controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                e.Passphrase = "a";
            };
            FileOperationStatus status = FileOperationStatus.Unknown;
            controller.Completed += (object sender, FileOperationEventArgs e) =>
            {
                status = e.Status;
            };

            using (ThreadWorker worker = new ThreadWorker(new ProgressContext()))
            {
                controller.DecryptAndLaunch(_helloWorldAxxPath, worker);
                worker.Join();
            }

            Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");

            Assert.That(launcher, Is.Not.Null, "There should be a call to launch.");
            Assert.That(Path.GetFileName(launcher.Path), Is.EqualTo("HelloWorld-Key-a.txt"), "The file should be decrypted and the name should be the original from the encrypted headers.");

            IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(launcher.Path);
            Assert.That(destinationInfo.Exists, "After decryption the destination file should be created.");

            string fileContent;
            using (Stream stream = destinationInfo.OpenRead())
            {
                fileContent = new StreamReader(stream).ReadToEnd();
            }

            Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
        }
        /// <summary>
        ///     Loads from the unofficial online tool
        /// </summary>
        public static void LoadBuildFromPoezone(SkillTree tree, string buildUrl)
        {
            if (!buildUrl.Contains('#')) throw new FormatException();

            const string dataUrl = "http://poezone.ru/skilltree/data.js";
            const string buildPostUrl = "http://poezone.ru/skilltree/";
            string build = buildUrl.Substring(buildUrl.LastIndexOf('#') + 1);

            string dataFile, buildFile;
            {
                var req = (HttpWebRequest) WebRequest.Create(dataUrl);
                req.UserAgent =
                    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534.30 (KHTML, like Gecko) Iron/12.0.750.0 Chrome/12.0.750.0 Safari/534.30";
                WebResponse resp = req.GetResponse();
                dataFile = new StreamReader(resp.GetResponseStream()).ReadToEnd();
            }

            {
                string postData = "build=" + build;
                byte[] postBytes = Encoding.ASCII.GetBytes(postData);
                var req = (HttpWebRequest) WebRequest.Create(buildPostUrl);
                req.Method = "POST";
                req.ContentLength = postBytes.Length;
                req.ContentType = "application/x-www-form-urlencoded";
                req.UserAgent =
                    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534.30 (KHTML, like Gecko) Iron/12.0.750.0 Chrome/12.0.750.0 Safari/534.30";
                req.Accept = "application/json, text/javascript, */*; q=0.01";
                req.Host = "poezone.ru";
                req.Referer = "http://poezone.ru/skilltree/";
                req.AutomaticDecompression = DecompressionMethods.GZip;
                //req.Headers.Add( "Accept", "application/json, text/javascript" );
                req.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.3");
                req.Headers.Add("Accept-Encoding", "gzip,deflate,sdch");
                req.Headers.Add("Accept-Language", "en-US,en;q=0.8");

                //req.Headers.Add( "Connection", "keep-alive" );
                //req.Headers.Add( "Host", "poezone.ru" );
                req.Headers.Add("Origin", "http://poezone.ru");
                //req.Headers.Add( "Referer", "http://poezone.ru/skilltree/" );
                //req.Headers.Add( "User-Agent", );
                req.Headers.Add("X-Requested-With", "XMLHttpRequest");
                req.Expect = "";
                req.Credentials = CredentialCache.DefaultCredentials;

                Stream dataStream = req.GetRequestStream();
                dataStream.Write(postBytes, 0, postBytes.Length);
                dataStream.Close();

                WebResponse resp = req.GetResponse();
                string status = (resp as HttpWebResponse).StatusDescription;
                buildFile = new StreamReader(resp.GetResponseStream()).ReadToEnd();
            }

            if (!buildFile.Contains("["))
            {
                Popup.Error(string.Format(L10n.Message("An error occured while attempting to load Skill tree from {0} location."), "poezone.ru"));
                return;
            }

            // position decompose
            var positions = new List<Vector2D?>();
            string[] lines = dataFile.Split('\n');
            foreach (string line in lines)
                if (line.StartsWith("skillpos="))
                {
                    string posString = line.Substring(line.IndexOf('[') + 1,
                        line.LastIndexOf(']') - line.IndexOf('[') - 1);
                    var sb = new StringBuilder();
                    bool inBracket = false;
                    foreach (char c in posString)
                    {
                        if (!inBracket && c == ',')
                        {
                            positions.Add(sb.Length == 0
                                ? null
                                : new Vector2D?(new Vector2D(
                                    int.Parse(sb.ToString().Split(',')[0]),
                                    int.Parse(sb.ToString().Split(',')[1])
                                    )));
                            sb.Clear();
                        }
                        else
                        {
                            if (c == '[') inBracket = true;
                            else if (c == ']') inBracket = false;
                            else sb.Append(c);
                        }
                    }
                    positions.Add(sb.Length == 0
                        ? null
                        : new Vector2D?(new Vector2D(
                            int.Parse(sb.ToString().Split(',')[0]),
                            int.Parse(sb.ToString().Split(',')[1])
                            )));
                }

            // min max
            double minx = float.MaxValue, miny = float.MaxValue, maxx = float.MinValue, maxy = float.MinValue;
            foreach (var posn in positions)
            {
                if (!posn.HasValue) continue;
                Vector2D pos = posn.Value;
                minx = Math.Min(pos.X, minx);
                miny = Math.Min(pos.Y, miny);
                maxx = Math.Max(pos.X, maxx);
                maxy = Math.Max(pos.Y, maxy);
            }

            double nminx = float.MaxValue, nminy = float.MaxValue, nmaxx = float.MinValue, nmaxy = float.MinValue;
            foreach (SkillNode node in SkillTree.Skillnodes.Values)
            {
                Vector2D pos = node.Position;
                nminx = Math.Min(pos.X, nminx);
                nminy = Math.Min(pos.Y, nminy);
                nmaxx = Math.Max(pos.X, nmaxx);
                nmaxy = Math.Max(pos.Y, nmaxy);
            }

            //respose
            string[] buildResp = buildFile.Replace("[", "").Replace("]", "").Split(',');
            int character = int.Parse(buildResp[0]);
            var skilled = new List<int>();

            tree.Chartype = character;
            tree.SkilledNodes.Clear();
            SkillNode startnode =
                SkillTree.Skillnodes.First(nd => nd.Value.Name == SkillTree.CharName[tree.Chartype].ToUpper()).Value;
            tree.SkilledNodes.Add(startnode.Id);

            for (int i = 1; i < buildResp.Length; ++i)
            {
                if (!positions[int.Parse(buildResp[i])].HasValue) Debugger.Break();

                Vector2D poezonePos = (positions[int.Parse(buildResp[i])].Value - new Vector2D(minx, miny))*
                                      new Vector2D(1/(maxx - minx), 1/(maxy - miny));
                double minDis = 2;
                var minNode = new KeyValuePair<ushort, SkillNode>();
                foreach (var node in SkillTree.Skillnodes)
                {
                    Vector2D nodePos = (node.Value.Position - new Vector2D(nminx, nminy))*
                                       new Vector2D(1/(nmaxx - nminx), 1/(nmaxy - nminy));
                    double dis = (nodePos - poezonePos).Length;
                    if (dis < minDis)
                    {
                        minDis = dis;
                        minNode = node;
                    }
                }

                tree.SkilledNodes.Add(minNode.Key);
            }
            tree.UpdateAvailNodes();

            //string dataFile = 
        }