-
Notifications
You must be signed in to change notification settings - Fork 7
/
HttpRequest.h
133 lines (97 loc) · 3.89 KB
/
HttpRequest.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
// Copyright (c) 2013 Matt Hill
// Use of this source code is governed by The MIT License
// that can be found in the LICENSE file.
//
// This class, along with HttpResponse, manages an HTTP Connection.
// Several requests can be sent using a single instance of this class.
// The receiveData callback is used to process the Response payload.
//
// Basic Usage:
//
// HttpRequest request("www.hyperceptive.org", 80);
// request.initCallbacks(foo, bar, baz, 0);
// request.sendRequest("GET", "/", 0, 0, 0);
//
// while(request.responsesPending())
// {
// request.processRequest();
// }
//
#ifndef HTTP_REQUEST_H
#define HTTP_REQUEST_H
#include "HttpResponse.h"
#include <deque>
#include <string>
#include <vector>
// Prototype for callbacks used to process an HTTP Response.
typedef void (*HeadersReady)(const HttpResponse *response, void *additionalParams);
typedef void (*ReceiveData)(const HttpResponse *response, void *additionalParams, const unsigned char *data, int sizeOfData);
typedef void (*ResponseComplete)(const HttpResponse *response, void *additionalParams);
class HttpRequest
{
friend class HttpResponse;
public:
static const int MaxRequestSize = 512;
static const int MaxSocketRecvSize = 2048;
HttpRequest(const char *host, int port);
~HttpRequest();
// Initialize callbacks for handling the HTTP Response.
// For each request, these are called by a corresponding HttpResponse object.
// headersReady : Called when response Headers have been received.
// receiveData : Called repeatedly to handle Body data.
// responseComplete : Called when response is complete.
// additionalParams : Passed back to all callbacks.
void initCallbacks(HeadersReady headersReady,
ReceiveData receiveData,
ResponseComplete responseComplete,
void *additionalParams);
// Make an HTTP request to the host and port specified in the Constructor.
// method : GET, POST, HEAD, etc.
// url : Path of URL, like "/fish/heads/yum.html"
// headers : Array of name/value pairs terminated by NULL (0)
// body : Body of request
// sizeOfBody : Size of the body
void sendRequest(const char *method,
const char *url,
const char *headers[] = 0,
const unsigned char *body = 0,
int sizeOfBody = 0);
bool responsesPending() const { return !_pendingResponses.empty(); }
void processRequest();
void cleanUp();
//**************************************************************************
// The following functions are used by sendRequest() to do the dirty work:
// - initRequest()
// - addHeader()
// - sendHeaders()
// - send()
//
// These functions can also be used directly by the caller.
// Look at the implementation of the sendRequest() method for an example.
//**************************************************************************
void initSocket();
// Initiate an HTTP Request
// method : GET, POST, HEAD, etc.
// url : Path of URL, like "/fish/heads/yum.html"
void initRequest(const char *method, const char *url);
// Add a name/value pair to the request Header. Call after initRequest().
void addHeader(const char *name, const char *value); // value is char
void addHeader(const char *name, int numericValue); // value is int
// Send the Headers over the socket. Call after adding all the Headers.
void sendHeaders();
// Send the data over the socket.
void send(const unsigned char *data, int sizeOfData);
protected:
HeadersReady _headersReady;
ReceiveData _receiveData;
ResponseComplete _responseComplete;
void *_additionalParams;
private:
enum { Idle, InProgress } _state;
std::string _host;
int _port;
int _socket;
std::vector<std::string> _currRequest;
std::deque<HttpResponse*> _pendingResponses;
};
#endif