Limit clients that can connect to server - c

Question

I made a TCP client-server program in C under Linux using select(). I was wondering how can I limit the number of clients that connect to the server. That is if I can before they get accept()-ed.
Here is the code, sorry of the language of comments. I still didn't get where to put that if.
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>
/* portul folosit */
#define PORT 2728
extern int errno; /* eroarea returnata de unele apeluri */
/* functie de convertire a adresei IP a clientului in sir de caractere */
char * conv_addr (struct sockaddr_in address)
{
static char str[25];
char port[7];
/* adresa IP a clientului */
strcpy (str, inet_ntoa (address.sin_addr));
/* portul utilizat de client */
bzero (port, 7);
sprintf (port, ":%d", ntohs (address.sin_port));
strcat (str, port);
return (str);
}
int v[4]; //vector cu 5 tipuri de mancare
/* programul */
int main ()
{ int nrclienti=0; v[0]=0; v[1]=0; v[2]=0; v[3]=0; v[4]=0;
int inchid=1;
int x,max,pmax;max=v[0];pmax=0;int pref;
struct sockaddr_in server; /* structurile pentru server si clienti */
struct sockaddr_in from;
fd_set readfds; /* multimea descriptorilor de citire */
fd_set actfds; /* multimea descriptorilor activi */
struct timeval tv; /* structura de timp pentru select() */
int sd, client; /* descriptori de socket */
int optval=1; /* optiune folosita pentru setsockopt()*/
int fd; /* descriptor folosit pentru
parcurgerea listelor de descriptori */
int nfds; /* numarul maxim de descriptori */
int len; /* lungimea structurii sockaddr_in */
/* creare socket */
if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
{
perror ("[server] Eroare la socket().\n");
return errno;
}
/*setam pentru socket optiunea SO_REUSEADDR */
setsockopt(sd, SOL_SOCKET, SO_REUSEADDR,&optval,sizeof(optval));
/* pregatim structurile de date */
bzero (&server, sizeof (server));
/* umplem structura folosita de server */
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl (INADDR_ANY);
server.sin_port = htons (PORT);
/* atasam socketul */
if (bind (sd, (struct sockaddr *) &server, sizeof (struct sockaddr)) == -1)
{
perror ("[server] Eroare la bind().\n");
return errno;
}
/* punem serverul sa asculte daca vin clienti sa se conecteze */
if (listen (sd, 5) == -1)
{
perror ("[server] Eroare la listen().\n");
return errno;
}
/* completam multimea de descriptori de citire */
FD_ZERO (&actfds); /* initial, multimea este vida */
FD_SET (sd, &actfds); /* includem in multime socketul creat */
tv.tv_sec = 1; /* se va astepta un timp de 1 sec. */
tv.tv_usec = 0;
/* valoarea maxima a descriptorilor folositi */
nfds = sd;
printf ("[server] Asteptam la portul %d...\n", PORT);
fflush (stdout);
/* servim in mod concurent clientii... */
while (inchid)
{ /* ajustam multimea descriptorilor activi (efectiv utilizati) */
bcopy ((char *) &actfds, (char *) &readfds, sizeof (readfds));
/* apelul select() */
if (select (nfds+1, &readfds, NULL, NULL, &tv) < 0)
{
perror ("[server] Eroare la select().\n");
return errno;
}
/* vedem daca e pregatit socketul pentru a-i accepta pe clienti */
if (FD_ISSET (sd, &readfds))
{
/* pregatirea structurii client */
len = sizeof (from);
bzero (&from, sizeof (from));
/* a venit un client, acceptam conexiunea */
client = accept (sd, (struct sockaddr *) &from, &len);
/* eroare la acceptarea conexiunii de la un client */
if (client < 0)
{
perror ("[server] Eroare la accept().\n");
continue;
}
if (nfds < client) /* ajusteaza valoarea maximului */
nfds = client;
printf("[server] S-a conectat clientul cu descriptorul %d, de la adresa %s.\n",client, conv_addr (from));
/* includem in lista de descriptori activi si acest socket */
FD_SET (client, &actfds);
fflush (stdout);
}
/* vedem daca e pregatit vreun socket client pentru a trimite raspunsul */
for (fd = 0; fd <= nfds; fd++) /* parcurgem multimea de descriptori */
{
/* este un socket de citire pregatit? */
if (fd != sd && FD_ISSET (fd, &readfds))
{ //func
char buffer[100]; /* mesajul */
int bytes; /* numarul de octeti cititi/scrisi */
char msg[100]; //mesajul primit de la client
char msgrasp[100]; //mesaj de raspuns pentru client
int replies=0;
do
{
//citim mesajul de la client
bytes = read (fd, msg, sizeof (buffer));
if (bytes < 0)
{
perror ("Eroare la read() de la client.\n");
return 0;
}
printf ("[server]Clientul cu descriptorul %d a ales mancarea %s\n",fd, msg);
int poz; //comanda alease introdusa in vectorul de comenzi
poz = msg[0] - '0';
v[poz-1]++;
//decidem felul preferat din meniu
printf("[server]");
for(x=0;x<=4;x++)
if (max<v[x]) {max=v[x];pmax=x;}
pref=pmax+1;
for(x=0;x<=4;x++) printf("%d|",v[x]);
printf(" Val max e %d\n",pref);
/*pregatim mesajul de raspuns */
bzero(msgrasp,100);
sprintf(msgrasp, "%d", pref);
//daca clientului corespunde cu mancarea favorita, trimitem raspunsul
if (msg[0]==msgrasp[0]) sprintf(msgrasp, "%d", 1);
else sprintf(msgrasp, "%d", 0);
printf("[server]Trimitem %s clientului %d\n",msgrasp,fd);
if (bytes && write (fd, msgrasp, bytes) < 0)
{
perror ("[server] Eroare la write() catre client.\n");
return 0;
}
//func
replies++;
}while((msgrasp[0]!=49)&&(replies<3));
printf ("[server] S-a deconectat clientul cu descriptorul %d.\n\n",fd);
fflush (stdout);
close (fd); /* inchidem conexiunea cu clientul */
FD_CLR (fd, &actfds);/* scoatem si din multime */
}
} /* for */
} /* while */
close(sd);} /* main */

Answer 1

I'm going to assume that you are running a non-threaded non-forking application using select(). If not, then the you will need to modify this a little but not much.
Prior to select(), you will be adding each of your fd's corresponding to an open session to your fd_set using FD_SET; you can count these whilst you loop through. You will also add your listener fd. Simply omit this second step if the number of open connections is at its maximum.
Note that open connections may still be accepted later - see how backlog works on listen().

Answer 2

Well, if you don't need a client you may not accept() him :) Thus you may limit the number of clients currently being processed. Just ignore events on your master socket and you've done.
Also you can limit the size of the queue for clients not been accepted yet using TCP backlog, notice the second parameter of listen()
But typically it's not quite, ehmm, polite. Maybe you should re-think your entire task and decide how to handle more clients simultaneously.