Debian Codegraph @

src/Socket.cpp

raw
1 /*
2 * Copyright (C) 2005-2021 Team Kodi (https://kodi.tv)
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later
5 * See LICENSE.md for more information.
6 */
7
8 #include "utils.h"
9 #include <string>
10 #include "Socket.h"
11
12 #include <kodi/General.h>
13
14 using namespace std;
15 using namespace MPTV;
16
17 namespace MPTV
18 {
19
20 /* Master defines for client control */
21 #define RECEIVE_TIMEOUT 6 //sec
22
23 Socket::Socket(const enum SocketFamily family, const enum SocketDomain domain, const enum SocketType type, const enum SocketProtocol protocol)
24 {
25 _sd = INVALID_SOCKET;
26 _family = family;
27 _domain = domain;
28 _type = type;
29 _protocol = protocol;
30 _port = 0;
31 memset (&_sockaddr, 0, sizeof( _sockaddr ) );
32 #ifdef TARGET_WINDOWS
33 memset(&_wsaData, 0, sizeof(_wsaData));
34 #endif
35 }
36
37
38 Socket::Socket()
39 {
40 // Default constructor, default settings
41 _sd = INVALID_SOCKET;
42 _family = af_inet;
43 _domain = pf_inet;
44 _type = sock_stream;
45 _protocol = tcp;
46 _port = 0;
47 memset (&_sockaddr, 0, sizeof( _sockaddr ) );
48 #ifdef TARGET_WINDOWS
49 memset(&_wsaData, 0, sizeof(_wsaData));
50 #endif
51 osInit();
52 }
53
54
55 Socket::~Socket()
56 {
57 close();
58 osCleanup();
59 }
60
61 bool Socket::setHostname(const std::string& host)
62 {
63 _hostname = host;
64 return true;
65 }
66
67 bool Socket::close()
68 {
69 if (is_valid())
70 {
71 if ((_sd != SOCKET_ERROR) && (_sd != INVALID_SOCKET))
72 {
73 closesocket(_sd);
74 }
75 _sd = INVALID_SOCKET;
76 return true;
77 }
78 return false;
79 }
80
81 bool Socket::create()
82 {
83 close();
84
85 return true;
86 }
87
88
89 bool Socket::bind ( const unsigned short port )
90 {
91
92 if (!is_valid())
93 {
94 return false;
95 }
96
97 _port = port;
98 _sockaddr.sin_family = (sa_family_t) _family;
99 _sockaddr.sin_addr.s_addr = INADDR_ANY; //listen to all
100 _sockaddr.sin_port = htons( _port );
101
102 int bind_return = ::bind(_sd, (sockaddr*)(&_sockaddr), sizeof(_sockaddr));
103
104 if ( bind_return == -1 )
105 {
106 errormessage( getLastError(), "Socket::bind" );
107 return false;
108 }
109
110 return true;
111 }
112
113
114 bool Socket::listen() const
115 {
116
117 if (!is_valid())
118 {
119 return false;
120 }
121
122 int listen_return = ::listen (_sd, SOMAXCONN);
123 //This is defined as 5 in winsock.h, and 0x7FFFFFFF in winsock2.h.
124 //linux 128//MAXCONNECTIONS =1
125
126 if (listen_return == -1)
127 {
128 errormessage( getLastError(), "Socket::listen" );
129 return false;
130 }
131
132 return true;
133 }
134
135
136 bool Socket::accept ( Socket& new_socket ) const
137 {
138 if (!is_valid())
139 {
140 return false;
141 }
142
143 socklen_t addr_length = sizeof( _sockaddr );
144 new_socket._sd = ::accept(_sd, const_cast<sockaddr*>( (const sockaddr*) &_sockaddr), &addr_length );
145
146 #ifdef TARGET_WINDOWS
147 if (new_socket._sd == INVALID_SOCKET)
148 #else
149 if (new_socket._sd <= 0)
150 #endif
151 {
152 errormessage( getLastError(), "Socket::accept" );
153 return false;
154 }
155
156 return true;
157 }
158
159
160 int Socket::send ( const std::string& data )
161 {
162 return Socket::send( (const char*) data.c_str(), (const unsigned int) data.size());
163 }
164
165
166 int Socket::send ( const char* data, const unsigned int len )
167 {
168 fd_set set_w, set_e;
169 struct timeval tv;
170 int result;
171
172 if (!is_valid())
173 {
174 return 0;
175 }
176
177 // fill with new data
178 tv.tv_sec = 0;
179 tv.tv_usec = 0;
180
181 FD_ZERO(&set_w);
182 FD_ZERO(&set_e);
183 FD_SET(_sd, &set_w);
184 FD_SET(_sd, &set_e);
185
186 result = select(FD_SETSIZE, &set_w, NULL, &set_e, &tv);
187
188 if (result < 0)
189 {
190 kodi::Log(ADDON_LOG_ERROR, "Socket::send - select failed");
191 close();
192 return 0;
193 }
194 if (FD_ISSET(_sd, &set_w))
195 {
196 kodi::Log(ADDON_LOG_ERROR, "Socket::send - failed to send data");
197 close();
198 return 0;
199 }
200
201 int status = ::send(_sd, data, len, 0 );
202
203 if (status == -1)
204 {
205 errormessage( getLastError(), "Socket::send");
206 kodi::Log(ADDON_LOG_ERROR, "Socket::send - failed to send data");
207 close();
208 return 0;
209 }
210 return status;
211 }
212
213
214 int Socket::sendto ( const char* data, unsigned int size, bool sendcompletebuffer)
215 {
216 int sentbytes = 0;
217 int i;
218
219 do
220 {
221 i = ::sendto(_sd, data, size, 0, (const struct sockaddr*) &_sockaddr, sizeof( _sockaddr ) );
222
223 if (i <= 0)
224 {
225 errormessage( getLastError(), "Socket::sendto");
226 osCleanup();
227 return i;
228 }
229 sentbytes += i;
230 } while ( (sentbytes < (int) size) && (sendcompletebuffer == true));
231
232 return i;
233 }
234
235
236 int Socket::receive ( std::string& data, unsigned int minpacketsize ) const
237 {
238 char * buf = NULL;
239 int status = 0;
240
241 if (!is_valid())
242 {
243 return 0;
244 }
245
246 buf = new char [ minpacketsize + 1 ];
247 memset ( buf, 0, minpacketsize + 1 );
248
249 status = receive( buf, minpacketsize, minpacketsize );
250
251 data = buf;
252
253 delete[] buf;
254 return status;
255 }
256
257
258 //Receive until error or \n
259 bool Socket::ReadLine (string& line)
260 {
261 fd_set set_r, set_e;
262 timeval timeout;
263 int retries = 6;
264 char buffer[2048];
265
266 if (!is_valid())
267 return false;
268
269 while (true)
270 {
271 size_t pos1 = line.find("\r\n", 0);
272 if (pos1 != std::string::npos)
273 {
274 line.erase(pos1, string::npos);
275 return true;
276 }
277
278 timeout.tv_sec = RECEIVE_TIMEOUT;
279 timeout.tv_usec = 0;
280
281 // fill with new data
282 FD_ZERO(&set_r);
283 FD_ZERO(&set_e);
284 FD_SET(_sd, &set_r);
285 FD_SET(_sd, &set_e);
286 int result = select(FD_SETSIZE, &set_r, NULL, &set_e, &timeout);
287
288 if (result < 0)
289 {
290 kodi::Log(ADDON_LOG_DEBUG, "%s: select failed", __FUNCTION__);
291 errormessage(getLastError(), __FUNCTION__);
292 close();
293 return false;
294 }
295
296 if (result == 0)
297 {
298 if (retries != 0)
299 {
300 kodi::Log(ADDON_LOG_DEBUG, "%s: timeout waiting for response, retrying... (%i)", __FUNCTION__, retries);
301 retries--;
302 continue;
303 } else {
304 kodi::Log(ADDON_LOG_DEBUG, "%s: timeout waiting for response. Aborting after 10 retries.", __FUNCTION__);
305 return false;
306 }
307 }
308
309 result = recv(_sd, buffer, sizeof(buffer) - 1, 0);
310 if (result < 0)
311 {
312 kodi::Log(ADDON_LOG_DEBUG, "%s: recv failed", __FUNCTION__);
313 errormessage(getLastError(), __FUNCTION__);
314 close();
315 return false;
316 }
317 buffer[result] = 0;
318
319 line.append(buffer);
320 }
321
322 return true;
323 }
324
325
326 int Socket::receive ( std::string& data) const
327 {
328 char buf[MAXRECV + 1];
329 int status = 0;
330
331 if ( !is_valid() )
332 {
333 return 0;
334 }
335
336 memset ( buf, 0, MAXRECV + 1 );
337 status = receive( buf, MAXRECV, 0 );
338 data = buf;
339
340 return status;
341 }
342
343 int Socket::receive ( char* data, const unsigned int buffersize, const unsigned int minpacketsize ) const
344 {
345 unsigned int receivedsize = 0;
346
347 if ( !is_valid() )
348 {
349 return 0;
350 }
351
352 while ( (receivedsize <= minpacketsize) && (receivedsize < buffersize) )
353 {
354 int status = ::recv(_sd, data+receivedsize, (buffersize - receivedsize), 0 );
355
356 if ( status == SOCKET_ERROR )
357 {
358 errormessage( getLastError(), "Socket::receive" );
359 return status;
360 }
361
362 receivedsize += status;
363 }
364
365 return receivedsize;
366 }
367
368
369 int Socket::recvfrom ( char* data, const int buffersize, struct sockaddr* from, socklen_t* fromlen) const
370 {
371 int status = ::recvfrom(_sd, data, buffersize, 0, from, fromlen);
372
373 return status;
374 }
375
376
377 bool Socket::connect ( const std::string& host, const unsigned short port )
378 {
379 close();
380
381 if ( !setHostname( host ) )
382 {
383 kodi::Log(ADDON_LOG_ERROR, "Socket::setHostname(%s) failed.\n", host.c_str());
384 return false;
385 }
386 _port = port;
387
388 char strPort[16];
389 snprintf(strPort, 15, "%hu", port);
390 strPort[15] = '\0';
391
392 struct addrinfo hints;
393 struct addrinfo* result = NULL;
394 struct addrinfo *address = NULL;
395 memset(&hints, 0, sizeof(hints));
396 hints.ai_family = _family;
397 hints.ai_socktype = _type;
398 hints.ai_protocol = _protocol;
399
400 int retval = getaddrinfo(host.c_str(), strPort, &hints, &result);
401 if (retval != 0)
402 {
403 errormessage(getLastError(), "Socket::connect");
404 return false;
405 }
406 if (result == NULL)
407 {
408 kodi::Log(ADDON_LOG_ERROR, "Socket::connect %s:%u: no address info found\n", host.c_str(), port);
409 return false;
410 }
411
412 for (address = result; address != NULL; address = address->ai_next)
413 {
414 // Create the socket
415 _sd = socket(address->ai_family, address->ai_socktype, address->ai_protocol);
416
417 if (_sd == INVALID_SOCKET)
418 {
419 errormessage(getLastError(), "Socket::create");
420 continue;
421 }
422
423 int status = ::connect(_sd, address->ai_addr, static_cast<int>(address->ai_addrlen));
424 if (status == SOCKET_ERROR)
425 {
426 close();
427 continue;
428 }
429
430 // We have a conection
431 break;
432 }
433
434 freeaddrinfo(result);
435
436 if (_sd == INVALID_SOCKET)
437 {
438 return false;
439 }
440
441 return true;
442 }
443
444 bool Socket::reconnect()
445 {
446 if ( is_valid() )
447 {
448 return true;
449 }
450
451 return connect(_hostname, _port);
452 }
453
454 bool Socket::is_valid() const
455 {
456 return (_sd != INVALID_SOCKET);
457 }
458
459 #if defined(TARGET_WINDOWS)
460 bool Socket::set_non_blocking ( const bool b )
461 {
462 u_long iMode;
463
464 if ( b )
465 iMode = 1; // enable non_blocking
466 else
467 iMode = 0; // disable non_blocking
468
469 if (ioctlsocket(_sd, FIONBIO, &iMode) == -1)
470 {
471 kodi::Log(ADDON_LOG_ERROR, "Socket::set_non_blocking - Can't set socket condition to: %i", iMode);
472 return false;
473 }
474
475 return true;
476 }
477
478 void Socket::errormessage( int errnum, const char* functionname) const
479 {
480 const char* errmsg = NULL;
481
482 switch (errnum)
483 {
484 case WSANOTINITIALISED:
485 errmsg = "A successful WSAStartup call must occur before using this function.";
486 break;
487 case WSAENETDOWN:
488 errmsg = "The network subsystem or the associated service provider has failed";
489 break;
490 case WSA_NOT_ENOUGH_MEMORY:
491 errmsg = "Insufficient memory available";
492 break;
493 case WSA_INVALID_PARAMETER:
494 errmsg = "One or more parameters are invalid";
495 break;
496 case WSA_OPERATION_ABORTED:
497 errmsg = "Overlapped operation aborted";
498 break;
499 case WSAEINTR:
500 errmsg = "Interrupted function call";
501 break;
502 case WSAEBADF:
503 errmsg = "File handle is not valid";
504 break;
505 case WSAEACCES:
506 errmsg = "Permission denied";
507 break;
508 case WSAEFAULT:
509 errmsg = "Bad address";
510 break;
511 case WSAEINVAL:
512 errmsg = "Invalid argument";
513 break;
514 case WSAENOTSOCK:
515 errmsg = "Socket operation on nonsocket";
516 break;
517 case WSAEDESTADDRREQ:
518 errmsg = "Destination address required";
519 break;
520 case WSAEMSGSIZE:
521 errmsg = "Message too long";
522 break;
523 case WSAEPROTOTYPE:
524 errmsg = "Protocol wrong type for socket";
525 break;
526 case WSAENOPROTOOPT:
527 errmsg = "Bad protocol option";
528 break;
529 case WSAEPFNOSUPPORT:
530 errmsg = "Protocol family not supported";
531 break;
532 case WSAEAFNOSUPPORT:
533 errmsg = "Address family not supported by protocol family";
534 break;
535 case WSAEADDRINUSE:
536 errmsg = "Address already in use";
537 break;
538 case WSAECONNRESET:
539 errmsg = "Connection reset by peer";
540 break;
541 case WSAHOST_NOT_FOUND:
542 errmsg = "Authoritative answer host not found";
543 break;
544 case WSATRY_AGAIN:
545 errmsg = "Nonauthoritative host not found, or server failure";
546 break;
547 case WSAEISCONN:
548 errmsg = "Socket is already connected";
549 break;
550 case WSAETIMEDOUT:
551 errmsg = "Connection timed out";
552 break;
553 case WSAECONNREFUSED:
554 errmsg = "Connection refused";
555 break;
556 case WSANO_DATA:
557 errmsg = "Valid name, no data record of requested type";
558 break;
559 default:
560 errmsg = "WSA Error";
561 }
562 kodi::Log(ADDON_LOG_ERROR, "%s: (Winsock error=%i) %s\n", functionname, errnum, errmsg);
563 }
564
565 int Socket::getLastError() const
566 {
567 return WSAGetLastError();
568 }
569
570 int Socket::win_usage_count = 0; //Declared static in Socket class
571
572 bool Socket::osInit()
573 {
574 win_usage_count++;
575 // initialize winsock:
576 if (WSAStartup(MAKEWORD(2,2),&_wsaData) != 0)
577 {
578 return false;
579 }
580
581 WORD wVersionRequested = MAKEWORD(2,2);
582
583 // check version
584 if (_wsaData.wVersion != wVersionRequested)
585 {
586 return false;
587 }
588
589 return true;
590 }
591
592 void Socket::osCleanup()
593 {
594 win_usage_count--;
595 if(win_usage_count == 0)
596 {
597 WSACleanup();
598 }
599 }
600
601 #elif defined TARGET_LINUX || defined TARGET_DARWIN || defined TARGET_FREEBSD
602 bool Socket::set_non_blocking ( const bool b )
603 {
604 int opts;
605
606 opts = fcntl(_sd, F_GETFL);
607
608 if ( opts < 0 )
609 {
610 return false;
611 }
612
613 if ( b )
614 opts = ( opts | O_NONBLOCK );
615 else
616 opts = ( opts & ~O_NONBLOCK );
617
618 if(fcntl (_sd , F_SETFL, opts) == -1)
619 {
620 kodi::Log(ADDON_LOG_ERROR, "Socket::set_non_blocking - Can't set socket flags to: %i", opts);
621 return false;
622 }
623 return true;
624 }
625
626 void Socket::errormessage( int errnum, const char* functionname) const
627 {
628 const char* errmsg = NULL;
629
630 switch ( errnum )
631 {
632 case EAGAIN: //same as EWOULDBLOCK
633 errmsg = "EAGAIN: The socket is marked non-blocking and the requested operation would block";
634 break;
635 case EBADF:
636 errmsg = "EBADF: An invalid descriptor was specified";
637 break;
638 case ECONNRESET:
639 errmsg = "ECONNRESET: Connection reset by peer";
640 break;
641 case EDESTADDRREQ:
642 errmsg = "EDESTADDRREQ: The socket is not in connection mode and no peer address is set";
643 break;
644 case EFAULT:
645 errmsg = "EFAULT: An invalid userspace address was specified for a parameter";
646 break;
647 case EINTR:
648 errmsg = "EINTR: A signal occurred before data was transmitted";
649 break;
650 case EINVAL:
651 errmsg = "EINVAL: Invalid argument passed";
652 break;
653 case ENOTSOCK:
654 errmsg = "ENOTSOCK: The argument is not a valid socket";
655 break;
656 case EMSGSIZE:
657 errmsg = "EMSGSIZE: The socket requires that message be sent atomically, and the size of the message to be sent made this impossible";
658 break;
659 case ENOBUFS:
660 errmsg = "ENOBUFS: The output queue for a network interface was full";
661 break;
662 case ENOMEM:
663 errmsg = "ENOMEM: No memory available";
664 break;
665 case EPIPE:
666 errmsg = "EPIPE: The local end has been shut down on a connection oriented socket";
667 break;
668 case EPROTONOSUPPORT:
669 errmsg = "EPROTONOSUPPORT: The protocol type or the specified protocol is not supported within this domain";
670 break;
671 case EAFNOSUPPORT:
672 errmsg = "EAFNOSUPPORT: The implementation does not support the specified address family";
673 break;
674 case ENFILE:
675 errmsg = "ENFILE: Not enough kernel memory to allocate a new socket structure";
676 break;
677 case EMFILE:
678 errmsg = "EMFILE: Process file table overflow";
679 break;
680 case EACCES:
681 errmsg = "EACCES: Permission to create a socket of the specified type and/or protocol is denied";
682 break;
683 case ECONNREFUSED:
684 errmsg = "ECONNREFUSED: A remote host refused to allow the network connection (typically because it is not running the requested service)";
685 break;
686 case ENOTCONN:
687 errmsg = "ENOTCONN: The socket is associated with a connection-oriented protocol and has not been connected";
688 break;
689 //case E:
690 // errmsg = "";
691 // break;
692 default:
693 break;
694 }
695 kodi::Log(ADDON_LOG_ERROR, "%s: (errno=%i) %s\n", functionname, errnum, errmsg);
696 }
697
698 int Socket::getLastError() const
699 {
700 return errno;
701 }
702
703 bool Socket::osInit()
704 {
705 // Not needed for Linux
706 return true;
707 }
708
709 void Socket::osCleanup()
710 {
711 // Not needed for Linux
712 }
713 #endif //TARGET_WINDOWS || TARGET_LINUX || TARGET_DARWIN || TARGET_FREEBSD
714
715 } //namespace MPTV