Commit 4387b6ec authored by Sebastian Schinzel's avatar Sebastian Schinzel

Initialer Commit.

parents
# 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)
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.
#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;
}
#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);
}
/* 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;
}
test:{SHA}Uau5Y2B43vv4iNhFenx2+FyPEUw=
test1:{SHA}tenJq093fBkbyEfhrKIi1oNnFLc=
abnahme:$apr1$qHfCDuwg$jw9.yjScDqE8w9qFVRRQV0
<html>
<body>
<h1>Willkommen im externen Bereich!</h1>
<pre>
HTTP-Methode: GET
HTTP-Ressource: /index.html
HTTP-Protokoll-Version: 1.1
</pre>
</body>
</html>
#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;
}
/*
* # 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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment