Allow for both Windows and Linux to use the same 'client'

chatserver/README.md

@@ -6,7 +6,3 @@ Use the client to communicate with the chatserver by running `python client.py`
 
 ## chatserver information
 Included is the server and client written in Python.
-
-## pcap information
-A demonstration of the chatserver has been captured with Wireshark in the 
-included `demo.pcap` file.

chatserver/client.py

@@ -0,0 +1,77 @@
+import socket
+import sys
+import select
+import os
+
+BUFFER_SIZE = 1024
+DEFAULT_HOST = 'localhost'
+DEFAULT_PORT = 8181
+
+def main():
+    if len(sys.argv) != 3:
+        SERVER_HOST = input(f"Enter server host (default: {DEFAULT_HOST}): ") or DEFAULT_HOST
+        SERVER_PORT = input(f"Enter server port (default: {DEFAULT_PORT}): ") or DEFAULT_PORT
+        SERVER_PORT = int(SERVER_PORT)
+    else:
+        SERVER_HOST = sys.argv[1]
+        SERVER_PORT = int(sys.argv[2])
+
+    # create a socket object
+    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        # connect to the server
+        client_socket.connect((SERVER_HOST, SERVER_PORT))
+        print(f"Connected to chat server at {SERVER_HOST}:{SERVER_PORT}")
+        
+        if os.name == 'nt':  # Windows-specific logic
+            import msvcrt
+            client_socket.setblocking(False)  # Set the socket to non-blocking mode
+
+            while True:
+                # Check for server messages
+                try:
+                    server_message = client_socket.recv(BUFFER_SIZE).decode('utf-8')
+                    if server_message:
+                        print(f"\n{server_message}")
+                        print("> ", end="", flush=True)
+                except BlockingIOError:
+                    pass
+
+                # Check for user input
+                if msvcrt.kbhit():
+                    client_message = input("> ")
+                    if client_message.strip() == "%!":
+                        print("Exiting chat...")
+                        break
+                    client_socket.send(client_message.encode('utf-8'))
+
+        else:  # Linux/Unix-specific logic
+            while True:
+                # use select to wait for either server messages or user input
+                read_sockets, _, _ = select.select([client_socket, sys.stdin], [], [])
+                
+                for sock in read_sockets:
+                    if sock == client_socket:
+                        # receive message from server
+                        server_message = client_socket.recv(BUFFER_SIZE).decode('utf-8')
+                        if not server_message:
+                            print("Disconnected from server")
+                            return
+                        print(f"\n{server_message}")
+                        print("> ", end="", flush=True)
+                    else:
+                        # prompt for user input
+                        client_message = input()
+                        if client_message.strip() == "%!":
+                            print("Exiting chat...")
+                            return
+                        client_socket.send(client_message.encode('utf-8'))
+
+    except Exception as e:
+        print(f"Error: {e}")
+    finally:
+        client_socket.close()
+        print("Connection closed")
+
+if __name__ == "__main__":
+    main()

chatserver/server.py

@@ -1,11 +1,59 @@
 import socket
 import select
+import uuid
+import pickle
+import os
 
 CHATPORT = 8181
 BUFFER_SIZE = 1024
 MAX_CONNECT_QUEUE = 10
