internal WebException(string message, string data, Exception innerException, WebExceptionStatus status, WebResponse response, WebExceptionInternalStatus internalStatus) : base(message + ((data != null) ? (": '" + data + "'") : ""), innerException)
 {
     this.m_Status = WebExceptionStatus.UnknownError;
     this.m_Status = status;
     this.m_Response = response;
     this.m_InternalStatus = internalStatus;
 }

 /// <summary>
 /// Represents errors that occur during application execution
 /// </summary>
 /// <param name="message">The message that describes the error</param>
 /// <param name="response">The response from server</param>
 /// <param name="status">The <see cref="System.Net.WebExceptionStatus"/> that triggered this exception.</param>
 /// <param name="request">HTTP request sent by this SDK.</param>
 public ConnectionException(string message, string response, WebExceptionStatus status, HttpWebRequest request)
     : base(message)
 {
     this.Response = response;
     this.WebExceptionStatus = status;
     this.Request = request;
 }

 private void InitOption(HttpStatus status, HttpCause cause)
 {
     this.mStatus = status;
     this.mCause = cause;
     this.mHttpErrorResponse = null;
     this.mWebStatus = WebExceptionStatus.Success;
 }

 internal override IAsyncResult BeginMultipleWrite(BufferOffsetSize[] buffers, AsyncCallback callback, object state)
 {
     IAsyncResult result2;
     if (!this.m_Worker.IsAuthenticated)
     {
         BufferAsyncResult result = new BufferAsyncResult(this, buffers, state, callback);
         if (this.ProcessAuthentication(result))
         {
             return result;
         }
     }
     try
     {
         result2 = this.m_Worker.SecureStream.BeginWrite(buffers, callback, state);
     }
     catch
     {
         if (this.m_Worker.IsCertValidationFailed)
         {
             this.m_ExceptionStatus = WebExceptionStatus.TrustFailure;
         }
         else if (this.m_Worker.LastSecurityStatus != SecurityStatus.OK)
         {
             this.m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure;
         }
         else
         {
             this.m_ExceptionStatus = WebExceptionStatus.SendFailure;
         }
         throw;
     }
     return result2;
 }

        //
        // This version of an Ssl Stream is for internal HttpWebrequest use.
        // This Ssl client owns the underlined socket
        // The TlsStream will own secured read/write and disposal of the passed "networkStream" stream.
        //
        public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext)
               :base(networkStream, true) {

        // WebRequest manages the execution context manually so we have to ensure we get one for SSL client certificate demand
        _ExecutionContext = executionContext;
        if (_ExecutionContext == null)
        {
            _ExecutionContext = ExecutionContext.Capture();
        }

        // 


         GlobalLog.Enter("TlsStream::TlsStream", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "none" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));
         if (Logging.On) Logging.PrintInfo(Logging.Web, this, ".ctor", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));

         m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure;
         m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy);

         m_DestinationHost = destinationHost;
         m_ClientCertificates = clientCertificates;

         RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest);
         m_Worker.SetCertValidationDelegate(certValidationCallback);

         // The Handshake is NOT done at this point
         GlobalLog.Leave("TlsStream::TlsStream (Handshake is not done)");
        }

	public WebException(String msg, Exception inner, 
		WebExceptionStatus status, WebResponse response) 
		: base(msg, inner) 
			{
				myresponse = response;
				mystatus = status;
			}

        static HttpWebException()
        {
#if PORTABLE
            if (!Enum.TryParse("ProtocolError", out ProtocolError))
                ProtocolError = WebExceptionStatus.UnknownError;
#else
            ProtocolError = WebExceptionStatus.ProtocolError;
#endif
        }

		public WebException(string message, 
				    Exception innerException,
		   		    WebExceptionStatus status, 
		   		    WebResponse response)
			: base (message, innerException)
		{
			this.status = status;
			this.response = response;
		}

        public WebException(string message,
                            Exception innerException,
                            WebExceptionStatus status,
                            WebResponse response) :
            base(message, innerException)
        {
            _status = status;
            _response = response;

            if (innerException != null)
            {
                HResult = innerException.HResult;
            }
        }

 internal static string GetWebStatusString(WebExceptionStatus status)
 {
     int index = (int) status;
     if ((index >= s_Mapping.Length) || (index < 0))
     {
         throw new InternalException();
     }
     string str = s_Mapping[index];
     if (str == null)
     {
         str = "net_webstatus_" + status.ToString();
         s_Mapping[index] = str;
     }
     return str;
 }

        /*++

            GetWebStatusString - Get a WebExceptionStatus-specific resource string


            This method takes an input string and a WebExceptionStatus. We use the input
            string as a key to find a status message and the webStatus to produce
            a status-specific message, then we combine the two.

            Input:

                Res             - Id for resource string.
                Status          - The WebExceptionStatus to be formatted.

            Returns:

                string for localized message.

        --*/
        public static string GetWebStatusString(string Res, WebExceptionStatus Status) {
            string Msg;
            string StatusMsg;

            StatusMsg = SR.GetString(WebExceptionMapping.GetWebStatusString(Status));

            // Get the base status.

            Msg = SR.GetString(Res);

            // Format the status specific message into the base status and return
            // that

            return String.Format(CultureInfo.CurrentCulture, Msg, StatusMsg);
        }

 protected internal virtual void FailRequest(WebExceptionStatus webStatus)
 {
     if (Logging.On)
     {
         Logging.PrintError(Logging.RequestCache, SR.GetString("net_log_cache_failing_request_with_exception", new object[] { webStatus.ToString() }));
     }
     if (webStatus == WebExceptionStatus.CacheEntryNotFound)
     {
         throw ExceptionHelper.CacheEntryNotFoundException;
     }
     if (webStatus == WebExceptionStatus.RequestProhibitedByCachePolicy)
     {
         throw ExceptionHelper.RequestProhibitedByCachePolicyException;
     }
     throw new WebException(NetRes.GetWebStatusString("net_requestaborted", webStatus), webStatus);
 }

 public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext) : base(networkStream, true)
 {
     this.m_PendingIO = new ArrayList();
     this._ExecutionContext = executionContext;
     if (this._ExecutionContext == null)
     {
         this._ExecutionContext = ExecutionContext.Capture();
     }
     if (Logging.On)
     {
         Logging.PrintInfo(Logging.Web, this, ".ctor", "host=" + destinationHost + ", #certs=" + ((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));
     }
     this.m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure;
     this.m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy);
     this.m_DestinationHost = destinationHost;
     this.m_ClientCertificates = clientCertificates;
     RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest);
     this.m_Worker.SetCertValidationDelegate(certValidationCallback);
 }

        public static string Send(string request)
        {
            try
            {

                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(request);

                req.ReadWriteTimeout = 9000;
                req.Timeout = 10000;

                HttpWebResponse response = (HttpWebResponse)req.GetResponse();
                status = KannelReqCode.SuccessfullyAccepted;
                // Get the stream associated with the response.
                Stream receiveStream = response.GetResponseStream();

                // Pipes the stream to a higher level stream reader with the required encoding format.
                StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);

                string answer = readStream.ReadLine();
                //MessageBox.Show(response.StatusCode.ToString() + "\n" + readStream.ReadLine(), "SMS Sender", MessageBoxButtons.OK, MessageBoxIcon.Information);

                response.Close();
                readStream.Close();
                return answer;
            }
            catch (WebException ex)
            {
                if (ex.Status == WebExceptionStatus.Timeout)
                    status = KannelReqCode.OperationTimeout;
                else
                    status = KannelReqCode.UnknownError;
                wes = ex.Status;
                return ex.Message;
            }
            catch(Exception ex)
            {
                wes = WebExceptionStatus.SendFailure;
                status = KannelReqCode.UnknownError;
                return ex.Message;
            }
        }

 private static RollbarResponseCode ToRollbarStatus(WebExceptionStatus status) {
     switch ((int) status) {
         case 200:
             return RollbarResponseCode.Success;
         case 400:
             return RollbarResponseCode.BadRequest;
         case 401:
             return RollbarResponseCode.Unauthorized;
         case 403:
             return RollbarResponseCode.AccessDenied;
         case 413:
             return RollbarResponseCode.RequestTooLarge;
         case 422:
             return RollbarResponseCode.UnprocessablePayload;
         case 429:
             return RollbarResponseCode.TooManyRequests;
         case 500:
             return RollbarResponseCode.InternalServerError;
         default:
             throw new ArgumentException("Invalid Status returned from Rollbar", "status");
     }
 }

        internal RESTResponse(HttpWebResponse response, long elapsedTime = 0, string error = null, WebExceptionStatus errorStatus = WebExceptionStatus.Success)
        {
            if (!object.ReferenceEquals(response, null))
            {
                this.Content = this.GetContent(response);
                this.ContentEncoding = response.ContentEncoding;
                this.ContentLength = response.ContentLength;
                this.ContentType = response.ContentType;
                this.Cookies = response.Cookies;
                this.Headers = response.Headers;
                this.ResponseStatus = response.StatusCode.ToString();
                this.ResponseUri = response.ResponseUri;
                this.ReturnedError = (this.ErrorStatus.Equals(WebExceptionStatus.Success)) ? false : true;
                this.Server = response.Server;
                this.StatusCode = response.StatusCode;
                this.StatusDescription = response.StatusDescription;
            }

            this.ElapsedTime = elapsedTime;
            this.Error = error;
            this.ErrorStatus = errorStatus;
        }

        /*++

            GetWebStatusString - Get a WebExceptionStatus-specific resource string


            This method takes an input string and a WebExceptionStatus. We use the input
            string as a key to find a status message and the webStatus to produce
            a status-specific message, then we combine the two.

            Input:

                Res             - Id for resource string.
                Status          - The WebExceptionStatus to be formatted.

            Returns:

                string for localized message.

        --*/
        public static string GetWebStatusString(string Res, WebExceptionStatus Status) {
            string Msg;
            string StatusEnumName;
            string StatusMsg;

            // First, convert the WebExceptionStatus to its label.

            StatusEnumName = ((Enum)Status).ToString();

            // Now combine the label with the base enum key and look up the
            // status msg.

            StatusMsg = SR.GetString("net_webstatus_" + StatusEnumName);

            // Get the base status.

            Msg = SR.GetString(Res);

            // Format the status specific message into the base status and return
            // that

            return String.Format(Msg, StatusMsg);
        }

 public WebException(string message, WebExceptionStatus status)
     : base(message)
 {
     this.status = status;
 }

		internal Stream CreateStream (byte[] buffer)
		{
			sslStream = provider.CreateSslStream (networkStream, false, settings);

			try {
				sslStream.AuthenticateAsClient (
					request.Address.Host, request.ClientCertificates,
					(SslProtocols)ServicePointManager.SecurityProtocol,
					ServicePointManager.CheckCertificateRevocationList);

				status = WebExceptionStatus.Success;
			} catch (Exception ex) {
				status = WebExceptionStatus.SecureChannelFailure;
				throw;
			} finally {
				if (CertificateValidationFailed)
					status = WebExceptionStatus.TrustFailure;

				if (status == WebExceptionStatus.Success)
					request.ServicePoint.UpdateClientCertificate (sslStream.InternalLocalCertificate);
				else {
					request.ServicePoint.UpdateClientCertificate (null);
					sslStream = null;
				}
			}

			try {
				if (buffer != null)
					sslStream.Write (buffer, 0, buffer.Length);
			} catch {
				status = WebExceptionStatus.SendFailure;
				sslStream = null;
				throw;
			}

			return sslStream.AuthenticatedStream;
		}

		public MonoTlsStream (HttpWebRequest request, NetworkStream networkStream)
		{
			this.request = request;
			this.networkStream = networkStream;

			settings = request.TlsSettings;
			provider = request.TlsProvider ?? MonoTlsProviderFactory.GetProviderInternal ();
			status = WebExceptionStatus.SecureChannelFailure;

			validationHelper = ChainValidationHelper.Create (provider.Provider, ref settings, this);
		}