Initialer Commit.

CMakeLists.txt

+# Projekteinstellungen
+cmake_minimum_required(VERSION 3.2)
+project(echo_server
+        VERSION 2.1.0)
+set(PROJECT_DESCRIPTION
+        "Echo-Server")
+set(PROJECT_URL
+        "https://git.fh-muenster.de/schinzel/PSE2020")
+
+# "Debug" als Standard wählen
+if (NOT CMAKE_BUILD_TYPE)
+    message(STATUS "No build type selected, using DEBUG")
+    set(CMAKE_BUILD_TYPE "DEBUG")
+endif ()
+
+# Warnungen! Viele!
+set(CMAKE_C_FLAGS
+        "${CMAKE_C_FLAGS} -Wall -Werror")
+
+# Ausführbare Datei: echo_server
+add_executable(echo_server
+        echo_server.c)
+set_property(TARGET echo_server
+        PROPERTY C_STANDARD 11)
+install(TARGETS echo_server
+        DESTINATION bin)

README.md

+Das ist das zentrale Repository zur Verteilung von Daten für Projekt Systementwicklung (PSE) 2020.
+
+Hier sollten Sie immer mal vorbei schauen und nach neuen Informationen gucken.

base64-test.c

+#include "base64.c"
+#include <string.h>
+#include <stdio.h>
+
+int main() {
+       const char* test = "Das ist ein Test!";
+       size_t output_length = 0;
+       char* out1 = base64_encode(test, strlen(test), &output_length);
+       int i;
+
+       printf("--> %s\n", out1);
+       for(i = 0; i < output_length; i++) {
+                putchar(out1[i]);
+       }
+       putchar('\0');
+
+       char* out2 = base64_decode(out1, strlen(out1), &output_length);
+       printf("--> %s\n", out2);
+       for(i = 0; i < output_length; i++) {
+                putchar(out2[i]);
+       }
+       putchar('\0');
+
+       free(out1);
+       free(out2);
+
+       return 0;
+}
+

base64.c

+#include <stdint.h>
+#include <stdlib.h>
+
+
+static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+                                'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+                                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+                                'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+                                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+                                'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+                                'w', 'x', 'y', 'z', '0', '1', '2', '3',
+                                '4', '5', '6', '7', '8', '9', '+', '/'};
+static char *decoding_table = NULL;
+static int mod_table[] = {0, 2, 1};
+
+void build_decoding_table1() {
+
+    int i;
+    decoding_table = malloc(256);
+
+    for (i = 0; i < 64; i++)
+        decoding_table[(unsigned char) encoding_table[i]] = i;
+}
+
+
+
+char *base64_encode(const unsigned char *data,
+                    size_t input_length,
+                    size_t *output_length) {
+
+    int i,j;
+    *output_length = 4 * ((input_length + 2) / 3);
+
+    char *encoded_data = malloc(*output_length + 1);
+    if (encoded_data == NULL) return NULL;
+
+    for (i = 0, j = 0; i < input_length;) {
+
+        uint32_t octet_a = i < input_length ? data[i++] : 0;
+        uint32_t octet_b = i < input_length ? data[i++] : 0;
+        uint32_t octet_c = i < input_length ? data[i++] : 0;
+
+        uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+
+        encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
+        encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
+        encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
+        encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
+    }
+
+    for (i = 0; i < mod_table[input_length % 3]; i++)
+        encoded_data[*output_length - 1 - i] = '=';
+    encoded_data[*output_length] = '\0';
+
+    return encoded_data;
+}
+
+
+unsigned char *base64_decode(const char *data,
+                             size_t input_length,
+                             size_t *output_length) {
+
+    int i, j;
+    if (decoding_table == NULL) build_decoding_table1();
+
+    if (input_length % 4 != 0) return NULL;
+
+    *output_length = input_length / 4 * 3;
+    if (data[input_length - 1] == '=') (*output_length)--;
+    if (data[input_length - 2] == '=') (*output_length)--;
+
+    unsigned char *decoded_data = malloc(*output_length + 1);
+    if (decoded_data == NULL) return NULL;
+
+    for (i = 0, j = 0; i < input_length;) {
+
+        uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
+        uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
+        uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
+        uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
+
+        uint32_t triple = (sextet_a << 3 * 6)
+        + (sextet_b << 2 * 6)
+        + (sextet_c << 1 * 6)
+        + (sextet_d << 0 * 6);
+
+        if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
+        if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
+        if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
+    }
+    decoded_data[*output_length] = '\0';
+
+    return decoded_data;
+}
+
+
+void base64_cleanup() {
+    free(decoding_table);
+}

echo_server.c