+DATA_FILE = 'server_data.pkl'
+ADMIN_USERNAME = "admin"
+ADMIN_PASSWORD = "adminpass"
+UUID_FILE = 'uuids.pkl'
+
+def save_data(client_info, chat_rooms, client_states):
+    serializable_client_info = {info["user_id"]: info for sock, info in client_info.items()}
+    serializable_chat_rooms = {info["user_id"]: chat_rooms[sock] for sock, info in client_info.items()}
+    serializable_client_states = {info["user_id"]: client_states[sock] for sock, info in client_info.items()}
+    with open(DATA_FILE, 'wb') as f:
+        pickle.dump((serializable_client_info, serializable_chat_rooms, serializable_client_states), f)
+
+def load_data():
+    if os.path.exists(DATA_FILE):
+        with open(DATA_FILE, 'rb') as f:
+            serializable_client_info, serializable_chat_rooms, serializable_client_states = pickle.load(f)
+            client_info = {uuid.UUID(user_id): info for user_id, info in serializable_client_info.items()}
+            chat_rooms = {uuid.UUID(user_id): room for user_id, room in serializable_chat_rooms.items()}
+            client_states = {uuid.UUID(user_id): state for user_id, state in serializable_client_states.items()}
+            return client_info, chat_rooms, client_states
+    return {}, {}, {}
+
+def save_uuids(uuid_dict):
+    with open(UUID_FILE, 'wb') as f:
+        pickle.dump(uuid_dict, f)
+
+def load_uuids():
+    if os.path.exists(UUID_FILE):
+        with open(UUID_FILE, 'rb') as f:
+            return pickle.load(f)
+    return {}
+
+def get_client_uuid(client_socket, uuid_dict):
+    client_address = client_socket.getpeername()
+    client_key = f"{client_address[0]}_{client_address[1]}"
+
+    if client_key in uuid_dict:
+        user_id = uuid_dict[client_key]
+    else:
+        user_id = str(uuid.uuid4())
+        uuid_dict[client_key] = user_id
+        save_uuids(uuid_dict)
+
+    return user_id
 
 def main():
+    global quitFlag
     # set the flag variable to true for infinite loop
     quitFlag = True
     # create a socket object
@@ -23,14 +71,9 @@ def main():
 
     # create a list to store the sockets, server and client
     socket_list = [server_socket]
-    # since a socket is associated with a username and a chatroom, 
-    # and each one can only be associated one way at once, use dictionaries to
-    # associate with each other.
-    usernames = {}
-    chat_rooms = {}
-    # keep track of the states of each client connected, and if they are 
-    # technically in an 'unsafe' state like in change username or chatroom mode.
-    client_states = {}
+    # load persistent data
+    client_info, chat_rooms, client_states = load_data()
+    uuid_dict = load_uuids()
     # let the user know the server is listening on port CHATPORT.
     print(f"Chatserver listening on port: {CHATPORT}")
 
@@ -50,6 +93,9 @@ def main():
                 client_socket.send(b"\nUse '%!' to exit, or '%?' for help.\n")
                 client_socket.send(b"\nType in a username: \n")
                 client_states[client_socket] = "WAITING_FOR_USERNAME"
+                # Get or generate a unique user ID for the client
+                user_id = get_client_uuid(client_socket, uuid_dict)
+                client_info[client_socket] = {"user_id": user_id}
             # otherwise the socket is a client socket.
             else:
                 # try to receive the message from the client
@@ -58,14 +104,30 @@ def main():
                     if message:
                         state = client_states.get(sock, "NORMAL")
                         if state == "WAITING_FOR_USERNAME":
-                            usernames[sock] = message.strip()
+                            username = message.strip()
+                            if username == ADMIN_USERNAME:
+                                sock.send(b"\nEnter admin password: \n")
+                                client_states[sock] = "WAITING_FOR_ADMIN_PASSWORD"
+                                client_info[sock]["username"] = username
+                            else:
+                                client_info[sock]["username"] = username
                                 chat_rooms[sock] = "default"
                                 sock.send(b"\nUsername accepted. You are now in the 'default' chatroom.\n")
                                 client_states[sock] = "NORMAL"
+                        elif state == "WAITING_FOR_ADMIN_PASSWORD":
+                            password = message.strip()
+                            if password == ADMIN_PASSWORD:
+                                sock.send(b"\nAdmin authenticated successfully.\n")
+                                client_info[sock]["is_admin"] = True
+                                chat_rooms[sock] = "default"
+                                client_states[sock] = "NORMAL"
+                            else:
+                                sock.send(b"\nInvalid admin password. Please enter a username: \n")
+                                client_states[sock] = "WAITING_FOR_USERNAME"
                         elif state == "WAITING_FOR_NEW_USERNAME":
