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
|
// OpenVPN -- An application to securely tunnel IP networks
// over a single port, with support for SSL/TLS-based
// session authentication and key exchange,
// packet encryption, packet authentication, and
// packet compression.
//
// Copyright (C) 2012- OpenVPN Inc.
//
// SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
#ifndef OPENVPN_CLIENT_CLIHALT_H
#define OPENVPN_CLIENT_CLIHALT_H
#include <string>
#include <sstream>
#include <vector>
#include <openvpn/common/exception.hpp>
#include <openvpn/common/split.hpp>
#include <openvpn/common/unicode.hpp>
#include <openvpn/common/string.hpp>
// Process halt/restart messages from server:
// HALT,<client_reason> -> disconnect
// RESTART,<client_reason> -> restart with reason, don't preserve session ID
// RESTART,[P]:<client_reason> -> restart with reason, do preserve session ID
namespace openvpn {
class ClientHalt
{
typedef std::vector<std::string> StringList;
public:
OPENVPN_SIMPLE_EXCEPTION(client_halt_error);
ClientHalt(const std::string &msg, const bool unicode_filter)
{
// get operator (halt or restart)
StringList sl;
parse_msg(sl, msg);
if (is_halt(sl))
;
else if (is_restart(sl))
restart_ = true;
else
throw client_halt_error();
// get flags and reason
if (sl.size() >= 2)
{
size_t reason_pos = 0;
if (restart_ && string::starts_with(sl[1], "[P]:"))
{
psid_ = true;
reason_pos = 4;
}
reason_ = sl[1].substr(reason_pos);
if (unicode_filter)
reason_ = Unicode::utf8_printable(reason_, 256);
}
}
static bool match(const std::string &msg)
{
StringList sl;
parse_msg(sl, msg);
return is_halt(sl) || is_restart(sl);
}
// returns true for restart, false for halt
bool restart() const
{
return restart_;
}
// returns true if session ID should be preserved
bool psid() const
{
return psid_;
}
// returns user-visible reason string
const std::string &reason() const
{
return reason_;
}
std::string render() const
{
std::ostringstream os;
os << (restart_ ? "RESTART" : "HALT") << " psid=" << psid_ << " reason='" << reason_ << '\'';
return os.str();
}
private:
static void parse_msg(StringList &sl, const std::string &msg)
{
sl.reserve(2);
Split::by_char_void<StringList, NullLex, Split::NullLimit>(sl, msg, ',', 0, 1);
}
static bool is_halt(const StringList &sl)
{
return sl.size() >= 1 && sl[0] == "HALT";
}
static bool is_restart(const StringList &sl)
{
return sl.size() >= 1 && sl[0] == "RESTART";
}
bool restart_ = false;
bool psid_ = false;
std::string reason_;
};
} // namespace openvpn
#endif
|
