Skip to content
This repository was archived by the owner on Jun 12, 2018. It is now read-only.

Commit f7da46e

Browse files
eidheimeidheim
committed
Changed free function SimpleWeb::status_codes() from static to inline, and changed size_t to std::size_t
1 parent fdf3095 commit f7da46e

6 files changed

Lines changed: 99 additions & 99 deletions

File tree

‎client_ws.hpp‎

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ namespace SimpleWeb {
5151
SendStream() noexcept : std::iostream(&streambuf) {}
5252

5353
/// Returns the size of the buffer
54-
size_t size() const noexcept {
54+
std::size_t size() const noexcept {
5555
return streambuf.size();
5656
}
5757
};
@@ -143,7 +143,7 @@ namespace SimpleWeb {
143143
void send_from_queue() {
144144
auto self = this->shared_from_this();
145145
strand.post([self]() {
146-
asio::async_write(*self->socket, self->send_queue.begin()->send_stream->streambuf, self->strand.wrap([self](const error_code &ec, size_t /*bytes_transferred*/) {
146+
asio::async_write(*self->socket, self->send_queue.begin()->send_stream->streambuf, self->strand.wrap([self](const error_code &ec, std::size_t /*bytes_transferred*/) {
147147
auto lock = self->handler_runner->continue_lock();
148148
if(!lock)
149149
return;
@@ -186,17 +186,17 @@ namespace SimpleWeb {
186186
mask.resize(4);
187187
std::uniform_int_distribution<unsigned short> dist(0, 255);
188188
std::random_device rd;
189-
for(size_t c = 0; c < 4; c++)
189+
for(std::size_t c = 0; c < 4; c++)
190190
mask[c] = static_cast<unsigned char>(dist(rd));
191191

192192
auto send_stream = std::make_shared<SendStream>();
193193

194-
size_t length = message_stream->size();
194+
std::size_t length = message_stream->size();
195195

196196
send_stream->put(static_cast<char>(fin_rsv_opcode));
197197
// Masked (first length byte>=128)
198198
if(length >= 126) {
199-
size_t num_bytes;
199+
std::size_t num_bytes;
200200
if(length > 0xffff) {
201201
num_bytes = 8;
202202
send_stream->put(static_cast<char>(127 + 128));
@@ -206,16 +206,16 @@ namespace SimpleWeb {
206206
send_stream->put(static_cast<char>(126 + 128));
207207
}
208208

209-
for(size_t c = num_bytes - 1; c != static_cast<size_t>(-1); c--)
209+
for(std::size_t c = num_bytes - 1; c != static_cast<std::size_t>(-1); c--)
210210
send_stream->put((static_cast<unsigned long long>(length) >> (8 * c)) % 256);
211211
}
212212
else
213213
send_stream->put(static_cast<char>(length + 128));
214214

215-
for(size_t c = 0; c < 4; c++)
215+
for(std::size_t c = 0; c < 4; c++)
216216
send_stream->put(static_cast<char>(mask[c]));
217217

218-
for(size_t c = 0; c < length; c++)
218+
for(std::size_t c = 0; c < length; c++)
219219
send_stream->put(message_stream->get() ^ mask[c % 4]);
220220

221221
auto self = this->shared_from_this();
@@ -250,7 +250,7 @@ namespace SimpleWeb {
250250

251251
public:
252252
unsigned char fin_rsv_opcode;
253-
size_t size() noexcept {
253+
std::size_t size() noexcept {
254254
return length;
255255
}
256256

@@ -268,7 +268,7 @@ namespace SimpleWeb {
268268

269269
private:
270270
Message() noexcept : std::istream(&streambuf) {}
271-
size_t length;
271+
std::size_t length;
272272
asio::streambuf streambuf;
273273
};
274274

@@ -342,8 +342,8 @@ namespace SimpleWeb {
342342
std::shared_ptr<ScopeRunner> handler_runner;
343343

344344
SocketClientBase(const std::string &host_port_path, unsigned short default_port) noexcept : handler_runner(new ScopeRunner()) {
345-
size_t host_end = host_port_path.find(':');
346-
size_t host_port_end = host_port_path.find('/');
345+
std::size_t host_end = host_port_path.find(':');
346+
std::size_t host_port_end = host_port_path.find('/');
347347
if(host_end == std::string::npos) {
348348
host_end = host_port_end;
349349
port = default_port;
@@ -384,7 +384,7 @@ namespace SimpleWeb {
384384
nonce.resize(16);
385385
std::uniform_int_distribution<unsigned short> dist(0, 255);
386386
std::random_device rd;
387-
for(size_t c = 0; c < 16; c++)
387+
for(std::size_t c = 0; c < 16; c++)
388388
nonce[c] = static_cast<char>(dist(rd));
389389

390390
auto nonce_base64 = std::make_shared<std::string>(Crypto::Base64::encode(nonce));
@@ -397,14 +397,14 @@ namespace SimpleWeb {
397397
connection->message = std::shared_ptr<Message>(new Message());
398398

399399
connection->set_timeout(config.timeout_request);
400-
asio::async_write(*connection->socket, *write_buffer, [this, connection, write_buffer, nonce_base64](const error_code &ec, size_t /*bytes_transferred*/) {
400+
asio::async_write(*connection->socket, *write_buffer, [this, connection, write_buffer, nonce_base64](const error_code &ec, std::size_t /*bytes_transferred*/) {
401401
connection->cancel_timeout();
402402
auto lock = connection->handler_runner->continue_lock();
403403
if(!lock)
404404
return;
405405
if(!ec) {
406406
connection->set_timeout(this->config.timeout_request);
407-
asio::async_read_until(*connection->socket, connection->message->streambuf, "\r\n\r\n", [this, connection, nonce_base64](const error_code &ec, size_t /*bytes_transferred*/) {
407+
asio::async_read_until(*connection->socket, connection->message->streambuf, "\r\n\r\n", [this, connection, nonce_base64](const error_code &ec, std::size_t /*bytes_transferred*/) {
408408
connection->cancel_timeout();
409409
auto lock = connection->handler_runner->continue_lock();
410410
if(!lock)
@@ -435,7 +435,7 @@ namespace SimpleWeb {
435435
}
436436

437437
void read_message(const std::shared_ptr<Connection> &connection) {
438-
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(2), [this, connection](const error_code &ec, size_t bytes_transferred) {
438+
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(2), [this, connection](const error_code &ec, std::size_t bytes_transferred) {
439439
auto lock = connection->handler_runner->continue_lock();
440440
if(!lock)
441441
return;
@@ -458,11 +458,11 @@ namespace SimpleWeb {
458458
return;
459459
}
460460

461-
size_t length = (first_bytes[1] & 127);
461+
std::size_t length = (first_bytes[1] & 127);
462462

463463
if(length == 126) {
464464
// 2 next bytes is the size of content
465-
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(2), [this, connection](const error_code &ec, size_t /*bytes_transferred*/) {
465+
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(2), [this, connection](const error_code &ec, std::size_t /*bytes_transferred*/) {
466466
auto lock = connection->handler_runner->continue_lock();
467467
if(!lock)
468468
return;
@@ -471,10 +471,10 @@ namespace SimpleWeb {
471471
length_bytes.resize(2);
472472
connection->message->read(reinterpret_cast<char *>(&length_bytes[0]), 2);
473473

474-
size_t length = 0;
475-
size_t num_bytes = 2;
476-
for(size_t c = 0; c < num_bytes; c++)
477-
length += static_cast<size_t>(length_bytes[c]) << (8 * (num_bytes - 1 - c));
474+
std::size_t length = 0;
475+
std::size_t num_bytes = 2;
476+
for(std::size_t c = 0; c < num_bytes; c++)
477+
length += static_cast<std::size_t>(length_bytes[c]) << (8 * (num_bytes - 1 - c));
478478

479479
connection->message->length = length;
480480
this->read_message_content(connection);
@@ -485,7 +485,7 @@ namespace SimpleWeb {
485485
}
486486
else if(length == 127) {
487487
// 8 next bytes is the size of content
488-
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(8), [this, connection](const error_code &ec, size_t /*bytes_transferred*/) {
488+
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(8), [this, connection](const error_code &ec, std::size_t /*bytes_transferred*/) {
489489
auto lock = connection->handler_runner->continue_lock();
490490
if(!lock)
491491
return;
@@ -494,10 +494,10 @@ namespace SimpleWeb {
494494
length_bytes.resize(8);
495495
connection->message->read(reinterpret_cast<char *>(&length_bytes[0]), 8);
496496

497-
size_t length = 0;
498-
size_t num_bytes = 8;
499-
for(size_t c = 0; c < num_bytes; c++)
500-
length += static_cast<size_t>(length_bytes[c]) << (8 * (num_bytes - 1 - c));
497+
std::size_t length = 0;
498+
std::size_t num_bytes = 8;
499+
for(std::size_t c = 0; c < num_bytes; c++)
500+
length += static_cast<std::size_t>(length_bytes[c]) << (8 * (num_bytes - 1 - c));
501501

502502
connection->message->length = length;
503503
this->read_message_content(connection);
@@ -517,7 +517,7 @@ namespace SimpleWeb {
517517
}
518518

519519
void read_message_content(const std::shared_ptr<Connection> &connection) {
520-
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(connection->message->length), [this, connection](const error_code &ec, size_t /*bytes_transferred*/) {
520+
asio::async_read(*connection->socket, connection->message->streambuf, asio::transfer_exactly(connection->message->length), [this, connection](const error_code &ec, std::size_t /*bytes_transferred*/) {
521521
auto lock = connection->handler_runner->continue_lock();
522522
if(!lock)
523523
return;

‎crypto.hpp‎

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ namespace SimpleWeb {
2222
#endif
2323

2424
class Crypto {
25-
const static size_t buffer_size = 131072;
25+
const static std::size_t buffer_size = 131072;
2626

2727
public:
2828
class Base64 {
@@ -40,7 +40,7 @@ namespace SimpleWeb {
4040
BIO_set_mem_buf(b64, bptr, BIO_CLOSE);
4141

4242
// Write directly to base64-buffer to avoid copy
43-
auto base64_length = static_cast<size_t>(round(4 * ceil(static_cast<double>(ascii.size()) / 3.0)));
43+
auto base64_length = static_cast<std::size_t>(round(4 * ceil(static_cast<double>(ascii.size()) / 3.0)));
4444
base64.resize(base64_length);
4545
bptr->length = 0;
4646
bptr->max = base64_length + 1;
@@ -73,7 +73,7 @@ namespace SimpleWeb {
7373

7474
auto decoded_length = BIO_read(bio, &ascii[0], static_cast<int>(ascii.size()));
7575
if(decoded_length > 0)
76-
ascii.resize(static_cast<size_t>(decoded_length));
76+
ascii.resize(static_cast<std::size_t>(decoded_length));
7777
else
7878
ascii.clear();
7979

@@ -92,117 +92,117 @@ namespace SimpleWeb {
9292
return hex_stream.str();
9393
}
9494

95-
static std::string md5(const std::string &input, size_t iterations = 1) noexcept {
95+
static std::string md5(const std::string &input, std::size_t iterations = 1) noexcept {
9696
std::string hash;
9797

9898
hash.resize(128 / 8);
9999
MD5(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
100100

101-
for(size_t c = 1; c < iterations; ++c)
101+
for(std::size_t c = 1; c < iterations; ++c)
102102
MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
103103

104104
return hash;
105105
}
106106

107-
static std::string md5(std::istream &stream, size_t iterations = 1) noexcept {
107+
static std::string md5(std::istream &stream, std::size_t iterations = 1) noexcept {
108108
MD5_CTX context;
109109
MD5_Init(&context);
110110
std::streamsize read_length;
111111
std::vector<char> buffer(buffer_size);
112112
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
113-
MD5_Update(&context, buffer.data(), static_cast<size_t>(read_length));
113+
MD5_Update(&context, buffer.data(), static_cast<std::size_t>(read_length));
114114
std::string hash;
115115
hash.resize(128 / 8);
116116
MD5_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
117117

118-
for(size_t c = 1; c < iterations; ++c)
118+
for(std::size_t c = 1; c < iterations; ++c)
119119
MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
120120

121121
return hash;
122122
}
123123

124-
static std::string sha1(const std::string &input, size_t iterations = 1) noexcept {
124+
static std::string sha1(const std::string &input, std::size_t iterations = 1) noexcept {
125125
std::string hash;
126126

127127
hash.resize(160 / 8);
128128
SHA1(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
129129

130-
for(size_t c = 1; c < iterations; ++c)
130+
for(std::size_t c = 1; c < iterations; ++c)
131131
SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
132132

133133
return hash;
134134
}
135135

136-
static std::string sha1(std::istream &stream, size_t iterations = 1) noexcept {
136+
static std::string sha1(std::istream &stream, std::size_t iterations = 1) noexcept {
137137
SHA_CTX context;
138138
SHA1_Init(&context);
139139
std::streamsize read_length;
140140
std::vector<char> buffer(buffer_size);
141141
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
142-
SHA1_Update(&context, buffer.data(), static_cast<size_t>(read_length));
142+
SHA1_Update(&context, buffer.data(), static_cast<std::size_t>(read_length));
143143
std::string hash;
144144
hash.resize(160 / 8);
145145
SHA1_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
146146

147-
for(size_t c = 1; c < iterations; ++c)
147+
for(std::size_t c = 1; c < iterations; ++c)
148148
SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
149149

150150
return hash;
151151
}
152152

153-
static std::string sha256(const std::string &input, size_t iterations = 1) noexcept {
153+
static std::string sha256(const std::string &input, std::size_t iterations = 1) noexcept {
154154
std::string hash;
155155

156156
hash.resize(256 / 8);
157157
SHA256(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
158158

159-
for(size_t c = 1; c < iterations; ++c)
159+
for(std::size_t c = 1; c < iterations; ++c)
160160
SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
161161

162162
return hash;
163163
}
164164

165-
static std::string sha256(std::istream &stream, size_t iterations = 1) noexcept {
165+
static std::string sha256(std::istream &stream, std::size_t iterations = 1) noexcept {
166166
SHA256_CTX context;
167167
SHA256_Init(&context);
168168
std::streamsize read_length;
169169
std::vector<char> buffer(buffer_size);
170170
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
171-
SHA256_Update(&context, buffer.data(), static_cast<size_t>(read_length));
171+
SHA256_Update(&context, buffer.data(), static_cast<std::size_t>(read_length));
172172
std::string hash;
173173
hash.resize(256 / 8);
174174
SHA256_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
175175

176-
for(size_t c = 1; c < iterations; ++c)
176+
for(std::size_t c = 1; c < iterations; ++c)
177177
SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
178178

179179
return hash;
180180
}
181181

182-
static std::string sha512(const std::string &input, size_t iterations = 1) noexcept {
182+
static std::string sha512(const std::string &input, std::size_t iterations = 1) noexcept {
183183
std::string hash;
184184

185185
hash.resize(512 / 8);
186186
SHA512(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
187187

188-
for(size_t c = 1; c < iterations; ++c)
188+
for(std::size_t c = 1; c < iterations; ++c)
189189
SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
190190

191191
return hash;
192192
}
193193

194-
static std::string sha512(std::istream &stream, size_t iterations = 1) noexcept {
194+
static std::string sha512(std::istream &stream, std::size_t iterations = 1) noexcept {
195195
SHA512_CTX context;
196196
SHA512_Init(&context);
197197
std::streamsize read_length;
198198
std::vector<char> buffer(buffer_size);
199199
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
200-
SHA512_Update(&context, buffer.data(), static_cast<size_t>(read_length));
200+
SHA512_Update(&context, buffer.data(), static_cast<std::size_t>(read_length));
201201
std::string hash;
202202
hash.resize(512 / 8);
203203
SHA512_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
204204

205-
for(size_t c = 1; c < iterations; ++c)
205+
for(std::size_t c = 1; c < iterations; ++c)
206206
SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
207207

208208
return hash;
@@ -211,7 +211,7 @@ namespace SimpleWeb {
211211
/// key_size is number of bytes of the returned key.
212212
static std::string pbkdf2(const std::string &password, const std::string &salt, int iterations, int key_size) noexcept {
213213
std::string key;
214-
key.resize(static_cast<size_t>(key_size));
214+
key.resize(static_cast<std::size_t>(key_size));
215215
PKCS5_PBKDF2_HMAC_SHA1(password.c_str(), password.size(),
216216
reinterpret_cast<const unsigned char *>(salt.c_str()), salt.size(), iterations,
217217
key_size, reinterpret_cast<unsigned char *>(&key[0]));

0 commit comments

Comments
 (0)