public void RemoveConnection(HttpConnection connection)
 {
     lock (this._requests)
     {
         this._requests.Remove(connection);
     }
 }
		internal HttpListenerContext (HttpConnection cnc)
		{
			this.cnc   = cnc;
			err_status = 400;
			request    = new HttpListenerRequest (this);
			response   = new HttpListenerResponse (this);
		}
Exemple #3
0
 IObservable<HttpConnection> GetConnection(Uri uri)
 {
     if(m_connection!= null 
         && m_connection.Uri.Host==uri.Host 
         && m_connection.Uri.Port==uri.Port
         && m_connection.IsConnected
         )
     {
         return Observable.Return(m_connection)
             .Do(x =>
             {
                 Console.WriteLine("<KeepAlive>");
             })
             ;
     }
     else
     {
         return HttpConnection.Create(uri).Connect()
             .Do(x => {
                 m_connection = x;
                 Console.WriteLine(x);
             })
             ;
     }
 }
Exemple #4
0
        public void Setup()
        {
            requestedUrl.Clear();
            partialData = false;
            int i;
            for (i = 0; i < 1000; i++)
            {
                try
                {
                    listener = new HttpListener();
                    listener.Prefixes.Add(string.Format(listenerURL, i));
                    listener.Start();
                    break;
                }
                catch
                {

                }
            }
            listener.BeginGetContext(GotContext, null);
            rig = TestRig.CreateMultiFile();
            connection = new HttpConnection(new Uri(string.Format(listenerURL, i)));
            connection.Manager = rig.Manager;

            id = new PeerId(new Peer("this is my id", connection.Uri), rig.Manager);
            id.Connection = connection;
            id.IsChoking = false;
            id.AmInterested = true;
            id.BitField.SetAll(true);
            id.MaxPendingRequests = numberOfPieces;
            
            requests = rig.Manager.PieceManager.Picker.PickPiece(id, new List<PeerId>(), numberOfPieces);
        }
 internal HttpListenerContext(HttpConnection cnc, ILogger logger)
 {
     this.cnc = cnc;
     _logger = logger;
     request = new HttpListenerRequest(this);
     response = new HttpListenerResponse(this, _logger);
 }
 public void SendMessageSendsAndReceivesAMessage()
 {
     var action = "DoSomething";
     var request = new ServerRequest
     {
         ServerName = "TestServer"
     };
     var url = "http://somewhere/";
     var factory = new TestClientFactory((u, a, d) =>
     {
         Assert.AreEqual(url + "server/TestServer/RawXmlMessage.aspx", u.AbsoluteUri);
         Assert.AreEqual("POST", a);
         Assert.AreEqual(action, d["action"]);
         Assert.AreEqual(request.ToString(), d["message"]);
         var theResponse = new Response
         {
             RequestIdentifier = request.Identifier
         };
         return Encoding.UTF8.GetBytes(theResponse.ToString());
     });
     var connection = new HttpConnection(new Uri(url), factory);
     var response = connection.SendMessage(action, request);
     Assert.IsInstanceOf<Response>(response);
     Assert.AreEqual(request.Identifier, response.RequestIdentifier);
 }
Exemple #7
0
        protected ApiClient(ApiKeyConnection connection)
        {
            Ensure.ArgumentNotNull(connection, nameof(connection));

            ApiKeyConnection = connection;
            HttpConnection = new HttpConnection(ApiKeyConnection);
        }
 public void ExecuteTest()
 {
     HttpConnection target = new HttpConnection();
     HttpWebRequest httpRequest = GetHttpWebRequest();
     string actual = target.Execute(payLoad, httpRequest);
     Assert.IsNotNull(actual);
 }
Exemple #9
0
 void Close()
 {
     if(m_connection!=null && m_connection.IsConnected)
     {
         (m_connection as IDisposable).Dispose();
         m_connection = null;
     }
 }
Exemple #10
0
        public Client(HttpConnection connection)
        {
            _nodeName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_NODE_NAME") ?? "undefined node";
            _serviceName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_SERVICE_NAME") ?? "undefined service";
            _datacenterName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_DATACENTER_NAME") ?? "dc1";

            _catalog = new Catalog(connection);
        }
