all: server client

server: server.c server.h helper.c helper.h hashtable.c hashtable.h

gcc -o server server.c helper.c hashtable.c

client: client.c helper.c helper.h

gcc -o client client.c helper.c

clean:

rm server client

Write a program [webserver.c](./webserver.c) using which works in the following way:

- It

- Establish signal handler for SIGIO using `signal()` and `sigaction()`

- Set socket owner. `fcntl()` with `F_SETOWN`. It tells who will receive signals

- `fcntl(fd, F_SETOWN, getpid());`

- Enable signal driven I/O for the socket using `O_ASYNC`

- Make connection sockets to be non-blocking bcz u get edge-triggered notifications. So you have to read all available data by performs I/O system calls until a call fails with the error `EAGAIN` or `EWOULDBLOCK`.

- use `O_NONBLOCK` flag.

- `fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_ASYNC | O_NONBLOCK);`

- Specify a realtime signal to be used in place of SIGIO to avoid queuing and handling multiple connections.

- Use `SA_SIGINFO` flag in `sigaction()` to establish handler for RT signals.

#include "helper.h"

#define BUFFERSIZE 128

int main(void)

{

int sockfd = 0;

struct sockaddr_in serverAddr;

/* Create a socket first */

sockfd = Socket(AF_INET, SOCK_STREAM, 0);

/* Initialize sockaddr_in data structure */

serverAddr.sin_family = AF_INET;

serverAddr.sin_port = htons(8004); // port

serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

/* Attempt a connection */

if(connect(sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0){

errorExit("connect");

}

char buf[BUFFERSIZE];

strcpy(buf, "hello server\n");

Write(sockfd, buf, strlen(buf));

sleep(10);

close(sockfd);

return 0;

}

#include "hashtable.h"

int hash(int fd){

return fd % TABLE_SIZE;

}

void initTable(hashTable table) {

if (table == NULL) {

errorExit("HASH table allocation error");

}

for (int i = 0; i < TABLE_SIZE; i++) {

table[i].present = false;

table[i].cliInfo = NULL;

}

}

void insertInTable(hashTable table, int fd, clientNode *clInfo){

// printf("Inserting entry for %d in table\n", fd);

int hashValue;

hashValue = hash(fd);

// printf("hash is %d\n", hashValue);

// printf("is cliInfo null? %s\n", (clInfo == NULL) ? "Yeah" : "Hell no" );

int probeNum = 1;

while (table[hashValue].present == true) {

if(table[hashValue].fd == fd) //updating a key's value instead inserting a new one

break;

hashValue = (hashValue + probeNum * probeNum) % TABLE_SIZE;

probeNum++;

}

table[hashValue].present = true;

table[hashValue].fd = fd;

table[hashValue].cliInfo = clInfo;

}

clientNode *searchTable(hashTable table, int fd) {

// printf("Searching in hashtable for %d\n", fd);

int hashValue = hash(fd);

// printf("hash is %d\n", hashValue);

int probeNum = 1;

while (table[hashValue].present == true)

{

if (table[hashValue].fd == fd) {

return table[hashValue].cliInfo;

}

hashValue = (hashValue + probeNum * probeNum) % TABLE_SIZE;

probeNum++;

}

return CLIENT_DNE;

}

void removeFromTable(hashTable table, int fd){

int hashValue = hash(fd);

int probeNum = 1;

while (table[hashValue].present == true)

{

if (table[hashValue].fd == fd) {

table[hashValue].present = false;

return;

}

hashValue = (hashValue + probeNum * probeNum) % TABLE_SIZE;

probeNum++;

}

}

#ifndef HASHTABLE_H

#define HASHTABLE_H

#include "helper.h"

#define PRIME 119

#define TABLE_SIZE 67

#define MAX_LEXEME_LEN 100

#define CLIENT_DNE NULL

typedef struct {

int fd;

clientNode *cliInfo;

bool present;

} hashElem;

typedef hashElem hashTable[TABLE_SIZE];

void initTable(hashTable table);

int hash(int fd);

clientNode *searchTable(hashTable table, int fd);

void insertInTable(hashTable table, int fd, clientNode *clInfo);

void removeFromTable(hashTable table, int fd);

#include "helper.h"

void errorExit(char *msg){

perror(msg);

exit(EXIT_FAILURE);

}

int Socket(int domain, int type, int protocol){

int sockfd = socket(domain, type, protocol);

if( sockfd < 0){

errorExit("socket failed");

}

return sockfd;

}

int Listen(int sockfd, int backlog){

if(listen(sockfd, backlog) < 0){

errorExit("listen failed");

}

return SUCCESS;

}

int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen){

if(bind(sockfd, addr, addrlen) < 0){

errorExit("bind failed");

}

return SUCCESS;

}

int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen){

int connfd = accept(sockfd, addr, addrlen);

if( connfd < 0){

errorExit("accept failed");

}

return connfd;

}

ssize_t Read(int fd, void *buf, size_t count){

int numRead = read(fd, buf, count);

if( numRead < 0){

if(errno != ECONNRESET && errno != EBADF)

errorExit("read failed");

}

return numRead;

}

ssize_t Write(int fd, const void *buf, size_t count){

int numWritten = write(fd, buf, count);

if(numWritten < 0){

if(errno != EWOULDBLOCK && errno != EAGAIN){

if(errno != ECONNRESET && errno != EBADF)

errorExit("write failed");

}

}

return numWritten;

}

int Close(int fd){

if(close(fd) < 0 ){

if(errno != EBADF)

errorExit("close failed");

}

return SUCCESS;

}

char *getTimestamp(){

char *buf = (char*)malloc(sizeof(char) * 1000);

time_t now = time(0);

struct tm tm = *gmtime(&now);

strftime(buf, sizeof buf, "%a, %d %b %Y %H:%M:%S %Z", &tm);

return buf;

}

#ifndef HELPER_H

#define HELPER_H

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/msg.h>

#include <sys/ipc.h>

#include <sys/socket.h>

#include <sys/epoll.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h> // for read() / write()

#include <errno.h>

#include <pthread.h>

#include <string.h>

#include <ctype.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#define SUCCESS 1

typedef enum {false, true} bool;

typedef struct clientNode{

int fd;

struct clientNode *nextClient;

struct clientNode *prevClient; /* stored to perform deletion in O(1)*/

} clientNode;

typedef struct clientsInfo{

int numClients;

clientNode *firstClient;

clientNode *lastClient;

} clientsInfo;

void errorExit(char *msg);

void errorExitPthread(char *msg, int errnum);

int Socket(int domain, int type, int protocol);

int Listen(int sockfd, int backlog);

int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int Open(const char *pathname, int flags);

ssize_t Read(int fd, void *buf, size_t count);

ssize_t Write(int fd, const void *buf, size_t count);

int Close(int fd);

char *getTimestamp();