Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
#include "net.h"
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
#include <assert.h>
|
2021-11-26 15:10:37 +08:00
|
|
|
#include <errno.h>
|
2018-02-16 21:55:33 +08:00
|
|
|
#include <stdio.h>
|
2019-12-16 04:55:43 +08:00
|
|
|
#include <SDL2/SDL_platform.h>
|
2018-02-16 21:55:33 +08:00
|
|
|
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
#include "log.h"
|
|
|
|
|
|
|
|
#ifdef __WINDOWS__
|
2021-11-18 08:02:53 +08:00
|
|
|
# include <ws2tcpip.h>
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
typedef int socklen_t;
|
2021-10-27 04:49:45 +08:00
|
|
|
typedef SOCKET sc_raw_socket;
|
2021-11-26 15:10:37 +08:00
|
|
|
# define SC_RAW_SOCKET_NONE INVALID_SOCKET
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
#else
|
|
|
|
# include <sys/types.h>
|
|
|
|
# include <sys/socket.h>
|
|
|
|
# include <netinet/in.h>
|
|
|
|
# include <arpa/inet.h>
|
|
|
|
# include <unistd.h>
|
2021-11-26 15:10:37 +08:00
|
|
|
# include <fcntl.h>
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
# define SOCKET_ERROR -1
|
|
|
|
typedef struct sockaddr_in SOCKADDR_IN;
|
|
|
|
typedef struct sockaddr SOCKADDR;
|
|
|
|
typedef struct in_addr IN_ADDR;
|
2021-10-27 04:49:45 +08:00
|
|
|
typedef int sc_raw_socket;
|
2021-11-26 15:10:37 +08:00
|
|
|
# define SC_RAW_SOCKET_NONE -1
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
#endif
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
bool
|
|
|
|
net_init(void) {
|
|
|
|
#ifdef __WINDOWS__
|
|
|
|
WSADATA wsa;
|
|
|
|
int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
|
|
|
|
if (res < 0) {
|
|
|
|
LOGC("WSAStartup failed with error %d", res);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
net_cleanup(void) {
|
|
|
|
#ifdef __WINDOWS__
|
|
|
|
WSACleanup();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
static inline sc_socket
|
|
|
|
wrap(sc_raw_socket sock) {
|
|
|
|
#ifdef __WINDOWS__
|
|
|
|
if (sock == INVALID_SOCKET) {
|
2021-11-13 16:58:52 +08:00
|
|
|
return SC_SOCKET_NONE;
|
2021-10-27 04:49:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
struct sc_socket_windows *socket = malloc(sizeof(*socket));
|
|
|
|
if (!socket) {
|
2021-11-25 05:06:11 +08:00
|
|
|
LOG_OOM();
|
2021-10-27 04:49:45 +08:00
|
|
|
closesocket(sock);
|
2021-11-13 16:58:52 +08:00
|
|
|
return SC_SOCKET_NONE;
|
2021-10-27 04:49:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
socket->socket = sock;
|
2021-10-27 04:49:45 +08:00
|
|
|
socket->closed = (atomic_flag) ATOMIC_FLAG_INIT;
|
2021-10-27 04:49:45 +08:00
|
|
|
|
|
|
|
return socket;
|
|
|
|
#else
|
|
|
|
return sock;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline sc_raw_socket
|
|
|
|
unwrap(sc_socket socket) {
|
|
|
|
#ifdef __WINDOWS__
|
2021-11-13 16:58:52 +08:00
|
|
|
if (socket == SC_SOCKET_NONE) {
|
2021-10-27 04:49:45 +08:00
|
|
|
return INVALID_SOCKET;
|
|
|
|
}
|
|
|
|
|
|
|
|
return socket->socket;
|
|
|
|
#else
|
|
|
|
return socket;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2022-01-02 06:27:34 +08:00
|
|
|
#ifndef HAVE_SOCK_CLOEXEC // avoid unused-function warning
|
2021-11-26 15:10:37 +08:00
|
|
|
static inline bool
|
|
|
|
sc_raw_socket_close(sc_raw_socket raw_sock) {
|
|
|
|
#ifndef _WIN32
|
|
|
|
return !close(raw_sock);
|
|
|
|
#else
|
|
|
|
return !closesocket(raw_sock);
|
|
|
|
#endif
|
|
|
|
}
|
2022-01-02 06:27:34 +08:00
|
|
|
#endif
|
2021-11-26 15:10:37 +08:00
|
|
|
|
|
|
|
#ifndef HAVE_SOCK_CLOEXEC
|
|
|
|
// If SOCK_CLOEXEC does not exist, the flag must be set manually once the
|
|
|
|
// socket is created
|
|
|
|
static bool
|
|
|
|
set_cloexec_flag(sc_raw_socket raw_sock) {
|
|
|
|
#ifndef _WIN32
|
|
|
|
if (fcntl(raw_sock, F_SETFD, FD_CLOEXEC) == -1) {
|
|
|
|
perror("fcntl F_SETFD");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (!SetHandleInformation((HANDLE) raw_sock, HANDLE_FLAG_INHERIT, 0)) {
|
|
|
|
LOGE("SetHandleInformation socket failed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-09-10 00:07:38 +08:00
|
|
|
static void
|
|
|
|
net_perror(const char *s) {
|
|
|
|
#ifdef _WIN32
|
2022-01-28 16:05:36 +08:00
|
|
|
sc_log_windows_error(s, WSAGetLastError());
|
2021-09-10 00:07:38 +08:00
|
|
|
#else
|
|
|
|
perror(s);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_socket
|
2021-11-01 05:01:57 +08:00
|
|
|
net_socket(void) {
|
2021-11-26 15:10:37 +08:00
|
|
|
#ifdef HAVE_SOCK_CLOEXEC
|
|
|
|
sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
|
|
|
#else
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
|
2021-11-26 15:10:37 +08:00
|
|
|
if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
|
|
|
|
sc_raw_socket_close(raw_sock);
|
|
|
|
return SC_SOCKET_NONE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_socket sock = wrap(raw_sock);
|
2021-11-13 16:58:52 +08:00
|
|
|
if (sock == SC_SOCKET_NONE) {
|
2021-09-10 00:07:38 +08:00
|
|
|
net_perror("socket");
|
2018-03-12 15:35:51 +08:00
|
|
|
}
|
2021-11-01 05:01:57 +08:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
|
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
2018-03-12 15:35:51 +08:00
|
|
|
|
|
|
|
SOCKADDR_IN sin;
|
|
|
|
sin.sin_family = AF_INET;
|
|
|
|
sin.sin_addr.s_addr = htonl(addr);
|
|
|
|
sin.sin_port = htons(port);
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
if (connect(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
|
2021-09-10 00:07:38 +08:00
|
|
|
net_perror("connect");
|
2021-11-01 05:01:57 +08:00
|
|
|
return false;
|
2018-03-12 15:35:51 +08:00
|
|
|
}
|
|
|
|
|
2021-11-01 05:01:57 +08:00
|
|
|
return true;
|
2018-03-12 15:35:51 +08:00
|
|
|
}
|
|
|
|
|
2021-11-01 05:01:57 +08:00
|
|
|
bool
|
|
|
|
net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
|
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
|
2018-02-16 22:05:43 +08:00
|
|
|
int reuse = 1;
|
2021-10-27 04:49:45 +08:00
|
|
|
if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
|
2019-03-03 03:09:56 +08:00
|
|
|
sizeof(reuse)) == -1) {
|
2021-09-10 00:07:38 +08:00
|
|
|
net_perror("setsockopt(SO_REUSEADDR)");
|
2018-02-16 22:05:43 +08:00
|
|
|
}
|
|
|
|
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
SOCKADDR_IN sin;
|
|
|
|
sin.sin_family = AF_INET;
|
|
|
|
sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
|
|
|
|
sin.sin_port = htons(port);
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
if (bind(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
|
2021-09-10 00:07:38 +08:00
|
|
|
net_perror("bind");
|
2021-11-01 05:01:57 +08:00
|
|
|
return false;
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
if (listen(raw_sock, backlog) == SOCKET_ERROR) {
|
2021-09-10 00:07:38 +08:00
|
|
|
net_perror("listen");
|
2021-11-01 05:01:57 +08:00
|
|
|
return false;
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
|
|
|
|
2021-11-01 05:01:57 +08:00
|
|
|
return true;
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_socket
|
|
|
|
net_accept(sc_socket server_socket) {
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_server_socket = unwrap(server_socket);
|
|
|
|
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
SOCKADDR_IN csin;
|
|
|
|
socklen_t sinsize = sizeof(csin);
|
2021-11-26 15:10:37 +08:00
|
|
|
|
|
|
|
#ifdef HAVE_SOCK_CLOEXEC
|
|
|
|
sc_raw_socket raw_sock =
|
|
|
|
accept4(raw_server_socket, (SOCKADDR *) &csin, &sinsize, SOCK_CLOEXEC);
|
|
|
|
#else
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock =
|
|
|
|
accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
|
2021-11-26 15:10:37 +08:00
|
|
|
if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
|
|
|
|
sc_raw_socket_close(raw_sock);
|
|
|
|
return SC_SOCKET_NONE;
|
|
|
|
}
|
|
|
|
#endif
|
2021-10-27 04:49:45 +08:00
|
|
|
|
|
|
|
return wrap(raw_sock);
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
|
|
|
|
2019-03-03 03:09:56 +08:00
|
|
|
ssize_t
|
2021-10-27 04:49:45 +08:00
|
|
|
net_recv(sc_socket socket, void *buf, size_t len) {
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
|
|
|
return recv(raw_sock, buf, len, 0);
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
|
|
|
|
2019-03-03 03:09:56 +08:00
|
|
|
ssize_t
|
2021-10-27 04:49:45 +08:00
|
|
|
net_recv_all(sc_socket socket, void *buf, size_t len) {
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
|
|
|
return recv(raw_sock, buf, len, MSG_WAITALL);
|
2018-02-16 06:55:52 +08:00
|
|
|
}
|
|
|
|
|
2019-03-03 03:09:56 +08:00
|
|
|
ssize_t
|
2021-10-27 04:49:45 +08:00
|
|
|
net_send(sc_socket socket, const void *buf, size_t len) {
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
|
|
|
return send(raw_sock, buf, len, 0);
|
Replace SDL_net by custom implementation
SDL_net is not very suitable for scrcpy.
For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it
by calling many SDL_Net-specific functions to make it blocking.
But above all, SDLNet_TCP_Open() is a server socket only when no IP is
provided; otherwise, it's a client socket. Therefore, it is not possible
to create a server socket bound to localhost, so it accepts connections
from anywhere.
This is a problem for scrcpy, because on start, the application listens
for nearly 1 second until it accepts the first connection, supposedly
from the device. If someone on the local network manages to connect to
the server socket first, then they can stream arbitrary H.264 video.
This may be troublesome, for example during a public presentation ;-)
Provide our own simplified API (net.h) instead, implemented for the
different platforms.
2018-02-16 05:59:21 +08:00
|
|
|
}
|
2018-02-16 06:55:52 +08:00
|
|
|
|
2019-03-03 03:09:56 +08:00
|
|
|
ssize_t
|
2021-10-27 04:49:45 +08:00
|
|
|
net_send_all(sc_socket socket, const void *buf, size_t len) {
|
2021-07-16 00:16:26 +08:00
|
|
|
size_t copied = 0;
|
2018-02-16 06:55:52 +08:00
|
|
|
while (len > 0) {
|
2021-10-27 04:49:45 +08:00
|
|
|
ssize_t w = net_send(socket, buf, len);
|
2018-02-16 06:55:52 +08:00
|
|
|
if (w == -1) {
|
2021-07-16 00:16:26 +08:00
|
|
|
return copied ? (ssize_t) copied : -1;
|
2018-02-16 06:55:52 +08:00
|
|
|
}
|
|
|
|
len -= w;
|
2018-04-04 16:48:14 +08:00
|
|
|
buf = (char *) buf + w;
|
2021-07-16 00:16:26 +08:00
|
|
|
copied += w;
|
2018-02-16 06:55:52 +08:00
|
|
|
}
|
2021-07-16 00:16:26 +08:00
|
|
|
return copied;
|
2018-02-16 06:55:52 +08:00
|
|
|
}
|
2018-02-16 18:11:07 +08:00
|
|
|
|
2019-03-03 06:52:22 +08:00
|
|
|
bool
|
2021-10-27 04:49:45 +08:00
|
|
|
net_interrupt(sc_socket socket) {
|
2021-11-13 16:58:52 +08:00
|
|
|
assert(socket != SC_SOCKET_NONE);
|
2021-10-27 04:49:45 +08:00
|
|
|
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
2021-10-27 04:49:45 +08:00
|
|
|
|
|
|
|
#ifdef __WINDOWS__
|
|
|
|
if (!atomic_flag_test_and_set(&socket->closed)) {
|
|
|
|
return !closesocket(raw_sock);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
#else
|
|
|
|
return !shutdown(raw_sock, SHUT_RDWR);
|
|
|
|
#endif
|
2018-02-16 18:11:07 +08:00
|
|
|
}
|
2019-12-16 04:55:43 +08:00
|
|
|
|
|
|
|
bool
|
2021-10-27 04:49:45 +08:00
|
|
|
net_close(sc_socket socket) {
|
2021-10-27 04:49:45 +08:00
|
|
|
sc_raw_socket raw_sock = unwrap(socket);
|
|
|
|
|
2019-12-16 04:55:43 +08:00
|
|
|
#ifdef __WINDOWS__
|
2021-10-27 04:49:45 +08:00
|
|
|
bool ret = true;
|
|
|
|
if (!atomic_flag_test_and_set(&socket->closed)) {
|
|
|
|
ret = !closesocket(raw_sock);
|
|
|
|
}
|
2021-10-27 04:49:45 +08:00
|
|
|
free(socket);
|
2021-10-27 04:49:45 +08:00
|
|
|
return ret;
|
2019-12-16 04:55:43 +08:00
|
|
|
#else
|
2021-10-27 04:49:45 +08:00
|
|
|
return !close(raw_sock);
|
2019-12-16 04:55:43 +08:00
|
|
|
#endif
|
|
|
|
}
|
2021-11-18 08:02:53 +08:00
|
|
|
|
|
|
|
bool
|
|
|
|
net_parse_ipv4(const char *s, uint32_t *ipv4) {
|
|
|
|
struct in_addr addr;
|
|
|
|
if (!inet_pton(AF_INET, s, &addr)) {
|
|
|
|
LOGE("Invalid IPv4 address: %s", s);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ipv4 = ntohl(addr.s_addr);
|
|
|
|
return true;
|
|
|
|
}
|