//		private bool _headersSent;

		/// <summary>
		/// Initializes a new instance of the AspWorkerRequest class
		/// </summary>
		/// <param name="connection"></param>
		/// <param name="request"></param>
		public AspWorkerRequest(AspHost aspHost, HttpConnection connection, HttpRequest request) : base(string.Empty, string.Empty, null)
		{						
			_aspHost = aspHost;
			_connection = connection;
			_request = request;
			_response = new HttpResponse(new OkStatus());

			this.ParsePathInfo();
		}
 public void Dispose()
 {
     lock (this)
     {
         if (_httpConnection != null)
         {
             _httpConnection.Dispose();
             _httpConnection = null;
         }
     }
 }
		/// <summary>
		/// Initializes a new instance of the AddressBookItemConnectionManager class
		/// </summary>
		/// <param name="item">The address book item that defines the remote host to connect to</param>
		/// <param name="connection">The Tcp connection that will be used throughout the lifetime of the connection</param>
		public AddressBookItemConnectionManager(AddressBookItem item, HttpConnection connection)
		{
			if (item == null)
				throw new ArgumentNullException("item");

			if (connection == null)
				throw new ArgumentNullException("connection");

			_propertyBag = new Hashtable();
			_item = item;
			_connection = connection;
			_connection.Opened += new HttpConnectionEventHandler(OnInternalConnectionOpened);
			_connection.Closed += new HttpConnectionEventHandler(OnInternalConnectionClosed);
			_connection.Exception += new ExceptionEventHandler(OnInternalConnectionException);
		}      
        public NanoHttpRequest(HttpConnection conn, string request)
        {
            Connection = conn;
            if (string.IsNullOrEmpty(request))
            {
                Invalid = true;
                return;
            }

            var fls = request.Split(new char[]{ ' ' }, 3);

            if (fls.Length < 2)
            {
                Invalid = true;
                return;
            }

            Method = fls[0];
            Address = fls[1];

            //if (Method == "POST")
            {
                var heco = request.Split(new string[]{ "\r\n\r\n" }, 2, StringSplitOptions.None);

                if (heco.Length < 2)
                {
                    Invalid = true;
                    return;
                }

                var he = heco[0];
                var co = heco[1];
                Content = co;
                var lines = he.Split(new string[]{ "\r\n", "\n" }, StringSplitOptions.None);

                for (int i = 1; i < lines.Length; i++)
                {
                    var hl = lines[i].Split(new String[]{": "}, 2, StringSplitOptions.None);
                    if (hl.Length < 2) continue;
                    Headers[hl[0]] = hl[1];
                }
            }
        }
Exemple #15
0
        public void RequestTimeout(HttpConnection connection)
        {
            var param = connection.Param;
            int msgId = param.Get("MsgId").ToInt();
            int actionId = param.Get("ActionId").ToInt();
            int errorCode = LanguageHelper.GetLang().ErrorCode;
            string errorMsg = LanguageHelper.GetLang().RequestTimeout;
            var head = new MessageHead(msgId, actionId, "st", errorCode, errorMsg);
            head.HasGzip = true;
            var ms = new MessageStructure();
            ms.WriteBuffer(head);
            byte[] data = ms.ReadBuffer();

            string remoteAddress = connection.Context.Request.RemoteEndPoint.Address.ToString();
            string successMsg = string.Format("{0}>>发送超时到{1} {2}字节!",
                                              DateTime.Now.ToString("HH:mm:ss:ms"), remoteAddress, data.Length);
            Console.WriteLine(successMsg);
            OnResponseCompleted(connection, data);
        }
Exemple #16
0
        private void Process(HttpConnection connection, NanoHttpRequest request)
        {
            if (request.Address == "/")
            {
                connection.Response(_root.Handle(request));
                return;
            }

            var endpoint = request.Address.Split(new char[]{'/'}, StringSplitOptions.RemoveEmptyEntries)[0];

            if (_handlers.ContainsKey(endpoint))
            {
                connection.Response(_handlers[endpoint].Handle(request));
            }

            else
            {
                connection.Response(new ErrorHandler(StatusCode.BadRequest, "Unknown endpoint: " + endpoint).Handle(request));
            }
        }
Exemple #17
0
        protected override void Run()
        {
            this._listener.Start();
            while (true)
            {
                try
                {
                    TcpClient client = this._listener.AcceptTcpClient();
                    HttpConnection connection = new HttpConnection(this, client);
                    lock (this._requests)
                    {
                        this._requests.Add(connection);
                    }
                    connection.Start();

                }
                catch {
                
                }
            }
            
        }
Exemple #18
0
        public virtual void OnAccept( IAsyncResult ar )
        {
            try
            {
                Socket newSocket = listenSocket.EndAccept( ar );

                if ( newSocket != null )
                {
                    HttpConnection newClient = new HttpConnection( newSocket, new RemoveClientDelegate( this.RemoveClient ) );
                    clients.Add( newClient );
                    newClient.Start();
                }
            }
            catch {}
            try
            {
                listenSocket.BeginAccept( new AsyncCallback( this.OnAccept ), listenSocket );
            }
            catch
            {
                Dispose();
            }
        }
        internal HttpRequest(IPEndPoint client, string method, string path, string protocol, string version, NameValueCollection headers, byte[] postData, HttpConnection connection)
        {
            m_connection = connection;

            Client = client;
            Method = method;

            var pathDelim = path.IndexOf('?');
            if (pathDelim == -1)
            {
                Path = HttpUtility.UrlDecode(path);
                QueryString = new NameValueCollection();
            }
            else
            {
                Path = HttpUtility.UrlDecode(path.Substring(0, pathDelim));
                QueryString = HttpUtility.ParseQueryString(path.Substring(pathDelim + 1));
            }

            Protocol = protocol;
            Version = version;
            Headers = headers;
            PostData = postData;
        }
