Commit | Line | Data |
---|---|---|
0665b239 BS |
1 | /** @file |
2 | * @brief IPHelper class implementation. This class represents a Helper to get the actual IP. | |
3 | * | |
4 | * | |
5 | * | |
6 | * @copyright Intra2net AG | |
7 | * @license GPLv2 | |
8 | */ | |
9 | ||
ad0e5016 | 10 | #include "ip_addr_helper.h" |
0665b239 | 11 | #include <boost/asio.hpp> |
1c0908b5 | 12 | #include <boost/regex.hpp> |
1d2e2f56 BS |
13 | #include <arpa/inet.h> |
14 | #include <sys/socket.h> | |
15 | #include <netdb.h> | |
16 | #include <ifaddrs.h> | |
17 | ||
0665b239 BS |
18 | |
19 | using namespace std; | |
20 | ||
21 | namespace net = boost::asio; | |
22 | ||
23 | /** | |
24 | * Default constructor. | |
25 | */ | |
ad0e5016 | 26 | IPAddrHelper::IPAddrHelper() |
b30f392d | 27 | : Log(new Logger) |
2b0f7c11 | 28 | , WebcheckInterval(0) |
20399847 | 29 | , LastWebcheck(0) |
b30f392d | 30 | , ProxyPort(0) |
0665b239 BS |
31 | , UseIPv6(false) |
32 | { | |
33 | } | |
34 | ||
35 | ||
36 | /** | |
37 | * Constructor. | |
38 | */ | |
20399847 | 39 | IPAddrHelper::IPAddrHelper(const Logger::Ptr _log, const string& _webcheck_url, const string& _webcheck_url_alt, const int _webcheck_interval, const int _last_webcheck ,const bool _use_ipv6, const string& _proxy, const int _proxy_port) |
9a0aff44 BS |
40 | : Log(_log) |
41 | , WebcheckIpUrl(_webcheck_url) | |
b30f392d | 42 | , WebcheckIpUrlAlt(_webcheck_url_alt) |
2b0f7c11 | 43 | , WebcheckInterval(_webcheck_interval) |
20399847 | 44 | , LastWebcheck(_last_webcheck) |
9a0aff44 BS |
45 | , Proxy(_proxy) |
46 | , ProxyPort(_proxy_port) | |
47 | , UseIPv6(_use_ipv6) | |
0665b239 | 48 | { |
019dc0d9 | 49 | Hostname = net::ip::host_name(); |
019dc0d9 | 50 | Log->print_hostname(Hostname); |
0665b239 BS |
51 | } |
52 | ||
53 | ||
54 | /** | |
55 | * Default destructor | |
56 | */ | |
ad0e5016 | 57 | IPAddrHelper::~IPAddrHelper() |
0665b239 BS |
58 | { |
59 | } | |
60 | ||
61 | ||
62 | /** | |
1d2e2f56 | 63 | * Tests if a given IP is a local IPv6 address |
4ef36a12 BS |
64 | * @param ip The IP to test |
65 | * @return true if given IP is local, false if not. | |
66 | */ | |
1d2e2f56 BS |
67 | bool IPAddrHelper::is_local_ipv6(const string ip) const |
68 | { | |
69 | // IPv6 any | |
70 | boost::regex expr_any_ipv6("^::$"); | |
71 | ||
72 | // IPV6 loopback | |
73 | boost::regex expr_loopback_ipv6("^::1$"); | |
74 | ||
75 | // IPV6 local unicast address | |
76 | boost::regex expr_local_unicast_ipv6("^fc00:"); | |
77 | ||
78 | // IPV6 link local | |
79 | boost::regex expr_link_local_ipv6("^fe[8,9,a,b]{1}"); | |
80 | ||
81 | // IPV6 site local | |
82 | boost::regex expr_site_local_ipv6("^fe[c,d,e,f]{1}"); | |
83 | ||
84 | // It's time to test against the regex patterns | |
85 | if ( boost::regex_search(ip,expr_any_ipv6) ) | |
86 | { | |
87 | Log->print_regex_match(expr_any_ipv6.str(),ip); | |
88 | return true; | |
89 | } | |
90 | else if ( boost::regex_search(ip,expr_loopback_ipv6) ) | |
91 | { | |
92 | Log->print_regex_match(expr_loopback_ipv6.str(),ip); | |
93 | return true; | |
94 | } | |
95 | else if ( boost::regex_search(ip,expr_local_unicast_ipv6) ) | |
96 | { | |
97 | Log->print_regex_match(expr_local_unicast_ipv6.str(),ip); | |
98 | return true; | |
99 | } | |
100 | else if ( boost::regex_search(ip,expr_link_local_ipv6) ) | |
101 | { | |
102 | Log->print_regex_match(expr_link_local_ipv6.str(),ip); | |
103 | return true; | |
104 | } | |
105 | else if ( boost::regex_search(ip,expr_site_local_ipv6) ) | |
106 | { | |
107 | Log->print_regex_match(expr_site_local_ipv6.str(),ip); | |
108 | return true; | |
109 | } | |
110 | ||
111 | return false; | |
112 | } | |
113 | ||
114 | ||
115 | /** | |
116 | * Tests if a given IP is a local IPv4 address | |
117 | * @param ip The IP to test | |
118 | * @return true if given IP is local, false if not. | |
119 | */ | |
120 | bool IPAddrHelper::is_local_ipv4(const string ip) const | |
4ef36a12 BS |
121 | { |
122 | // 127.0.0.1 | |
123 | boost::regex expr_loopback("127\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
124 | ||
125 | // 192.168.x.x | |
126 | boost::regex expr_192("192\\.168\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
127 | ||
128 | // 10.x.x.x | |
129 | boost::regex expr_10("10\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
130 | ||
131 | // 169.254.x.x | |
132 | boost::regex expr_169_254("169\\.254\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
133 | ||
134 | // 172.16.x.x -> 172.31.x.x | |
135 | boost::regex expr_172_1("172\\.1[6-9]{1}\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
136 | boost::regex expr_172_2("172\\.2[0-9]{1}\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
137 | boost::regex expr_172_3("172\\.3[0-1]{1}\\.[0-9]{1,3}\\.[0-9]{1,3}"); | |
138 | ||
139 | // It's time to test against the regex patterns | |
140 | if ( boost::regex_search(ip,expr_loopback) ) | |
141 | { | |
142 | Log->print_regex_match(expr_loopback.str(),ip); | |
143 | return true; | |
144 | } | |
145 | else if ( boost::regex_search(ip,expr_192) ) | |
146 | { | |
147 | Log->print_regex_match(expr_192.str(),ip); | |
148 | return true; | |
149 | } | |
150 | else if ( boost::regex_search(ip,expr_10) ) | |
151 | { | |
152 | Log->print_regex_match(expr_10.str(),ip); | |
153 | return true; | |
154 | } | |
155 | else if ( boost::regex_search(ip,expr_169_254) ) | |
156 | { | |
157 | Log->print_regex_match(expr_169_254.str(),ip); | |
158 | return true; | |
159 | } | |
160 | else if ( boost::regex_search(ip,expr_172_1) ) | |
161 | { | |
162 | Log->print_regex_match(expr_172_1.str(),ip); | |
163 | return true; | |
164 | } | |
165 | else if ( boost::regex_search(ip,expr_172_2) ) | |
166 | { | |
167 | Log->print_regex_match(expr_172_2.str(),ip); | |
168 | return true; | |
169 | } | |
170 | else if ( boost::regex_search(ip,expr_172_3) ) | |
171 | { | |
172 | Log->print_regex_match(expr_172_3.str(),ip); | |
173 | return true; | |
174 | } | |
175 | ||
176 | return false; | |
177 | } | |
178 | ||
179 | ||
180 | /** | |
0665b239 BS |
181 | * Get the actual IP of this host through a conventional DNS query or through a IP webcheck URL if configured so. |
182 | * @return A string representation of the actual IP in dotted format or an empty string if something went wrong. | |
183 | */ | |
2b0f7c11 | 184 | string IPAddrHelper::get_actual_ip() |
0665b239 | 185 | { |
3c0cd271 | 186 | string ip; |
1d2e2f56 | 187 | |
20a5e1e4 | 188 | if ( WebcheckIpUrl.empty() ) |
1d2e2f56 | 189 | ip = get_local_wan_nic_ip(); |
0665b239 | 190 | else |
3c0cd271 | 191 | ip = webcheck_ip(); |
3c0cd271 | 192 | |
1d2e2f56 BS |
193 | return ip; |
194 | } | |
195 | ||
196 | ||
197 | /** | |
198 | * Get the IP address of the local wan interface if there is one. | |
199 | * @return The IP address of the wan interface or an empty string if something went wrong. | |
200 | */ | |
ce70569b | 201 | string IPAddrHelper::get_local_wan_nic_ip() const |
1d2e2f56 BS |
202 | { |
203 | struct ifaddrs *if_addr_struct, *ifa; | |
ce70569b BS |
204 | unsigned short address_family; |
205 | int ret_val; | |
1d2e2f56 BS |
206 | char ip_addr_buff[NI_MAXHOST]; |
207 | list<string> external_ipv4_addresses; | |
208 | list<string> external_ipv6_addresses; | |
209 | ||
210 | // Get linked list of all interface addresses. | |
211 | if ( getifaddrs(&if_addr_struct) == -1 ) | |
4ef36a12 | 212 | { |
1d2e2f56 BS |
213 | Log->print_error_getting_local_wan_ip("getifaddrs", strerror(errno)); |
214 | freeifaddrs(if_addr_struct); | |
4ef36a12 BS |
215 | return ""; |
216 | } | |
3c0cd271 | 217 | |
1d2e2f56 BS |
218 | // Iterate through the linked list. |
219 | for ( ifa = if_addr_struct; ifa != NULL; ifa = ifa->ifa_next) | |
220 | { | |
221 | // Get the address family of the actual address. | |
222 | address_family = ifa->ifa_addr->sa_family; | |
223 | ||
224 | // If it is an IPv4 then process further. | |
225 | if ( address_family == AF_INET ) | |
226 | { | |
227 | // Translate the address to a protocol independent representation (dottet format). Copy address into ip_addr_buff. | |
228 | ret_val = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip_addr_buff, NI_MAXHOST, NULL, 0, NI_NUMERICHOST); | |
229 | if ( ret_val != 0 ) | |
230 | { | |
231 | Log->print_error_getting_local_wan_ip("getnameinfo", gai_strerror(ret_val)); | |
232 | freeifaddrs(if_addr_struct); | |
233 | return ""; | |
234 | } | |
235 | ||
236 | // Generate IPv4 string out of char array. | |
237 | string ipv4_addr(ip_addr_buff); | |
238 | ||
239 | Log->print_own_ipv4(ipv4_addr, Hostname); | |
240 | ||
241 | // Test if it is a local address. | |
242 | if ( !is_local_ipv4(ipv4_addr) ) | |
243 | external_ipv4_addresses.push_back(ipv4_addr); | |
244 | else | |
245 | Log->print_ip_is_local(ipv4_addr); | |
246 | } | |
247 | // If it is an IPv6 address and IPv6 is enabled then process further. | |
ce70569b | 248 | else if ( (address_family == AF_INET6) && (UseIPv6) ) |
1d2e2f56 BS |
249 | { |
250 | // Translate the address to a protocol independent representation (dottet format). Copy address into ip_addr_buff. | |
251 | ret_val = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip_addr_buff, NI_MAXHOST, NULL, 0, NI_NUMERICHOST); | |
252 | if ( ret_val != 0 ) | |
253 | { | |
254 | Log->print_error_getting_local_wan_ip("getnameinfo", gai_strerror(ret_val)); | |
255 | freeifaddrs(if_addr_struct); | |
256 | return ""; | |
257 | } | |
258 | ||
259 | // Generate IPv6 string out of char array. | |
260 | string ipv6_addr(ip_addr_buff); | |
261 | ||
262 | Log->print_own_ipv6(ipv6_addr, Hostname); | |
263 | ||
264 | // Test if it is a local address. | |
265 | if ( !is_local_ipv6(ipv6_addr) ) | |
266 | external_ipv6_addresses.push_back(ipv6_addr); | |
267 | else | |
268 | Log->print_ip_is_local(ipv6_addr); | |
269 | } | |
270 | } | |
271 | freeifaddrs(if_addr_struct); | |
272 | ||
273 | // Return the first element in IPv6 list if IPv6 is enabled, otherwise return first element in IPv4 list. | |
ce70569b | 274 | if ( (UseIPv6) && (!external_ipv6_addresses.empty()) ) |
1d2e2f56 BS |
275 | return external_ipv6_addresses.front(); |
276 | else if ( !external_ipv4_addresses.empty() ) | |
277 | return external_ipv4_addresses.front(); | |
278 | ||
279 | return ""; | |
0665b239 BS |
280 | } |
281 | ||
0665b239 BS |
282 | |
283 | /** | |
687d99fb | 284 | * Get the actual IP of the given host through a DNS query. |
c3dea5dc | 285 | * @param _hostname The hostname for the dns lookup, if empty string, then perform a dns lookup to the local hostname. |
0665b239 BS |
286 | * @return A string representation of the actual IP in dotted format or an empty string if something went wrong. |
287 | */ | |
ad0e5016 | 288 | string IPAddrHelper::dns_query(const string& _hostname) const |
0665b239 | 289 | { |
1d2e2f56 BS |
290 | list<string> external_ipv4_addresses; |
291 | list<string> external_ipv6_addresses; | |
0665b239 | 292 | |
1d2e2f56 | 293 | // Init the hostname with the given _hostname or with local Hostname if empty. |
c3dea5dc BS |
294 | string hostname = Hostname; |
295 | if ( !_hostname.empty() ) | |
296 | hostname = _hostname; | |
297 | ||
0665b239 BS |
298 | try |
299 | { | |
300 | // BOOST asio isn't the simplest way to perform a DNS lookup, but it works just fine. | |
301 | net::io_service io_service; | |
302 | net::ip::tcp::resolver resolver(io_service); | |
1d2e2f56 BS |
303 | |
304 | // Define the DNS query. | |
305 | net::ip::tcp::resolver::query query(hostname, "0", net::ip::resolver_query_base::address_configured | net::ip::resolver_query_base::all_matching); | |
306 | ||
307 | // Perform the DNS query. | |
0665b239 BS |
308 | net::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); |
309 | net::ip::tcp::resolver::iterator end; | |
1d2e2f56 BS |
310 | |
311 | // Iterate through the returned IP addresses. | |
0665b239 BS |
312 | while(endpoint_iterator != end) |
313 | { | |
1d2e2f56 | 314 | // Get the IP address out of the endpoint iterator. |
687d99fb BS |
315 | net::ip::address ip; |
316 | ip = endpoint_iterator->endpoint().address(); | |
1d2e2f56 BS |
317 | |
318 | // Test if it is a IPv4 address. | |
0665b239 | 319 | if ( ip.is_v4() ) |
1d2e2f56 BS |
320 | { |
321 | // Get the string representation. | |
322 | string ipv4_addr = ip.to_string(); | |
323 | ||
324 | Log->print_own_ipv4(ipv4_addr, hostname); | |
325 | ||
326 | // If it is not a local address then push it in the external ipv4 address list. | |
327 | if ( !is_local_ipv4(ipv4_addr) ) | |
328 | external_ipv4_addresses.push_back(ipv4_addr); | |
329 | else | |
330 | Log->print_ip_is_local(ipv4_addr); | |
331 | } | |
332 | // Test if it is a IPv6 address and if IPv6 is enabled. | |
ce70569b | 333 | else if ( (ip.is_v6()) && (UseIPv6) ) |
1d2e2f56 BS |
334 | { |
335 | // Get the string representation. | |
336 | string ipv6_addr = ip.to_string(); | |
337 | ||
338 | Log->print_own_ipv6(ipv6_addr, hostname); | |
339 | ||
340 | // If it is not a local address then push it in the external ipv6 address list. | |
341 | if ( !is_local_ipv6(ipv6_addr) ) | |
342 | external_ipv6_addresses.push_back(ipv6_addr); | |
343 | else | |
344 | Log->print_ip_is_local(ipv6_addr); | |
345 | } | |
0665b239 BS |
346 | endpoint_iterator++; |
347 | } | |
348 | io_service.reset(); | |
349 | } | |
ce70569b | 350 | catch(const exception& e) |
0665b239 | 351 | { |
c3dea5dc | 352 | Log->print_error_hostname_to_ip(e.what(),hostname); |
0665b239 BS |
353 | return ""; |
354 | } | |
355 | ||
1d2e2f56 | 356 | // Return the first element in IPv6 list if IPv6 is enabled, otherwise return first element in IPv4 list. |
ce70569b | 357 | if ( (UseIPv6) && (!external_ipv6_addresses.empty()) ) |
1d2e2f56 BS |
358 | return external_ipv6_addresses.front(); |
359 | else if ( !external_ipv4_addresses.empty() ) | |
360 | return external_ipv4_addresses.front(); | |
0665b239 | 361 | |
1d2e2f56 BS |
362 | // Could not get a external IP address, so return empty string. |
363 | return ""; | |
0665b239 BS |
364 | } |
365 | ||
366 | ||
367 | /** | |
368 | * Get the actual IP of this host through a IP webcheck URL. | |
369 | * @return A string representation of the actual IP in dotted format or an empty string if something went wrong. | |
370 | */ | |
2b0f7c11 | 371 | string IPAddrHelper::webcheck_ip() |
0665b239 | 372 | { |
2b0f7c11 | 373 | // Init IPAddress with a empty string. |
1c0908b5 BS |
374 | string ip_addr = ""; |
375 | ||
2b0f7c11 | 376 | // Get the current time. |
ce70569b | 377 | time_t current_time = time(NULL); |
2b0f7c11 BS |
378 | |
379 | // Test if webcheck is allowed due to webcheck_interval. | |
380 | if ( (LastWebcheck + (WebcheckInterval*60)) >= current_time ) | |
381 | { | |
382 | // Webcheck not allowed, log it and return empty string. | |
383 | Log->print_webcheck_exceed_interval( LastWebcheck, (WebcheckInterval*60), current_time ); | |
1d2e2f56 | 384 | return ""; |
2b0f7c11 BS |
385 | } |
386 | ||
1c0908b5 BS |
387 | // Init CURL buffers |
388 | string curl_writedata_buff; | |
389 | char curl_err_buff[CURL_ERROR_SIZE]; | |
390 | int curl_err_code=1; | |
391 | ||
392 | // Init URL List | |
393 | list<string> url_list; | |
394 | url_list.push_back(WebcheckIpUrl); | |
395 | url_list.push_back(WebcheckIpUrlAlt); | |
396 | string actual_url; | |
397 | ||
398 | // Init CURL | |
399 | CURL * curl_easy_handle = init_curl(curl_writedata_buff,curl_err_buff); | |
ce70569b BS |
400 | if ( curl_easy_handle == NULL ) |
401 | { | |
402 | return ""; | |
403 | } | |
1c0908b5 BS |
404 | |
405 | // If perform_curl_operation returns a connection problem indicating return code, try the next ip webcheck url if there is one. | |
406 | while ( (curl_err_code == 1) && (url_list.size() != 0) && (url_list.front() != "") ) | |
407 | { | |
408 | // Set URL | |
409 | actual_url = url_list.front(); | |
410 | url_list.pop_front(); | |
411 | set_curl_url(curl_easy_handle,actual_url); | |
412 | ||
2b0f7c11 | 413 | // Perform curl operation, err_code of 1 indicated connection problem, so try next url. |
1c0908b5 BS |
414 | curl_err_code = perform_curl_operation(curl_easy_handle, curl_err_buff, actual_url); |
415 | } | |
416 | ||
417 | // Cleanup CURL handle | |
418 | curl_easy_cleanup(curl_easy_handle); | |
419 | ||
420 | // If curl_err_code is not 0, the ip couldn't be determined through any configured webcheck url. | |
421 | if ( curl_err_code != 0 ) | |
422 | { | |
2b0f7c11 | 423 | // Log it and return the empty string. |
1c0908b5 | 424 | Log->print_webcheck_no_ip(); |
1d2e2f56 | 425 | return ""; |
1c0908b5 BS |
426 | } |
427 | ||
2b0f7c11 | 428 | // Log the received curl data. |
1c0908b5 BS |
429 | Log->print_received_curl_data(curl_writedata_buff); |
430 | ||
1d2e2f56 BS |
431 | // Try to parse a IPv4 address out of the received data. |
432 | ip_addr = parse_ipv4(curl_writedata_buff); | |
433 | ||
5ad93dad BS |
434 | // TODO: Parsing of IPv6 address out of received curl data via webcheck IP. |
435 | ||
1d2e2f56 BS |
436 | if ( !ip_addr.empty() ) |
437 | { | |
438 | // Got a IPv4 address out of the received data. | |
439 | Log->print_own_ipv4(ip_addr, Hostname); | |
440 | } | |
441 | else | |
442 | { | |
443 | return ""; | |
444 | } | |
0665b239 | 445 | |
2b0f7c11 BS |
446 | // Set the LastWebcheck time to current time. |
447 | LastWebcheck = current_time; | |
448 | ||
1d2e2f56 BS |
449 | // If IP is within a private range then return "" |
450 | if ( is_local_ipv4(ip_addr) ) | |
451 | { | |
452 | Log->print_ip_is_local(ip_addr); | |
453 | return ""; | |
454 | } | |
455 | ||
2b0f7c11 | 456 | // Return the parsed IPAddress. |
0665b239 BS |
457 | return ip_addr; |
458 | } | |
1c0908b5 BS |
459 | |
460 | ||
461 | /** | |
1d2e2f56 | 462 | * Tries to find a IPv4 Address in dottet format in a given string and returns the IP-Address found. |
1c0908b5 BS |
463 | * @param data The string data to search in for a valid IPv4-Address. |
464 | * @return The IP Address found or an empty string. | |
465 | */ | |
1d2e2f56 | 466 | string IPAddrHelper::parse_ipv4(const string& data) const |
1c0908b5 BS |
467 | { |
468 | string ip = ""; | |
469 | ||
1d2e2f56 | 470 | // Regex for ipv4 address in dottet format |
1c0908b5 BS |
471 | boost::regex expr("([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3})"); |
472 | ||
473 | boost::smatch matches; | |
474 | ||
475 | if ( boost::regex_search(data,matches,expr) ) | |
476 | { | |
477 | ip = matches[1]; | |
1d2e2f56 | 478 | Log->print_regex_match(expr.str(),ip); |
1c0908b5 BS |
479 | } |
480 | else | |
481 | { | |
482 | Log->print_regex_ip_not_found(data); | |
483 | } | |
484 | ||
485 | return ip; | |
486 | } | |
487 | ||
488 | ||
489 | /** | |
490 | * Performs the curl operation. | |
491 | * @param curl_easy_handle The initialized and configured curl handle. | |
492 | * @param curl_err_buff The pointer to the curl error buffer to get error messages from. | |
493 | * @param actual_url The actual configured URL. | |
494 | * @return 0 if all is fine, 1 if an connection problem to the configured url occurs, -1 on other errors. | |
495 | */ | |
ce70569b | 496 | int IPAddrHelper::perform_curl_operation(CURL * curl_easy_handle, const char* curl_err_buff, const string& actual_url) const |
1c0908b5 | 497 | { |
ce70569b BS |
498 | CURLcode curl_err_code; |
499 | if ( (curl_err_code = curl_easy_perform(curl_easy_handle) ) != CURLE_OK ) | |
1c0908b5 BS |
500 | { |
501 | // CURL error occured | |
502 | if ( (curl_err_code == CURLE_COULDNT_CONNECT) || (curl_err_code == CURLE_OPERATION_TIMEOUTED) || (curl_err_code == CURLE_COULDNT_RESOLVE_HOST) ) | |
503 | { | |
504 | // In case of connection problems we should return 1, that the fallback url will be used. | |
505 | Log->print_webcheck_url_connection_problem(curl_err_buff, actual_url); | |
506 | return 1; | |
507 | } | |
508 | else | |
509 | { | |
510 | // other error | |
511 | Log->print_webcheck_error(curl_err_buff, actual_url); | |
512 | return -1; | |
513 | } | |
514 | } | |
515 | // Operation performed without any problems | |
516 | return 0; | |
517 | } | |
518 | ||
519 | ||
520 | /** | |
521 | * Sets a url to the easy curl handle | |
522 | * @param curl_easy_handle The easy curl handle to set the url for. | |
523 | * @param url The url to set. | |
524 | */ | |
ad0e5016 | 525 | void IPAddrHelper::set_curl_url(CURL * curl_easy_handle, const string& url) const |
1c0908b5 BS |
526 | { |
527 | curl_easy_setopt(curl_easy_handle,CURLOPT_URL,url.c_str()); | |
528 | } | |
529 | ||
530 | ||
531 | /** | |
532 | * Initialized curl easy handle with a few options. | |
533 | * @param curl_writedata_buff Reference to a string wich will be filled with the curl result | |
534 | * @param curl_err_buff A pointer to an char array which will be filled with error message. | |
535 | * @return A pointer to the easy curl handle. | |
536 | */ | |
ad0e5016 | 537 | CURL * IPAddrHelper::init_curl(string& curl_writedata_buff,char* curl_err_buff) const |
1c0908b5 | 538 | { |
ce70569b BS |
539 | string user_agent = "Bullet Proof DYNDNS Daemon 0.1.1 - Intra2net AG 2009"; |
540 | ||
1c0908b5 | 541 | CURL *curl_easy_handle = curl_easy_init(); |
ce70569b BS |
542 | if ( curl_easy_handle == NULL ) |
543 | { | |
544 | // something went wrong. | |
545 | Log->print_curl_error_init("Could not initialize CURL object.",CURLE_FAILED_INIT); | |
546 | return NULL; | |
547 | } | |
1c0908b5 | 548 | |
ce70569b BS |
549 | CURLcode curlError = CURLE_OK; |
550 | ||
551 | if ( curlError == CURLE_OK ) | |
552 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_NOPROGRESS,1); | |
553 | if ( curlError == CURLE_OK) | |
554 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_CONNECTTIMEOUT,5); | |
555 | if ( curlError == CURLE_OK) | |
556 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_TIMEOUT,10); | |
557 | if ( curlError == CURLE_OK) | |
558 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_BUFFERSIZE,1024); | |
559 | if ( curlError == CURLE_OK) | |
560 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_ERRORBUFFER,curl_err_buff); | |
561 | if ( curlError == CURLE_OK) | |
562 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_WRITEFUNCTION,http_receive); | |
563 | if ( curlError == CURLE_OK) | |
564 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_WRITEDATA,&curl_writedata_buff); | |
565 | if ( curlError == CURLE_OK) | |
566 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_USERAGENT,&user_agent); | |
1c0908b5 | 567 | |
4eb87664 BS |
568 | if ( !Proxy.empty() ) |
569 | { | |
ce70569b BS |
570 | if ( curlError == CURLE_OK) |
571 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_PROXY,Proxy.c_str()); | |
572 | if ( curlError == CURLE_OK) | |
573 | curlError = curl_easy_setopt(curl_easy_handle,CURLOPT_PROXYPORT,ProxyPort); | |
574 | } | |
575 | ||
576 | if ( curlError != CURLE_OK ) | |
577 | { | |
578 | // Some options could not be set, so destroy the CURL handle. | |
579 | Log->print_curl_error_init("Could not set CURL options properly.",curlError); | |
580 | curl_easy_cleanup(curl_easy_handle); | |
581 | curl_easy_handle = NULL; | |
4eb87664 BS |
582 | } |
583 | ||
1c0908b5 BS |
584 | return curl_easy_handle; |
585 | } | |
586 | ||
587 | ||
588 | /** | |
589 | * Callback Function is called every time CURL is receiving data from HTTPS-Server and will copy all received Data to the given stream pointer | |
590 | * @param inBuffer Pointer to input. | |
591 | * @param size How many mem blocks are received | |
592 | * @param nmemb size of each memblock | |
593 | * @param outBuffer Pointer to output stream. | |
594 | * @return The size received. | |
595 | */ | |
ce70569b | 596 | size_t IPAddrHelper::http_receive( const char *inBuffer, size_t size, size_t nmemb, string *outBuffer ) |
1c0908b5 BS |
597 | { |
598 | outBuffer->append(inBuffer); | |
599 | return (size*nmemb); | |
600 | } | |
20399847 BS |
601 | |
602 | ||
603 | /** | |
604 | * Get member LastWebcheck | |
605 | * @return LastWebcheck | |
606 | */ | |
607 | int IPAddrHelper::get_last_webcheck() const | |
608 | { | |
609 | return LastWebcheck; | |
610 | } |