mini_server

[Adrian-REH]

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>

int extract_message(char **buf, char **msg)
{
	char	*newbuf;
	int	i;

	*msg = 0;
	if (*buf == 0)
		return (0);
	i = 0;
	while ((*buf)[i])
	{
		if ((*buf)[i] == '\n')
		{
			newbuf = calloc(1, sizeof(*newbuf) * (strlen(*buf + i + 1) + 1));
			if (newbuf == 0)
				return (-1);
			strcpy(newbuf, *buf + i + 1);
			*msg = *buf;
			(*msg)[i + 1] = 0;
			*buf = newbuf;
			return (1);
		}
		i++;
	}
	return (0);
}

char *str_join(char *buf, char *add)
{
	char	*newbuf;
	int		len;

	if (buf == 0)
		len = 0;
	else
		len = strlen(buf);
	newbuf = malloc(sizeof(*newbuf) * (len + strlen(add) + 1));
	if (newbuf == 0)
		return (0);
	newbuf[0] = 0;
	if (buf != 0)
		strcat(newbuf, buf);
	free(buf);
	strcat(newbuf, add);
	return (newbuf);
}


int main() {
	int sockfd, connfd, len;
	struct sockaddr_in servaddr, cli; 

	// socket create and verification 
	sockfd = socket(AF_INET, SOCK_STREAM, 0); 
	if (sockfd == -1) { 
		printf("socket creation failed...\n"); 
		exit(0); 
	} 
	else
		printf("Socket successfully created..\n"); 
	bzero(&servaddr, sizeof(servaddr)); 

	// assign IP, PORT 
	servaddr.sin_family = AF_INET; 
	servaddr.sin_addr.s_addr = htonl(2130706433); //127.0.0.1
	servaddr.sin_port = htons(8081); 

	// Binding newly created socket to given IP and verification 
	if ((bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr))) != 0) { 
		printf("socket bind failed...\n"); 
		exit(0); 
	} 
	else
		printf("Socket successfully binded..\n");
	if (listen(sockfd, 10) != 0) {
		printf("cannot listen\n"); 
		exit(0); 
	}
	len = sizeof(cli);
	connfd = accept(sockfd, (struct sockaddr *)&cli, &len);
	if (connfd < 0) { 
        printf("server acccept failed...\n"); 
        exit(0); 
    } 
    else
        printf("server acccept the client...\n");
}

#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>


typedef struct s_client {
    int id;
    char *buffer;
}t_client;

typedef struct s_server {
    int sockfd;
    int count;
    int maxfd;
    char write[42];
    char read[1001];
    t_client clients[65536];
    fd_set read_fds;
    fd_set write_fds;
    fd_set current_fds;

} t_server;

void fatal() {
    write(2, "Fatal error\n", 13);
    exit(1);
}

int extract_message(char **buf, char **msg)
{
	char	*newbuf;
	int	i;

	*msg = 0;
	if (*buf == 0)
		return (0);
	i = 0;
	while ((*buf)[i])
	{
		if ((*buf)[i] == '\n')
		{
			newbuf = calloc(1, sizeof(*newbuf) * (strlen(*buf + i + 1) + 1));
			if (newbuf == 0)
				return (-1);
			strcpy(newbuf, *buf + i + 1);
			*msg = *buf;
			(*msg)[i + 1] = 0;
			*buf = newbuf;
			return (1);
		}
		i++;
	}
	return (0);
}

char *str_join(char *buf, char *add)
{
	char	*newbuf;
	int		len;

	if (buf == 0)
		len = 0;
	else
		len = strlen(buf);
	newbuf = malloc(sizeof(*newbuf) * (len + strlen(add) + 1));
	if (newbuf == 0)
		return (0);
	newbuf[0] = 0;
	if (buf != 0)
		strcat(newbuf, buf);
	free(buf);
	strcat(newbuf, add);
	return (newbuf);
}