Exemple #20
0
        public void Request(HttpConnection connection, string clientAddress, byte[] data)
        {
            string paramString = string.Empty;
            try
            {
                paramString = Encoding.ASCII.GetString(data);
                PacketMessage packet = ParsePacketMessage(clientAddress, paramString, ConnectType.Http);
                packet.Head.SSID = connection.SSID.ToString("N");
                HttpConnectionManager.Push(connection);

                if (ReceiveCompleted != null)
                {
                    //分发送到游戏服
                    byte[] packData = packet.ToByte();
                    string successMsg = string.Format("{0}>>{1}接收到{2}字节!",
                        DateTime.Now.ToString("HH:mm:ss:ms"), clientAddress, data.Length);
                    ReceiveCompleted.BeginInvoke(clientAddress, packData, OnReceiveCompleted, successMsg);
                }
            }
            catch (Exception ex)
            {
                TraceLog.WriteError("Receive form http request:{0} error:{1}", paramString, ex);
            }
        }
Exemple #21
0
        public async Task ConnectionCanSendAndReceiveMessages(TransportType transportType, TransferMode requestedTransferMode)
        {
            using (StartLog(out var loggerFactory, testName: $"ConnectionCanSendAndReceiveMessages_{transportType.ToString()}"))
            {
                var logger = loggerFactory.CreateLogger <EndToEndTests>();

                const string message = "Major Key";

                var url        = _serverFixture.Url + "/echo";
                var connection = new HttpConnection(new Uri(url), transportType, loggerFactory);

                connection.Features.Set <ITransferModeFeature>(
                    new TransferModeFeature {
                    TransferMode = requestedTransferMode
                });
                try
                {
                    var receiveTcs = new TaskCompletionSource <string>();
                    connection.OnReceived((data, state) =>
                    {
                        logger.LogInformation("Received {length} byte message", data.Length);

                        if (IsBase64Encoded(requestedTransferMode, connection))
                        {
                            data = Convert.FromBase64String(Encoding.UTF8.GetString(data));
                        }
                        var tcs = (TaskCompletionSource <string>)state;
                        tcs.TrySetResult(Encoding.UTF8.GetString(data));
                        return(Task.CompletedTask);
                    }, receiveTcs);

                    logger.LogInformation("Starting connection to {url}", url);
                    await connection.StartAsync().OrTimeout();

                    logger.LogInformation("Started connection to {url}", url);

                    var bytes = Encoding.UTF8.GetBytes(message);

                    // Need to encode binary payloads sent over text transports
                    if (IsBase64Encoded(requestedTransferMode, connection))
                    {
                        bytes = Encoding.UTF8.GetBytes(Convert.ToBase64String(bytes));
                    }

                    logger.LogInformation("Sending {length} byte message", bytes.Length);
                    try
                    {
                        await connection.SendAsync(bytes).OrTimeout();
                    }
                    catch (OperationCanceledException)
                    {
                        // Because the server and client are run in the same process there is a race where websocket.SendAsync
                        // can send a message but before returning be suspended allowing the server to run the EchoEndpoint and
                        // send a close frame which triggers a cancellation token on the client and cancels the websocket.SendAsync.
                        // Our solution to this is to just catch OperationCanceledException from the sent message if the race happens
                        // because we know the send went through, and its safe to check the response.
                    }
                    logger.LogInformation("Sent message", bytes.Length);

                    logger.LogInformation("Receiving message");
                    Assert.Equal(message, await receiveTcs.Task.OrTimeout());
                    logger.LogInformation("Completed receive");
                    await connection.Closed.OrTimeout();
                }
                catch (Exception ex)
                {
                    logger.LogInformation(ex, "Test threw exception");
                    throw;
                }
                finally
                {
                    logger.LogInformation("Disposing Connection");
                    await connection.DisposeAsync().OrTimeout();

                    logger.LogInformation("Disposed Connection");
                }
            }
        }