+/* Version: 2.1.2 */
+#include <errno.h>      // errno
+#include <netinet/ip.h> // ^
+#include <signal.h>     // sigaction, struct sigaction, siginfo_t, SIGTERM
+#include <stdbool.h>    // bool
+#include <stdio.h>      // fprintf
+#include <stdlib.h>     // exit, malloc, free
+#include <string.h>     // memset, strerror
+#include <sys/socket.h> // struct sockaddr_in, socket, setsockopt, bind, listen, socklen_t, accept
+#include <unistd.h> // read, write, close
+
+#define PORT 31337
+#define BUFFER_SIZE 1024
+
+/**
+ * Globale Variablen.
+ */
+static bool run = true;
+
+/**
+ * Fehlerbehandlung.
+ */
+static void error(char *msg) {
+  fprintf(stderr, "%s", msg);
+  if (errno) {
+    fprintf(stderr, ", errno: %s", strerror(errno));
+  }
+  fprintf(stderr, "\n");
+  exit(1);
+}
+
+/**
+ * Behandlung des SIGINT-Signals (Strg+C) um den Server zu beenden.
+ */
+static void handle_signal(int signum) {
+  if (signum != SIGINT) {
+    error("ERROR unexpected signal");
+  }
+
+  /*
+   * Beende den Server nach dem Abarbeiten des letzten Clients.
+   */
+  run = false;
+}
+
+/**
+ * Registriert das SIGINT-Signal (Strg+C) um den Server beenden zu können.
+ */
+static void register_signal() {
+  struct sigaction action;
+
+  /*
+   * Konfigurieren des Signal-Handlers.
+   */
+  memset(&action, 0, sizeof(action));
+  action.sa_handler = handle_signal;
+
+  /*
+   * Registrierung des Signal-Handlers.
+   */
+  if (sigaction(SIGINT, &action, NULL) < 0) {
+    error("ERROR registering signal handler");
+  }
+}
+
+/**
+ * Erstellt und konfiguriert den Netzwerk-Socket, über den die Verbindungen
+ * angenommen werden.
+ */
+static int setup_socket() {
+#ifdef STDIN_ONLY
+  return STDOUT_FILENO;
+#endif
+
+  int opt = 1;
+  int sockfd = 0;
+  struct sockaddr_in serv_addr;
+
+  /*
+   * Setzt Konfigurationsvariablen für den Socket, z.B. die Portnummer.
+   */
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = INADDR_ANY;
+  serv_addr.sin_port = htons(PORT);
+
+  /*
+   * Erstelle den Socket.
+   */
+  sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (sockfd < 0) {
+    error("ERROR opening socket");
+  }
+
+  /*
+   * Verwende den Socket, selbst wenn er aus einer vorigen Ausführung
+   * im TIME_WAIT Status ist.
+   */
+  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt,
+                 sizeof(int)) < 0)
+    error("ERROR on setsockopt");
+
+  /*
+   * Melde, dass der Socket eingehende Verbindungen akzeptieren soll.
+   */
+  if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+    error("ERROR on binding");
+  }
+
+  /*
+   * Horche auf dem Socket nach eingehenden Verbindungen. Es werden maximal
+   * fünf gleichzeitige Verbindungen erlaubt.
+   */
+  if (listen(sockfd, 5) < 0) {
+    error("listen");
+  }
+  return sockfd;
+}
+
+/**
+ * Die Hauptschleife, in der eingehende Verbindungen angenommen werden.
+ */
+static void main_loop(int sockfd) {
+  int newsockfd;
+  ssize_t length;
+
+#ifndef STDIN_ONLY
+  struct sockaddr_in cli_addr;
+  socklen_t clilen = sizeof(cli_addr);
+#endif
+
+  void *const buffer = malloc(BUFFER_SIZE);
+  if (buffer == NULL) {
+    error("ERROR at malloc.");
+  }
+
+  /*
+   * Die Hauptshleife des Programms.
+   */
+  while (run) {
+
+#ifndef STDIN_ONLY
+    /*
+     * Der accept()-Aufruf blockiert, bis eine neue Verbindung rein kommt.
+     */
+    newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
+    if (newsockfd < 0) {
+      /*
+       * Wenn der Server mit dem SIGINT-Signal beendet wird, schlägt accept
+       * mit EINTR (interrupted) fehl.
+       */
+      if (errno == EINTR) {
+        break;
+      }
+      error("ERROR on accept");
+    }
+#else
+    newsockfd = STDIN_FILENO;
+#endif
+
+    /*
+     * Lies die ankommenden Daten von dem Socket in das Array buffer.
+     */
+    memset(buffer, 0, BUFFER_SIZE);
+    length = read(newsockfd, buffer, BUFFER_SIZE - 1);
+    if (length < 0) {
+      if (errno == EINTR) {
+        break;
+      }
+      error("ERROR reading from socket");
+    }
+
+/*
+ * Schreibe die ausgehenden Daten auf den Socket.
+ */
+#ifndef STDIN_ONLY
+    length = write(newsockfd, buffer, (size_t)length);
+    if (length < 0) {
+      error("ERROR writing to socket");
+    }
+#else
+    /*
+     * Gib die eingegangenen Daten auf der Kommandozeile aus.
+     */
+    if (write(STDOUT_FILENO, buffer, length) < 0) {
+      error("ERROR writing to STDOUT");
+    }
+#endif
+
+/*
+ * Schließe die Verbindung.
+ */
+#ifndef STDIN_ONLY
+    if (close(newsockfd) < 0) {
+      error("ERROR on close");
+    }
+#endif
+  }
+
+  /*
+   * Lösche den Buffer und schließe den Socket. Dieser Aufruf sollte wegen der
+   * Endlosschleife niemals ausgeführt werden.
+   */
+  free(buffer);
+#ifndef STDIN_ONLY
+  if (close(sockfd) < 0) {
+    error("ERROR on close");
+  }
+#endif
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  register_signal();
+  const int sockfd = setup_socket();
+  main_loop(sockfd);
+
+  return 0;
+}

