Coverage Report

Created: 2021-02-21 07:20

/src/botan/src/lib/utils/socket/uri.cpp
Line
Count
Source (jump to first uncovered line)
1
/*
2
* (C) 2019 Nuno Goncalves <nunojpg@gmail.com>
3
*
4
* Botan is released under the Simplified BSD License (see license.txt)
5
*/
6
7
#include <botan/internal/uri.h>
8
#include <botan/exceptn.h>
9
10
#include <regex>
11
12
#if defined(BOTAN_TARGET_OS_HAS_SOCKETS)
13
   #include <arpa/inet.h>
14
   #include <sys/socket.h>
15
   #include <netinet/in.h>
16
#elif defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
17
   #include <ws2tcpip.h>
18
#endif
19
20
#if defined(BOTAN_TARGET_OS_HAS_SOCKETS) || defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
21
22
namespace {
23
24
constexpr bool isdigit(char ch)
25
208k
   {
26
208k
   return ch >= '0' && ch <= '9';
27
208k
   }
28
29
bool isDomain(const std::string& domain)
30
475
   {
31
#if defined(__GLIBCXX__) && (__GLIBCXX__ < 20160726)
32
   // GCC 4.8 does not support regex
33
   BOTAN_UNUSED(domain);
34
   return true;
35
#else
36
475
   std::regex re(
37
475
      R"(^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$)");
38
475
   std::cmatch m;
39
475
   return std::regex_match(domain.c_str(), m, re);
40
475
#endif
41
475
   }
42
43
bool isIPv4(const std::string& ip)
44
653
   {
45
653
   sockaddr_storage inaddr;
46
653
   return !!inet_pton(AF_INET, ip.c_str(), &inaddr);
47
653
   }
48
49
bool isIPv6(const std::string& ip)
50
55
   {
51
55
   sockaddr_storage in6addr;
52
55
   return !!inet_pton(AF_INET6, ip.c_str(), &in6addr);
53
55
   }
54
}
55
56
namespace Botan {
57
58
URI URI::fromDomain(const std::string& uri)
59
492
   {
60
492
   unsigned port = 0;
61
492
   const auto port_pos = uri.find(':');
62
492
   if(port_pos != std::string::npos)
63
75
      {
64
75
      for(char c : uri.substr(port_pos+1))
65
848
         {
66
848
         if(!isdigit(c))
67
10
            { throw Invalid_Argument("invalid"); }
68
838
         port = port*10 + c - '0';
69
838
         if(port > 65535)
70
6
            { throw Invalid_Argument("invalid"); }
71
838
         }
72
75
      }
73
476
   const auto domain = uri.substr(0, port_pos);
74
476
   if(isIPv4(domain))
75
1
      { throw Invalid_Argument("invalid"); }
76
475
   if(!isDomain(domain))
77
365
      { throw Invalid_Argument("invalid"); }
78
110
   return {Type::Domain, domain, uint16_t(port)};
79
110
   }
80
81
URI URI::fromIPv4(const std::string& uri)
82
47
   {
83
47
   unsigned port = 0;
84
47
   const auto port_pos = uri.find(':');
85
47
   if(port_pos != std::string::npos)
86
46
      {
87
46
      for(char c : uri.substr(port_pos+1))
88
335
         {
89
335
         if(!isdigit(c))
90
1
            { throw Invalid_Argument("invalid"); }
91
334
         port = port*10 + c - '0';
92
334
         if(port > 65535)
93
4
            { throw Invalid_Argument("invalid"); }
94
334
         }
95
46
      }
96
42
   const auto ip = uri.substr(0, port_pos);
97
42
   if(!isIPv4(ip))
98
0
      { throw Invalid_Argument("invalid"); }
99
42
   return { Type::IPv4, ip, uint16_t(port) };
100
42
   }
101
102
URI URI::fromIPv6(const std::string& uri)
103
117
   {
104
117
   unsigned port = 0;
105
117
   const auto port_pos = uri.find(']');
106
117
   const bool with_braces = (port_pos != std::string::npos);
107
117
   if((uri[0]=='[') != with_braces)
108
12
      { throw Invalid_Argument("invalid"); }
109
110
105
   if(with_braces && (uri.size() > port_pos + 1))
111
83
      {
112
83
      if(uri[port_pos+1]!=':')
113
29
         { throw Invalid_Argument("invalid"); }
114
54
      for(char c : uri.substr(port_pos+2))
115
367
         {
116
367
         if(!isdigit(c))
117
15
            { throw Invalid_Argument("invalid"); }
118
352
         port = port*10 + c - '0';
119
352
         if(port > 65535)
120
6
            { throw Invalid_Argument("invalid"); }
121
352
         }
122
54
      }
123
55
   const auto ip = uri.substr((with_braces ? 1 : 0), port_pos - with_braces);
124
55
   if(!isIPv6(ip))
125
52
      { throw Invalid_Argument("invalid"); }
126
3
   return { Type::IPv6, ip, uint16_t(port) };
127
3
   }
128
129
URI URI::fromAny(const std::string& uri)
130
656
   {
131
132
656
   bool colon_seen=false;
133
656
   bool non_number=false;
134
656
   if(uri[0]=='[')
135
91
      { return fromIPv6(uri); }
136
565
   for(auto c : uri)
137
207k
      {
138
207k
      if(c == ':')
139
173
         {
140
173
         if(colon_seen) //seen two ':'
141
26
            { return fromIPv6(uri); }
142
147
         colon_seen = true;
143
147
         }
144
206k
      else if(!isdigit(c) && c !=  '.')
145
185k
         {
146
185k
         non_number=true;
147
185k
         }
148
207k
      }
149
539
   if(!non_number)
150
135
      {
151
135
      if(isIPv4(uri.substr(0, uri.find(':'))))
152
47
         {
153
47
         return fromIPv4(uri);
154
47
         }
155
492
      }
156
492
   return fromDomain(uri);
157
492
   }
158
159
std::string URI::to_string() const
160
0
   {
161
0
   if(type == Type::NotSet)
162
0
      {
163
0
      throw Invalid_Argument("not set");
164
0
      }
165
166
0
   if(port != 0)
167
0
      {
168
0
      if(type == Type::IPv6)
169
0
         { return "[" + host + "]:" + std::to_string(port); }
170
0
      return host + ":" + std::to_string(port);
171
0
      }
172
0
   return host;
173
0
   }
174
175
}
176
177
#else
178
179
namespace Botan {
180
181
URI URI::fromDomain(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
182
URI URI::fromIPv4(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
183
URI URI::fromIPv6(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
184
URI URI::fromAny(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
185
186
}
187
188
#endif