Exemple #22
0
 public ChunkedEncodingWriteStream(HttpConnection connection)
     : base(connection)
 {
 }
        private string GenerateOAuthToken(string base64ClientID)
        {
            string response = null;

                Uri uniformResourceIdentifier = null;
                Uri baseUri = null;
                if (config.ContainsKey(BaseConstants.OAUTH_ENDPOINT))
                {
                    baseUri = new Uri(config[BaseConstants.OAUTH_ENDPOINT]);
                }
                else if (config.ContainsKey(BaseConstants.END_POINT_CONFIG))
                {
                    baseUri = new Uri(config[BaseConstants.END_POINT_CONFIG]);
                }
                bool success = Uri.TryCreate(baseUri, OAUTHTOKENPATH, out uniformResourceIdentifier);
                ConnectionManager connManager = ConnectionManager.Instance;
                HttpWebRequest httpRequest = connManager.GetConnection(ConfigManager.Instance.GetProperties(), uniformResourceIdentifier.AbsoluteUri);

                Dictionary<string, string> headers = new Dictionary<string, string>();
                headers.Add("Authorization", "Basic " + base64ClientID);
                string postRequest = "grant_type=client_credentials";
                httpRequest.Method = "POST";
                httpRequest.Accept = "*/*";
                httpRequest.UserAgent = RESTConfiguration.FormUserAgentHeader();
                foreach (KeyValuePair<string, string> header in headers)
                {
                    httpRequest.Headers.Add(header.Key, header.Value);
                }

                HttpConnection httpConnection = new HttpConnection(config);
                response = httpConnection.Execute(postRequest, httpRequest);
                JObject deserializedObject = (JObject)JsonConvert.DeserializeObject(response);
                string generatedToken = (string)deserializedObject["token_type"] + " " + (string)deserializedObject["access_token"];
                appID = (string)deserializedObject["app_id"];
                secondsToExpire = (int)deserializedObject["expires_in"];
                timeInMilliseconds = DateTime.Now.Millisecond;
                return generatedToken;
        }
 private void _RequestLineRecieved(string[] words)
 {
     _idleTimer.Dispose();
     _idleTimer = new Timer(new TimerCallback(_IdleTimeout), null, _CONNECTION_IDLE_TIMEOUT, Timeout.Infinite);
     _currentConnection = this;
     if (words[0].ToUpper() != "HTTP"&&!_shutdown)
     {
         HttpRequest req = Requests.Dequeue();
         lock (_requests)
         {
             req.StartRequest(_rand.NextLong(), words, this, ref _parser);
             _requests.Add(req);
         }
     }
 }
Exemple #25
0
 public HttpContentWriteStream(HttpConnection connection)
 {
     Debug.Assert(connection != null);
     _connection = connection;
 }
Exemple #26
0
 public async Task <AnalyticsListResponse <EventAnalytic> > GetEventAnalyticsListAsync()
 {
     return(await HttpConnection.GetAsync <AnalyticsListResponse <EventAnalytic> >("/analytics/events/list"));
 }
 public AccessTokenHttpMessageHandler(HttpMessageHandler inner, HttpConnection httpConnection) : base(inner)
 {
     _httpConnection = httpConnection;
 }
Exemple #28
0
        private HttpResponse Navigate(HttpRequest request, HttpBehavior httpBehavior)
        {
            bool         ContinueRedirect = true;
            HttpResponse response         = null;

            HttpConnectionFactory connFactory = new HttpConnectionFactory();
            HttpConnection        connection  = connFactory.GetConnnection(request.Uri, this.m_proxy);

            HttpBehavior.RedirectStep rs = null;
            string redirectUri           = null;
            int    responseCode          = 0;
            int    redirectCounter       = 0;

            try
            {
                while (ContinueRedirect)
                {
                    try
                    {
                        response     = SendRequestAndGetResponse(connection, request);
                        redirectUri  = response.Location;
                        responseCode = response.ResponseCode;

                        // response code 100 means that we need to wait for another response
                        // and receive the response from the socket again on the same connection
                        if (responseCode == 100)
                        {
                            response     = GetResponse(connection);
                            redirectUri  = response.Location;
                            responseCode = response.ResponseCode;
                        }

                        if (httpBehavior != null)
                        {
                            rs = httpBehavior.GetNextStep();
                            rs.Compare(responseCode, redirectUri);
                            ContinueRedirect = !httpBehavior.IsEmpty();
                        }
                        else
                        {
                            ContinueRedirect = (redirectCounter < this.m_maxRedirects && (responseCode == 301 || responseCode == 302));
                            redirectCounter++;
                        }

                        if (ContinueRedirect)
                        {
                            request = new HttpGet(new Uri(redirectUri));
                            // make sure the connection is still open and redirect url is from the same host
                            connection = connFactory.GetConnnection(request.Uri, this.m_proxy, connection);
                        }
                    }
                    catch (Exception ex)
                    {
                        int i = 0;
                        throw ex;
                    }
                }
            }
            finally
            {
                connection.Close();
            }
            return(response);
        }
		/// <summary>
		/// Runs the background thread that listens for incoming connections
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnThreadRun(object sender, BackgroundThreadStartEventArgs e)
		{
			try
			{
				IPEndPoint ep = (IPEndPoint)e.Args[0];
            
				Debug.Assert(ep != null);
				Trace.WriteLineIf(_verbose, string.Format("Binding to the end point '{0}'.", ep.ToString()), TraceCategory);
                  
				_listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
				_listeningSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
				_listeningSocket.Bind(ep);
            
				Trace.WriteLineIf(_verbose, string.Format("Listening for inbound connections on '{0}'.", ep.ToString()), TraceCategory);

				while(true)
				{           
					_listeningSocket.Listen(100); // pending connections queue length

					// accept the connection
					Socket socket = _listeningSocket.Accept();
      
					Trace.WriteLineIf(_verbose, string.Format("Accepted an inbound connection from '{0}'.", socket.RemoteEndPoint.ToString()), TraceCategory);

					// create a new connection for the connection
					HttpConnection connection = new HttpConnection(socket, _verbose);
					connection.RequestDispatcher = _dispatcher;
					connection.Exception += new EventHandler<ExceptionEventArgs>(this.OnConnectionException);
					connection.Opened += new EventHandler<HttpConnectionEventArgs>(this.OnConnectionOpened);
                    connection.Closed += new EventHandler<HttpConnectionEventArgs>(this.OnConnectionClosed); 
					connection.IsServerSideConnection = true;
					connection.BeginSession(true);                                       
				}  
			}
			catch(ThreadAbortException)
			{
			}
			catch(Exception ex)
			{
				this.OnException(this, new ExceptionEventArgs(ex));
			}
		}
