261 lines
7.0 KiB
C
261 lines
7.0 KiB
C
#include <arpa/inet.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <netdb.h>
|
|
#include <netinet/in.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#include "server.h"
|
|
|
|
extern char *program_name;
|
|
|
|
extern volatile sig_atomic_t quit;
|
|
|
|
/*
|
|
* Prints a usage message and exits.
|
|
* @param msg Additional output message.
|
|
*/
|
|
static void usage(const char *msg) {
|
|
fprintf(stderr, "Usage: %s [-p PORT] COMMAND\n%s\n", program_name, msg);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
/*
|
|
* Print an error message and exit with EXIT_FAILURE.
|
|
* @param msg Additional output message.
|
|
*/
|
|
static void error_exit(const char *msg) {
|
|
if (errno == 0)
|
|
fprintf(stderr, "[%s] [ERROR] %s\n", program_name, msg);
|
|
else
|
|
fprintf(stderr, "[%s] [ERROR] %s - %s\n", program_name, msg,
|
|
strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
static void print_error(const char *msg) {
|
|
fprintf(stderr, "[%s] [ERROR] %s - %s\n", program_name, msg,
|
|
strerror(errno));
|
|
}
|
|
|
|
static void print_message(const char *msg) {
|
|
fprintf(stderr, "[%s] %s\n", program_name, msg);
|
|
}
|
|
|
|
/**
|
|
* @brief Function freeing the resources.
|
|
*/
|
|
void free_resources(void) {
|
|
}
|
|
|
|
/*
|
|
* Parse Arguments
|
|
*/
|
|
void parse_arguments(int argc, char *argv[], struct arguments *args) {
|
|
memset(args, 0, sizeof(*args));
|
|
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "p:")) != -1) {
|
|
switch (opt) {
|
|
case 'p':
|
|
if (args->port_str)
|
|
usage("-p option allowed only once");
|
|
args->port_str = optarg;
|
|
break;
|
|
default:
|
|
usage("invalid option");
|
|
}
|
|
}
|
|
if (args->port_str == NULL)
|
|
args->port_str = "2020";
|
|
|
|
if (argc - optind != 1)
|
|
usage("invalid number of arguments");
|
|
|
|
args->command = argv[optind];
|
|
}
|
|
|
|
/*
|
|
* Custom getaddrinfo implementation for localhost only.
|
|
*/
|
|
int getaddrinfo(const char *node, const char *service,
|
|
const struct addrinfo *hints, struct addrinfo **res) {
|
|
struct in_addr localhost;
|
|
localhost.s_addr = htonl(0x7f000001); // 127.0.0.1
|
|
|
|
// check hostname (allow only `localhost' or any string which `inet_aton()'
|
|
// converts to 127.0.0.1)
|
|
struct in_addr node_addr;
|
|
if (node != NULL &&
|
|
(inet_aton(node, &node_addr) == 0 ||
|
|
node_addr.s_addr != localhost.s_addr) &&
|
|
strcmp(node, "localhost") != 0)
|
|
return EAI_NONAME;
|
|
|
|
// check port (allow only numerical ports)
|
|
char *endptr;
|
|
int port = strtol(service, &endptr, 10);
|
|
|
|
if (*endptr != '\0')
|
|
return EAI_NONAME;
|
|
|
|
// check hints (NULL is acceptable)
|
|
if (hints != NULL) {
|
|
// check family
|
|
if (hints->ai_family != AF_UNSPEC && hints->ai_family != AF_INET)
|
|
return EAI_FAMILY;
|
|
|
|
// check socket type
|
|
if (hints->ai_socktype != 0 && hints->ai_socktype != SOCK_STREAM)
|
|
return EAI_SOCKTYPE;
|
|
|
|
// check protocol
|
|
if (hints->ai_protocol != 0 && hints->ai_protocol != IPPROTO_TCP)
|
|
return EAI_SOCKTYPE;
|
|
}
|
|
|
|
// allocate memory for result
|
|
*res = malloc(sizeof(struct addrinfo));
|
|
struct sockaddr_in *sin = malloc(sizeof(struct sockaddr_in));
|
|
|
|
if (*res == NULL || sin == NULL)
|
|
return EAI_MEMORY;
|
|
|
|
memset(sin, 0, sizeof(struct sockaddr_in));
|
|
sin->sin_family = AF_INET;
|
|
sin->sin_addr = localhost;
|
|
sin->sin_port = htons(port);
|
|
|
|
(*res)->ai_flags = (AI_V4MAPPED | AI_ADDRCONFIG);
|
|
(*res)->ai_family = AF_INET;
|
|
(*res)->ai_socktype = SOCK_STREAM;
|
|
(*res)->ai_protocol = IPPROTO_TCP;
|
|
(*res)->ai_addrlen = sizeof(struct sockaddr_in);
|
|
(*res)->ai_addr = (struct sockaddr *)sin;
|
|
(*res)->ai_canonname = NULL;
|
|
(*res)->ai_next = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* DEMO FUNCTIONS
|
|
*****************************************************************************/
|
|
int DEMO_setup_connection(const char *port_str) {
|
|
struct addrinfo hints, *ai;
|
|
memset(&hints, 0, sizeof hints);
|
|
hints.ai_family = AF_INET;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
int res = getaddrinfo(NULL, port_str, &hints, &ai);
|
|
if (res != 0)
|
|
error_exit("getaddrinfo() failed");
|
|
|
|
int sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
|
|
if (sockfd < 0)
|
|
error_exit("socket() failed");
|
|
|
|
int reuse = 1;
|
|
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
|
|
error_exit("setsockopt() failed");
|
|
|
|
if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0)
|
|
error_exit("bind() failed");
|
|
|
|
freeaddrinfo(ai);
|
|
|
|
if (listen(sockfd, 1) < 0)
|
|
error_exit("listen() failed");
|
|
return sockfd;
|
|
}
|
|
|
|
void DEMO_server_request_handler(int sockfd, const char *command, int flags) {
|
|
int connfd = accept(sockfd, NULL, NULL);
|
|
if (connfd < 0)
|
|
error_exit("accept() failed");
|
|
|
|
print_message("Accepted connection");
|
|
|
|
FILE *fps = fdopen(connfd, "w+");
|
|
|
|
char argument[MAX_ARGUMENT_LEN + 1] = {0};
|
|
fgets(argument, sizeof(argument), fps);
|
|
|
|
FILE *fpc = NULL;
|
|
if (flags & USE_DEMO) {
|
|
print_message("Calling DEMO_execute_command()");
|
|
fpc = DEMO_execute_command(command, argument);
|
|
} else {
|
|
print_message("Calling execute_command()");
|
|
fpc = execute_command(command, argument);
|
|
}
|
|
|
|
if (fpc) {
|
|
int c;
|
|
while ((c = fgetc(fpc)) != EOF)
|
|
fputc(c, fps);
|
|
fclose(fpc);
|
|
} else {
|
|
fputs("COMMAND_FAILED", fps);
|
|
}
|
|
fflush(fps);
|
|
fclose(fps);
|
|
}
|
|
|
|
FILE *DEMO_execute_command(const char *command, const char *argument) {
|
|
// file stream to read the output of the process
|
|
FILE *proc_output = NULL;
|
|
|
|
// file descriptors for the pipe for parent-child process communication
|
|
int c2p[2];
|
|
|
|
// create the pipes
|
|
if (pipe(c2p) == -1)
|
|
error_exit("cannot create pipe");
|
|
|
|
pid_t pid = fork();
|
|
switch (pid) {
|
|
case 0:
|
|
// duplicate write end to stdout
|
|
if (dup2(c2p[1], STDOUT_FILENO) == -1) {
|
|
error_exit("dup2() failed");
|
|
}
|
|
close(c2p[0]);
|
|
close(STDIN_FILENO);
|
|
|
|
// exec the command
|
|
if (execlp(command, command, argument, NULL) == -1) {
|
|
error_exit("exec() failed");
|
|
}
|
|
case -1:
|
|
error_exit("fork() failed");
|
|
|
|
default:
|
|
// parent process
|
|
proc_output = fdopen(c2p[0], "r");
|
|
if (proc_output == NULL) {
|
|
error_exit("fdopen() failed");
|
|
}
|
|
close(c2p[1]);
|
|
|
|
int stat = 0;
|
|
wait(&stat);
|
|
|
|
if (WIFEXITED(stat) && WEXITSTATUS(stat) == 0) {
|
|
print_message("child process exited normally");
|
|
} else {
|
|
print_error("child process exited abnormally");
|
|
proc_output = NULL;
|
|
}
|
|
}
|
|
return proc_output;
|
|
}
|