htpasswd

+test:{SHA}Uau5Y2B43vv4iNhFenx2+FyPEUw=
+test1:{SHA}tenJq093fBkbyEfhrKIi1oNnFLc=
+abnahme:$apr1$qHfCDuwg$jw9.yjScDqE8w9qFVRRQV0

index.html

+<html>
+ <body>
+  <h1>Willkommen im externen Bereich!</h1>
+  <pre> 
+HTTP-Methode: GET 
+HTTP-Ressource: /index.html 
+HTTP-Protokoll-Version: 1.1 
+  </pre>
+ </body>
+</html> 

realpath-test.c

+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+
+#define DOC_ROOT "/Users/ssc/Desktop/test2"
+// /Users/ssc/Desktop/test1   | existiert
+// /Users/ssc/Desktop/test2   | existiert
+// /Users/ssc/Desktop/test2/a | existiert nicht
+// /Users/ssc/Desktop/test3   | existiert nicht
+
+int test(char* test) {
+        char *ptr = realpath(test, NULL);
+
+        if(ptr == NULL) {
+                // Der Pfad existiert nicht, aber liegt er wenigstens im DocRoot?
+                char *old = calloc(1, PATH_MAX);
+                if(old == NULL)
+                        exit(1);
+
+                realpath(test, old);
+                if(strncmp(DOC_ROOT, old, strlen(DOC_ROOT)) == 0) {
+                        printf("ist im DocRoot       | existiert nicht\n");
+                } else {
+                        printf("ist nicht im DocRoot | existiert nicht\n");
+                }
+        } else {
+                // Der Pfad existiert, aber liegt er im DocRoot?
+                if(strncmp(DOC_ROOT, ptr, strlen(DOC_ROOT)) == 0) {
+                        printf("ist im DocRoot       | existiert\n");
+                } else {
+                        printf("ist nicht im DocRoot | existiert\n");
+                }
+        }
+
+        return 0;
+
+}
+
+int main() {
+        test("/Users/ssc/Desktop/test2/../test2/a"); // ist im DocRoot       | existiert nicht
+        test("/Users/ssc/Desktop/test2/../test3");   // ist nicht im DocRoot | existiert nicht
+        test("/Users/ssc/Desktop/test1/../test2");   // ist im DocRoot       | existiert
+        test("/Users/ssc/Desktop/test1/../test1");   // ist nicht im DocRoot | existiert
+        return 0;
+}

sha1.c

+/*
+ * # Kompilieren mit: 
+ * $ gcc sha1.c -o sha1 -lcrypto -Wall
+ * # (Voraussetzung ist, dass OpenSSL installiert ist. Auf Ubuntu ist das das Paket "libssl-dev"
+ * 
+ * # Test:
+ * $ echo -n 'Moin!' | sha1sum
+ * b6503ca0189b9da255a6b4e5aaa01d0464597c51  -
+ * $ ./sha1 
+ * b6503ca0189b9da255a6b4e5aaa01d0464597c51
+ */
+#include <stdio.h>
+#include <string.h>
+#include <openssl/sha.h>
+int main() {
+	char data[] = "Moin!";
+
+	unsigned char hash[SHA_DIGEST_LENGTH];
+	SHA1((const unsigned char*) data, strlen(data), hash);
+	
+	for(int i = 0; i < sizeof(hash); i++) {
+		printf("%02x", hash[i]);
+	}
+	printf("\n");
+	
+	return 0;
+}