Exemple #30
0
 public ChunkedEncodingReadStream(HttpConnection connection)
     : base(connection)
 {
     _chunkBytesRemaining = 0;
 }
        public void IsBusyReturnsFalseWhenNothingIsHappening()
        {
            var connection = new HttpConnection("http://somewhere");

            Assert.IsFalse(connection.IsBusy);
        }
Exemple #32
0
        internal static WsStream CreateServerStream(HttpListenerContext context)
        {
            HttpConnection connection = context.Connection;

            return(new WsStream(connection.Stream, connection.IsSecure));
        }
Exemple #33
0
 public ContentLengthWriteStream(HttpConnection connection)
     : base(connection)
 {
 }
        public void TestConnectionInitialize()
        {
            var connection = new HttpConnection(ElasticUrl);

            Assert.IsNotNull(connection);
        }
		/// <summary>
		/// Connects to the server specified by the endpoint, sends the request and waits for a response.
		/// </summary>
		/// <param name="ep">The address:port of the server</param>
		/// <param name="request">The request to send</param>
		/// <param name="exception">Any exception that is throw or encountered during the request/response session with the server</param>
		/// <param name="verbose">A flag that indicates the connection's verbosity level, true for more messages</param>
		/// <returns></returns>
		public static HttpResponse GetResponse(
			IPEndPoint ep,
			HttpRequest request, 
			out Exception exception, 
			bool verbose,
			EventHandler<HttpMessageProgressEventArgs> onSendProgress,
			EventHandler<HttpMessageProgressEventArgs> onRecvProgress,
			object stateObject)
		{
			#region Params Validation

			if (ep == null)
				throw new ArgumentNullException("ep");

			if (request == null)
				throw new ArgumentNullException("request");

			exception = null;

			#endregion

			// define a connection for this request/response session
			HttpConnection connection = null;

			try
			{
				// create a connection to the remote end point
				connection = new HttpConnection(ep, false, verbose, HttpOptions.SendTimeout, HttpOptions.RecvTimeout);
				
				// return a response from the server
				return HttpRequest.GetResponse(connection, request, out exception, onSendProgress, onRecvProgress, stateObject);
			}
            catch (ThreadAbortException)
            {
                
            }
			catch(Exception ex)
			{
                //Debug.WriteLine(ex);
				exception = ex;
			}
			finally
			{
				// always try and close the connect up afterwards
				if (connection != null)
					connection.Close();
			}
			return null;
		}
Exemple #36
0
 private void WalkCallback(HttpConnection connection)
 {
     connection.Tick(_now);
 }
 internal void RemoveConnection (HttpConnection connection)
 {
   lock (_unregisteredSync)
     _unregistered.Remove (connection);
 }
        private void OnReceive(IAsyncResult ar)
        {
            _currentConnection = this;
            if (_idleTimer != null)
            {
                try
                {
                    _idleTimer.Change(_CONNECTION_IDLE_TIMEOUT, Timeout.Infinite);
                }
                catch (Exception e) { }
            }
            // been closed by our side.
            if (_inputStream == null)
                return;
            try
            {
                int bytesLeft = _inputStream.EndRead(ar);
                if (bytesLeft == 0)
                {
                    Logger.Trace("Client disconnected.");
                    if (_requests.Count > 0)
                    {
                        throw new ParserException("Failed to send complete request");
                    }
                    else
                    {
                        Close();
                        return;
                    }
                }

                Logger.Debug(Client.ToString() + " received " + bytesLeft + " bytes.");

                if (bytesLeft < 5000)
                {
                    string temp = Encoding.Default.GetString(_buffer, 0, bytesLeft);
                    Logger.Trace(temp);
                }

                int offset = _parser.Parse(_buffer,0,bytesLeft);
                bytesLeft -= offset;

                if (bytesLeft > 0)
                {
                    Logger.Trace("Moving " + bytesLeft + " from " + offset + " to beginning of array.");
                    Buffer.BlockCopy(_buffer, offset, _buffer, 0, bytesLeft);
                }
                try
                {
                    _inputStream.BeginRead(_buffer, 0, _buffer.Length - offset, OnReceive, null);
                }
                catch (Exception e)
                {
                    Close();
                }
            }
            catch (ParserException err)
            {
                Logger.Trace(err.ToString());
                SendBuffer(Encoding.Default.GetBytes("HTTP/1.0 " + ((int)HttpStatusCode.BadRequest).ToString() + " " + err.Message),false);
                Close();
            }
            catch (Exception err)
            {
                if (!(err is IOException))
                {
                    Logger.Error("Failed to read from stream: " + err);
                    SendBuffer(Encoding.Default.GetBytes("HTTP/1.0 " + ((int)HttpStatusCode.InternalServerError).ToString() + " " + err.Message),false);
                }
                Close();
            }
        }
