public string Create(string url)
        {
            try
            {
                // setup web request to tinyurl
                request = (HttpWebRequest)WebRequest.Create(string.Format(TINYURL_ADDRESS_TEMPLATE, url));
                request.Timeout = REQUEST_TIMEOUT;
                request.UserAgent = USER_AGENT;

                // get response
                response = (HttpWebResponse)request.GetResponse();

                // prase response stream to string
                Stream stream = response.GetResponseStream();
                StreamReader reader = new StreamReader(stream, Encoding.GetEncoding(ENCODING_NAME));

                // convert the buffer into string and store in content
                StringBuilder sb = new StringBuilder();
                while (reader.Peek() >= 0)
                {
                    sb.Append(reader.ReadLine());
                }
                return sb.ToString();
            }
            catch (Exception)
            {
                return null;
            }
        }

 public static void Download()
 {
     using (WebClient wcDownload = new WebClient())
     {
         try
         {
             webRequest = (HttpWebRequest)WebRequest.Create(optionDownloadURL);
             webRequest.Credentials = CredentialCache.DefaultCredentials;
             webResponse = (HttpWebResponse)webRequest.GetResponse();
             Int64 fileSize = webResponse.ContentLength;
             strResponse = wcDownload.OpenRead(optionDownloadURL);
             strLocal = new FileStream(optionDownloadPath, FileMode.Create, FileAccess.Write, FileShare.None);
             int bytesSize = 0;
             byte[] downBuffer = new byte[2048];
             downloadForm.Refresh();
             while ((bytesSize = strResponse.Read(downBuffer, 0, downBuffer.Length)) > 0)
             {
                 strLocal.Write(downBuffer, 0, bytesSize);
                 PercentProgress = Convert.ToInt32((strLocal.Length * 100) / fileSize);
                 pBar.Value = PercentProgress;
                 pLabel.Text = "Downloaded " + strLocal.Length + " out of " + fileSize + " (" + PercentProgress + "%)";
                 downloadForm.Refresh();
             }
         }
         catch { }
         finally
         {
             webResponse.Close();
             strResponse.Close();
             strLocal.Close();
             extractAndCleanup();
             downloadForm.Hide();
         }
     }
 }

 private static void DisposeObject(ref HttpWebRequest request, ref HttpWebResponse response,
     ref Stream responseStream, ref StreamReader reader)
 {
     if (request != null)
     {
         request = null;
     }
     if (response != null)
     {
         response.Close();
         response = null;
     }
     if (responseStream != null)
     {
         responseStream.Close();
         responseStream.Dispose();
         responseStream = null;
     }
     if (reader != null)
     {
         reader.Close();
         reader.Dispose();
         reader = null;
     }
 }

        public HttpResponse(HttpWebResponse httpWebResponse)
        {
            CharacterSet = httpWebResponse.CharacterSet;

            ContentEncoding = httpWebResponse.ContentEncoding;
            ContentLength = httpWebResponse.ContentLength;
            ContentType = httpWebResponse.ContentType;

            //Cookies = httpWebResponse.Cookies;
            Headers = httpWebResponse.Headers;

            //IsFromCache = httpWebResponse.IsFromCache;
            //IsMutuallyAuthenticated = httpWebResponse.IsMutuallyAuthenticated;

            //LastModified = httpWebResponse.LastModified;

            Method = httpWebResponse.Method;
            //ProtocolVersion = httpWebResponse.ProtocolVersion;

            //ResponseUri = httpWebResponse.ResponseUri;
            //Server = httpWebResponse.Server;

            HttpStatusCode = (int)httpWebResponse.StatusCode;
            StatusDescription = httpWebResponse.StatusDescription;
        }

 public CouchResponse(HttpWebResponse response)
 {
     responseString = response.GetResponseString();
     statusCode = response.StatusCode;
     statusDescription = response.StatusDescription;
     etag = response.Headers["ETag"];
 }

        public DisneyPostRequest(String url, AuthToken token, String partySize, String mealPeriod, String searchDate)
        {
            String parameters = "grant_type=assertion&assertion_type=public&client_id=WDPRO-MOBILE.CLIENT-PROD&partySize=" + partySize + "&mealPeriod=" + mealPeriod + "&searchDate=" + searchDate;

            IDisneyReservationRequest disneyRequest = this;
            HttpWebRequest request = disneyRequest.setHeadersWithAuthorization(url, token);
            HttpWebResponse response = disneyRequest.makeReservationRequest(request, parameters);
            try
            {
                _response = response;
                String responseMessage = disneyRequest.returnResponse(response);
                ResponseMessage = responseMessage;
                WebHeaderCollection responseHeaders = response.Headers;
                _reservationUrl = responseHeaders.Get("Location");

            }
            catch (NullReferenceException err)
            {
                Console.WriteLine(err.Message);

            }

            DisneyGetRequest reservationRequest = new DisneyGetRequest(_reservationUrl, token);
            ResponseMessage = reservationRequest.ResponseMessage;
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="NetworkDirectWebResponse"/> class.
		/// </summary>
		/// <param name="requestUri">The request URI.</param>
		/// <param name="response">The response.</param>
		internal NetworkDirectWebResponse(Uri requestUri, HttpWebResponse response)
			: base(requestUri, response) {
			Requires.NotNull(requestUri, "requestUri");
			Requires.NotNull(response, "response");
			this.httpWebResponse = response;
			this.responseStream = response.GetResponseStream();
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NetworkDirectWebResponse"/> class.
		/// </summary>
		/// <param name="requestUri">The request URI.</param>
		/// <param name="response">The response.</param>
		internal NetworkDirectWebResponse(Uri requestUri, HttpWebResponse response)
			: base(requestUri, response) {
			Contract.Requires<ArgumentNullException>(requestUri != null);
			Contract.Requires<ArgumentNullException>(response != null);
			this.httpWebResponse = response;
			this.responseStream = response.GetResponseStream();
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="WebResponseEventArgs"/> class
        /// with the specified web response.
        /// </summary>
        /// <param name="response">The HTTP web response.</param>
        /// <exception cref="ArgumentNullException">If <paramref name="response"/> is <c>null</c>.</exception>
        public WebResponseEventArgs(HttpWebResponse response)
        {
            if (response == null)
                throw new ArgumentNullException("response");

            _response = response;
        }

 public static CacheMetaData AddToCache(HttpWebResponse resp, string file)
 {
     string md5 = resp.Headers[HttpResponseHeader.ETag].Split(':')[0].Substring(1);
     CacheMetaData meta = new CacheMetaData(resp.ContentLength, md5.ToByteArray());
     meta.Save(file);
     return meta;
 }

 public virtual string GetContent(HttpWebResponse webResp, Encoding encoding)
 {
     string content = null;
       var countTry = 3;
       var repeat = true;
       while (repeat && countTry > 0)
     try
     {
       var responseStream = webResp.GetResponseStream();
       responseStream.ReadTimeout = 8000;
       using (var sr = new StreamReader(responseStream, encoding))
       {
     content = sr.ReadToEnd();
     repeat = false;
       }
     }
     catch (WebException exWeb)
     {
       countTry--;
       File.AppendAllText("log.txt", exWeb.Message + Environment.NewLine);
       File.AppendAllText("log.txt", "++" + Environment.NewLine);
       File.AppendAllText("log.txt", exWeb.Status.ToString() + Environment.NewLine);
       File.AppendAllText("log.txt", "++" + Environment.NewLine);
       File.AppendAllText("log.txt", "GetContent" + Environment.NewLine);
       File.AppendAllText("log.txt", "------" + Environment.NewLine);
       var webReq = GetHttpWebReq(url);
       webResp = GetHttpWebResp(webReq);
     }
       return content;
 }

 public HttpResponse(HttpWebRequest con)
 {
     this.con = con;
     this.rsp = (HttpWebResponse)con.GetResponse();
     this.stream = rsp.GetResponseStream();
     this.reader = new StreamReader(stream, Encoding.UTF8);
 }

        private PageInfo ExtractFromResponse(HttpWebResponse response)
        {
            var info = new PageInfo();

            using (var responseStream = response.GetResponseStream())
            {
                var htmlDocument = new HtmlDocument();
                htmlDocument.Load(responseStream);
                htmlDocument.OptionFixNestedTags = true;

                var quote = htmlDocument.DocumentNode
                                        .SelectSingleNode("//body")
                                        .SelectNodes("//p").Where(a => a.Attributes.Any(x => x.Name == "class" && x.Value == "qt"))
                                        .SingleOrDefault();

                var title = htmlDocument.DocumentNode
                                        .SelectSingleNode("//title");

                //Quote might not be found, bash.org doesn't have a 404 page
                if (quote == null || title == null)
                {
                    return null;
                }

                //Strip out any HTML that isn't defined in the WhiteList
                SanitizeHtml(quote);

                info.Quote = quote.InnerHtml;
                info.PageURL = response.ResponseUri.AbsoluteUri;
                info.QuoteNumber = title.InnerHtml;
            }

            return info;
        }

        public static void CheckUpdate()
        {
            kIRCVersionChecker.Init();
            Updater = (HttpWebRequest)HttpWebRequest.Create(update_checkerurl);
            Updater_Response = (HttpWebResponse)Updater.GetResponse();

            if (Updater_Response.StatusCode == HttpStatusCode.OK)
            {
                Rocket.Unturned.Logging.Logger.Log("kIRC: Contacting updater...");
                Stream reads = Updater_Response.GetResponseStream();
                byte[] buff = new byte[10];
                reads.Read(buff, 0, 10);
                string ver = Encoding.UTF8.GetString(buff);
                ver = ver.ToLower().Trim(new[] { ' ', '\r', '\n', '\t' }).TrimEnd(new[] { '\0' });

                if (ver == VERSION.ToLower().Trim())
                {
                    Rocket.Unturned.Logging.Logger.Log("kIRC: This plugin is using the latest version!");
                }
                else
                {
                    Rocket.Unturned.Logging.Logger.LogWarning("kIRC Warning: Plugin version mismatch!");
                    Rocket.Unturned.Logging.Logger.LogWarning("Current version: "+VERSION+", Latest version on repository is " + ver + ".");
                }
            }
            else
            {
                Rocket.Unturned.Logging.Logger.LogError("kIRC Error: Failed to contact updater.");
            }
            Updater.Abort();
            Updater = null;
            Updater_Response = null;
            lastchecked = DateTime.Now;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        internal static PagSeguroServiceException CreatePagSeguroServiceException(HttpWebResponse response)
        {
            if (response == null)
                throw new PagSeguroServiceException("response answered with null value");

            if (response.StatusCode == HttpStatusCode.OK)
                throw new ArgumentException("response.StatusCode must be different than HttpStatusCode.OK", "response");

            using (XmlReader reader = XmlReader.Create(response.GetResponseStream()))
            {
                switch (response.StatusCode)
                {
                    case HttpStatusCode.BadRequest:
                        List<ServiceError> errors = new List<ServiceError>();
                        try
                        {
                            ErrorsSerializer.Read(reader, errors);
                        }
                        catch (XmlException e)
                        {
                            return new PagSeguroServiceException(response.StatusCode, e);
                        }

                        return new PagSeguroServiceException(response.StatusCode, errors);

                    default:
                        return new PagSeguroServiceException(response.StatusCode);
                }
            }
        }

 /// <summary>
 /// Extracts the next visibility time from a web response header.
 /// </summary>
 /// <param name="response">The web response.</param>
 /// <returns>The time of next visibility stored in the header of the response.</returns>
 public static DateTime GetNextVisibleTime(HttpWebResponse response)
 {
     return DateTime.Parse(
         response.Headers[Constants.HeaderConstants.NextVisibleTime],
         System.Globalization.DateTimeFormatInfo.InvariantInfo,
         System.Globalization.DateTimeStyles.AdjustToUniversal);
 }

        public override void Handle(HttpWebResponse web_response)
        {
            string str = this.ReadResponse(ref web_response);

            if (!set_nucleus_id(str))
                throw new RequestException<WebAppPage>("Unable to find nucleus id");
        }

        /// <summary>
        /// Parses HTTP response and creates new instance of this class
        /// </summary>
        /// <param name="response">HTTP response</param>
        /// <returns>New instance of this class</returns>
        internal static UploadMappingResults Parse(HttpWebResponse response)
        {
            UploadMappingResults result = Parse<UploadMappingResults>(response);
            if (result.Mappings == null)
                result.Mappings = new Dictionary<string, string>();

            if (result.JsonObj != null)
            {
                // parsing message
                var message = result.JsonObj.Value<string>("message") ?? string.Empty;
                result.Message = message;

                // parsing mappings
                var mappingsJToken = result.JsonObj["mappings"];
                if (mappingsJToken != null)
                {
                    var mappings = mappingsJToken.Children();
                    foreach(var mapping in mappings)
                    {
                        result.Mappings.Add(mapping["folder"].ToString(), mapping["template"].ToString());
                    }
                }

                // parsing single mapping
                var folder = result.JsonObj.Value<string>("folder") ?? string.Empty;
                var template = result.JsonObj.Value<string>("template") ?? string.Empty;
                if (!string.IsNullOrEmpty(folder))
                    result.Mappings.Add(folder, template);

                //parsing NextCursor
                result.NextCursor = result.JsonObj.Value<string>("next_cursor") ?? string.Empty;
            }

            return result;
        }

 public bool GetRequest(string url, string referer)
 {
     bool result = false;
     try
     {
         HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
         httpWebRequest.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US)AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.70 Safari/533.4";
         httpWebRequest.Referer = referer;
         httpWebRequest.Headers.Add("Cache-Control", "max-age=0");
         httpWebRequest.Accept = "application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5";
         httpWebRequest.Headers.Add("Accept-Encoding", "gzip,deflate,sdch");
         httpWebRequest.Headers.Add("Accept-Language", "ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4");
         httpWebRequest.Headers.Add("Accept-Charset", "windows-1251,utf-8;q=0.7,*;q=0.3");
         httpWebRequest.AllowAutoRedirect = this.AutoRedirect;
         httpWebRequest.CookieContainer = this.Cookie;
         this.HttpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
         this.GetCookiesFromResponse();
         result = true;
     }
     catch
     {
         result = false;
         return result;
     }
     return result;
 }

        public string GetContent(HttpWebResponse webResp, Encoding encoding)
        {
            string content = null;
              var countTry = 3;
              var repeat = true;
              while (repeat && countTry > 0 && webResp != null)
            try
            {
              var responseStream = webResp.GetResponseStream();
              responseStream.ReadTimeout = 8000;
              using (var sr = new StreamReader(responseStream, encoding))
              {
            content = sr.ReadToEnd();
            webResp = null;
            if (content.Equals("обновите страницу, пожалуйста"))
              throw new WebException("ParsersChe error: Proxy no Russian");
            repeat = false;
              }
            }
            catch (WebException exWeb)
            {
              countTry--;
              content = null;
              Log(exWeb, "GetContent");
              var webReq = GetHttpWebReqNewProxy(url);
              if (webReq != null)
            webResp = GetHttpWebResp(webReq);
            }

              return content;
        }