From bc48f521390b360e1e1b131fc670cc3d02dcaf89 Mon Sep 17 00:00:00 2001 From: Niklas Halle Date: Thu, 28 May 2020 13:16:29 +0200 Subject: init task 3 --- 03_exercise/Makefile | 32 +++++++++ 03_exercise/cli/Makefile | 23 +++++++ 03_exercise/cli/client.c | 13 ++++ 03_exercise/echo_server/Makefile | 22 ++++++ 03_exercise/echo_server/client.c | 47 +++++++++++++ 03_exercise/echo_server/server.c | 56 +++++++++++++++ 03_exercise/srv/Makefile | 23 +++++++ 03_exercise/srv/array.c | 59 ++++++++++++++++ 03_exercise/srv/array.h | 142 +++++++++++++++++++++++++++++++++++++++ 03_exercise/srv/server.c | 16 +++++ 10 files changed, 433 insertions(+) create mode 100644 03_exercise/Makefile create mode 100644 03_exercise/cli/Makefile create mode 100644 03_exercise/cli/client.c create mode 100644 03_exercise/echo_server/Makefile create mode 100644 03_exercise/echo_server/client.c create mode 100644 03_exercise/echo_server/server.c create mode 100644 03_exercise/srv/Makefile create mode 100644 03_exercise/srv/array.c create mode 100644 03_exercise/srv/array.h create mode 100644 03_exercise/srv/server.c diff --git a/03_exercise/Makefile b/03_exercise/Makefile new file mode 100644 index 0000000..8c02dc9 --- /dev/null +++ b/03_exercise/Makefile @@ -0,0 +1,32 @@ +#!/usr/bin/make +.SUFFIXES: +.PHONY: all run pack clean +.SILENT: run + +TAR = cli/client srv/server +PCK = lab-3.zip + +export CFLAGS = -std=gnu11 -c -g -Os -Wall -Werror -MMD -MP + +cli/client: $(wildcard cli/*.c) $(wildcard cli/*.h) + @$(MAKE) -C $(@D) + +srv/server: $(wildcard srv/*.c) $(wildcard srv/*.h) + @$(MAKE) -C $(@D) + +all: $(TAR) + +run: all + srv/server& echo $$! > .srv_pid + echo "Client Ready:" + cli/client + kill `cat .srv_pid` + $(RM) $(RMFILES) .srv_pid + +pack: clean + zip -r $(PCK) cli srv Makefile -x "*/.*" + +clean: + @$(MAKE) -C cli clean + @$(MAKE) -C srv clean + $(RM) $(RMFILES) $(PCK) diff --git a/03_exercise/cli/Makefile b/03_exercise/cli/Makefile new file mode 100644 index 0000000..c09533d --- /dev/null +++ b/03_exercise/cli/Makefile @@ -0,0 +1,23 @@ +#!/usr/bin/make +.SUFFIXES: +.PHONY: all run clean +TAR = client +SRC = $(wildcard *.c) +OBJ = $(SRC:%.c=%.o) + +DEP = $(OBJ:%.o=%.d) +-include $(DEP) + +%.o: %.c + $(CC) $(CFLAGS) $< -o $@ + +$(TAR): $(OBJ) + $(CC) $(LFLAGS) $^ -o $@ + +all: $(TAR) + +run: all + ./$(TAR) + +clean: + $(RM) $(RMFILES) $(OBJ) $(TAR) $(DEP) diff --git a/03_exercise/cli/client.c b/03_exercise/cli/client.c new file mode 100644 index 0000000..48bf724 --- /dev/null +++ b/03_exercise/cli/client.c @@ -0,0 +1,13 @@ +#include +#include + +#define PORT 9000 +#define HOST "127.0.0.1" + +int main() +{ + getc(stdin); + printf("Client Exit\n"); + + return 0; +} diff --git a/03_exercise/echo_server/Makefile b/03_exercise/echo_server/Makefile new file mode 100644 index 0000000..df023d1 --- /dev/null +++ b/03_exercise/echo_server/Makefile @@ -0,0 +1,22 @@ +#!/usr/bin/make +.SUFFIXES: +.PHONY: all run clean +.SILENT: run + +TAR = client server +CFLAGS = -c -Os -Wall -Werror + +%.o: %.c + $(CC) $(CFLAGS) $^ -o $@ + +%: %.o + $(CC) -o $@ $^ + +all: $(TAR) + +run: all + ./server& + ./client + +clean: + $(RM) $(RMFILES) $(TAR) *.o diff --git a/03_exercise/echo_server/client.c b/03_exercise/echo_server/client.c new file mode 100644 index 0000000..a664221 --- /dev/null +++ b/03_exercise/echo_server/client.c @@ -0,0 +1,47 @@ + +#include +#include + +#include +#include +#include +#include + +static inline void die(const char* msg) +{ + perror(msg); + exit(-1); +} + +int main() +{ + struct sockaddr_in addr = { + .sin_family = AF_INET, + .sin_port = htons(8000), + .sin_addr.s_addr = inet_addr("127.0.0.1") + }; + char buf[256]; + int cfd; + + if ((cfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) + die("Couldn't open the socket"); + + if (connect(cfd, (struct sockaddr*) &addr, sizeof(addr)) < 0) + die("Couldn't connect to socket"); + + for (int i = 0; i < 5; ++i) + { + if (write(cfd, "Ping", 4) < 0) + die("Couldn't send message"); + + printf("[send] Ping\n"); + + if (read(cfd, buf, sizeof(buf)) < 0) + die("Couldn't receive message"); + + printf("[recv] %s\n", buf); + } + + close(cfd); + return 0; +} diff --git a/03_exercise/echo_server/server.c b/03_exercise/echo_server/server.c new file mode 100644 index 0000000..faf309c --- /dev/null +++ b/03_exercise/echo_server/server.c @@ -0,0 +1,56 @@ + +#include +#include + +#include +#include +#include +#include + +static inline void die(const char* msg) +{ + perror(msg); + exit(-1); +} + +int main() +{ + struct sockaddr_in srv_addr, cli_addr; + int sockopt = 1; + socklen_t sad_sz = sizeof(struct sockaddr_in); + int sfd, cfd; + ssize_t bytes; + char buf[256]; + + srv_addr.sin_family = AF_INET; + srv_addr.sin_port = htons(8000); + srv_addr.sin_addr.s_addr = INADDR_ANY; + + if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) + die("Couldn't open the socket"); + + setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char*) &sockopt, sizeof(sockopt)); + + if (bind(sfd, (struct sockaddr*) &srv_addr, sad_sz) < 0) + die("Couldn't bind socket"); + + if (listen(sfd, 1) < 0) + die("Couldn't listen to the socket"); + + cfd = accept(sfd, (struct sockaddr*) &cli_addr, &sad_sz); + if (cfd < 0) + die("Couldn't accept incoming connection"); + + while ((bytes = read(cfd, buf, sizeof(buf))) != 0) + { + if (bytes < 0) + die("Couldn't receive message"); + + if (write(cfd, buf, bytes) < 0) + die("Couldn't send message"); + } + + close(cfd); + close(sfd); + return 0; +} diff --git a/03_exercise/srv/Makefile b/03_exercise/srv/Makefile new file mode 100644 index 0000000..4fede74 --- /dev/null +++ b/03_exercise/srv/Makefile @@ -0,0 +1,23 @@ +#!/usr/bin/make +.SUFFIXES: +.PHONY: all run clean +TAR = server +SRC = $(wildcard *.c) +OBJ = $(SRC:%.c=%.o) + +DEP = $(OBJ:%.o=%.d) +-include $(DEP) + +%.o: %.c + $(CC) $(CFLAGS) $< -o $@ + +$(TAR): $(OBJ) + $(CC) $(LFLAGS) $^ -o $@ + +all: $(TAR) + +run: all + ./$(TAR) + +clean: + $(RM) $(RMFILES) $(OBJ) $(TAR) $(DEP) diff --git a/03_exercise/srv/array.c b/03_exercise/srv/array.c new file mode 100644 index 0000000..4f08366 --- /dev/null +++ b/03_exercise/srv/array.c @@ -0,0 +1,59 @@ +/***************************************************************************//** + * @file array.c + * @author Dorian Weber + * @brief Implementation des generalisierten Arrays. + ******************************************************************************/ + +#include "array.h" +#include +#include +#include + +/* ********************************************************* public functions */ + +/* (die runden Klammern um einige Funktionsnamen sind notwendig, da Makros + * gleichen Namens existieren und der Präprozessor diese expandieren würde) */ + +void* (arrayInit)(size_t capacity, size_t size) { + ArrayHdr *hdr = malloc(sizeof(*hdr) + size*capacity); + + if (hdr == NULL) + return NULL; + + hdr->len = 0; + hdr->cap = capacity; + + return hdr + 1; +} + +void arrayRelease(void* self) { + free(((ArrayHdr*) self) - 1); +} + +void* (arrayPush)(void* self, size_t size) { + ArrayHdr *hdr = ((ArrayHdr*) self) - 1; + + if (hdr->len == hdr->cap) { + hdr->cap *= 2; + hdr = realloc(hdr, sizeof(*hdr) + size*hdr->cap); + + if (hdr == NULL) { + fputs("program ran out of heap memory\n", stderr); + exit(-1); + } + } + + ++hdr->len; + return hdr + 1; +} + +void (arrayPop)(void* self) { + ArrayHdr *hdr = ((ArrayHdr*) self) - 1; + assert(hdr->len > 0); + --hdr->len; +} + +/* Symbol für die Inline-Funktionen erzeugen und aus diesem Modul exportieren */ +extern void arrayClear(void* self); +extern int arrayIsEmpty(const void* self); +extern size_t arrayLen(const void* self); diff --git a/03_exercise/srv/array.h b/03_exercise/srv/array.h new file mode 100644 index 0000000..78d21c9 --- /dev/null +++ b/03_exercise/srv/array.h @@ -0,0 +1,142 @@ +/***************************************************************************//** + * @file array.h + * @author Dorian Weber + * @brief Generischer Array-Typ. + * + * @details + * Diese Datei enthält die Schnittstelle eines generischen Array-Typs. Um den + * Element-Typ des Arrays festzulegen, deklariert man eine Variable als Zeiger + * auf den Element-Typ. Diese kann danach initialisiert und so benutzt werden, + * als wäre sie ein Zeiger auf ein Array variabler Länge. + * + * Hier ist ein Nutzungsbeispiel: + * @code + * int *array; + * + * arrayInit(array); + * arrayPush(array) = 1; + * arrayPush(array) = 2; + * arrayPush(array) = 3; + * + * while (!arrayIsEmpty(array)) + * printf("%i\n", arrayPop(array)); + * + * arrayRelease(array); + * @endcode + * + * Viele der genutzten Funktionen sind in Form von Makros implementiert, die die + * Variable, die den Zeiger auf das Array hält, aktualisieren, obwohl es so + * aussieht, als würde sich dieser Wert niemals ändern. Das macht es riskant + * mehr als einen Zeiger auf das Array zu halten, da jede Vergrößerung des + * Arrays alle Zeiger auf und in das Array potentiell invalidiert. Obwohl diese + * Fehlerquelle subtil und äußerst schwer diagnostizierbar ist - es ist eine + * extrem einfache Abstraktion - führt diese Datenstruktur meiner Meinung nach + * trotzdem zu einem massiven Produktivitätsgewinn; man sollte sich nur in etwa + * im Klaren über die unterliegende Implementation sein, um genau die Untermenge + * von Programmiertechniken auszuwählen, die korrekt funktioniert. + ******************************************************************************/ + +#ifndef ARRAY_H_INCLUDED +#define ARRAY_H_INCLUDED + +/* *** includes ************************************************************* */ + +#include + +/* *** structures *********************************************************** */ + +/**@brief Arrayheader. + * + * Diese Struktur wird jedem Array im Speicher vorangestellt und beinhaltet + * Informationen über Kapazität und aktuelle Auslastung des Arrays. Die + * Arrayelemente schließen sich dieser Struktur unmittelbar an, so dass der + * Nutzer von dieser versteckten Information nichts bemerkt. + */ +typedef struct ArrayHdr +{ + size_t len; /**<@brief Anzahl der Array-Elemente. */ + size_t cap; /**<@brief Kapazität des reservierten Speichers. */ +} ArrayHdr; + +/* *** interface ************************************************************ */ + +/**@internal + * @brief Initialisiert und gibt einen Zeiger auf den Start des Arrays zurück. + * @param capacity initiale Kapazität + * @param size Größe der Arrayelemente + * @return ein Zeiger auf den Start des Arrays, falls erfolgreich,\n + * \c NULL im Falle eines Speicherfehlers + */ +extern void* arrayInit(size_t capacity, size_t size); + +/**@brief Initialisiert ein neues Array. + * @param self das Array + * @return 0, falls keine Fehler bei der Initialisierung aufgetreten sind,\n + * -1 ansonsten + */ +#define arrayInit(self) \ + ((self = arrayInit(8, sizeof((self)[0]))) == NULL ? -1 : 0) + +/**@brief Gibt das Array und alle assoziierten Strukturen frei. + * @param self das Array + */ +extern void arrayRelease(void* self); + +/**@internal + * @brief Reserviert Platz für einen neuen Wert im Array. + * @param self das Array + * @param size Größe der Arrayelemente + * @return der neue Zeiger auf den Start des Arrays + */ +extern void* arrayPush(void* self, size_t size); + +/**@brief Legt einen Wert auf das Array. + * @param self das Array + */ +#define arrayPush(self) \ + (self = arrayPush(self, sizeof((self)[0])), (self)+arrayLen(self)-1)[0] + +/**@brief Entfernt das oberste Element des Arrays. + * @param self das Array + */ +extern void arrayPop(void* self); + +/**@brief Entfernt und liefert das oberste Element des Arrays. + * @param self das Array + * @return das oberste Element von \p self + */ +#define arrayPop(self) \ + (arrayPop(self), (self)+arrayLen(self))[0] + +/**@brief Gibt das oberste Element des Arrays zurück. + * @param self das Array + * @return das oberste Element von \p self + */ +#define arrayTop(self) \ + (self)[arrayLen(self) - 1] + +/**@brief Setzt die Länge des Arrays auf 0 zurück. +* @param self das Array +*/ +inline void arrayClear(void* self) { + ((ArrayHdr*) self)[-1].len = 0; +} + +/**@brief Gibt zurück, ob das Array leer ist. + * @param self das Array + * @return 0, falls nicht leer\n + 1, falls leer + */ +inline int arrayIsEmpty(const void* self) { + return ((ArrayHdr*) self)[-1].len == 0; +} + +/**@brief Gibt die Anzahl der Array-Elemente zurück. + * @param self das Array + * @return Anzahl der Elemente des Arrays + */ +inline size_t arrayLen(const void* self) { + return ((ArrayHdr*) self)[-1].len; +} + +#endif /* ARRAY_H_INCLUDED */ diff --git a/03_exercise/srv/server.c b/03_exercise/srv/server.c new file mode 100644 index 0000000..972b11f --- /dev/null +++ b/03_exercise/srv/server.c @@ -0,0 +1,16 @@ +#include +#include +#include + +#define PORT 9000 + +int main() +{ + while (1) + { + printf("[srv]: idle\n"); + sleep(2); + } + + return 0; +} -- cgit v1.2.3-54-g00ecf