dergeorg/twmailer_vsys
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

RM Old Code

Browse Source
This commit is contained in:
Georg Reisinger
2020-10-26 13:00:36 +01:00
parent 356d9e3463
commit ef7dfdd80b
2 changed files with 0 additions and 724 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
myclient.c
View File

@@ -1,144 +0,0 @@
/* myclient.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUF 1024
//#define PORT 6543
//Client Logik
//Im vorgehen ähnlich wie der server, wartet auf einen gewissen Befehl im Datenstrom
//Wird er gefunden, wird wieder mit dem mode und last die art des befehles und die durchführungsposition gemerkt.
//Bei list wird einiges empfangen und um dort ein ende zu signalisieren, wird dort auf LISTREADSTOPNOW\n gewartet,
//bis das Programm wieder fortsetzt.
int main(int argc, char **argv)
{
char *meinport = argv[2];
int create_socket;
char buffer[BUF];
struct sockaddr_in address;
int size;
if (argc < 2)
{
printf("Usage: %s ServerAdresse\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((create_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("Socket error");
return EXIT_FAILURE;
}
memset(&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(*meinport);
inet_aton(argv[1], &address.sin_addr);
if (connect(create_socket, (struct sockaddr *)&address, sizeof(address)) == 0)
{
printf("Connection with server (%s) established\n", inet_ntoa(address.sin_addr));
size = recv(create_socket, buffer, BUF - 1, 0);
if (size > 0)
{
buffer[size] = '\0';
printf("%s", buffer);
}
}
else
{
perror("Connect error - no server available");
return EXIT_FAILURE;
}
int last = 0;
int mode = 0;
char bufferString[1024];
do
{
if (strncmp(bufferString, "send", 4) == 0 || mode == 1)
{
switch (last)
{
case 0:
last += 1;
mode = 1;
printf("\x1B[34m");
printf("->SEND->Sender eingeben: \n");
break;
case 1:
last += 1;
printf("\x1B[34m");
printf("->SEND->Empfänger eingeben: \n");
break;
case 2:
last += 1;
printf("\x1B[34m");
printf("->SEND->Betreff eingeben: \n");
break;
case 3:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->SEND->Nachricht eingeben: \n");
break;
}
}
else if (strncmp(bufferString, "list", 4) == 0 || mode == 2)
{
switch (last)
{
case 0:
last += 1;
mode = 2;
printf("\x1B[34m");
printf("->LIST->Username eingeben: \n");
break;
case 1:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->List");
do
{
size = recv(create_socket, buffer, BUF - 1, 0);
if (size > 0)
{
buffer[size] = '\0';
printf("\x1B[37m %s", buffer);
//printf("CHECK LASTLINE: %d", strncmp(buffer, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n")));
//printf("CHECK LASTLINE other: %d", strcmp(buffer, "LISTREADSTOPNOW\n"));
}
}
while (strncmp(buffer, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n")) != 0);
break;
}
}
else if (strncmp(bufferString, "read", 4) == 0)
{
printf("READ wurde endlich erkannt!\n");
}
else if (strncmp(bufferString, "del", 4) == 0)
{
printf("DEL wurde endlich erkannt!\n");
}
else
{
char *p = getenv("USER");
printf("\x1B[32m");
printf("%s@%s:%d", p, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
}
printf("\x1B[33m$ \x1B[37m");
fgets(buffer, BUF, stdin);
strcpy(bufferString, buffer);
send(create_socket, buffer, strlen(buffer), 0);
} while (strcmp(buffer, "quit\n") != 0);
close(create_socket);
return EXIT_SUCCESS;
}

580
myserver.c
View File

@@ -1,580 +0,0 @@
/* myserver.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#define BUF 1024
//#define PORT 6543
//Data Verzeichnis
char *verzeichnis;
//Dateistruktur des Speichers der aktuellen Message Nummer
struct msgNumber
{
int index;
};
//Dateistruktur von Postein/ausgang
struct msgNumberArr
{
int lenght;
int index[1024];
};
//Schreibt Nachrichten eines bestimmten Users(username) in ein file
//Dafür werden in msgNumbs die Message Nummern der zu speicherten Nachrichten gegeben
//lenght ist die anzahl der Message Nummern
//Nachrichten werden nach dem msgNumberArr struct gespeichert
//Return 0 = Fehler --> Entsprechende Fehlermeldung wird ausgegeben
//Return 1 = Erfolgreich
int writeUsersMessages(char username[1024], int *msgNumbs, int lenght)
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, username);
strcat(filename, ".bin");
printf("Start writeUsersMessages() filename: %s\n", filename);
filePointer = fopen(filename, "wb");
if (!filePointer)
{
printf("\x1B[31mUser Message Speicher konnte nicht geschrieben werden!\x1B[37m\n");
return 0;
}
struct msgNumberArr msgNumberStruct;
msgNumberStruct.lenght = lenght;
for (int i = 0; i < lenght; i++)
{
printf("MSG NUMMBER IN writeUserMessages(): %d\n", msgNumbs[i]);
msgNumberStruct.index[i] = msgNumbs[i];
}
fwrite(&msgNumberStruct, sizeof(struct msgNumberArr), 1, filePointer);
free(msgNumbs);
fclose(filePointer);
return 1;
}
//Holt alle nachrichten eines users(username)
//username wird als Pfad verwendet..... posteingang/<username> ..... postausgang/<username>
//liest die Nachrichten als msgNumberArr struct und gibt sie auch in dieser form zurück
//Return ein msgNumberArr struct mit der länge 0 = Fehler --> Entsprechende Fehler ausgabe
// .... länge > 0 = Erfolgreich
struct msgNumberArr getUserMessages(char username[1024])
{
FILE *filePointer;
char filename[1024];
if ('\n' == username[strlen(username) - 1])
{
username[strlen(username) - 1] = '\0';
}
strcpy(filename, verzeichnis);
strcat(filename, username);
strcat(filename, ".bin");
printf("getUserMessages() Filename: %s\n", filename);
filePointer = fopen(filename, "rb");
printf("\n\nstart getUserMessages() Filename: %s, Username: %s\n\n", filename, username);
if (!filePointer)
{
printf("\x1B[31User Message Speicher konnte nicht gelesen werden!\x1B[37m\n");
struct msgNumberArr nullstruct;
nullstruct.lenght = 0;
return nullstruct;
}
int i = 0;
struct msgNumberArr msgNumbersStruct;
fread(&msgNumbersStruct, sizeof(struct msgNumberArr), 1, filePointer);
fclose(filePointer);
return msgNumbersStruct;
}
//Eine Nachricht wird den vorherigen User(username) Nachrichten hinzugefügt
//die nachricht wird mit der msgNumber angegeben
//
//Es wird zuerst versucht alle user Nachrichten mit getUserMessages() zu holen
//Wenn welche vorhanden sind, werden sie temporär in einem Array gespeichert,
//die neue Nummer wird hinzugefügt und es wird mit writeUsersMessages() gespeichert
//
//Sind keine vorherigen nachrichten vorhanden, dann wird eben nur die aktuelle nummer gespeichert
int addUserMessage(char username[1024], int msgNumber)
{
if ('\n' == username[strlen(username) - 1])
{
username[strlen(username) - 1] = '\0';
}
printf("addUserMessage(), username: %s, msgNumber: %d\n", username, msgNumber);
int msgNumbers[1024];
struct msgNumberArr msgNumbersStruct = getUserMessages(username);
printf("msgnumberstruct lenght: %d", msgNumbersStruct.lenght);
for (int i = 0; i < msgNumbersStruct.lenght; i++)
{
msgNumbers[i] = msgNumbersStruct.index[i];
printf("MSG NUMMBER IN addUserMessage(): %d\n", msgNumbers[i]);
}
printf("Nach getUserMessages()\n");
int result;
if (msgNumbersStruct.lenght == 0)
{
printf("Es wurden keine vorherigen Messages des Users gefunden!\n");
int *msgNumbs = malloc(1024);
msgNumbs[0] = msgNumber;
printf("Username in addUserMessage(): %s", username);
result = writeUsersMessages(username, msgNumbs, 1);
}
else
{
printf("Es wurden vorherige Messages des Users gefunden, füge neue Message an alte Messages an!\n");
int nMsgs = msgNumbersStruct.lenght;
int *newNumbers = malloc(1024);
newNumbers[0] = msgNumber;
for (int i = 1; i <= nMsgs; i++)
{
printf("addUserMessage() msg number old: %d", msgNumbers[i - 1]);
newNumbers[i] = msgNumbers[i - 1];
}
printf("Vor dem writeUsersMessages() username: %s", username);
result = writeUsersMessages(username, newNumbers, nMsgs + 1);
printf("Nach dem writeUsersMessages() result: %d", result);
}
if (result == 0)
{
printf("\x1B[31mMessage konnte wegen eines fehlers, in writeUserMessages(), nicht gespeichert werden!\x1B[37m\n");
return 0;
}
else
{
return 1;
}
}
//Speichert die aktuelle Message Nummer in einer Datei nach dem msgNumber struct
// Return 0 = Fehler --> Entsprechende Meldung
// 1 = Erfolgreich
int writeMessageNumber(int number)
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, "msgNumber.bin");
filePointer = fopen(filename, "wb");
struct msgNumber my_record;
my_record.index = number;
printf("MSG NUMMBER IN writeMessageNumber(): %d\n", number);
if (!filePointer)
{
printf("\x1B[31mMessage Nummer Speicher konnte nicht geschrieben werden!\x1B[37m\n");
return 0;
}
fwrite(&my_record, sizeof(struct msgNumber), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN writeMessageNumber() ist FERTIG!\n");
return 1;
}
//Liest die aktuelle Message Nummer
//Ist keine vorhanden, wird eine neue erstellt
// Return 0 = Fehler --> Entsprechende Meldung
// 1 = Speicher neu erstellt --> Entsprechende Meldung
// > 1 = Speicher gelesen
int readLastMessageNumber()
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, "msgNumber.bin");
filePointer = fopen(filename, "rb");
struct msgNumber my_record;
if (!filePointer)
{
printf("\x1B[31mMessage Nummer Speicher wurde nicht gefunden!\n\x1B[32mNeuer Nummer Speicher wird angelegt!\x1B[37m\n");
int result = writeMessageNumber(1);
if (result == 0)
{
printf("\x1B[31mMessage Nummer Speicher konnte nicht geschrieben werden!");
return 0;
}
else
{
return 1;
}
}
fread(&my_record, sizeof(struct msgNumber), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN readLastMessageNumber(): %d\n", my_record.index);
return my_record.index;
}
//Liest die aktuelle Message Nummer mit readLastMessageNumber()
//und rechnet +1 um die neue Message Nummer zu bekommen,
//die neue Nummer wird dann auch gleich mit writeMessageNumber() in ein File geschrieben
//Return 0 = Fehler --> Entsprechende Mitteilung
// 1 = Nicht möglich, da immer +1 gerechnet wird
// > 1 = Erfolgreiche Abfrage
int getNextMessageNumber()
{
int msgNumber = readLastMessageNumber();
printf("MSG NUMMBER IN getNextMessageNumber() lastmsgNumber: %d\n", msgNumber);
if (msgNumber == 0)
{
printf("\x1B[31mMessage Nummer kam nicht von readLastMessageNumber()!\x1B[37m\n");
return 0;
}
else
{
int result = writeMessageNumber(msgNumber + 1);
printf("After write MEssage nummber, result: %d\n", result);
if (result == 0)
{
printf("\x1B[31mMessage Nummer konnte nicht gespeichert werden!\x1B[37m\n");
return 0;
}
else
{
printf("MSG NUMMBER IN getNextMessageNumber() FERTIG!\n");
return msgNumber + 1;
}
}
}
//Dateistruktur einer Nachricht
struct rec
{
char *sender, *receiver, *betreff, *msg;
};
//Liest ein Nachrichten File, ergebnis ist ein rec struct
//filename gibt den dateinamen an, z.b. 7
//Return das rec struct der Datei
//Error --> Wenn die Datei nicht gelesen werden konnte
struct rec readFile(char filename[1024])
{
FILE *filePointer;
char fullfilename[1024];
strcpy(fullfilename, verzeichnis);
strcat(fullfilename, filename);
strcat(fullfilename, ".bin");
filePointer = fopen(fullfilename, "rb");
printf("ReadFile Fullfilename: %s\n", fullfilename);
if (!filePointer)
{
perror("\x1B[31mFile konnte nicht gelesen werden!\x1B[37m\n");
}
struct rec *my_record;
fread(my_record, sizeof(struct rec), 1, filePointer);
printf("\nBETREFF in readFile(): %s", my_record->betreff);
fclose(filePointer);
return *my_record;
}
//Schreibt eine neue Nachricht in eine File, anhand des rec struct
//zuerst wird die neue Message Nummer mit getNextMessageNumber() ermittelt
//Danach ein neues File geöffnet und mit dem rec struct befüllt
//Danach werden den usern die in sender und receiver angegeben wurden mit addUserMessage(),
//die gesendeten/empfangenen nachrichten gespeichert
//
//Return 0 = Fehler --> Entsprechende Message
// 1 = Erfolgreich
int writeToFile(char sender[1024], char betreff[1024], char receiver[1024], char message[1024])
{
FILE *filePointer;
char filename[1024];
int msgNumber = getNextMessageNumber();
if (msgNumber == 0)
{
printf("\x1B[31mWrite File konnte nicht geöffnet werden!\x1B[37m\n");
return 0;
}
else
{
printf("MSG NUMMBER found, schreibe file mit msgNummber: %d!\n", msgNumber);
strcpy(filename, verzeichnis);
char msgNumberStr[1024];
sprintf(msgNumberStr, "%d", msgNumber);
strcat(filename, msgNumberStr);
strcat(filename, ".bin");
printf("\nwriteToFile() Filename: %s\n", filename);
filePointer = fopen(filename, "wb");
struct rec my_record;
if (!filePointer)
{
printf("\x1B[31mWrite File konnte nicht geöffnet werden!\x1B[37m\n");
return 0;
}
else
{
my_record.sender = sender;
my_record.receiver = receiver;
my_record.betreff = betreff;
my_record.msg = message;
printf("Vor useradd() in writeToFile()! sender: %s, msgnumber: %d, msg: %s, betrf: %s, empf: %s\n", sender, msgNumber, message, betreff, receiver);
char receiverfile[1024];
strcpy(receiverfile, "posteingang/");
strcat(receiverfile, receiver);
int receiverresult = addUserMessage(receiverfile, msgNumber);
printf("receiverresult: %d", receiverresult);
char senderfile[1024];
strcpy(senderfile, "postausgang/");
strcat(senderfile, sender);
int senderresult = addUserMessage(senderfile, msgNumber);
printf("senderresult: %d", senderresult);
if (senderresult == 0 || receiverresult == 0)
{
printf("\x1B[31mKonnte die Nachricht dem User nicht hinzufügen! Das Speichern der Nachricht wird abgebrochen!\x1B[37m\n");
return 0;
}
else
{
fwrite(&my_record, sizeof(struct rec), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN writeToFile(): %d\n", msgNumber);
return 1;
}
}
}
}
//Main Funktion, beeinhaltet die Server Logik
//Wenn ich in dem Datenstrom einen der Gesuchten Befehle finde,
// dann "schalte ich in den entsprechenden modus um", indem ich in
//int mode den aktuellen befehl speichere. Mit int last wird der
//aktuelle programmschritt gespeichert
int main(int argc, char **argv)
{
verzeichnis = strdup(argv[1]);
char *meinport = argv[2];
printf("\x1B[35mMein server Verzeichniss: %s\n", verzeichnis);
printf("Mein server Port: %s\n", meinport);
int create_socket, new_socket;
socklen_t addrlen;
char buffer[BUF];
int size;
struct sockaddr_in address, cliaddress;
create_socket = socket(AF_INET, SOCK_STREAM, 0);
memset(&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(*meinport);
if (bind(create_socket, (struct sockaddr *)&address, sizeof(address)) != 0)
{
perror("bind error");
return EXIT_FAILURE;
}
listen(create_socket, 5);
addrlen = sizeof(struct sockaddr_in);
struct rec recToSave;
while (1)
{
printf("\x1B[36mWaiting for connections...\n");
new_socket = accept(create_socket, (struct sockaddr *)&cliaddress, &addrlen);
if (new_socket > 0)
{
printf("\x1B[32mClient connected from %s:%d...\n", inet_ntoa(cliaddress.sin_addr), ntohs(cliaddress.sin_port));
strcpy(buffer, "\x1B[34mWelcome to myserver, Please enter your command:\x1B[37m\n");
send(new_socket, buffer, strlen(buffer), 0);
}
char bufferString[BUF];
int last = 0;
int mode = 0;
do
{
size = read(new_socket, buffer, BUF - 1);
if (size > 0)
{
buffer[size] = '\0';
strcpy(bufferString, buffer);
if (strncmp(bufferString, "send", 4) == 0 || mode == 1)
{
switch (last)
{
case 0:
last += 1;
mode = 1;
printf("\x1B[34m");
printf("->SEND:\x1B[33m %s\x1B[37m\n", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 1:
last += 1;
printf("\x1B[34m");
printf("->SEND->Sender wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char sender[1024];
strcat(sender, bufferString);
recToSave.sender = strdup(bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 2:
last += 1;
printf("\x1B[34m");
printf("->SEND->Empfänger wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char empf[1024];
strcat(empf, bufferString);
recToSave.receiver = strdup(bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 3:
last += 1;
printf("\x1B[34m");
printf("->SEND->Betreff wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char betreff[1024];
strcat(betreff, bufferString);
recToSave.betreff = strdup(bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
break;
case 4:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->SEND->Nachricht wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char msg[1024];
strcat(msg, bufferString);
recToSave.msg = strdup(bufferString);
printf("BUFFER STRING: %s", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
printf("Sender: %s, Empf: %s, Betreff: %s, MSG: %s", recToSave.sender, recToSave.receiver, recToSave.betreff, recToSave.msg);
int returnWrite = writeToFile(recToSave.sender, recToSave.betreff, recToSave.receiver, recToSave.msg);
if (returnWrite == 0)
{
printf("\x1B[31mNachricht konnte nicht gespeichert werden!\x1B[33m\n");
}
else
{
printf("\x1B[32mNachricht wurde gespeichert!\x1B[33m\n");
}
break;
}
}
else if (strncmp(bufferString, "list", 4) == 0 || mode == 2)
{
switch (last)
{
case 0:
last += 1;
mode = 2;
printf("\x1B[34m");
printf("->LIST:\x1B[33m %s\x1B[37m\n", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 1:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->LIST->Username wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char *username;
username = strdup(bufferString);
//POSTEINGANG
char filename[1024];
strcpy(filename, "posteingang/");
strcat(filename, username);
printf("Filename: %s ENDE\n", filename);
struct msgNumberArr msgNumbersStruct = getUserMessages(filename);
printf("msgnumberstruct lenght: %d\n", msgNumbersStruct.lenght);
struct rec userFilesStruct[1024];
//Send to client
char posteingangMsg[1024];
sprintf(posteingangMsg, "\x1B[32mPOSTEINGANG Nachrichten: %d\n\n\n\n", msgNumbersStruct.lenght);
int sendresult = send(new_socket, posteingangMsg, strlen(posteingangMsg), 0);
printf("Send result: %d", sendresult);
for (int i = 0; i < msgNumbersStruct.lenght; i++)
{
char filename[1024];
sprintf(filename, "%d", msgNumbersStruct.index[i]);
struct rec my_record_p = readFile(filename);
//Send to client
printf("\n\nEINGANG -- Nachricht: %d Betreff: %s", i, my_record_p.betreff);
sprintf(posteingangMsg, "\x1B[34mBetreff: %s\n", my_record_p.betreff);
sendresult = send(new_socket, posteingangMsg, strlen(posteingangMsg), 0);
printf("Send result: %d\n", sendresult);
userFilesStruct[i] = my_record_p;
}
//postausgang
filename[1024];
strcpy(filename, "postausgang/");
strcat(filename, username);
printf("Filename: %s ENDE\n", filename);
struct msgNumberArr msgNumbersStructAusgang = getUserMessages(filename);
printf("msgnumberstruct lenght: %d\n", msgNumbersStructAusgang.lenght);
//Send to client
char postausgangMsg[1024];
sprintf(postausgangMsg, "\x1B[32mPOSTAUSGANG Nachrichten: %d\n", msgNumbersStructAusgang.lenght);
sendresult = send(new_socket, postausgangMsg, strlen(postausgangMsg), 0);
printf("Send result: %d", sendresult);
struct rec userFilesStructAusgang[1024];
for (int i = 0; i < msgNumbersStructAusgang.lenght; i++)
{
char filename[1024];
sprintf(filename, "%d", msgNumbersStructAusgang.index[i]);
struct rec my_record_p = readFile(filename);
printf("\n\nAUSGANG -- Nachricht: %d Betreff: %s\n\n", i, my_record_p.betreff);
//Send to client
char postausgangMsg[1024];
sprintf(postausgangMsg, "\x1B[34mBetreff: %s\n", my_record_p.betreff);
sendresult = send(new_socket, postausgangMsg, strlen(postausgangMsg), 0);
printf("Send result: %d", sendresult);
userFilesStructAusgang[i] = my_record_p;
}
//Send to client
sendresult = send(new_socket, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n"), 0);
printf("Send result: %d", sendresult);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
}
}
else if (strncmp(bufferString, "read", 4) == 0)
{
printf("READ wurde endlich erkannt!\n");
}
else if (strncmp(bufferString, "del", 4) == 0)
{
printf("DEL wurde endlich erkannt!\n");
}
else
{
printf("\x1B[33mBefehl wurde nicht erkannt: \x1B[31m%s\n", bufferString);
}
printf("\x1B[37m");
}
else if (size == 0)
{
printf("\x1B[33mClient closed remote socket\x1B[37m\n");
break;
}
else
{
perror("recv error");
return EXIT_FAILURE;
}
} while (strncmp(buffer, "quit", 4) != 0);
close(new_socket);
}
close(create_socket);
return EXIT_SUCCESS;
}