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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
#pragma once
#include <nall/decode/url.hpp>
#include <nall/encode/url.hpp>
#include <nall/http/message.hpp>
namespace nall::HTTP {
struct Request : Message {
using type = Request;
enum class RequestType : u32 { None, Head, Get, Post };
explicit operator bool() const { return requestType() != RequestType::None; }
auto head(const function<bool (const u8* data, u32 size)>& callback) const -> bool override;
auto setHead() -> bool override;
auto body(const function<bool (const u8* data, u32 size)>& callback) const -> bool override;
auto setBody() -> bool override;
auto ipv4() const -> bool { return _ipv6 == false; }
auto ipv6() const -> bool { return _ipv6 == true; }
auto ip() const -> string { return _ip; }
auto requestType() const -> RequestType { return _requestType; }
auto setRequestType(RequestType value) -> void { _requestType = value; }
auto path() const -> string { return _path; }
auto setPath(const string& value) -> void { _path = value; }
Variables cookie;
Variables get;
Variables post;
//private:
bool _ipv6 = false;
string _ip;
RequestType _requestType = RequestType::None;
string _path;
};
inline auto Request::head(const function<bool (const u8*, u32)>& callback) const -> bool {
if(!callback) return false;
string output;
string request = path();
if(get.size()) {
request.append("?");
for(auto& variable : get) {
request.append(Encode::URL(variable.name()), "=", Encode::URL(variable.value()), "&");
}
request.trimRight("&", 1L);
}
switch(requestType()) {
case RequestType::Head: output.append("HEAD ", request, " HTTP/1.1\r\n"); break;
case RequestType::Get : output.append("GET ", request, " HTTP/1.1\r\n"); break;
case RequestType::Post: output.append("POST ", request, " HTTP/1.1\r\n"); break;
default: return false;
}
for(auto& variable : header) {
output.append(variable.name(), ": ", variable.value(), "\r\n");
}
output.append("\r\n");
return callback(output.data<u8>(), output.size());
}
inline auto Request::setHead() -> bool {
auto headers = _head.split("\n");
string request = headers.takeLeft().trimRight("\r", 1L);
string requestHost;
if(request.iendsWith(" HTTP/1.0")) request.itrimRight(" HTTP/1.0", 1L);
else if(request.iendsWith(" HTTP/1.1")) request.itrimRight(" HTTP/1.1", 1L);
else return false;
if(request.ibeginsWith("HEAD ")) request.itrimLeft("HEAD ", 1L), setRequestType(RequestType::Head);
else if(request.ibeginsWith("GET " )) request.itrimLeft("GET ", 1L), setRequestType(RequestType::Get );
else if(request.ibeginsWith("POST ")) request.itrimLeft("POST ", 1L), setRequestType(RequestType::Post);
else return false;
//decode absolute URIs
request.strip().itrimLeft("http://", 1L);
if(!request.beginsWith("/")) {
auto components = request.split("/", 1L);
requestHost = components(0);
request = {"/", components(1)};
}
auto components = request.split("?", 1L);
setPath(components(0));
if(auto queryString = components(1)) {
for(auto& block : queryString.split("&")) {
auto p = block.split("=", 1L);
auto name = Decode::URL(p(0));
auto value = Decode::URL(p(1));
if(name) get.append(name, value);
}
}
for(auto& header : headers) {
if(header.beginsWith(" ") || header.beginsWith("\t")) continue;
auto part = header.split(":", 1L).strip();
if(!part[0] || part.size() != 2) continue;
this->header.append(part[0], part[1]);
if(part[0].iequals("Cookie")) {
for(auto& block : part[1].split(";")) {
auto p = block.split("=", 1L).strip();
auto name = p(0);
auto value = p(1).trim("\"", "\"", 1L);
if(name) cookie.append(name, value);
}
}
}
if(requestHost) header.assign("Host", requestHost); //request URI overrides host header
return true;
}
inline auto Request::body(const function<bool (const u8*, u32)>& callback) const -> bool {
if(!callback) return false;
if(_body) {
return callback(_body.data<u8>(), _body.size());
}
return true;
}
inline auto Request::setBody() -> bool {
if(requestType() == RequestType::Post) {
auto contentType = header["Content-Type"].value();
if(contentType.iequals("application/x-www-form-urlencoded")) {
for(auto& block : _body.split("&")) {
auto p = block.trimRight("\r").split("=", 1L);
auto name = Decode::URL(p(0));
auto value = Decode::URL(p(1));
if(name) post.append(name, value);
}
} else if(contentType.imatch("multipart/form-data; boundary=?*")) {
auto boundary = contentType.itrimLeft("multipart/form-data; boundary=", 1L).trim("\"", "\"", 1L);
auto blocks = _body.split({"--", boundary}, 1024L); //limit blocks to prevent memory exhaustion
for(auto& block : blocks) block.trim("\r\n", "\r\n", 1L);
if(blocks.size() < 2 || (blocks.takeLeft(), !blocks.takeRight().beginsWith("--"))) return false;
for(auto& block : blocks) {
string name;
string filename;
string contentType;
auto segments = block.split("\r\n\r\n", 1L);
for(auto& segment : segments(0).split("\r\n")) {
auto statement = segment.split(":", 1L);
if(statement(0).ibeginsWith("Content-Disposition")) {
for(auto& component : statement(1).split(";")) {
auto part = component.split("=", 1L).strip();
if(part(0).iequals("name")) {
name = part(1).trim("\"", "\"", 1L);
} else if(part(0).iequals("filename")) {
filename = part(1).trim("\"", "\"", 1L);
}
}
} else if(statement(0).ibeginsWith("Content-Type")) {
contentType = statement(1).strip();
}
}
if(name) {
post.append(name, segments(1));
post.append({name, ".filename"}, filename);
post.append({name, ".content-type"}, contentType);
}
}
}
}
return true;
}
}
|
