cdez/CS460-Projects
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

This branch has the chatserverplus stuff in it, copied over the client, removed the unnecessary files included.

Browse source
This commit is contained in:
Charles Descamps 2025-03-19 17:52:34 -07:00
parent a2adaa05a6
commit f3c913c97c
11 changed files with 56 additions and 352 deletions
Download patch file Download diff file Expand all files Collapse all files

4
chatserver/README.md
View file

@ -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.

55
chatserver/client.py
View file

@ -0,0 +1,55 @@
import socket
import sys
import select
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}")
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
# send message to server
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()

20
echoserver/Makefile
View file

@ -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

10
echoserver/README.md
View file

@ -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.

150
echoserver/echoserver.c
View file

@ -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: ???
*/

25
echoserver/echoserver.h
View file

@ -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

20
timeserver/Makefile
View file

@ -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

16
timeserver/README.md
View file

@ -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.

BIN
timeserver/demo.pcap
View file

Binary file not shown.

83
timeserver/timeserver.c
View file

@ -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: ???
*/

23
timeserver/timeserver.h
View file

@ -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