{

windows_request_context();

virtual ~windows_request_context();

// Asynchronously starts processing the current request.

void async_process_request(HTTP_REQUEST_ID request_id, http::http_request msg, const unsigned long headers_size);

// Dispatch request to the provided http_listener.

void dispatch_request_to_listener(_In_ web::http::experimental::listener::details::http_listener_impl *pListener);

enum class ShouldWaitForBody

{

Wait,

DontWait

};

// Initialise the response task callbacks. If the body has been requested, we should wait for it to avoid race conditions.

void init_response_callbacks(ShouldWaitForBody shouldWait);

// Read in a portion of the request body.

void read_request_body_chunk();

// Start processing the response.

void async_process_response();

void transmit_body();

// Read request headers io completion callback function .

void read_headers_io_completion(DWORD error_code, DWORD bytes_read);

// Read request body io completion callback function.

void read_body_io_completion(DWORD error_code, DWORD bytes_read);

// Send response io completion callback function .

void send_response_io_completion(DWORD error_code, DWORD bytes_read);

// Send response body io completion callback function.

void send_response_body_io_completion(DWORD error_code, DWORD bytes_read);

// Cancel request io completion callback function.

void cancel_request_io_completion(DWORD error_code, DWORD bytes_read);

// TCE that indicates the completion of response

// Workaround for ppl task_completion_event bug.

std::mutex m_responseCompletedLock;

pplx::task_completion_event<void> m_response_completed;

// Id of the currently processed request on this connection.

HTTP_REQUEST_ID m_request_id;

bool m_sending_in_chunks;

bool m_transfer_encoding;

size_t m_remaining_to_write;

HTTP_REQUEST *m_request;

std::unique_ptr<unsigned char[]> m_request_buffer;

std::unique_ptr<HTTP_UNKNOWN_HEADER []> m_headers;

std::vector<std::string> m_headers_buffer;

http_overlapped m_overlapped;

http_request m_msg;

http_response m_response;

std::exception_ptr m_except_ptr;

windows_request_context(const windows_request_context &);

windows_request_context& operator=(const windows_request_context &);

// Sends entity body chunk.

void send_entity_body(_In_reads_(data_length) unsigned char * data, _In_ size_t data_length);

// Cancels this request.

void cancel_request(std::exception_ptr except_ptr);

std::vector<unsigned char> m_body_data;

{

/// <summary>

/// Constructs a http_windows_server.

/// </summary>

http_windows_server();

/// <summary>

/// Releases resources held.

/// </summary>

~http_windows_server();

/// <summary>

/// Start listening for incoming requests.

/// </summary>

virtual pplx::task<void> start();

/// <summary>

/// Registers an http listener.

/// </summary>

virtual pplx::task<void> register_listener(_In_ web::http::experimental::listener::details::http_listener_impl *pListener);

/// <summary>

/// Unregisters an http listener.

/// </summary>

virtual pplx::task<void> unregister_listener(_In_ web::http::experimental::listener::details::http_listener_impl *pListener);

/// <summary>

/// Stop processing and listening for incoming requests.

/// </summary>

virtual pplx::task<void> stop();

/// <summary>

/// Asynchronously sends the specified http response.

/// </summary>

/// <param name="response">The http_response to send.</param>

/// <returns>A operation which is completed once the response has been sent.</returns>

virtual pplx::task<void> respond(http::http_response response);

friend struct details::windows_request_context;

// Structure to hold each registered listener.

class listener_registration

{

public:

listener_registration(HTTP_URL_GROUP_ID urlGroupId)

: m_urlGroupId(urlGroupId)

{}

// URL group id for this listener. Each listener needs it own URL group

// because configuration like timeouts, authentication, etc...

HTTP_URL_GROUP_ID m_urlGroupId;

// Request handler lock to guard against removing a listener while in user code.

pplx::extensibility::reader_writer_lock_t m_requestHandlerLock;

};

// Registered listeners

pplx::extensibility::reader_writer_lock_t _M_listenersLock;

std::unordered_map<web::http::experimental::listener::details::http_listener_impl *, std::unique_ptr<listener_registration>> _M_registeredListeners;

// HTTP Server API server session id.

HTTP_SERVER_SESSION_ID m_serverSessionId;

// Tracks the number of outstanding requests being processed.

std::atomic<int> m_numOutstandingRequests;

pplx::extensibility::event_t m_zeroOutstandingRequests;

// Handle to HTTP Server API request queue.

HANDLE m_hRequestQueue;

// Threadpool I/O structure for overlapped I/O.

TP_IO * m_threadpool_io;

// Task which actually handles receiving requests from HTTP Server API request queue.

pplx::task<void> m_receivingTask;

void receive_requests();