void ft_broadcast(int sender, t_server *server, char*msg) {
    for (int fd = 0; fd <= server->maxfd; fd++) {
        if (FD_ISSET(fd, &server->write_fds) && fd != sender) {
            send(fd, msg, strlen(msg), 0);
        }
    }
}

void ft_send_msg (int sender, t_server *server) {
    char *msg;
    while (extract_message(&server->clients[sender].buffer, &msg)) {
        sprintf(server->write, "client %d: ", server->clients[sender].id);
        ft_broadcast(sender, server, server->write);
        ft_broadcast(sender, server, msg);
        free(msg);
    }
}

void ft_remove_cli(int sender, t_server * server) {

    FD_CLR(sender, &server->current_fds);
    close(sender);
    if (server->clients[sender].buffer) {
        free(server->clients[sender].buffer);
    }
    server->clients[sender].buffer = (NULL);
    sprintf(server->write, "server: client %d just left\n", server->clients[sender].id);
    ft_broadcast(sender, server, server->write);
}


int ft_read_msg (int sender, t_server * server) {
    int bytes = recv(sender, server->read, 1000, 0);
    if (bytes <= 0) {
        ft_remove_cli(sender, server);
        return - 1;
    }
    server->read[bytes] = 0;
    server->clients[sender].buffer = str_join(server->clients[sender].buffer, server->read);
    ft_send_msg(sender, server);
    return 0;
}


void ft_config_srv (t_server *server, uint16_t port) {
    struct sockaddr_in addrsrv; 
    bzero(&addrsrv, sizeof(addrsrv));

    server->sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (server->sockfd < 0 ) {
        fatal();
    }

    FD_ZERO(&server->current_fds);
    FD_SET(server->sockfd, &server->current_fds);


    addrsrv.sin_family = AF_INET;
    addrsrv.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addrsrv.sin_port = htons(port);

    server->maxfd = server->sockfd;

    if (bind(server->sockfd, (const struct sockaddr *)&addrsrv, sizeof(addrsrv)) < 0)
        fatal();
    if (listen(server->sockfd, 65536) < 0)
        fatal();
}


void ft_accept_cli(t_server *server) {
    struct sockaddr_in addrcli;
    socklen_t len;
    bzero(&addrcli, sizeof(addrcli));

    len = sizeof(addrcli);
    int clifd = accept(server->sockfd, (struct sockaddr *)&addrcli, &len);
    if (clifd < 0 ) {
        fatal();
    }

    FD_SET(clifd, &server->current_fds);

    //Save
    server->maxfd  =clifd > server->maxfd ? clifd: server->maxfd;
    server->clients[clifd].id = server->count++;
    server->clients[clifd].buffer = NULL;
    //Notify

    sprintf(server->write, "server: client %d just arrived\n", server->clients[clifd].id);
    ft_broadcast(clifd, server, server->write);
}

int main (int argc, char **arg) {
    t_server server;
    if (argc != 2) {
        write(2, "Wrong number of arguments\n", 27);
        exit(1);
    }

    bzero(&server, sizeof(server));
    ft_config_srv(&server, atoi(arg[1]));

    while (1) {
        server.read_fds= server.current_fds;
        server.write_fds= server.current_fds;
        if (select(server.maxfd + 1, &server.read_fds, &server.write_fds, NULL, NULL) < 0) {
            fatal();
        }
        for (int fd = 0; fd <= server.maxfd; fd++) {
            if (FD_ISSET(fd, &server.read_fds)) {
                if (fd == server.sockfd) {
                    ft_accept_cli(&server);
                } else {
                    if (ft_read_msg(fd, &server) < 0)
                        break;
                }
            }
        }
    }

    return 0;
}

Execute

Terminal A

cc mini_srv.c -o mini_srv
./mini_srv 8080

Terminal B

nc 127.0.0.1 8080

Terminal C

nc 127.0.0.1 8080

[Adrian-REH]

#include <sys/select.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <strings.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

static fd_set master;

static int sockfd, maxfd, next_id;

static int ids[FD_SETSIZE];