Exemple #39
0
 /// <summary>
 /// Creates a new IConnection to a URL. Use to fetch and parse a HTML page.
 /// Use examples:
 /// <ul>
 /// <li><code>Document doc = NSoupClient.Connect("http://example.com").UserAgent("Mozilla").Data("name", "jsoup").Get();</code></li>
 /// <li><code>Document doc = NSoupClient.Connect("http://example.com").Cookie("auth", "token").Post();</code></li>
 /// </ul>
 /// </summary>
 /// <param name="url">URL to connect to. The protocol must be <code>http</code> or <code>https</code>.</param>
 /// <returns>the connection. You can add data, cookies, and headers; set the user-agent, referrer, method; and then execute.</returns>
 public static IConnection Connect(string url)
 {
     return(HttpConnection.Connect(url));
 }
 internal static void SetCurrentConnection(HttpConnection con)
 {
     _currentConnection = con;
 }
Exemple #41
0
 public HttpContentStream(HttpConnection connection)
 {
     _connection = connection;
 }
		/// <summary>
		/// Sends the specified request and waits for a response using the specified connection.
		/// </summary>
		/// <param name="connection">The connection to use for communication</param>
		/// <param name="request">The request to send</param>
		/// <param name="exception">Any exception that is throw or encountered during the request/response session with the server</param>
		/// <returns></returns>
		public static HttpResponse GetResponse(
			HttpConnection connection, 
			HttpRequest request, 
			out Exception exception,
			EventHandler<HttpMessageProgressEventArgs> onSendProgress,
			EventHandler<HttpMessageProgressEventArgs> onRecvProgress,
			object stateObject)
		{
			#region Params Validation

			if (connection == null)
				throw new ArgumentNullException("connection");

			if (request == null)
				throw new ArgumentNullException("request");

			exception = null;

			#endregion

			// use the connection to get a response
			HttpResponse response = connection.GetResponse(request, onSendProgress, onRecvProgress, stateObject);

            exception = connection.GetLastException();

			// if there is no response, then obviously something went wrong, retrieve the last exception from the connection
			if (response == null)
			{
				if (exception != null)
					if (exception.GetType() == typeof(ThreadAbortException))
						throw exception;
			}
			
			// return the response
			return response;
		}
Exemple #43
0
 public ConnectionCloseReadStream(HttpConnection connection)
     : base(connection)
 {
 }
    private static void processAccepted (Socket socket, EndPointListener listener)
    {
      HttpConnection conn = null;
      try {
        conn = new HttpConnection (socket, listener);
        lock (listener._unregisteredSync)
          listener._unregistered[conn] = conn;

        conn.BeginReadRequest ();
      }
      catch {
        if (conn != null) {
          conn.Close (true);
          return;
        }

        socket.Close ();
      }
    }