-                            usernames[sock] = message.strip()
+                            client_info[sock]["username"] = message.strip()
                             sock.send(b"\nUsername changed successfully.\n")
-                            print(f"\nClient switched username to {usernames[sock]}.")
+                            print(f"\nClient switched username to {client_info[sock]['username']}.")
                             client_states[sock] = "NORMAL"
                         elif state == "WAITING_FOR_NEW_CHATROOM":
                             old_chatroom = chat_rooms[sock]
@@ -79,7 +141,7 @@ def main():
                             if message.strip() == "%!":
                                 sock.close()
                                 socket_list.remove(sock)
-                                del usernames[sock]
+                                del client_info[sock]
                                 del chat_rooms[sock]
                                 del client_states[sock]
                                 print("\nClient has closed connection.")
@@ -92,14 +154,38 @@ def main():
                                 sock.send(b"\t%! : Exit from the Chat Server.\n")
                                 sock.send(b"\t%* : Switch to another chatroom.\n")
                                 sock.send(b"\t%$ : Change Username.\n")
+                                sock.send(b"\t%@ <username> <message> : Send a direct message to a user.\n")
+                                if client_info[sock].get("is_admin"):
+                                    sock.send(b"\t%stop : Stop the server.\n")
                             elif message.strip() == "%*":
                                 sock.send(b"\nEnter chatroom name: \n")
                                 client_states[sock] = "WAITING_FOR_NEW_CHATROOM"
                             elif message.strip() == "%$":
                                 sock.send(b"\nEnter new username: \n")
                                 client_states[sock] = "WAITING_FOR_NEW_USERNAME"
+                            elif message.strip().startswith("%@ "):
+                                parts = message.strip().split(' ', 2)
+                                if len(parts) < 3:
+                                    sock.send(b"\nInvalid direct message format. Use: %@ <username> <message>\n")
                                 else:
-                                username = usernames[sock]
+                                    target_username = parts[1]
+                                    dm_message = parts[2]
+                                    target_sock = None
+                                    for s, info in client_info.items():
+                                        if info.get("username") == target_username:
+                                            target_sock = s
+                                            break
+                                    if target_sock:
+                                        sender_username = client_info[sock]["username"]
+                                        target_sock.send(f"DM from {sender_username}: {dm_message}\n".encode('utf-8'))
+                                        sock.send(b"\nDirect message sent.\n")
+                                    else:
+                                        sock.send(b"\nUser not found.\n")
+                            elif message.strip() == "%stop" and client_info[sock].get("is_admin"):
+                                print("\nAdmin has stopped the server.")
+                                quitFlag = False
+                            else:
+                                username = client_info[sock]["username"]
                                 chat_room = chat_rooms[sock]
                                 send_message = f"{username} >> {message}".encode('utf-8')
                                 for client_sock in socket_list:
@@ -108,8 +194,8 @@ def main():
                     else:
                         sock.close()
                         socket_list.remove(sock)
-                        if sock in usernames:
-                            del usernames[sock]
+                        if sock in client_info:
+                            del client_info[sock]
                         if sock in chat_rooms:
                             old_chatroom = chat_rooms[sock]
                             del chat_rooms[sock]
@@ -122,8 +208,8 @@ def main():
                     print(f"Error: {err}")
                     sock.close()
                     socket_list.remove(sock)
-                    if sock in usernames:
-                        del usernames[sock]
+                    if sock in client_info:
+                        del client_info[sock]
                     if sock in chat_rooms:
                         old_chatroom = chat_rooms[sock]
                         del chat_rooms[sock]
@@ -133,6 +219,8 @@ def main():
                         del client_states[sock]
                     print("\nClient has closed connection.")
 
+    # Save data before closing the server
+    save_data(client_info, chat_rooms, client_states)
     server_socket.close()
 
 if __name__ == "__main__":

echoserver/Makefile

