int main(int argc, char **argv) {
int fd;
int len;
char ip[32];
char buf[1025];
int port;
int client;
pid_t pid;
pthread_t tid;
struct sockaddr sa;
struct sockaddr_in sin;
// int iplong = inet_addr("192.168.0.6");
// printf("iplong=%x\n", iplong);
if(argc == 3) {
strcpy(ip, argv[1]);
port = atoi(argv[2]);
}
else {
strcpy(ip, "127.0.0.1");
port = 8000;
}
signal(SIGPIPE, SIG_IGN);
fd = socket(AF_INET, SOCK_STREAM, 0);
if(myBind(fd, NULL, port) == 0) {
printf("Bind to %s, %d success\n", ip, port);
}
else {
printf("Bind to %s:%d failed\n", ip, port);
}
/////////////////////////////////////
listen(fd, 1);
int *sock;
while(1) {
client = accept(fd, &sa, &len);
if(client <= 0) {
printf("Accept failed\n");
break;
}
sock = (int *)malloc(4);
memcpy(sock, &client, 4);
memcpy(&sin, &sa, len);
printf("Accept connection: %s,%d\n",
inet_ntop(AF_INET, &(sin.sin_addr), buf, 64), ntohs(sin.sin_port));
pthread_create(&tid, NULL, sessionThread, sock);
// sleep(1);
}
getchar();
close(fd);
return 0;
}
int initSock(int port) {
int i;
int sock;
for(i=0; i<MAX_CLIENTS; i++) {
socks[i] = -1;
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if(myBind(sock, NULL, port) < 0) {
perror("bind");
return -1;
}
listen(sock, 100);
socks[0] = sock;
maxFD = sock;
maxNum = 0;
FD_ZERO(&ofds);
FD_SET(socks[0], &ofds);
return sock;
}
int main(int argc, char **argv) {
struct sockaddr_in clientAddr;
int servSock;
int clientSock;
servSock = socket(AF_INET, SOCK_STREAM, 0);
if(myBind(servSock, NULL, 8000) != 0) {
perror("bind");
return 1;
}
listen(servSock, 10);
socklen_t len = sizeof(clientAddr);
int size;
char buf[101];
while(1) {
clientSock = accept(servSock, (struct sockaddr *)&clientAddr, &len);
if(clientSock > 0) {
printf("Accepted\n");
SetRecvTimeOut(clientSock, 5, 0);
size = recv(clientSock, buf, 100, 0);
if(size <= 0) {
if(errno == EAGAIN) {
printf("EAGAIN\n");
}
else {
printf("errno=%d, %s\n", errno, strerror(errno));
}
}
else {
buf[size] = 0;
printf("Recv %s\n", buf);
}
// DoClient(clientSock);
close(clientSock);
}
}
}
int main(int argc, char * argv[]){
//first, check the number of argument
if (argc != 2){
printf("Usage: serveur.exe <port number>\n");
exit(1);
}
//trap SIGINT
signal(SIGINT,SIGINT_handler);
//variable definition
int sock_Data, addr_len,pid, seq, cwnd,normal_wnd, advanced_wnd;
int test =-1;
int SEG_SIZE,size,inc,descriptorToCheck[2];
int reuse = 1;
int ctrlBuff_SIZE = 12;
int isSYN=0;
int seq_advanced, seq_expected,checkBreak=0;
char SYN_ACK[12];
char FIN[4]="FIN";
char ctrlBuffer[ctrlBuff_SIZE];
char * dataBuffer;
FILE * file;
DATA DATA = NULL;
struct timeval ZERO = {0, 0};
// struct sockaddr_in
SOCKADDR_IN * my_addr_UDP;//Adress for listening UDP
SOCKADDR_IN * my_client_addr;//Adress client, for control
SOCKADDR_IN * data_addr;//Adress client for Data
int port_nb = atoi(argv[1]);
int sock_Control= mySocket(AF_INET,SOCK_DGRAM,0); //socketUDP
//display the descriptor value and pid of server
printf("Id Socket: %i\n",sock_Control);
printf("PID father: %i\n",getpid());
//allow to reuse immediately the socket
setsockopt( sock_Control, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
// structure sockaddr_in initialization
my_addr_UDP = conf_sock_addr(AF_INET, port_nb, "0.0.0.0");
my_client_addr = init_sock_addr();
size = sizeof(*my_client_addr);
//link the socket to the structure
myBind(sock_Control,my_addr_UDP,sizeof(*my_addr_UDP));
descriptorToCheck[0] = sock_Control;
//init fd set
fd_set * my_read_set = init_fd_set();
//loop to be a daemon
while (isSIGINT==0){
//set the fd_set
set_fd_set(my_read_set,descriptorToCheck[0]);
select(sock_Control+1,my_read_set,NULL,NULL,&ZERO);
if ( FD_ISSET(sock_Control, my_read_set) ){
// message reception
myReceiveFrom(sock_Control, ctrlBuffer, ctrlBuff_SIZE,my_client_addr,&size);
printf("Reception UDP by %d: %s\n",getpid(),ctrlBuffer);
// if message of type SYN
if ( check_SYN(ctrlBuffer) == 1){
port_nb= (port_nb+1)%8975+1025 ;
sprintf(SYN_ACK,"SYN-ACK%04d",port_nb);
//new socket for receiving data
sock_Data = mySocket(AF_INET,SOCK_DGRAM,0);
data_addr = conf_sock_addr(AF_INET, port_nb, "0.0.0.0");
addr_len = sizeof(* data_addr);
descriptorToCheck[1]=sock_Data;
//binding sock on addr client
myBind(sock_Data,data_addr,addr_len);
printf("Connexion Asked by client, dialoguing on port %d \n", ntohs(data_addr->sin_port));
printf("Adresse client %s\n",inet_ntoa(my_client_addr->sin_addr));
data_addr = conf_sock_addr(AF_INET, port_nb, inet_ntoa(my_client_addr->sin_addr));
// variable for receiving
SEG_SIZE= getMTU(data_addr)-28; // (MTU - header UDP + header IP)
SEG_SIZE=(SEG_SIZE> 5000)?5000:SEG_SIZE;
dataBuffer = (char *)malloc(SEG_SIZE*sizeof(char));
isSYN=1;
mySendTo(sock_Control, SYN_ACK,12,my_client_addr);
}
if ( check_ACK(ctrlBuffer) == 1 && isSYN ==1){
printf("Connexion Accept\n");
isSYN = 0;
//a little fork
pid = fork();
//if error
if (pid == -1){
perror("Fork Error\n");
exit(-1);
}
/*======================================================================================*/
/*===================================== child code =====================================*/
/*======================================================================================*/
else if (pid == 0){
myClose(sock_Control);
// reception of file name
myReceiveFrom(sock_Data,dataBuffer, SEG_SIZE,data_addr,&addr_len);
printf("Client Asking for file %s\n",dataBuffer);
//retrieve file name
file=myOpen(dataBuffer,"r");
seq=1, seq_advanced=1, cwnd =400,normal_wnd=320, advanced_wnd=cwnd-normal_wnd;
//while something to send, send and wait for ack
do {
checkBreak=0;
seq_expected=(seq == seq_advanced)?seq+cwnd:seq_advanced+advanced_wnd;
printf("seq :%d, seq_expected %d, seq_advanced %d\n",seq, seq_expected, seq_advanced);
//construct DATA to send from file
if (test == -1) test= readFileToBUFFER(file,&DATA,seq,(seq+cwnd==seq_expected)?cwnd:seq_advanced-seq+advanced_wnd,SEG_SIZE);
else readFileToBUFFER(file,&DATA,seq,test-seq,SEG_SIZE);
//send dataBuffer to client
if(seq+normal_wnd==seq_expected || seq == 1) {
sendData(sock_Data, cwnd, DATA, data_addr);
}else{
printf("fast retransmit, resend sequence presumed lost\n");
sendData(sock_Data, normal_wnd, DATA, data_addr);
printf("fast retransmit, send selected data\n");
sendSelectedData(sock_Data,seq_advanced,advanced_wnd,DATA,data_addr);
}
//while there is something to read
set_fd_set(my_read_set, descriptorToCheck[1]);
select(sock_Data + 1, my_read_set, NULL, NULL, &ZERO);
while (FD_ISSET(sock_Data,my_read_set) ) {
//reception
myReceiveFrom(sock_Data, ctrlBuffer, ctrlBuff_SIZE, data_addr, &addr_len);
//number of sequences acknowledged, (-1 si duplicate ACK)
inc = check_ACK_Seq(seq,cwnd,ctrlBuffer);
if (inc == -1) // if duplicate ACK
{
printf("ACK Duplicate ");
sendSelectedData(sock_Data,seq,1,DATA,data_addr);
if (checkBreak==0){
usleep(100000);
checkBreak=1;
}
}
else if (inc > 0){// if good ACK
checkBreak=0;
seq += inc;
if (seq==seq_expected)break;
}
//set the descriptor to check
set_fd_set(my_read_set, descriptorToCheck[1]);
select(sock_Data + 1, my_read_set, NULL, NULL, &ZERO);
}
if ( test == -1)
seq_advanced=(seq_advanced+advanced_wnd > seq+2000 || seq_advanced < seq+normal_wnd)?seq+normal_wnd:seq_advanced+advanced_wnd;
else
seq_advanced=(seq_advanced+advanced_wnd > seq + 2000 || seq_advanced+advanced_wnd> test+1)?seq+normal_wnd:seq_advanced+advanced_wnd;
} while(seq != test+1 );
printf("client dialoguing on port %d\n",ntohs(data_addr->sin_port));
for(reuse=0;reuse<1000000;reuse++)
mySendTo(sock_Data, FIN, 4, data_addr); //Send FIN to client
//to do a clean exit
myClose(sock_Data);
free(my_addr_UDP);
free(my_client_addr);
free(dataBuffer);
free_Data(DATA);
fclose(file);
printf("\e[1;3%dmEnd of connexion. Son with pid:%d is closing, communicate on %d\e[0m\n", sock_Data % 8, getpid(),port_nb);
exit(1);
}
/*======================================================================================*/
/*==================================== end of child ====================================*/
/*======================================================================================*/
}
}
int main(int argc, char** argv){
int sockListen, errorIndicator;
int maxClientFd;
int i, j;
struct sockaddr_in myaddr;
struct sockaddr addrBind;
struct in_addr inAddr;
fd_set fdSetRead, fdSetWrite;
struct timeval timeout = { 60, 0 };
int h;
int port;
if (argc < 4 || argc > 5){
printf(ILLEGAL_ARGS);
exit(1);
}
for (j = 1; j < 4; j++){
sscanf(argv[j], "%d", &h);
game.heaps[j - 1] = h;
}
if (argc == 5) sscanf(argv[4], "%d", &port);
else port = DEFAULT_PORT;
game.valid = 1;
game.win = -1;
//game.numOfPlayers = p;
game.msg = 0;
//game.moveCount = 0;
// Set listner. accepting only in main loop
sockListen = socket(AF_INET, SOCK_STREAM, 0);
checkForNegativeValue(sockListen, "socket", sockListen);
addrBind.sa_family = AF_INET;
myaddr.sin_family = AF_INET;
myaddr.sin_port = htons(port);
inAddr.s_addr = htonl(INADDR_ANY);
myaddr.sin_addr = inAddr;
errorIndicator = myBind(sockListen, &myaddr, sizeof(addrBind));
checkForNegativeValue(errorIndicator, "bind", sockListen);
errorIndicator = listen(sockListen, 2);
checkForNegativeValue(errorIndicator, "listen", sockListen);
while (1){
// clear set and add listner
maxClientFd = sockListen;
FD_ZERO(&fdSetRead);
FD_ZERO(&fdSetWrite);
FD_SET(sockListen, &fdSetRead);
// add all clients to fdSetRead
for (i = 0; i < conPlayers; i++){
FD_SET(ClientsQueue[i].fd, &fdSetRead);
if (strlen(ClientsQueue[i].writeBuf) > 0){
FD_SET(ClientsQueue[i].fd, &fdSetWrite);
}
if (ClientsQueue[i].fd > maxClientFd) maxClientFd = ClientsQueue[i].fd;
}
// TODO: need to add timeout
select(maxClientFd + 1, &fdSetRead, &fdSetWrite, NULL, &timeout);
if (FD_ISSET(sockListen, &fdSetRead)){
int fdCurr = accept(sockListen, (struct sockaddr*)NULL, NULL);
checkForNegativeValue(fdCurr, "accept", fdCurr);
if (fdCurr >= 0){
if ((conPlayers) == 2) SendCantConnectToClient(fdCurr);
else addClientToQueue(fdCurr);
}
}
// Service all the sockets with input pending.
for (i = 0; i < conPlayers; ++i){
if (FD_ISSET(ClientsQueue[i].fd, &fdSetRead)){
errorIndicator = receiveFromClient(i);
if (errorIndicator < 0){
close(ClientsQueue[i].fd);
notifyOnDisconnectionToPlayer(i);
}
else if (errorIndicator == 1){
handleReadBuf(i);
}
}
if (FD_ISSET(ClientsQueue[i].fd, &fdSetWrite)){
errorIndicator = sendToClient(i);
if (errorIndicator < 0){
close(ClientsQueue[i].fd);
notifyOnDisconnectionToPlayer(i);
}
}
}
}
}
int main(int argc, char** argv){
int sockListen, errorIndicator;
int maxClientFd;
int i;
struct sockaddr_in myaddr;
struct sockaddr addrBind;
struct in_addr inAddr;
/*struct socklen_t *addrlen;*/
/*char buf[MSG_SIZE];*/
fd_set fdSetRead, fdSetWrite;
int M, port, p;
/*struct clientMsg clientMove;*/
/*Region input Check*/
if(argc<=3 || argc>=6){
//printf("Illegal arguments\n");
exit(1);
}
sscanf(argv[1],"%d",&p);
/*//printf("argv[1] %s\n", argv[2]);*/
sscanf(argv[2],"%d",&M);
if( strcmp(argv[3],"0") ==0 ){
game.isMisere =0;
}
else if(strcmp(argv[3],"1") ==0 ){
game.isMisere=1;
}
else{
//printf("Illegal arguments. Misere should be 0/1\n");
exit(1);
}
if(argc==5){
sscanf(argv[4],"%d",&port);
}
else{
port =6325;
}
game.heapA = M;
game.heapB = M;
game.heapC = M;
game.heapD = M;
game.valid=1;
game.win = -1;
game.numOfPlayers = p;
game.msg = 0;
game.moveCount = 0;
/*//printf("Set all arguments, start server\n");*/
// Set listner. accepting only in main loop
sockListen = socket(AF_INET, SOCK_STREAM, 0);
checkForNegativeValue(sockListen, "socket", sockListen);
/*//printf("Succesfully got a socket number: %d\n", sockListen);*/
addrBind.sa_family = AF_INET;
myaddr.sin_family = AF_INET;
myaddr.sin_port = htons(port);
inAddr.s_addr = htonl( INADDR_ANY );
myaddr.sin_addr = inAddr;
errorIndicator=myBind(sockListen, &myaddr, sizeof(addrBind));
checkForNegativeValue(errorIndicator, "bind", sockListen);
/*//printf("Succesfully binded %d\n", sock);*/
errorIndicator=listen(sockListen, 9);
checkForNegativeValue(errorIndicator, "listen", sockListen);
/*//printf("Succesfully started listening: %d\n", sock);*/
while(1){
// clear set and add listner
maxClientFd = sockListen;
FD_ZERO(&fdSetRead);
FD_ZERO(&fdSetWrite);
FD_SET(sockListen, &fdSetRead);
//printf("listening socket is:%d\n",sockListen);
// add all clients to fdSetRead
//printf("clients to add. players:%d, viewers:%d\n",conPlayers,conViewers);
for(i=0 ; i< conViewers + conPlayers ; i++){
//printf("Adding fd:%d to read\n",ClientsQueue[i].fd);
FD_SET(ClientsQueue[i].fd, &fdSetRead);
if(strlen(ClientsQueue[i].writeBuf) > 0){
//printf("Adding fd:%d to write\n",ClientsQueue[i].fd);
FD_SET(ClientsQueue[i].fd, &fdSetWrite);
}
else{
//printf("ClientsQueue[i].writeBuf = %s\n",ClientsQueue[i].writeBuf);
}
if(ClientsQueue[i].fd > maxClientFd) { maxClientFd = ClientsQueue[i].fd; }
}
// TODO: need to add timeout
//printf("Select...\n");
select(maxClientFd+1, &fdSetRead, &fdSetWrite, NULL, NULL);
//printf("Exit select...fdReady = %d\n",fdready);
// //printf("%s...\n",strerror(errno));
if (FD_ISSET (sockListen, &fdSetRead))
{
//printf("Reading from sock listen\n");
int fdCurr = accept(sockListen, (struct sockaddr*)NULL, NULL );
checkForNegativeValue(fdCurr, "accept", fdCurr);
if(fdCurr >= 0){
//printf("Got a valid FD after accept, fd:%d\n",fdCurr);
if( (conViewers + conPlayers) == 9){
// too much connected clients. sending "can't connect" to client
SendCantConnectToClient(fdCurr);
}
else if(conPlayers == p){
// max amount of players. new client is a viewer
//printf("new client is a viewer: fd:%d\n",fdCurr);
addClientToQueue(fdCurr, 0);
}
else{
// new client is a player
//printf("new client is a player: fd:%d\n",fdCurr);
addClientToQueue(fdCurr, 1);
}
}
}
/* Service all the sockets with input pending. */
for (i = 0; i < conPlayers+conViewers; ++i){
//printf("checking: i=%d, fd=%d\n", i, ClientsQueue[i].fd);
if (FD_ISSET (ClientsQueue[i].fd, &fdSetRead)){
//printf("sock %d is ready for read\n", ClientsQueue[i].fd);
errorIndicator = receiveFromClient(i);
if(errorIndicator < 0){
close(ClientsQueue[i].fd);
delClientFromQueue(ClientsQueue[i].fd);
}
else if(errorIndicator == 1){
//printf("handling received data\n");
handleReadBuf(i);
}
}
if (FD_ISSET (ClientsQueue[i].fd, &fdSetWrite)){
//printf("sock %d is ready for write\n", ClientsQueue[i].fd);
errorIndicator = sendToClient(i);
if(errorIndicator < 0){
close(ClientsQueue[i].fd);
delClientFromQueue(ClientsQueue[i].fd);
}
}
}
}
}