Exemple #45
0
        protected internal override HttpResponse HandleRequest(TestContext ctx, HttpConnection connection, HttpRequest request, RequestFlags effectiveFlags)
        {
            Debug(ctx, 2, "HANDLE POST", request.Path, request.Method, effectiveFlags);

            if (request.Headers.ContainsKey("X-Mono-Redirected"))
            {
                effectiveFlags |= RequestFlags.Redirected;
            }

            if ((effectiveFlags & RequestFlags.RedirectedAsGet) != 0)
            {
                if (!ctx.Expect(request.Method, Is.EqualTo("GET"), "method"))
                {
                    return(null);
                }
            }
            else if (Method != null)
            {
                if (!ctx.Expect(request.Method, Is.EqualTo(Method), "method"))
                {
                    return(null);
                }
            }
            else
            {
                if (!ctx.Expect(request.Method, Is.EqualTo("POST").Or.EqualTo("PUT"), "method"))
                {
                    return(null);
                }
            }

            if (customHandler != null)
            {
                var customResponse = customHandler(request);
                if (customResponse != null)
                {
                    return(customResponse);
                }
            }

            var hasContentLength    = request.Headers.ContainsKey("Content-Length");
            var hasTransferEncoding = request.Headers.ContainsKey("Transfer-Encoding");

            if ((effectiveFlags & RequestFlags.RedirectedAsGet) != 0)
            {
                ctx.Expect(hasContentLength, Is.False, "Content-Length header not allowed");
                ctx.Expect(hasTransferEncoding, Is.False, "Transfer-Encoding header not allowed");
                return(HttpResponse.CreateSuccess());
            }

            if ((effectiveFlags & RequestFlags.NoContentLength) != 0)
            {
                ctx.Expect(hasContentLength, Is.False, "Content-Length header not allowed");
                ctx.Expect(hasTransferEncoding, Is.False, "Transfer-Encoding header not allowed");
            }

            Debug(ctx, 2, "HANDLE POST #1", hasContentLength, hasTransferEncoding);

            var content = request.ReadBody();

            switch (Mode)
            {
            case TransferMode.Default:
                if (Content != null)
                {
                    ctx.Expect(hasContentLength, Is.True, "Missing Content-Length");
                    break;
                }
                else
                {
                    ctx.Expect(hasContentLength, Is.False, "Content-Length header not allowed");
                    return(HttpResponse.CreateSuccess());
                }

            case TransferMode.ContentLength:
                ctx.Expect(hasContentLength, Is.True, "Missing Content-Length");
                ctx.Expect(hasTransferEncoding, Is.False, "Transfer-Encoding header not allowed");
                break;

            case TransferMode.Chunked:
                if ((effectiveFlags & RequestFlags.Redirected) != 0)
                {
                    goto case TransferMode.ContentLength;
                }

                ctx.Expect(hasContentLength, Is.False, "Content-Length header not allowed");
                var ok = ctx.Expect(hasTransferEncoding, Is.True, "Missing Transfer-Encoding header");
                if (!ok)
                {
                    break;
                }

                var transferEncoding = request.Headers ["Transfer-Encoding"];
                ok &= ctx.Expect(transferEncoding.ToLowerInvariant(), Is.EqualTo("chunked"), "Invalid Transfer-Encoding");
                break;

            default:
                ctx.Expect(false, "Unknown TransferMode: '{0}'", Mode);
                return(null);
            }

            Debug(ctx, 5, "BODY", content);
            if ((effectiveFlags & RequestFlags.NoBody) != 0)
            {
                ctx.Expect(HttpContent.IsNullOrEmpty(content), "Must not send a body with this request.");
                return(null);
            }

            if (Content != null)
            {
                HttpContent.Compare(ctx, content, Content, true);
            }
            else
            {
                ctx.Expect(HttpContent.IsNullOrEmpty(content), "null or empty content");
            }

            return(null);
        }
