init task 3

10 files changed, 433 insertions, 0 deletions

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 <stdio.h>
+#include <stdlib.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+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 <stdio.h>
+#include <stdlib.h>
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+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 <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* ********************************************************* 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 <stddef.h>
+
+/* *** 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 <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define PORT 9000
+
+int main()
+{
+	while (1)
+	{
+		printf("[srv]: idle\n");
+		sleep(2);
+	}
+	
+	return 0;
+}