266 lines
6.4 KiB
C
266 lines
6.4 KiB
C
#include <errno.h>
|
|
#include <locale.h>
|
|
#include <netdb.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#include <fcntl.h>
|
|
#include <sys/prctl.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <syslog.h>
|
|
#include <unistd.h>
|
|
|
|
#include <linux/seccomp.h>
|
|
|
|
#ifndef SPOOF
|
|
#include <bcm2835.h>
|
|
#endif //SPOOF
|
|
|
|
#define LOGF(x, ...) do { logf_impl(x, __FILE__, __LINE__, __func__, __VA_ARGS__); } while(0);
|
|
#define LOG(x) do { log_impl(x, __FILE__, __LINE__, __func__); } while(0);
|
|
#define DEFAULT_PORT 9305
|
|
#define MBUF_SIZE 2048
|
|
|
|
#define TROMMEL_PIN 17
|
|
|
|
const char *SOCKET_ERROR = "Socket-fout";
|
|
const char *LOG_FMT = "[%s:%d %s]: %s";
|
|
int log_prefix_length = 0;
|
|
|
|
typedef struct mbuf {
|
|
/// Internal buffer
|
|
char buffer[MBUF_SIZE];
|
|
/// Socket/file descriptor
|
|
int sock;
|
|
/// Read position
|
|
size_t rpos,
|
|
/// Write position
|
|
wpos;
|
|
|
|
} mbuf_t;
|
|
|
|
void log_impl(const char *message, const char *file, int line, const char *func) {
|
|
syslog(LOG_INFO, LOG_FMT, file + log_prefix_length, line, func, message);
|
|
}
|
|
void logf_impl(const char *message, const char *file, int line, const char *func, ...) {
|
|
va_list args;
|
|
va_start(args, func);
|
|
|
|
int c = snprintf(NULL, 0, LOG_FMT, file + log_prefix_length, line, func, message);
|
|
char *msg = malloc(c + 1);
|
|
snprintf(msg, c + 1, LOG_FMT, file + log_prefix_length, line, func, message);
|
|
|
|
vsyslog(LOG_INFO, msg, args);
|
|
va_end(args);
|
|
}
|
|
|
|
int quit_if_fail(int err, const char *failMessage) {
|
|
if (err < 0) {
|
|
int no = errno;
|
|
LOGF( "%s: %s", failMessage, strerror(no));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
mbuf_t *mbuf_create(void) {
|
|
mbuf_t *res = malloc(sizeof(mbuf_t));
|
|
res->rpos = 0;
|
|
res->wpos = 0;
|
|
res->sock = -1;
|
|
memset(res->buffer, 0, MBUF_SIZE * sizeof(char));
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Reads until it encounters `c` from the given socket
|
|
*
|
|
* `c` is not included in the output. The output is null-terminated.
|
|
*
|
|
* @param c The character to stop reading
|
|
* @param out A pointer to allocated memory where the read line can be stored.
|
|
* @param max_size The max size.
|
|
*/
|
|
int mbuf_read_until(mbuf_t *buf, char c, char *out, size_t max_size) {
|
|
size_t i = 0;
|
|
ssize_t n;
|
|
|
|
while (i < max_size) {
|
|
if (buf->rpos == buf->wpos) {
|
|
size_t wpos = buf->wpos % MBUF_SIZE;
|
|
if ((n = read(buf->sock, buf->buffer + wpos, MBUF_SIZE - wpos)) < 0) {
|
|
//if (errno == EINTR) continue;
|
|
return -1;
|
|
} else if (n == 0) {
|
|
return 0;
|
|
} else {
|
|
buf->wpos += n;
|
|
}
|
|
}
|
|
|
|
out[i++] = buf->buffer[buf->rpos++ % MBUF_SIZE];
|
|
if (out[i - 1] == c) break;
|
|
}
|
|
|
|
if (i == max_size) {
|
|
errno = EOVERFLOW;
|
|
//LOGF("Buffer is te klein (bijts gelezen %d > %d)", i, max_size);
|
|
return -1;
|
|
}
|
|
out[i - 1] = '\0';
|
|
return i - 1;
|
|
}
|
|
|
|
void do_trommel() {
|
|
#ifndef SPOOF
|
|
bcm2835_gpio_write(TROMMEL_PIN, HIGH);
|
|
bcm2835_delay(250);
|
|
bcm2835_gpio_write(TROMMEL_PIN, LOW);
|
|
#endif //SPOOF
|
|
}
|
|
|
|
int do_handshake(mbuf_t *mbuf) {
|
|
char buf[1024];
|
|
if (mbuf_read_until(mbuf, '\n', buf, sizeof(buf)) < 0) return -1;
|
|
int reslen = strlen(buf) - strlen("e gaat 'ie?");
|
|
if (reslen < 2 || (reslen & 1)) {
|
|
errno = EPROTO;
|
|
return -1;
|
|
}
|
|
|
|
// oed\0
|
|
size_t response_size = reslen + 4;
|
|
char *response = (char *) malloc(response_size);
|
|
response[0] = '\0';
|
|
reslen /= 2;
|
|
for (int i = 0; i < reslen; i++) {
|
|
strcat(response, "go");
|
|
}
|
|
strcat(response, "ed\n");
|
|
if (write(mbuf->sock, response, response_size - 1) < 0) return -1;
|
|
free(response);
|
|
return 0;
|
|
}
|
|
|
|
int do_command_loop(mbuf_t *mbuf) {
|
|
char buf[1024];
|
|
int len;
|
|
|
|
while(1) {
|
|
if ( (len = mbuf_read_until(mbuf, '\n', buf, sizeof(buf))) < 0) return -1;
|
|
if (len == 0) return 0;
|
|
LOGF("COMMANDO: %s", buf);
|
|
if (strcmp(buf, "trommel") == 0) {
|
|
do_trommel();
|
|
const char *ok = "oké\n";
|
|
write(mbuf->sock, ok, strlen(ok) * sizeof(char));
|
|
} else if (strcmp(buf, "ping") == 0) {
|
|
write(mbuf->sock, "pong\n", 5 * sizeof(char));
|
|
} else {
|
|
const char *mesg = "onbekend commando\n";
|
|
write(mbuf->sock, mesg, strlen(mesg) * sizeof(char));
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
#ifdef LOG_PREFIX
|
|
log_prefix_length = strlen(LOG_PREFIX);
|
|
#endif
|
|
openlog(argv[0], LOG_ODELAY, LOG_DAEMON);
|
|
|
|
if (argc < 3) {
|
|
LOGF("GEBRUIK: %s ADRES POORT", argv[0]);
|
|
return EXIT_FAILURE;
|
|
}
|
|
LOG("Kerstezel starten");
|
|
|
|
// Daemonize
|
|
//pid_t pid;
|
|
//pid = quit_if_fail(fork(), "Kon niet vorken");
|
|
//if (pid > 0) exit(EXIT_SUCCESS);
|
|
quit_if_fail(chdir("/"), "Kon werkmap niet veranderen");
|
|
//quit_if_fail(setsid(), "Kon sid niet veranderen");
|
|
|
|
// Zorg ervoor dat de daemon geen TTY kan bemachtigen
|
|
//pid = quit_if_fail(fork(), "Kon niet vorken");
|
|
//if (pid > 0) exit(EXIT_SUCCESS);
|
|
|
|
// WRITE PIDFILE
|
|
/*FILE *fd = fopen(pid_path, "w");
|
|
if (fd != NULL) {
|
|
fprintf(fd, "%d", getpid());
|
|
fclose(fd);
|
|
}*/
|
|
|
|
close(STDIN_FILENO);
|
|
close(STDOUT_FILENO);
|
|
close(STDERR_FILENO);
|
|
|
|
#ifndef SPOOF
|
|
bcm2835_init();
|
|
bcm2835_gpio_fsel(TROMMEL_PIN, BCM2835_GPIO_FSEL_OUTP);
|
|
LOG("bcm2835 geinitialiseerd")
|
|
#endif //SPOOF
|
|
|
|
struct addrinfo hints, *servinfo, *p;
|
|
|
|
memset(&hints, 0, sizeof(struct addrinfo));
|
|
hints.ai_family = AF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
int res, res2;
|
|
if ((res = getaddrinfo(argv[1], argv[2], &hints, &servinfo)) != 0) {
|
|
LOGF("Fout bij het herleiden van de gastheernaam: %s", gai_strerror(res));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
mbuf_t *buf = mbuf_create();
|
|
|
|
char address[INET6_ADDRSTRLEN] = {0};
|
|
for (p = servinfo; p != NULL; p = p->ai_next) {
|
|
void *ptr = NULL;
|
|
switch(p->ai_family) {
|
|
case AF_INET:
|
|
ptr = &((struct sockaddr_in *) p->ai_addr)->sin_addr;
|
|
break;
|
|
case AF_INET6:
|
|
ptr = &((struct sockaddr_in6 *) p->ai_addr)->sin6_addr;
|
|
break;
|
|
}
|
|
if (inet_ntop(p->ai_family, ptr, address, p->ai_addrlen) == NULL) {
|
|
LOGF("Kon adres niet omzetten: %s", strerror(errno));
|
|
} else {
|
|
LOGF("Verbinden met %s", address);
|
|
}
|
|
res = socket(p->ai_family, SOCK_STREAM, 0);
|
|
if (res < 0) continue;
|
|
res2 = connect(res, p->ai_addr, sizeof(address));
|
|
if (res2 == 0) break;
|
|
}
|
|
buf->sock = res;
|
|
|
|
quit_if_fail(res, "Kon niet verbinden");
|
|
//(void) quit_if_fail(connect(buf->sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)), "Kon niet verbinden");
|
|
|
|
/*if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) < 0) {
|
|
LOGF("Kon seccomp niet aanroepen: %s", strerror(errno));
|
|
}*/
|
|
|
|
(void) quit_if_fail(do_handshake(buf), "Handenschudden mislukt");
|
|
LOG("Handjeschudden voltooid")
|
|
(void) quit_if_fail(do_command_loop(buf), "Fout");
|
|
LOG("De andere kant heeft de verbinding verbroken");
|
|
free(buf);
|
|
#ifndef SPOOF
|
|
bcm2835_close();
|
|
#endif //SPOOF
|
|
return 0;
|
|
}
|