@@ -1,20 +0,0 @@
-CC = gcc -Wall -std=c11 -pedantic
-SOURCES = echoserver.c 
-OBJECTS = echoserver.o 
-
-all: echoserver
-
-echoserver: $(OBJECTS)
-	$(CC) $(OBJECTS) -o echoserver
-
-echoserver.o: echoserver.c
-	$(CC) -c echoserver.c -o echoserver.o
-
-clean:
-	rm -f $(OBJECTS) echoserver echoserver.out
-
-clean_objects:
-	rm -f $(OBJECTS)
-
-run:
-	./echoserver

echoserver/README.md

@@ -1,10 +0,0 @@
-# Running the echoserver
-Use `make` to compile the echoserver.
-Use `make run` to run the echoserver. This will run on an infinite loop.
-Use `Ctrl+C` to stop the echoserver.
-
-## echoserver communication
-Communicating with the server can happen using telnet in TCP mode.
-
-## echoserver information
-The echoserver runs on TCP port 8888.

echoserver/echoserver.c

@@ -1,150 +0,0 @@
-// header files
-#include "echoserver.h"
-
-// constants
-// echoserver port is 8888
-#define ECHOPORT 8888
-#define BUFFER_SIZE 1024
-#define MAX_CONNECT_QUEUE 10
-
-// prototypes
-
-// main function
-int main(int argc, char **argv)
-{
-    // initialize program (variables and structs)
-    bool quitFlag = true;
-    int socketEchoFD;
-    int clientEchoFD;
-    int reuseAddrOpt = 1;
-    int keepAliveOpt = 1;
-    char message[BUFFER_SIZE];
-    int messageBytes;
-    struct sockaddr_in serverAddr;
-    struct sockaddr_storage clientAddr;
-    socklen_t clientSize;
-    memset(&serverAddr, 0, sizeof(serverAddr));
-    memset(&clientAddr, 0, sizeof(clientAddr));
-    // define a TCP socket
-    socketEchoFD = socket(AF_INET, SOCK_STREAM, 0);
-    if(socketEchoFD < 0)
-    {
-        printf("Unable to create the socket.\n");
-        return -1;
-    }
-    // use the setsockopt function to make the socket accept different configurations
-    // allow for the reuse of the address/bind.
-    setsockopt(socketEchoFD, SOL_SOCKET, SO_REUSEADDR, &reuseAddrOpt, sizeof(reuseAddrOpt));
-    // also need to set the socket to keepalive using setsockopt
-    setsockopt(socketEchoFD, SOL_SOCKET, SO_KEEPALIVE, &keepAliveOpt, sizeof(keepAliveOpt));
-    // bind the TCP socket to port 8888 / ECHOPORT
-    serverAddr.sin_family = AF_INET;
-    serverAddr.sin_addr.s_addr = INADDR_ANY;
-    serverAddr.sin_port = htons(ECHOPORT);
-    int bindCheck = bind(socketEchoFD, &serverAddr, sizeof(serverAddr));
-    if(bindCheck < 0)
-    {
-        printf("Unable to bind the socket to the port or address.\n Is either in use?");
-        return -1;
-    }
-    // use fnctl to set the non-blocking flag for the socket
-    fcntl(socketEchoFD, F_SETFL, O_NONBLOCK);
-    // the server will now accept client connections by listening.
-    listen(socketEchoFD, MAX_CONNECT_QUEUE);
-    // create a file descriptor set, to keep track of the sockets in use using fd_set and FD_ZERO?
-    fd_set socketList;
-    FD_ZERO(&socketList);
-    // add the socketEchoFD to the file descriptor set using fd_set
-    FD_SET(socketEchoFD, &socketList);
-    // max file descriptor, this will be used to 'find' the socket currently connected
-    int maxFD = socketEchoFD;
-    // while loop that will continue to listen for messages from clients.
-    printf("Echoserver listening on port: %d\n", ECHOPORT);
-    while (quitFlag)
-    {
-        // set of active connections
-        fd_set activeSet = socketList;
-        // use the select() function here to check the set of sockets
-        int selectedFD = select(maxFD+1, &activeSet, NULL, NULL, NULL);
-        // check to make sure select() didn't error out.
-        if(selectedFD == -1)
-        {
-            //
-            printf("\nUnable to select socket to listen to.\n");
-            return -1;
-        }
-        // for loop that loops up to the max file descriptor.
-        for(int fileIter = 0; fileIter <= maxFD; fileIter++)
-        {
-            // check to see if the file descriptor is in the set of sockets using FD_ISSET()
-            if(FD_ISSET(fileIter, &activeSet))
-            {
-                // if the server socket is being written to/read from,
-                if(fileIter == socketEchoFD)
-                {
-                    // create a client socket using accept
-                    clientSize = sizeof(clientAddr);
-                    clientEchoFD = accept(socketEchoFD, &clientAddr, &clientSize);
-                    // check to see if the client socket is connected (-1)
-                    if(clientEchoFD == -1)
-                    {
-                        printf("\nCould not connect the client to a socket.\n");
-                        return -1;
-                    }
-                    else
-                    {
-                        // set the non blocking flag using fnctl
-                        fcntl(clientEchoFD, F_SETFL, O_NONBLOCK);
-                        // add the client socket to the set of file descriptor sockets
-                        FD_SET(clientEchoFD, &socketList);
-                        // check to see if the new socket FD is greater than the current max (clientSocket > maxFD)
-                        if(clientEchoFD > maxFD)
-                        {
-                            // if it is, set the new max.
-                            maxFD = clientEchoFD;
-                        }
-                        printf("\nConnected client to socket.\n");
-                    }
-                    printf("\nAccepted connection from new client.\n");
-                }
-                // if the client socket(s) are being written to/read from,
-                else
-                {
-                    // grab the data from the client, save to message.
-                    messageBytes = recv(fileIter, message, BUFFER_SIZE, 0);
-                    // make sure that the connection is still open before attempting to send.
-                    if(messageBytes <= 0) // old: messageBytes <= 0
-                    {
-                        // if it is not open, close the socket and remove the socket from the socket list using FD_CLR()
-                        close(fileIter);
-                        FD_CLR(fileIter, &socketList);
-                        printf("\nClient has closed connection.\n");
-                    }
-                    else
-                    {
-                        // if it is open, send the message back to the client over the client socket
-                        send(fileIter, message, messageBytes, 0);
-                        printf("\nMessage has been sent back to client.\n");
-                    }
-                }
-            }
-        }
-    }
-    // close the socket
-    close(socketEchoFD);
-    // profit???
-    return 0;
-}
-
-// function definitions
-
-/*
-Name: ???
-Process: ???
-Function Input/Parameters: ???
-Function Output/Parameters: ???
-Function Output/Returned: ???
-Device Input/Device: ???
-Device Output/Device: ???
-Dependencies: ???
-*/

