| /* |
| * Copyright 2015-2023 Rivoreo |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation, either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| */ |
| |
| #include "common.h" |
| #include <sys/types.h> |
| #include <sys/time.h> |
| #include <sys/wait.h> |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| #include <unistd.h> |
| #include "syncrw.h" |
| #include <signal.h> |
| #include <string.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <errno.h> |
| |
| #define SELECT_TIMEOUT 60 |
| |
| extern int forward(int, int); |
| |
| //static int alrm = 0; |
| |
| static void signal_handler(int sig) { |
| switch(sig) { |
| case SIGCHLD: |
| while(1) switch(waitpid(-1, NULL, WNOHANG)) { |
| case -1: |
| if(errno == EINTR) continue; |
| if(errno == ECHILD) return; |
| perror("waitpid"); |
| return; |
| case 0: |
| return; |
| //default: |
| } |
| return; |
| //case SIGALRM: |
| // alrm = 1; |
| // return; |
| } |
| } |
| |
| static int fill_address_and_port_number(char *s, struct sockaddr_in *addr) { |
| int port; |
| char *col = strchr(s, ':'); |
| if(col) { |
| *col = 0; |
| if(inet_pton(AF_INET, s, &addr->sin_addr) < 1) { |
| fprintf(stderr, "Invalid address '%s'\n", s); |
| return -1; |
| } |
| port = atoi(col + 1); |
| } else { |
| addr->sin_addr.s_addr = htonl(INADDR_ANY); |
| port = atoi(s); |
| } |
| if(port < 1) { |
| fprintf(stderr, "Port number must be greater than 0, got %d\n", port); |
| return -1; |
| } |
| addr->sin_port = htons(port); |
| return 0; |
| } |
| |
| static void print_usage(const char *name) { |
| fprintf(stderr, "Usage: %s -d [<bind-address>:]<data-listen-port> -f [<bind-address>:]<forward-listen-port>\n" |
| " [-f [<bind-address>:]<forward-listen-port>] [...]\n" |
| "Usage: %s [<bind-address>:]<forward-listen-port> [<bind-address>:]<data-listen-port>\n", |
| name, name); |
| } |
| |
| int main(int argc, char **argv) { |
| const char *name = strrchr(argv[0], '/'); |
| if(name) name++; else name = argv[0]; |
| |
| struct sockaddr_in data_listen_addr = { |
| .sin_family = AF_INET, |
| .sin_addr.s_addr = htonl(INADDR_ANY), |
| .sin_port = 0 |
| }; |
| struct sockaddr_in *forward_listen_addr_list = NULL; |
| size_t forward_listen_count = 0, forward_listen_allocated_size = 0; |
| |
| if(argc == 3 && argv[1][0] != '-' && argv[2][0] != '-') { |
| forward_listen_addr_list = malloc(sizeof(struct sockaddr_in)); |
| if(!forward_listen_addr_list) { |
| perror("malloc"); |
| return 1; |
| } |
| forward_listen_count = 1; |
| memset(forward_listen_addr_list, 0, sizeof(struct sockaddr_in)); |
| forward_listen_addr_list->sin_family = AF_INET; |
| if(fill_address_and_port_number(argv[1], forward_listen_addr_list) < 0) return -1; |
| if(fill_address_and_port_number(argv[2], &data_listen_addr) < 0) return -1; |
| } else while(1) { |
| int c = getopt(argc, argv, "d:f:h"); |
| if(c == -1) break; |
| switch(c) { |
| case 'd': |
| if(data_listen_addr.sin_port) { |
| fprintf(stderr, "%s: only one data port can be specified\n", name); |
| return -1; |
| } |
| if(fill_address_and_port_number(optarg, &data_listen_addr) < 0) return 1; |
| break; |
| case 'f': |
| if(forward_listen_count * sizeof(struct sockaddr_in) >= forward_listen_allocated_size) { |
| forward_listen_addr_list = realloc(forward_listen_addr_list, forward_listen_allocated_size += 2 * sizeof(struct sockaddr_in)); |
| if(!forward_listen_addr_list) { |
| perror("realloc"); |
| return 1; |
| } |
| } |
| memset(forward_listen_addr_list + forward_listen_count, 0, sizeof(struct sockaddr_in)); |
| forward_listen_addr_list[forward_listen_count].sin_family = AF_INET; |
| if(fill_address_and_port_number(optarg, forward_listen_addr_list + forward_listen_count) < 0) { |
| return -1; |
| } |
| forward_listen_count++; |
| break; |
| case 'h': |
| print_usage(name); |
| return 0; |
| case '?': |
| #ifdef __ANDROID__ |
| fputc('\n', stderr); |
| #endif |
| return -1; |
| } |
| } |
| |
| if(!data_listen_addr.sin_port || !forward_listen_count) { |
| print_usage(name); |
| return -1; |
| } |
| if(optind > 1 && argc > optind) { |
| fprintf(stderr, "%s: Extra '%s' in command line\n", name, argv[optind]); |
| return -1; |
| } |
| |
| struct sigaction act = { .sa_handler = SIG_IGN }; |
| if(sigaction(SIGPIPE, &act, NULL) < 0) { |
| perror("sigaction"); |
| return 1; |
| } |
| act.sa_handler = signal_handler; |
| sigaction(SIGCHLD, &act, NULL); |
| //sigaction(SIGALRM, &act, NULL); |
| |
| fprintf(stderr, "\nTCP Reverse Port Forwarding Server - %s\n" |
| RIVOREO_COPYRIGHT_NOTICE "\n" |
| LICENSE_INFORMATION "\n\n", name); |
| |
| int forward_sockets[forward_listen_count]; |
| int data_socket = socket(AF_INET, SOCK_STREAM, 0); |
| if(data_socket == -1) { |
| perror("socket"); |
| return 1; |
| } |
| static const int reuseaddr = 1; |
| if(setsockopt(data_socket, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt"); |
| |
| static const struct timeval sendtimeout = { .tv_sec = 20 }; |
| if(setsockopt(data_socket, SOL_SOCKET, SO_SNDTIMEO, &sendtimeout, sizeof sendtimeout) < 0) perror("setsockopt"); |
| |
| while(bind(data_socket, (struct sockaddr *)&data_listen_addr, sizeof data_listen_addr) < 0) { |
| if(errno == EAGAIN || errno == EINTR) continue; |
| perror("bind: data"); |
| return 1; |
| } |
| |
| if(listen(data_socket, 1) < 0) { |
| perror("listen: data"); |
| return 1; |
| } |
| |
| int i = 0; |
| do { |
| int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); |
| if(fd == -1) { |
| perror("socket"); |
| return 1; |
| } |
| if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt"); |
| const struct sockaddr_in *addr = forward_listen_addr_list + i; |
| while(bind(fd, (const struct sockaddr *)addr, sizeof(struct sockaddr_in)) < 0) { |
| int e = errno; |
| if(e == EAGAIN || e == EINTR) continue; |
| //perror("bind: forward"); |
| fprintf(stderr, "%s: bind: %s:%hu: %s\n", name, inet_ntoa(addr->sin_addr), |
| ntohs(addr->sin_port), strerror(e)); |
| return 1; |
| } |
| if(listen(fd, 1) < 0) { |
| perror("listen: forward"); |
| return 1; |
| } |
| forward_sockets[i] = fd; |
| } while(++i < forward_listen_count); |
| |
| fd_set fdset; |
| struct timeval delay_tv; |
| |
| while(1) { |
| struct sockaddr_in data_client_addr; |
| socklen_t data_addr_len = sizeof data_client_addr; |
| int data_c_fd; |
| do { |
| data_c_fd = accept(data_socket, (struct sockaddr *)&data_client_addr, &data_addr_len); |
| } while(data_c_fd == -1 && errno == EINTR); |
| if(data_c_fd == -1) { |
| perror("accept: data"); |
| sleep(1); |
| continue; |
| } |
| fprintf(stderr, "connection to data port %hu from %s port %hu fd %d\n", |
| ntohs(data_listen_addr.sin_port), inet_ntoa(data_client_addr.sin_addr), |
| ntohs(data_client_addr.sin_port), data_c_fd); |
| |
| static const struct timeval receivetimeout = { .tv_sec = 20 }; |
| if(setsockopt(data_c_fd, SOL_SOCKET, SO_RCVTIMEO, &receivetimeout, sizeof receivetimeout) < 0) perror("setsockopt"); |
| |
| int max_fd = data_c_fd; |
| FD_ZERO(&fdset); |
| FD_SET(data_c_fd, &fdset); |
| for(i=0; i<forward_listen_count; i++) { |
| FD_SET(forward_sockets[i], &fdset); |
| if(forward_sockets[i] > max_fd) max_fd = forward_sockets[i]; |
| } |
| int keep_alive_sent = 0; |
| |
| while(1) { |
| fd_set rfdset = fdset; |
| delay_tv.tv_sec = SELECT_TIMEOUT; |
| delay_tv.tv_usec = 0; |
| int n = select(max_fd + 1, &rfdset, NULL, NULL, &delay_tv); |
| if(n < 0) { |
| if(errno == EINTR) continue; |
| perror("select"); |
| sleep(1); |
| continue; |
| } |
| if(n) { |
| for(i=0; i<forward_listen_count; i++) { |
| int forward_socket = forward_sockets[i]; |
| if(!FD_ISSET(forward_socket, &rfdset)) continue; |
| struct sockaddr_in forward_client_addr; |
| socklen_t forward_addr_len = sizeof forward_client_addr; |
| int forward_c_fd; |
| do { |
| forward_c_fd = accept(forward_socket, (struct sockaddr *)&forward_client_addr, &forward_addr_len); |
| } while(forward_c_fd == -1 && errno == EINTR); |
| if(forward_c_fd == -1) { |
| perror("accept: forward"); |
| sleep(1); |
| continue; |
| } |
| char to_addr_s[16], from_addr_s[16]; |
| const struct in_addr *to_addr; |
| uint16_t to_port; |
| struct sockaddr_in local_addr; |
| socklen_t local_addr_len = sizeof local_addr; |
| if(getsockname(forward_c_fd, (struct sockaddr *)&local_addr, &local_addr_len) < 0) { |
| perror("getsockname: forward_c_fd"); |
| to_addr = &forward_listen_addr_list[i].sin_addr; |
| to_port = forward_listen_addr_list[i].sin_port; |
| } else { |
| to_addr = &local_addr.sin_addr; |
| to_port = local_addr.sin_port; |
| } |
| fprintf(stderr, "connection to forward listen address %s port %hu from %s port %hu fd %d\n", |
| inet_ntop(AF_INET, to_addr, to_addr_s, sizeof to_addr_s), ntohs(to_port), |
| inet_ntop(AF_INET, &forward_client_addr.sin_addr, from_addr_s, sizeof from_addr_s), |
| ntohs(forward_client_addr.sin_port), forward_c_fd); |
| uint16_t packet_type = htons(NEW_CONNECTION); |
| struct new_connection_packet packet; |
| packet.len = htonl(sizeof packet); |
| packet.address = forward_client_addr.sin_addr; |
| packet.port = forward_client_addr.sin_port; |
| packet.dest_address = *to_addr; |
| packet.dest_port = to_port; |
| if(sync_write(data_c_fd, MAGIC, 4) < 0 || sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0 || sync_write(data_c_fd, &packet, sizeof packet) < 0) { |
| perror("write: data"); |
| goto close_old_and_reaccept_data_connection; |
| } |
| |
| pid_t pid = fork(); |
| if(pid < 0) { |
| perror("fork"); |
| close(forward_c_fd); |
| continue; |
| } |
| if(pid) { |
| //close(data_c_fd); // Will be closed after goto |
| close(forward_c_fd); |
| goto close_old_and_reaccept_data_connection; |
| } else { |
| close(data_socket); |
| for(i=0; i<forward_listen_count; i++) close(forward_sockets[i]); |
| free(forward_listen_addr_list); |
| exit(forward(data_c_fd, forward_c_fd) < 0 ? 1 : 0); |
| } |
| } |
| if(FD_ISSET(data_c_fd, &rfdset)) { |
| char magic[sizeof MAGIC - 1]; |
| int s; |
| do { |
| s = read(data_c_fd, magic, sizeof magic); |
| } while(s < 0 && errno == EINTR); |
| if(s < (int)sizeof magic) { |
| if(s < 0) perror("read: data"); |
| else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte(s))\n", name, s); |
| break; |
| } |
| if(memcmp(magic, MAGIC, sizeof magic)) { |
| fprintf(stderr, "%s: %s:%hu: Protocol mismatch\n", name, |
| inet_ntoa(data_client_addr.sin_addr), ntohs(data_client_addr.sin_port)); |
| break; |
| } |
| uint16_t packet_type; |
| //alarm(10); |
| //alrm = 0; |
| do { |
| s = read(data_c_fd, &packet_type, sizeof packet_type); |
| } while(s < 0 && errno == EINTR/* && !alrm*/); |
| //alarm(0); |
| if(s < (int)sizeof packet_type) { |
| if(s < 0) perror("read: data"); |
| else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte)\n", name, s); |
| break; |
| } |
| packet_type = ntohs(packet_type); |
| if(packet_type == KEEP_ALIVE) { |
| fprintf(stderr, "%s: keep alive from client\n", name); |
| packet_type = htons(KEEP_ALIVE_REPLY); |
| if(sync_write(data_c_fd, MAGIC, 4) < 0 || |
| sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) { |
| perror("write: data"); |
| break; |
| } |
| } else if(packet_type == KEEP_ALIVE_REPLY) { |
| if(!keep_alive_sent) { |
| fprintf(stderr, "%s: Unexpected keep alive reply from client, disconnecting\n", name); |
| break; |
| } |
| keep_alive_sent--; |
| } else { |
| fprintf(stderr, "%s: Unknown packet type %hu received from client\n", name, packet_type); |
| break; |
| } |
| } |
| } else { |
| if(keep_alive_sent) { |
| fprintf(stderr, "%s: Client dosen't reply the recent keep alive message in %u sec\n", |
| name, (unsigned int)SELECT_TIMEOUT); |
| break; |
| } |
| uint16_t packet_type = htons(KEEP_ALIVE); |
| if(sync_write(data_c_fd, MAGIC, 4) < 0 || sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) { |
| perror("write: data"); |
| break; |
| } |
| keep_alive_sent++; |
| } |
| } |
| close_old_and_reaccept_data_connection: |
| close(data_c_fd); |
| } |
| } |