blob: bc61f688ba8a272b9c2a477383fafa7ecef9f07d [file] [log] [blame] [raw]
/*
* 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 3 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.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include "syncrw.h"
#include "base64.h"
#include <fcntl.h>
#include <dirent.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <errno.h>
#include <arpa/inet.h>
#include "sshout/api.h"
#ifndef SSHOUT_USER_NAME
#define SSHOUT_USER_NAME "sshout"
#endif
#ifndef MIN
#define MIN(A,B) ((A)<(B)?(A):(B))
#endif
#ifdef __linux__
static struct stat root_status;
static void destroy_cpanel_securetmp() {
// Too lazy to translate this into C...
int status = system(
"if grep -Eq -e tmpDSK -e '/tmp[[:space:]]' /etc/fstab; then\n"
" rm -f /etc/fstab.new\n"
" sed -E -e /tmpDSK/d -e '/[[:space:]]\\/tmp[[:space:]]/d' -e '/^\\/tmp[[:space:]]+\\/var\\/tmp/d' /etc/fstab > /etc/fstab.new && mv /etc/fstab.new /etc/fstab\n"
"fi\n"
"from=\"`sed -En 's#^(/dev/loop[0-9]+) /tmp .+#\\\\1#p' /proc/mounts`\" && [ -n \"$from\" ] || exit\n"
"from=\"${from##*\n}\"\n"
"[ -b \"$from\" ] || exit\n"
"cat < /dev/urandom > \"$from\" &\n"
"umount -l /tmp/ &\n"
"true\n"
);
if(status) return;
struct stat tmp_status;
do {
if(stat("/tmp", &tmp_status) < 0) {
unlink("/tmp");
mkdir("/tmp", 01777);
chmod("/tmp", 01777);
return;
}
} while(tmp_status.st_dev != root_status.st_dev);
}
#endif
static const unsigned char sshout_server_public_key[] = {
SSHOUT_SERVER_PUBLIC_KEY
};
static const unsigned char sshout_client_private_key[] = {
SSHOUT_CLIENT_PRIVATE_KEY
};
extern const char check_sshout_server_public_key[sizeof sshout_server_public_key > 4 ? 1 : -1];
static char private_tmp_dir[sizeof "/tmp/sfc.XXXXXX"];
static void *malloc_wait(size_t size) {
void *p;
if(!size) return NULL;
while(!(p = malloc(size))) sleep(1);
return p;
}
static void *realloc_wait(void *p, size_t size) {
void *new_p;
if(!size) {
free(p);
return NULL;
}
while(!(new_p = realloc(p, size))) sleep(1);
return new_p;
}
static int prepare_tmp_files(char **ssh_user_known_hosts_file_option, char **identity_file_path) {
static uint32_t public_key_type_length;
if(!public_key_type_length) public_key_type_length = ntohl(*(uint32_t *)sshout_server_public_key);
#ifdef __linux__
destroy_cpanel_securetmp();
#endif
size_t base64_buffer_size = public_key_type_length + sizeof sshout_server_public_key * 2;
char server_public_key_base64[base64_buffer_size];
memcpy(server_public_key_base64, sshout_server_public_key + 4, public_key_type_length);
server_public_key_base64[public_key_type_length] = ' ';
base64_encode(sshout_server_public_key, sizeof sshout_server_public_key,
server_public_key_base64 + public_key_type_length + 1,
base64_buffer_size - public_key_type_length - 1,
BASE64_ADD_PADDING);
base64_buffer_size = sizeof sshout_client_private_key * 2;
char client_private_key_base64[base64_buffer_size];
base64_encode(sshout_client_private_key, sizeof sshout_client_private_key,
client_private_key_base64, base64_buffer_size, BASE64_ADD_PADDING);
strcpy(private_tmp_dir, "/tmp/sfc.XXXXXX");
if(!mkdtemp(private_tmp_dir)) {
*private_tmp_dir = 0;
return -1;
}
int dir_fd = open(private_tmp_dir, O_RDONLY | O_DIRECTORY);
if(dir_fd == -1) return -1;
int fd = openat(dir_fd, "known_hosts", O_WRONLY | O_CREAT | O_TRUNC, 0640);
if(fd == -1) {
close(dir_fd);
return -1;
}
FILE *f = fdopen(fd, "w");
if(!f) {
close(dir_fd);
close(fd);
return -1;
}
#if SSHOUT_SERVER_PORT != 22
if(fprintf(f, "[%s]:%u %s\n", SSHOUT_SERVER_NAME, SSHOUT_SERVER_PORT, server_public_key_base64) < 0) goto fail;
#endif
if(fprintf(f, "%s %s\n", SSHOUT_SERVER_NAME, server_public_key_base64) < 0) goto fail;
fclose(f);
fd = openat(dir_fd, "id_rsa", O_WRONLY | O_CREAT | O_TRUNC, 0600);
if(fd == -1) {
close(dir_fd);
return -1;
}
close(dir_fd);
dir_fd = -1;
f = fdopen(fd, "w");
if(!f) {
close(fd);
return -1;
}
//if(fprintf(f, "-----BEGIN RSA PRIVATE KEY-----\n%s\n-----END RSA PRIVATE KEY-----\n", client_private_key_base64) < 0) goto fail;
if(fputs("-----BEGIN RSA PRIVATE KEY-----\n", f) == EOF) goto fail;
int base64_len = strlen(client_private_key_base64);
int i = 0, chunk_size;
do {
chunk_size = MIN(base64_len - i, 64);
if(fwrite(client_private_key_base64 + i, chunk_size, 1, f) < 1) goto fail;
if(fputc('\n', f) == EOF) goto fail;
} while(chunk_size == 64 && (i += 64));
if(fputs("-----END RSA PRIVATE KEY-----\n", f) == EOF) goto fail;
fclose(f);
*ssh_user_known_hosts_file_option =
malloc_wait(sizeof "UserKnownHostsFile" + sizeof private_tmp_dir + sizeof "known_hosts");
memcpy(*ssh_user_known_hosts_file_option, "UserKnownHostsFile ", sizeof "UserKnownHostsFile");
memcpy(*ssh_user_known_hosts_file_option + sizeof "UserKnownHostsFile", private_tmp_dir, sizeof private_tmp_dir - 1);
(*ssh_user_known_hosts_file_option)[sizeof "UserKnownHostsFile" + sizeof private_tmp_dir - 1] = '/';
strcpy(*ssh_user_known_hosts_file_option + sizeof "UserKnownHostsFile" + sizeof private_tmp_dir, "known_hosts");
*identity_file_path = malloc_wait(sizeof private_tmp_dir + sizeof "id_rsa");
memcpy(*identity_file_path, private_tmp_dir, sizeof private_tmp_dir - 1);
(*identity_file_path)[sizeof private_tmp_dir - 1] = '/';
strcpy(*identity_file_path + sizeof private_tmp_dir, "id_rsa");
return 0;
fail:
fclose(f);
if(dir_fd != -1) close(dir_fd);
return -1;
}
static void clean_tmp_files() {
if(!*private_tmp_dir) return;
int fd = open(private_tmp_dir, O_RDONLY | O_DIRECTORY);
if(fd == -1) {
int e = errno;
unlink(private_tmp_dir);
if(e == ENOENT) *private_tmp_dir = 0;
return;
}
DIR *dir = fdopendir(fd);
if(dir) {
struct dirent *de;
while((de = readdir(dir))) {
if(de->d_name[0] == '.' && (!de->d_name[1] || (de->d_name[1] == '.' && !de->d_name[2]))) continue;
unlinkat(fd, de->d_name, 0);
}
closedir(dir);
} else close(fd);
rmdir(private_tmp_dir);
}
#define SSHOUT_MAX_API_VERSION 1
static pid_t sshout_ssh_pid = -1;
static void signal_handler(int sig) {
if(sig != SIGCHLD) return;
while(1) {
pid_t pid = waitpid(-1, NULL, WNOHANG);
if(pid == -1) {
if(errno == EINTR) continue;
if(errno == ECHILD) return;
perror("waitpid");
return;
}
if(!pid) return;
if(pid == sshout_ssh_pid) sshout_ssh_pid = -1;
}
}
static pid_t start_ssh_process(const char *host, uint16_t port, const char *user, const char *command, char **extra_argv, int *pipe_write_fd, int *pipe_read_fd) {
int pipe_fds_0[2];
int pipe_fds_1[2];
if(pipe(pipe_fds_0) < 0) {
perror("pipe");
goto failed;
}
if(pipe(pipe_fds_1) < 0) {
perror("pipe");
close(pipe_fds_0[0]);
close(pipe_fds_0[1]);
goto failed;
}
pid_t pid = fork();
if(pid < 0) {
perror("fork");
close(pipe_fds_0[0]);
close(pipe_fds_0[1]);
close(pipe_fds_1[0]);
close(pipe_fds_1[1]);
goto failed;
}
if(pid) {
close(pipe_fds_0[0]);
close(pipe_fds_1[1]);
*pipe_write_fd = pipe_fds_0[1];
*pipe_read_fd = pipe_fds_1[0];
return pid;
} else {
unsigned int count = 11;
if(extra_argv) {
char **v = extra_argv;
while(*v++) count++;
}
unsigned int count_without_command = count;
if(command) count += 2;
char port_number_s[6];
snprintf(port_number_s, sizeof port_number_s, "%hu", (unsigned short int)port);
char *full_argv[count + 1];
full_argv[0] = "ssh";
full_argv[1] = "-o";
full_argv[2] = "ServerAliveInterval=120";
full_argv[3] = "-o";
full_argv[4] = "PasswordAuthentication=no";
full_argv[5] = (char *)host;
full_argv[6] = "-p";
full_argv[7] = port_number_s;
full_argv[8] = "-l";
full_argv[9] = (char *)user;
full_argv[10] = "-Tv";
if(extra_argv && count_without_command > 11) memcpy(full_argv + 11, extra_argv, sizeof(char *) * (count_without_command - 11));
if(command) {
full_argv[count - 2] = "--";
full_argv[count - 1] = (char *)command;
}
full_argv[count] = NULL;
close(pipe_fds_0[1]);
close(pipe_fds_1[0]);
close(0);
close(1);
if(dup2(pipe_fds_0[0], 0) == -1) {
perror("dup2");
_exit(1);
}
if(dup2(pipe_fds_1[1], 1) == -1) {
perror("dup2");
_exit(1);
}
execvp("ssh", full_argv);
perror("ssh");
_exit(1);
}
failed:
*pipe_write_fd = -1;
*pipe_read_fd = -1;
return -1;
}
static unsigned int sshout_api_version;
static char sshout_canonical_user_name[32];
static unsigned int sshout_canonical_user_name_length;
#define GET_PACKET_EOF -1
#define GET_PACKET_ERROR -2
#define GET_PACKET_SHORT_READ -3
#define GET_PACKET_TOO_SMALL -4
#define GET_PACKET_TOO_LARGE -5
#define GET_PACKET_OUT_OF_MEMORY -6
#define GET_PACKET_INCOMPLETE -7
static int sshout_get_api_packet(int fd, struct sshout_api_packet **packet, uint32_t *length, int block_read) {
uint32_t orig_length;
int s;
if(block_read) s = sync_read(fd, &orig_length, sizeof orig_length);
else do {
s = read(fd, &orig_length, sizeof orig_length);
} while(s < 0 && errno == EINTR);
if(s < 0) return GET_PACKET_ERROR;
if(!s) return GET_PACKET_EOF;
if(s < sizeof orig_length) return block_read ? GET_PACKET_EOF : GET_PACKET_SHORT_READ;
*length = ntohl(orig_length);
if(*length < 1) return GET_PACKET_TOO_SMALL;
if(*length > SSHOUT_API_PACKET_MAX_LENGTH) return GET_PACKET_TOO_LARGE;
*packet = malloc(sizeof orig_length + *length);
if(!*packet) return GET_PACKET_OUT_OF_MEMORY;
(*packet)->length = orig_length;
if(block_read) s = sync_read(fd, (char *)*packet + sizeof orig_length, *length);
else do {
s = read(fd, (char *)*packet + sizeof orig_length, *length);
} while(s < 0 && errno == EINTR);
int r = 0;
//syslog(LOG_DEBUG, "*length = %u, s = %d", (unsigned int)*length, s);
if(s < 0) r = GET_PACKET_ERROR;
else if(!s) r = GET_PACKET_EOF;
else if(s < *length) r = block_read ? GET_PACKET_EOF : GET_PACKET_SHORT_READ;
if(r) free(*packet);
return r;
}
static void sshout_send_hello(int fd) {
uint32_t length = 1 + 6 + 2;
struct sshout_api_packet *packet = malloc_wait(4 + length);
packet->length = htonl(length);
packet->type = SSHOUT_API_HELLO;
uint8_t *p = packet->data;
memcpy(p, "SSHOUT", 6);
p += 6;
*(uint16_t *)p = htons(SSHOUT_MAX_API_VERSION);
if(sync_write(fd, packet, 4 + length) < 0) {
//perror("sshout_send_hello: write");
}
}
static void sshout_send_plain_text_message_fixed_length(int fd, const char *to_user, const char *message, size_t len) {
size_t user_name_len = strlen(to_user);
if(user_name_len > 255) user_name_len = 255;
size_t length = 1 + 1 + user_name_len + 1 + 4 + len;
struct sshout_api_packet *packet = malloc_wait(4 + length);
packet->length = htonl(length);
packet->type = SSHOUT_API_SEND_MESSAGE;
uint8_t *p = packet->data;
*p++ = user_name_len;
memcpy(p, to_user, user_name_len);
p += user_name_len;
*p++ = SSHOUT_API_MESSAGE_TYPE_PLAIN;
*(uint32_t *)p = htonl(len);
p += 4;
memcpy(p, message, len);
if(sync_write(fd, packet, 4 + length) < 0) {
//perror("sshout_send_plain_text_message_fixed_length: write");
}
free(packet);
}
static void report_shell_command_error(int sshout_write_fd, const char *to_user, const char *command, size_t command_len, const char *failed_call, int e) {
const char *emsg = strerror(e);
size_t emsg_len = strlen(emsg);
size_t func_name_len = strlen(failed_call);
size_t reply_len = 29 + command_len + 3 + func_name_len + 2 + emsg_len;
char reply[reply_len];
memcpy(reply, "Failed to run shell command '", 29);
memcpy(reply + 29, command, command_len);
memcpy(reply + 29 + command_len, "': ", 3);
memcpy(reply + 29 + command_len + 3, failed_call, func_name_len);
memcpy(reply + 29 + command_len + 3 + func_name_len, ": ", 2);
memcpy(reply + 29 + command_len + 3 + func_name_len + 2, emsg, emsg_len);
sshout_send_plain_text_message_fixed_length(sshout_write_fd, to_user, reply, reply_len);
}
static void run_shell_command(int sshout_write_fd, const char *to_user, const char *command, size_t command_len) {
int pipe_fds[2];
if(pipe(pipe_fds) < 0) {
report_shell_command_error(sshout_write_fd, to_user, command, command_len, "pipe", errno);
return;
}
pid_t pid = fork();
if(pid < 0) {
report_shell_command_error(sshout_write_fd, to_user, command, command_len, "fork", errno);
close(pipe_fds[0]);
close(pipe_fds[1]);
return;
}
if(pid) {
size_t output_length = 0;
size_t buffer_size = 4096;
char *buffer = malloc_wait(buffer_size);
close(pipe_fds[1]);
while(1) {
int s = read(pipe_fds[0], buffer + output_length, buffer_size - output_length);
if(s < 0) {
if(errno == EINTR) continue;
break;
}
if(!s) break;
output_length += s;
if(buffer_size <= output_length) {
buffer_size += 4096;
buffer = realloc_wait(buffer, buffer_size);
}
}
close(pipe_fds[0]);
int status;
while(waitpid(pid, &status, 0) < 0) {
if(errno == EINTR) continue;
report_shell_command_error(sshout_write_fd, to_user, command, command_len, "waitpid", errno);
return;
}
size_t reply_len = 9 + command_len + 32;
char *reply = malloc_wait(reply_len);
memcpy(reply, "Command '", 9);
memcpy(reply + 9, command, command_len);
int part3_len = WIFSIGNALED(status) ?
snprintf(reply + 9 + command_len, 32,
"' terminated by signal %d", WTERMSIG(status)) :
snprintf(reply + 9 + command_len, 32,
"' exited with status %d", WEXITSTATUS(status));
if(output_length) {
size_t final_reply_len = 9 + command_len + part3_len + 9 + output_length;
if(final_reply_len > reply_len) reply = realloc_wait(reply, final_reply_len);
reply_len = final_reply_len;
memcpy(reply + 9 + command_len + part3_len, "\nOutput:\n", 9);
memcpy(reply + 9 + command_len + part3_len + 9, buffer, output_length);
} else {
size_t final_reply_len = 9 + command_len + part3_len + 27;
if(final_reply_len > reply_len) reply = realloc_wait(reply, final_reply_len);
reply_len = final_reply_len;
memcpy(reply + 9 + command_len + part3_len, "\nCommand produces no output", 27);
}
free(buffer);
sshout_send_plain_text_message_fixed_length(sshout_write_fd, to_user, reply, reply_len);
free(reply);
} else {
close(pipe_fds[0]);
dup2(pipe_fds[1], STDOUT_FILENO);
dup2(pipe_fds[1], STDERR_FILENO);
if(pipe_fds[1] != STDOUT_FILENO && pipe_fds[1] != STDERR_FILENO) close(pipe_fds[1]);
char command_s[command_len + 1];
memcpy(command_s, command, command_len);
command_s[command_len] = 0;
#ifdef SHELL
execl(SHELL, SHELL, "-c", command_s, (char *)NULL);
#endif
execl("/bin/bash", "bash", "-c", command_s, (char *)NULL);
execlp("bash", "bash", "-c", command_s, (char *)NULL);
execl("/bin/sh", "sh", "-c", command_s, (char *)NULL);
execlp("sh", "sh", "-c", command_s, (char *)NULL);
_exit(127);
}
}
static int do_sshout_message(int sshout_write_fd, uint8_t *p, uint32_t data_length) {
if(8 + 1 > data_length) return -1;
//uint64_t t = ntoh64(*(uint64_t *)p);
p += 8;
uint8_t from_user_len = *p++;
if(8 + 1 + from_user_len > data_length) return -1;
char from_user[from_user_len + 1];
memcpy(from_user, p, from_user_len);
from_user[from_user_len] = 0;
p += from_user_len;
if(strcmp(from_user, sshout_canonical_user_name) == 0) return 0;
if(strcmp(from_user, PRIVILEGED_USER_NAME)) return 0;
uint8_t to_user_len = *p++;
if(8 + 1 + from_user_len + 1 + to_user_len > data_length) return -1;
char to_user[to_user_len + 1];
memcpy(to_user, p, to_user_len);
to_user[to_user_len] = 0;
p += to_user_len;
uint8_t message_type = *p++;
uint32_t message_len = ntohl(*(uint32_t *)p);
if(8 + 1 + from_user_len + 1 + to_user_len + 1 + 4 + message_len < message_len) return -1;
if(8 + 1 + from_user_len + 1 + to_user_len + 1 + 4 + message_len > data_length) return -1;
p += 4;
if(message_type != SSHOUT_API_MESSAGE_TYPE_PLAIN) return 0;
if(*p == '/') {
const char *command = (const char *)p + 1;
size_t len = message_len - 1;
char reply[17 + len + 1];
memcpy(reply, "Unknown command '", 17);
memcpy(reply + 17, command, len);
reply[17 + len] = '\'';
sshout_send_plain_text_message_fixed_length(sshout_write_fd, from_user, reply, 17 + len + 1);
return 0;
}
run_shell_command(sshout_write_fd, from_user, (const char *)p, message_len);
return 0;
}
static void do_sshout_packet(int sshout_read_fd, int sshout_write_fd) {
struct sshout_api_packet *packet;
uint32_t length;
int e = sshout_get_api_packet(sshout_read_fd, &packet, &length, 1);
switch(e) {
case GET_PACKET_EOF:
clean_tmp_files();
sleep(1);
return;
case GET_PACKET_ERROR:
fprintf(stderr, "fd %d: %s\n", sshout_read_fd, strerror(errno));
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
return;
case GET_PACKET_SHORT_READ:
fprintf(stderr, "fd %d short read\n", sshout_read_fd);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
return;
case GET_PACKET_TOO_SMALL:
fprintf(stderr, "Received API packet too small\n");
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
return;
case GET_PACKET_TOO_LARGE:
fprintf(stderr, "Received API packet too large (%u bytes)\n", length);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
return;
case GET_PACKET_OUT_OF_MEMORY:
fprintf(stderr, "Out of memory\n");
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
return;
case 0:
break;
default:
fprintf(stderr, "Unknown error %d from sshout_get_api_packet\n", e);
abort();
}
switch(packet->type) {
case SSHOUT_API_PASS:
if(length < 1 + 6 + 2 + 1) {
fprintf(stderr, "SSHOUT_API_PASS: malformed packet: too short (%u bytes)\n", (unsigned int)length);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
break;
}
if(memcmp(packet->data, "SSHOUT", 6)) {
fprintf(stderr, "SSHOUT_API_PASS: handshake failed, magic mismatch\n");
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
break;
}
if(sshout_api_version) {
fprintf(stderr, "SSHOUT_API_PASS: handshake is already done in this session\n");
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
//sshout_api_version = 0;
break;
}
sshout_api_version = ntohs(*(uint16_t *)(packet->data + 6));
if(sshout_api_version > SSHOUT_MAX_API_VERSION) {
// Server shouldn't reply version higher than what we passed in SSHOUT_API_HELLO, but...
fprintf(stderr, "SSHOUT_API_PASS: invalid API version %u from server\n", sshout_api_version);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
sshout_api_version = 0;
break;
}
{
uint8_t user_name_len = *(uint8_t *)(packet->data + 6 + 2);
if(user_name_len > sizeof sshout_canonical_user_name - 1) {
fprintf(stderr, "SSHOUT_API_PASS: user name too long (%hhu)\n", user_name_len);
user_name_len = sizeof sshout_canonical_user_name - 1;
}
if(1 + 6 + 2 + 1 + user_name_len > length) {
fprintf(stderr, "SSHOUT_API_PASS: malformed packet: user_name is longer than packet (user_name_len=%hhu)\n", user_name_len);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
break;
}
sshout_canonical_user_name_length = user_name_len;
memcpy(sshout_canonical_user_name, packet->data + 6 + 2 + 1, user_name_len);
sshout_canonical_user_name[user_name_len] = 0;
}
clean_tmp_files();
break;
case SSHOUT_API_ONLINE_USERS_INFO:
break;
case SSHOUT_API_RECEIVE_MESSAGE:
if(do_sshout_message(sshout_write_fd, packet->data, length - 1) < 0) {
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
}
break;
case SSHOUT_API_USER_STATE_CHANGE:
break;
case SSHOUT_API_ERROR:
if(1 + 4 + 4 > length) {
fprintf(stderr, "SSHOUT_API_ERROR: malformed packet: too short (%u bytes)\n", (unsigned int)length);
if(sshout_ssh_pid > 0) kill(sshout_ssh_pid, SIGTERM);
break;
}
{
uint32_t error_code = ntohl(*(uint32_t *)packet->data);
fprintf(stderr, "SSHOUT error %u\n", (unsigned int)error_code);
}
break;
case SSHOUT_API_MOTD:
break;
}
free(packet);
}
int main() {
#ifdef __linux__
if(stat("/", &root_status) < 0) {
perror("/");
return 1;
}
#endif
char *sshout_ssh_options[] = {
"-o", "ConnectTimeout 20",
"-o", "PubkeyAuthentication yes",
"-o", "StrictHostKeyChecking yes",
"-o", "GlobalKnownHostsFile /dev/null",
"-o", NULL,
"-i", NULL,
NULL
};
//char *sshout_server_name = NULL;
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);
int sshout_write_fd = -1, sshout_read_fd = -1;
fd_set rfdset;
while(1) {
if(sshout_ssh_pid == -1 || kill(sshout_ssh_pid, 0) < 0) {
clean_tmp_files();
if(sshout_write_fd != -1) close(sshout_write_fd);
if(sshout_read_fd != -1) close(sshout_read_fd);
if(prepare_tmp_files(sshout_ssh_options + 9, sshout_ssh_options + 11) < 0) {
sleep(1);
continue;
}
sshout_api_version = 0;
sshout_ssh_pid = start_ssh_process(SSHOUT_SERVER_NAME, SSHOUT_SERVER_PORT, SSHOUT_USER_NAME, "api", sshout_ssh_options, &sshout_write_fd, &sshout_read_fd);
free(sshout_ssh_options[9]);
free(sshout_ssh_options[11]);
if(sshout_ssh_pid == -1) {
sleep(1);
continue;
}
sshout_send_hello(sshout_write_fd);
}
FD_ZERO(&rfdset);
FD_SET(sshout_read_fd, &rfdset);
if(select(sshout_read_fd + 1, &rfdset, NULL, NULL, NULL) < 0) {
if(errno == EINTR) continue;
perror("select");
sleep(1);
continue;
}
if(FD_ISSET(sshout_read_fd, &rfdset)) {
do_sshout_packet(sshout_read_fd, sshout_write_fd);
}
}
}