Skip to content

Commit 5706828

Browse files
yhiroseZefz
yhirose
authored and
Zefz
committed
Replace C-style arrays and fix static-code analysis warnings
1 parent e743b8c commit 5706828

File tree

1 file changed

+69
-78
lines changed

1 file changed

+69
-78
lines changed

‎httplib.h

Lines changed: 69 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,7 @@ typedef SOCKET socket_t;
120120
#include <poll.h>
121121
#endif
122122
#include <pthread.h>
123-
#include <signal.h>
123+
#include <csignal>
124124
#include <sys/select.h>
125125
#include <sys/socket.h>
126126
#include <unistd.h>
@@ -129,7 +129,7 @@ typedef int socket_t;
129129
#define INVALID_SOCKET (-1)
130130
#endif //_WIN32
131131

132-
#include <assert.h>
132+
#include <cassert>
133133
#include <atomic>
134134
#include <condition_variable>
135135
#include <errno.h>
@@ -145,6 +145,7 @@ typedef int socket_t;
145145
#include <string>
146146
#include <sys/stat.h>
147147
#include <thread>
148+
#include <array>
148149

149150
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
150151
#include <openssl/err.h>
@@ -186,50 +187,46 @@ struct ci {
186187

187188
enum class HttpVersion { v1_0 = 0, v1_1 };
188189

189-
typedef std::multimap<std::string, std::string, detail::ci> Headers;
190+
using Headers = std::multimap<std::string, std::string, detail::ci>;
190191

191-
typedef std::multimap<std::string, std::string> Params;
192-
typedef std::smatch Match;
192+
using Params = std::multimap<std::string, std::string>;
193+
using Match = std::smatch;
193194

194-
typedef std::function<void(const char *data, size_t data_len)> DataSink;
195+
using DataSink = std::function<void(const char *data, size_t data_len)>;
195196

196-
typedef std::function<void()> Done;
197+
using Done = std::function<void()>;
197198

198-
typedef std::function<void(size_t offset, size_t length, DataSink sink)>
199-
ContentProvider;
199+
using ContentProvider = std::function<void(size_t offset, size_t length, DataSink sink)>;
200200

201-
typedef std::function<void(size_t offset, size_t length, DataSink sink,
202-
Done done)>
203-
ContentProviderWithCloser;
201+
using ContentProviderWithCloser = std::function<void(size_t offset, size_t length, DataSink sink, Done done)>;
204202

205-
typedef std::function<bool(const char *data, size_t data_length)>
206-
ContentReceiver;
203+
using ContentReceiver = std::function<bool(const char *data, size_t data_length)>;
207204

208-
typedef std::function<bool(ContentReceiver receiver)> ContentReader;
205+
using ContentReader = std::function<bool(ContentReceiver receiver)>;
209206

210-
typedef std::function<bool(uint64_t current, uint64_t total)> Progress;
207+
using Progress = std::function<bool(uint64_t current, uint64_t total)>;
211208

212209
struct Response;
213-
typedef std::function<bool(const Response &response)> ResponseHandler;
210+
using ResponseHandler = std::function<bool(const Response &response)>;
214211

215212
struct MultipartFile {
216213
std::string filename;
217214
std::string content_type;
218215
size_t offset = 0;
219216
size_t length = 0;
220217
};
221-
typedef std::multimap<std::string, MultipartFile> MultipartFiles;
218+
using MultipartFiles = std::multimap<std::string, MultipartFile>;
222219

223220
struct MultipartFormData {
224221
std::string name;
225222
std::string content;
226223
std::string filename;
227224
std::string content_type;
228225
};
229-
typedef std::vector<MultipartFormData> MultipartFormDataItems;
226+
using MultipartFormDataItems = std::vector<MultipartFormData>;
230227

231-
typedef std::pair<ssize_t, ssize_t> Range;
232-
typedef std::vector<Range> Ranges;
228+
using Range = std::pair<ssize_t, ssize_t>;
229+
using Ranges = std::vector<Range>;
233230

234231
struct Request {
235232
std::string method;
@@ -285,7 +282,7 @@ struct Response {
285282
void set_header(const char *key, const char *val);
286283
void set_header(const char *key, const std::string &val);
287284

288-
void set_redirect(const char *uri);
285+
void set_redirect(const char *url);
289286
void set_content(const char *s, size_t n, const char *content_type);
290287
void set_content(const std::string &s, const char *content_type);
291288

@@ -331,11 +328,11 @@ class SocketStream : public Stream {
331328
time_t read_timeout_usec);
332329
virtual ~SocketStream();
333330

334-
virtual int read(char *ptr, size_t size);
335-
virtual int write(const char *ptr, size_t size);
336-
virtual int write(const char *ptr);
337-
virtual int write(const std::string &s);
338-
virtual std::string get_remote_addr() const;
331+
int read(char *ptr, size_t size) override;
332+
int write(const char *ptr, size_t size) override;
333+
int write(const char *ptr) override;
334+
int write(const std::string &s) override;
335+
std::string get_remote_addr() const override;
339336

340337
private:
341338
socket_t sock_;
@@ -348,11 +345,11 @@ class BufferStream : public Stream {
348345
BufferStream() {}
349346
virtual ~BufferStream() {}
350347

351-
virtual int read(char *ptr, size_t size);
352-
virtual int write(const char *ptr, size_t size);
353-
virtual int write(const char *ptr);
354-
virtual int write(const std::string &s);
355-
virtual std::string get_remote_addr() const;
348+
int read(char *ptr, size_t size) override;
349+
int write(const char *ptr, size_t size) override;
350+
int write(const char *ptr) override;
351+
int write(const std::string &s) override;
352+
std::string get_remote_addr() const override;
356353

357354
const std::string &get_buffer() const;
358355

@@ -523,7 +520,7 @@ class Server {
523520
protected:
524521
bool process_request(Stream &strm, bool last_connection,
525522
bool &connection_close,
526-
std::function<void(Request &)> setup_request);
523+
const std::function<void(Request &)>& setup_request);
527524

528525
size_t keep_alive_max_count_;
529526
time_t read_timeout_sec_;
@@ -1117,7 +1114,7 @@ class stream_line_reader {
11171114
Stream &strm_;
11181115
char *fixed_buffer_;
11191116
const size_t fixed_buffer_size_;
1120-
size_t fixed_buffer_used_size_;
1117+
size_t fixed_buffer_used_size_ = 0;
11211118
std::string glowable_buffer_;
11221119
};
11231120

@@ -1184,7 +1181,7 @@ inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
11841181
(FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {
11851182
int error = 0;
11861183
socklen_t len = sizeof(error);
1187-
return getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&error, &len) >= 0 &&
1184+
return getsockopt(sock, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len) >= 0 &&
11881185
!error;
11891186
}
11901187
return false;
@@ -1321,11 +1318,11 @@ inline std::string get_remote_addr(socket_t sock) {
13211318
socklen_t len = sizeof(addr);
13221319

13231320
if (!getpeername(sock, reinterpret_cast<struct sockaddr *>(&addr), &len)) {
1324-
char ipstr[NI_MAXHOST];
1321+
std::array<char, NI_MAXHOST> ipstr{};
13251322

1326-
if (!getnameinfo(reinterpret_cast<struct sockaddr *>(&addr), len, ipstr,
1327-
sizeof(ipstr), nullptr, 0, NI_NUMERICHOST)) {
1328-
return ipstr;
1323+
if (!getnameinfo(reinterpret_cast<struct sockaddr *>(&addr), len, ipstr.data(), ipstr.size(),
1324+
nullptr, 0, NI_NUMERICHOST)) {
1325+
return ipstr.data();
13291326
}
13301327
}
13311328

@@ -1410,14 +1407,13 @@ inline bool compress(std::string &content) {
14101407

14111408
std::string compressed;
14121409

1413-
const auto bufsiz = 16384;
1414-
char buff[bufsiz];
1410+
std::array<char, 16384> buff{};
14151411
do {
1416-
strm.avail_out = bufsiz;
1417-
strm.next_out = reinterpret_cast<Bytef *>(buff);
1412+
strm.avail_out = buff.size();
1413+
strm.next_out = reinterpret_cast<Bytef*>(buff.data());
14181414
ret = deflate(&strm, Z_FINISH);
14191415
assert(ret != Z_STREAM_ERROR);
1420-
compressed.append(buff, bufsiz - strm.avail_out);
1416+
compressed.append(buff.data(), buff.size() - strm.avail_out);
14211417
} while (strm.avail_out == 0);
14221418

14231419
assert(ret == Z_STREAM_END);
@@ -1453,11 +1449,10 @@ class decompressor {
14531449
strm.avail_in = data_length;
14541450
strm.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
14551451

1456-
const auto bufsiz = 16384;
1457-
char buff[bufsiz];
1452+
std::array<char, 16384> buff{};
14581453
do {
1459-
strm.avail_out = bufsiz;
1460-
strm.next_out = reinterpret_cast<Bytef *>(buff);
1454+
strm.avail_out = buff.size();
1455+
strm.next_out = reinterpret_cast<Bytef*>(buff.data());
14611456

14621457
ret = inflate(&strm, Z_NO_FLUSH);
14631458
assert(ret != Z_STREAM_ERROR);
@@ -1467,7 +1462,7 @@ class decompressor {
14671462
case Z_MEM_ERROR: inflateEnd(&strm); return false;
14681463
}
14691464

1470-
if (!callback(buff, bufsiz - strm.avail_out)) { return false; }
1465+
if (!callback(buff.data(), buff.size() - strm.avail_out)) { return false; }
14711466
} while (strm.avail_out == 0);
14721467

14731468
return ret == Z_STREAM_END;
@@ -2245,18 +2240,17 @@ inline void Response::set_chunked_content_provider(
22452240
// Rstream implementation
22462241
template <typename... Args>
22472242
inline int Stream::write_format(const char *fmt, const Args &... args) {
2248-
const auto bufsiz = 2048;
2249-
char buf[bufsiz];
2243+
std::array<char, 2048> buf;
22502244

22512245
#if defined(_MSC_VER) && _MSC_VER < 1900
2252-
auto n = _snprintf_s(buf, bufsiz, bufsiz - 1, fmt, args...);
2246+
auto n = _snprintf_s(buf, bufsiz, buf.size() - 1, fmt, args...);
22532247
#else
2254-
auto n = snprintf(buf, bufsiz - 1, fmt, args...);
2248+
auto n = snprintf(buf.data(), buf.size() - 1, fmt, args...);
22552249
#endif
22562250
if (n <= 0) { return n; }
22572251

2258-
if (n >= bufsiz - 1) {
2259-
std::vector<char> glowable_buf(bufsiz);
2252+
if (n >= static_cast<int>(buf.size()) - 1) {
2253+
std::vector<char> glowable_buf(buf.size());
22602254

22612255
while (n >= static_cast<int>(glowable_buf.size() - 1)) {
22622256
glowable_buf.resize(glowable_buf.size() * 2);
@@ -2269,7 +2263,7 @@ inline int Stream::write_format(const char *fmt, const Args &... args) {
22692263
}
22702264
return write(&glowable_buf[0], n);
22712265
} else {
2272-
return write(buf, n);
2266+
return write(buf.data(), n);
22732267
}
22742268
}
22752269

@@ -2411,14 +2405,14 @@ inline bool Server::set_base_dir(const char *path) {
24112405
}
24122406

24132407
inline void Server::set_file_request_handler(Handler handler) {
2414-
file_request_handler_ = handler;
2408+
file_request_handler_ = std::move(handler);
24152409
}
24162410

24172411
inline void Server::set_error_handler(Handler handler) {
2418-
error_handler_ = handler;
2412+
error_handler_ = std::move(handler);
24192413
}
24202414

2421-
inline void Server::set_logger(Logger logger) { logger_ = logger; }
2415+
inline void Server::set_logger(Logger logger) { logger_ = std::move(logger); }
24222416

24232417
inline void Server::set_keep_alive_max_count(size_t count) {
24242418
keep_alive_max_count_ = count;
@@ -2728,8 +2722,7 @@ inline int Server::bind_internal(const char *host, int port, int socket_flags) {
27282722
if (address.ss_family == AF_INET) {
27292723
return ntohs(reinterpret_cast<struct sockaddr_in *>(&address)->sin_port);
27302724
} else if (address.ss_family == AF_INET6) {
2731-
return ntohs(
2732-
reinterpret_cast<struct sockaddr_in6 *>(&address)->sin6_port);
2725+
return ntohs(reinterpret_cast<struct sockaddr_in6 *>(&address)->sin6_port);
27332726
} else {
27342727
return -1;
27352728
}
@@ -2863,11 +2856,10 @@ Server::dispatch_request_for_content_reader(Request &req, Response &res,
28632856
inline bool
28642857
Server::process_request(Stream &strm, bool last_connection,
28652858
bool &connection_close,
2866-
std::function<void(Request &)> setup_request) {
2867-
const auto bufsiz = 2048;
2868-
char buf[bufsiz];
2859+
const std::function<void(Request &)>& setup_request) {
2860+
std::array<char, 2048> buf{};
28692861

2870-
detail::stream_line_reader line_reader(strm, buf, bufsiz);
2862+
detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
28712863

28722864
// Connection has been closed on client
28732865
if (!line_reader.getline()) { return false; }
@@ -2981,10 +2973,9 @@ inline socket_t Client::create_client_socket() const {
29812973
}
29822974

29832975
inline bool Client::read_response_line(Stream &strm, Response &res) {
2984-
const auto bufsiz = 2048;
2985-
char buf[bufsiz];
2976+
std::array<char, 2048> buf;
29862977

2987-
detail::stream_line_reader line_reader(strm, buf, bufsiz);
2978+
detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
29882979

29892980
if (!line_reader.getline()) { return false; }
29902981

@@ -3283,7 +3274,7 @@ inline std::shared_ptr<Response> Client::Get(const char *path) {
32833274

32843275
inline std::shared_ptr<Response> Client::Get(const char *path,
32853276
Progress progress) {
3286-
return Get(path, Headers(), progress);
3277+
return Get(path, Headers(), std::move(progress));
32873278
}
32883279

32893280
inline std::shared_ptr<Response> Client::Get(const char *path,
@@ -3298,7 +3289,7 @@ Client::Get(const char *path, const Headers &headers, Progress progress) {
32983289
req.method = "GET";
32993290
req.path = path;
33003291
req.headers = headers;
3301-
req.progress = progress;
3292+
req.progress = std::move(progress);
33023293

33033294
auto res = std::make_shared<Response>();
33043295
return send(req, *res) ? res : nullptr;
@@ -3307,35 +3298,35 @@ Client::Get(const char *path, const Headers &headers, Progress progress) {
33073298
inline std::shared_ptr<Response> Client::Get(const char *path,
33083299
ContentReceiver content_receiver) {
33093300
Progress dummy;
3310-
return Get(path, Headers(), nullptr, content_receiver, dummy);
3301+
return Get(path, Headers(), nullptr, std::move(content_receiver), dummy);
33113302
}
33123303

33133304
inline std::shared_ptr<Response> Client::Get(const char *path,
33143305
ContentReceiver content_receiver,
33153306
Progress progress) {
3316-
return Get(path, Headers(), nullptr, content_receiver, progress);
3307+
return Get(path, Headers(), nullptr, std::move(content_receiver), progress);
33173308
}
33183309

33193310
inline std::shared_ptr<Response> Client::Get(const char *path,
33203311
const Headers &headers,
33213312
ContentReceiver content_receiver) {
33223313
Progress dummy;
3323-
return Get(path, headers, nullptr, content_receiver, dummy);
3314+
return Get(path, headers, nullptr, std::move(content_receiver), dummy);
33243315
}
33253316

33263317
inline std::shared_ptr<Response> Client::Get(const char *path,
33273318
const Headers &headers,
33283319
ContentReceiver content_receiver,
33293320
Progress progress) {
3330-
return Get(path, headers, nullptr, content_receiver, progress);
3321+
return Get(path, headers, nullptr, std::move(content_receiver), progress);
33313322
}
33323323

33333324
inline std::shared_ptr<Response> Client::Get(const char *path,
33343325
const Headers &headers,
33353326
ResponseHandler response_handler,
33363327
ContentReceiver content_receiver) {
33373328
Progress dummy;
3338-
return Get(path, headers, response_handler, content_receiver, dummy);
3329+
return Get(path, headers, std::move(response_handler), content_receiver, dummy);
33393330
}
33403331

33413332
inline std::shared_ptr<Response> Client::Get(const char *path,
@@ -3347,9 +3338,9 @@ inline std::shared_ptr<Response> Client::Get(const char *path,
33473338
req.method = "GET";
33483339
req.path = path;
33493340
req.headers = headers;
3350-
req.response_handler = response_handler;
3351-
req.content_receiver = content_receiver;
3352-
req.progress = progress;
3341+
req.response_handler = std::move(response_handler);
3342+
req.content_receiver = std::move(content_receiver);
3343+
req.progress = std::move(progress);
33533344

33543345
auto res = std::make_shared<Response>();
33553346
return send(req, *res) ? res : nullptr;

0 commit comments

Comments
 (0)