static char *bufs[FD_SETSIZE * 2];

static char rbuf[1001 * 2], wbuf[128 * 2];

static void fatal(void){ write(2,"Fatal error\n",12); exit(1); }

/* === TUS FUNCIONES TAL CUAL (del archivo guía) === */

int extract_message(char **buf, char **msg)

{

char    *newbuf;

int i;



*msg = 0;

if (*buf == 0)

    return (0);

i = 0;

while ((*buf)[i])

{

    if ((*buf)[i] == '\n')

    {

        newbuf = calloc(1, sizeof(*newbuf) * (strlen(*buf + i + 1) + 1));

        if (newbuf == 0)

            return (-1);

        strcpy(newbuf, *buf + i + 1);

        *msg = *buf;

        (*msg)[i + 1] = 0;

        *buf = newbuf;

        return (1);

    }

    i++;

}

return (0);

}

char *str_join(char *buf, char *add)

{

char    *newbuf;

int     len;



if (buf == 0)

    len = 0;

else

    len = strlen(buf);

newbuf = malloc(sizeof(*newbuf) * (len + strlen(add) + 1));

if (newbuf == 0)

    return (0);

newbuf[0] = 0;

if (buf != 0)

    strcat(newbuf, buf);

free(buf);

strcat(newbuf, add);

return (newbuf);

}

/* === FIN de las funciones pegadas tal cual === */

static void bcast(int from, const char *msg, fd_set *wset){

for(int fd=0; fd<=maxfd; fd++)

    if(fd!=from && FD_ISSET(fd,&master) && FD_ISSET(fd,wset))

        send(fd,msg,strlen(msg),0);

}

static void drop(int fd, fd_set *wset){

sprintf(wbuf,"server: client %d just left\n", ids[fd]);

bcast(fd,wbuf,wset);

FD_CLR(fd,&master);

close(fd);

if(bufs[fd]){ free(bufs[fd]); bufs[fd]=0; }

}

static void handle(int fd, fd_set *wset){

int n = recv(fd,rbuf,1000,0);

if(n<=0){ drop(fd,wset); return; }

rbuf[n]=0;

bufs[fd]=str_join(bufs[fd], rbuf);     // usa str_join pegada tal cual

char *m;

while(extract_message(&bufs[fd], &m)){ // usa extract_message pegada tal cual

    sprintf(wbuf,"client %d: ", ids[fd]); bcast(fd,wbuf,wset);

    bcast(fd,m,wset); free(m);

}

}

static void accept_one(fd_set *wset){

struct sockaddr_in ca; socklen_t L=sizeof(ca);

int cfd = accept(sockfd,(struct sockaddr*)&ca,&L);

if(cfd<0) fatal();

FD_SET(cfd,&master); if(cfd>maxfd) maxfd=cfd;

ids[cfd]=next_id++; bufs[cfd]=0;

sprintf(wbuf,"server: client %d just arrived\n", ids[cfd]);

bcast(cfd,wbuf,wset);

}

int main(int ac, char **av){

if(ac!=2){ write(2,"Wrong number of arguments\n",26); return 1; }



struct sockaddr_in sa = {0};

sa.sin_family=AF_INET; sa.sin_addr.s_addr=htonl(2130706433); // 127.0.0.1

sa.sin_port=htons(atoi(av[1]));



sockfd=socket(AF_INET,SOCK_STREAM,0); if(sockfd<0) fatal();

if(bind(sockfd,(struct sockaddr*)&sa,sizeof(sa))<0) fatal();

if(listen(sockfd,128)<0) fatal();



FD_ZERO(&master); FD_SET(sockfd,&master); maxfd=sockfd;



while(1){

    fd_set r=master, w=master;

    if(select(maxfd+1,&r,&w,0,0)<0) continue;

    for(int fd=0; fd<=maxfd; fd++){

        if(!FD_ISSET(fd,&r)) continue;

        if(fd==sockfd) accept_one(&w);

        else handle(fd,&w);

    }

}

}