echoserver/echoserver.h

@@ -1,25 +0,0 @@
-#ifndef ECHOSERVER
-#define ECHOSERVER
-
-// included libraries
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/select.h>
-#include <netdb.h>
-#include <time.h>
-#include <unistd.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <fcntl.h>
-
-// data structures
-
-// function prototypes
-
-#endif // ECHOSERVER

timeserver/Makefile

@@ -1,20 +0,0 @@
-CC = gcc -Wall -std=c11 -pedantic
-SOURCES = timeserver.c 
-OBJECTS = timeserver.o 
-
-all: timeserver
-
-timeserver: $(OBJECTS)
-	$(CC) $(OBJECTS) -o timeserver
-
-timeserver.o: timeserver.c
-	$(CC) -c timeserver.c -o timeserver.o
-
-clean:
-	rm -f $(OBJECTS) timeserver timeserver.out
-
-clean_objects:
-	rm -f $(OBJECTS)
-
-run:
-	./timeserver

timeserver/README.md

@@ -1,16 +0,0 @@
-# Running the timeserver
-Use `make` to compile the timeserver.
-Use `make run` to run the timeserver. This will run on an infinite loop.
-Use `Ctrl+C` to stop the timeserver.
-
-## timeserver communication
-Communicating with the server can happen using netcat in UDP mode (-u flag).
-
-## timeserver information
-The timeserver runs on UDP port 8888.
-The timeserver will wait for `time\r\n` to be sent on this port, and if received,
-will send back a response of the time (in ms) since January 1st, 1970 (UNIX Epoch).
-
-## pcap information
-A demonstration of the timeserver has been captured with Wireshark in the 
-included `demo.pcap` file.