Exemple #46
0
        private async Task <IResponse> RequestV3(AbstractModel request, string actionName)
        {
            string endpoint = this.Endpoint;

            if (!string.IsNullOrEmpty(this.Profile.HttpProfile.Endpoint))
            {
                endpoint = this.Profile.HttpProfile.Endpoint;
            }
            string httpRequestMethod    = this.Profile.HttpProfile.ReqMethod;
            string canonicalURI         = "/";
            string canonicalQueryString = "";
            string requestPayload       = "";
            string contentType          = "application/x-www-form-urlencoded";

            if (HttpProfile.REQ_GET.Equals(httpRequestMethod))
            {
                Dictionary <string, string> param = new Dictionary <string, string>();
                request.ToMap(param, "");
                StringBuilder urlBuilder = new StringBuilder();
                foreach (KeyValuePair <string, string> kvp in param)
                {
                    urlBuilder.Append($"{WebUtility.UrlEncode(kvp.Key)}={WebUtility.UrlEncode(kvp.Value)}&");
                }
                canonicalQueryString = urlBuilder.ToString().TrimEnd('&');
            }
            else
            {
                requestPayload = JsonConvert.SerializeObject(request,
                                                             Newtonsoft.Json.Formatting.None,
                                                             new JsonSerializerSettings {
                    NullValueHandling = NullValueHandling.Ignore
                });
                contentType = "application/json";
            }
            // HttpContent->StringContent will add charset to utf-8 in content-type,
            // which leads to authentication failure in API...
            string canonicalHeaders     = "content-type:" + contentType + "; charset=utf-8\nhost:" + endpoint + "\n";
            string signedHeaders        = "content-type;host";
            string hashedRequestPayload = SignHelper.SHA256Hex(requestPayload);
            string canonicalRequest     = httpRequestMethod + "\n"
                                          + canonicalURI + "\n"
                                          + canonicalQueryString + "\n"
                                          + canonicalHeaders + "\n"
                                          + signedHeaders + "\n"
                                          + hashedRequestPayload;
            //Console.WriteLine(canonicalRequest);

            string algorithm              = "TC3-HMAC-SHA256";
            long   timestamp              = ToTimestamp() / 1000;
            string requestTimestamp       = timestamp.ToString();
            string date                   = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(timestamp).ToString("yyyy-MM-dd");
            string service                = endpoint.Split('.')[0];
            string credentialScope        = date + "/" + service + "/" + "tc3_request";
            string hashedCanonicalRequest = SignHelper.SHA256Hex(canonicalRequest);
            string stringToSign           = algorithm + "\n"
                                            + requestTimestamp + "\n"
                                            + credentialScope + "\n"
                                            + hashedCanonicalRequest;

            //Console.WriteLine(stringToSign);

            byte[] tc3SecretKey   = Encoding.UTF8.GetBytes("TC3" + Credential.SecretKey);
            byte[] secretDate     = SignHelper.HmacSHA256(tc3SecretKey, Encoding.UTF8.GetBytes(date));
            byte[] secretService  = SignHelper.HmacSHA256(secretDate, Encoding.UTF8.GetBytes(service));
            byte[] secretSigning  = SignHelper.HmacSHA256(secretService, Encoding.UTF8.GetBytes("tc3_request"));
            byte[] signatureBytes = SignHelper.HmacSHA256(secretSigning, Encoding.UTF8.GetBytes(stringToSign));
            string signature      = BitConverter.ToString(signatureBytes).Replace("-", "").ToLower();
            //Console.WriteLine(signature);

            string authorization = algorithm + " "
                                   + "Credential=" + Credential.SecretId + "/" + credentialScope + ", "
                                   + "SignedHeaders=" + signedHeaders + ", "
                                   + "Signature=" + signature;
            //Console.WriteLine(authorization);

            Dictionary <string, string> headers = new Dictionary <string, string>();

            headers.Add("Authorization", authorization);
            headers.Add("Host", endpoint);
            headers.Add("Content-Type", contentType);
            headers.Add("X-TC-Action", actionName);
            headers.Add("X-TC-Timestamp", requestTimestamp);
            headers.Add("X-TC-Version", this.ApiVersion);
            headers.Add("X-TC-Region", this.Region);
            headers.Add("X-TC-RequestClient", this.SdkVersion);
            if (!string.IsNullOrEmpty(this.Credential.Token))
            {
                headers.Add("X-TC-Token", this.Credential.Token);
            }

            HttpConnection conn = new HttpConnection(
                $"{this.Profile.HttpProfile.Protocol }{endpoint}",
                this.Profile.HttpProfile.Timeout,
                this.Profile.HttpProfile.WebProxy);

            try
            {
                if (this.Profile.HttpProfile.ReqMethod == HttpProfile.REQ_GET)
                {
                    return(await conn.GetRequest(this.Path, canonicalQueryString, headers));
                }
                else
                {
                    return(await conn.PostRequest(this.Path, requestPayload, headers));
                }
            }
            catch (Exception e)
            {
                throw new TencentCloudSDKException($"The request with exception: {e.Message}");
            }
        }
        protected async Task <string> InternalRequest(AbstractModel request, string actionName)
        {
            IResponse okRsp    = null;
            string    endpoint = this.Endpoint;

            if (!string.IsNullOrEmpty(this.Profile.HttpProfile.Endpoint))
            {
                endpoint = this.Profile.HttpProfile.Endpoint;
            }
            Dictionary <string, string> param = new Dictionary <string, string>();

            request.ToMap(param, "");
            // inplace change
            this.FormatRequestData(actionName, param);
            HttpConnection conn = new HttpConnection($"{this.Profile.HttpProfile.Protocol }{endpoint}", this.Profile.HttpProfile.Timeout, this.Profile.HttpProfile.WebProxy);

            if ((this.Profile.HttpProfile.ReqMethod != HttpProfile.REQ_GET) && (this.Profile.HttpProfile.ReqMethod != HttpProfile.REQ_POST))
            {
                throw new TencentCloudSDKException("Method only support (GET, POST)");
            }
            try
            {
                if (this.Profile.HttpProfile.ReqMethod == HttpProfile.REQ_GET)
                {
                    okRsp = await conn.GetRequest($"{this.Path}", param);
                }
                else if (this.Profile.HttpProfile.ReqMethod == HttpProfile.REQ_POST)
                {
                    okRsp = await conn.PostRequest(this.Path, param);
                }
            }
            catch (Exception ex)
            {
                throw new TencentCloudSDKException($"The request with exception: {ex.Message }");
            }

            if ((int)okRsp.Status != HTTP_RSP_OK)
            {
                throw new TencentCloudSDKException(okRsp.Status + await okRsp.Message.Content.ReadAsStringAsync());
            }
            string strResp = null;

            try
            {
                strResp = await okRsp.AsString();
            }
            catch (ApiException ex)
            {
                string responseText = await ex.Response.AsString();

                throw new TencentCloudSDKException($"The API responded with HTTP {ex.Response.Status}: {responseText}");
            }

            JsonResponseModel <JsonResponseErrModel> errResp = null;

            try
            {
                errResp = JsonConvert.DeserializeObject <JsonResponseModel <JsonResponseErrModel> >(strResp);
            }
            catch (JsonSerializationException e)
            {
                throw new TencentCloudSDKException(e.Message);
            }
            if (errResp.Response.Error != null)
            {
                throw new TencentCloudSDKException($"code:{errResp.Response.Error.Code} message:{errResp.Response.Error.Message} ",
                                                   errResp.Response.RequestId);
            }
            return(strResp);
        }
 public HttpSecureConnectionState(HttpConnection connection, Action<HttpConnection> callback)
 {
     Connection = connection;
     Callback = callback;
 }
 public void SetConnection(HttpConnection connection)
 {
     Task.Connection = connection ?? throw new ArgumentNullException(nameof(connection));
 }