timeserver/timeserver.c

@@ -1,83 +0,0 @@
-// header files
-#include "timeserver.h"
-
-// constants
-// timeserver port is 8888
-#define TIMEPORT 8888
-#define BUFFER_SIZE 1024
-
-// prototypes
-
-// main function
-int main(int argc, char **argv)
-{
-    // initialize program (variables and structs)
-    bool quitFlag = true;
-    int socketTimeFD;
-    char message[BUFFER_SIZE];
-    struct sockaddr_in serverAddr, clientAddr;
-    memset(&serverAddr, 0, sizeof(serverAddr));
-    memset(&clientAddr, 0, sizeof(clientAddr));
-    // define a UDP socket
-    socketTimeFD = socket(AF_INET, SOCK_DGRAM, 0);
-    if(socketTimeFD < 0)
-    {
-        printf("Unable to create the socket.");
-        return -1;
-    }
-    // bind the UDP socket to port 8888 / TIMEPORT
-    serverAddr.sin_family = AF_INET;
-    serverAddr.sin_addr.s_addr = INADDR_ANY;
-    serverAddr.sin_port = htons(TIMEPORT);
-    int bindCheck = bind(socketTimeFD, &serverAddr, sizeof(serverAddr));
-    if(bindCheck < 0)
-    {
-        printf("Unable to bind the socket to the port or address.\n Is either in use?");
-        return -1;
-    }
-    // while loop to see if the "time\r\n" has been received (recv call?)
-    printf("Timeserver listening on port: %d\n", TIMEPORT);
-    while(quitFlag)
-    {
-        int clientAddrLen;
-        int receivedDataLen;
-        // grab the data from the client
-        receivedDataLen = recvfrom(socketTimeFD, message, BUFFER_SIZE, MSG_WAITALL, &clientAddr, &clientAddrLen);
-        message[receivedDataLen] = '\0';
-        // if "time\r\n" is received, then send() back the linux epoch.
-        if(strcmp(message, "time\n") == 0 || strcmp(message, "time\r\n") == 0)
-        {
-            // setup the reply message
-            char reply[BUFFER_SIZE];
-            // add the current time to the reply
-            sprintf(reply, "%d", time(NULL));
-            // send the reply to the requestee
-            sendto(socketTimeFD, (const char *)reply, strlen(reply), 0, (const struct sockaddr *) &clientAddr, clientAddrLen);
-            // log the time command recv'd
-            printf("\nServer received time. Replied with: %d\n", time(NULL));
-        }
-        else if (strcmp(message, "close\n") == 0 || strcmp(message, "quit\n") == 0 || strcmp(message, "q\n") == 0)
-        {
-            // if the server recv'd the close command, then close the server.
-            printf("\nServer received close.\n");
-            quitFlag = false;
-        }
-    }
-    // close the socket
-    close(socketTimeFD);
-    // profit???
-    return 0;
-}
-
-// function definitions
-
-/*
-Name: ???
-Process: ???
-Function Input/Parameters: ???
-Function Output/Parameters: ???
-Function Output/Returned: ???
-Device Input/Device: ???
-Device Output/Device: ???
-Dependencies: ???
-*/

timeserver/timeserver.h

@@ -1,23 +0,0 @@
-#ifndef TIMESERVER
-#define TIMESERVER
-
-// included libraries
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <time.h>
-#include <unistd.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-// data structures
-
-// function prototypes
-
-#endif // TIMESERVER