Skip to content

Instantly share code, notes, and snippets.

@Fumesover

Fumesover/Client.c

Created April 22, 2018 13:59
Show Gist options
  • Save Fumesover/54f986a2b4ac61d6addf97d9fc1b7731 to your computer and use it in GitHub Desktop.
Save Fumesover/54f986a2b4ac61d6addf97d9fc1b7731 to your computer and use it in GitHub Desktop.
Download ZIP
421 - ISN Game
Raw
Client.c
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
#include <windows.h>
#include <string.h>
#define sleep(x) Sleep(x)
#include <locale.h>
// Pour les sockets :
#include <winsock2.h>
typedef int socklen_t;
#define PORT 23
int dernierscore = 0, meilleurscore = 0, erreur;
char ip_serveur[16] = "127.0.0.1";
char nom_du_joueur[16] = "User";
char display_pseudo[16];
int use_server = 0;
int use_folder = 0;
struct socketSTRUCT{
int err;
int connection_reussie;
SOCKET sock;
SOCKADDR_IN sin;
}sockets;
struct player
{
char pseudo[16];
char pseudo_alonged[32];
int result;
int place;
}player[10];
//typedef struct player player;
void big_print(char* to_print){
printf("/-----------------------------------------------------------------------------\\\n");
printf("| |\n");
printf("| Info |\n");
printf("| |\n");
printf("|-----------------------------------------------------------------------------|\n");
printf("| |\n");
printf("| |\n");
printf("| |\n");
printf("|%s|\n", to_print);
printf("| |\n");
printf("| |\n");
printf("| |\n");
printf("\\-----------------------------------------------------------------------------/\n");
}
void ligne(){
printf("*******************************************************************************\n\n");
} // Compliqué ? C'est juste une ligne pourtant !!
void sendscore(int score, char pseudo[16]){
// imput est le score a envoyer au serveur
char buffer[256]; int erreur = 0;
snprintf(buffer, sizeof(buffer), "%s:%d", pseudo, score);
if(!erreur)
{
/* Si l'on a réussi à se connecter et qu'il n'y a pas d'erreur*/
if(sockets.connection_reussie != SOCKET_ERROR)
{
//printf("Connection à %s sur le port %d reussie\n", inet_ntoa(sockets.sin.sin_addr), htons(sockets.sin.sin_port));
/* Si l'on reçoit des informations : on les affiche à l'écran */
sockets.err = send(sockets.sock, buffer, strlen(buffer), 0); // On envoie les données saisies a la main
if(sockets.err != SOCKET_ERROR) {
//printf("Chaine envoyée : %s\n", buffer);
} else {
//printf("Erreur de transmission\n");
use_server = 0;
}
}
/* sinon, on affiche "Impossible de se connecter" */
else
{
//printf("Impossible de se connecter\n");
use_server = 0;
}
}
}
void clean(const char *buffer, FILE *fp) { // Fonction permettant d'éliminer les \n des chaines
char *p = strchr(buffer,'\n');
if (p != NULL)
*p = 0;
else
{
int c;
while ((c = fgetc(fp)) != '\n' && c != EOF);
}
}
void mathinit(){ // Initialisation mathématique de la fonction alléatoire
srand(time(NULL));
}
void initialisation(){
sockets.sin.sin_addr.s_addr = inet_addr(ip_serveur);
sockets.sin.sin_family = AF_INET;
sockets.sin.sin_port = htons(PORT);
mathinit();
int i, nb = alea();
for(i = 0; i < nb; i ++){
snprintf(nom_du_joueur, sizeof(nom_du_joueur), "%s%d",nom_du_joueur, alea());
}
}
void reglages(){
char choix;
while(choix != 27){
system("cls");
ligne();
printf(" Echap pour quitter \n");
printf(" 1 -- Ip serveur : %s \n", ip_serveur);
printf(" 2 -- Pseudo joueur : %s \n", nom_du_joueur);
printf(" 3 -- Utiliser le serveur : %s \n", use_server ? "Oui" : "Non");
printf(" 4 -- Sauvegarder les scores : %s \n", use_folder ? "Oui" : "Non");
choix = getch();
if(choix == '1'){
printf("Ip du serveur : ");
scanf("%15s", ip_serveur);
if(use_server == 1) {
closesocket(sockets.sock);
use_server = 0;
}
/* Configuration de la connexion */
sockets.sin.sin_addr.s_addr = inet_addr(ip_serveur);
} else if (choix == '2'){
printf("Votre pseudo : ");
fgets(nom_du_joueur, sizeof(nom_du_joueur), stdin);
clean(nom_du_joueur, stdin);
} else if (choix == '3'){
printf("Utiliser un serveur ? : 1 = Oui | 2 = Non");
choix = getch();
if(choix == '1'){
if(use_server == 1) {
closesocket(sockets.sock);
}
use_server = 1;
/* Création de la socket */
sockets.sock = socket(AF_INET, SOCK_STREAM, 0);
/* On tente de se connecter */
sockets.connection_reussie = connect(sockets.sock, (SOCKADDR*)&sockets.sin, sizeof(sockets.sin));
if(sockets.connection_reussie != SOCKET_ERROR){
system("cls");
big_print(" Connection réussie ");
Sleep(1000);
} else {
system("cls");
big_print(" Connection ratée ");
Sleep(1000);
use_server = 0;
}
} else if (choix == '2'){
use_server = 0;
closesocket(sockets.sock);
}
} else if (choix == '4'){
if(use_folder == 1){
use_folder = 0;
} else {
use_folder = 1;
}
}
}
}
void printscoreboard(int scores[10]){
int i;
for(i = 0; i < 10; i++){
while(16 > strlen(player[i].pseudo)){
strcat(player[i].pseudo, " ");
}
}
char serveur[21];
char port[5];
sprintf(port,"%ld", htons(sockets.sin.sin_port));
strcpy(serveur, inet_ntoa(sockets.sin.sin_addr));
strcat(serveur,":");
strcat(serveur, port);
while(16 > strlen(serveur)){
strcat(serveur, " ");
}
// printf("Connection à %s sur le port %d reussie\n", inet_ntoa(sockets.sin.sin_addr), htons(sockets.sin.sin_port));
printf("/-----------------------------------------------------------------------------\\\n");
printf("| |\n");
printf("| ScoreBoard du serveur |\n");
printf("| %s |\n",serveur);
printf("| |\n");
printf("|-----------------------------------------------------------------------------|\n");
printf("| |\n");
printf("| |\n");
printf("| %der : %s -> %d %s %s |\n",player[0].place,player[0].pseudo,scores[0],scores[0] > 9 ? "" : " ", strncmp(nom_du_joueur,player[0].pseudo, strlen(nom_du_joueur)) == 0 ? "!!" : ".." );
for(i=1;i < 10; i++){
printf("| %de %s : %s -> %d %s %s |\n", player[i].place, player[i].place != 10 ? " " : "",player[i].pseudo,scores[i], scores[i] > 9 ? "" : " ", strncmp(nom_du_joueur,player[i].pseudo, strlen(nom_du_joueur)) == 0 ? "!!" : "..");
}
printf("| |\n");
printf("| |\n");
printf("| |\n");
printf("\\-----------------------------------------------------------------------------/\n");
}
void scoreboardaff(){
char *buffer = "Scores"; int err, i; int scores[10];
system("cls");
err = send (sockets.sock, buffer, strlen (buffer), 0);
if (err != SOCKET_ERROR)
{
for(i = 0; i < 10; i++){
recv(sockets.sock, &player[i], sizeof(player), 0);
scores[i] = player[i].result; // Pour une raison inconue, les scores sont rezet lorsque l'on passe a l'affichage des scores alors ils sont passés a la fonction via un tableau ...
}
printscoreboard(scores);
}
else
{
big_print (" Erreur - Non connecté ou problème de communication ");
use_server = 0;
}
getch();
}
void credits(){
int i;
system("cls");
ligne();
printf(" _____________ \n\n");
printf(" Crédits \n");
printf(" _____________ \n\n\n\n");
for(i=1;i<50;i++){
if(kbhit()){ // si on appuie sur une touche alors on arrete les credits
break;
}
printf("Développement serveur ::: Albin Parou \n");
sleep(500);
if(kbhit()){ // si on appuie sur une touche alors on arrete les credits
break;
}
printf("Interface utilisateur ::: Gabriel Delepine \n");
Sleep(500);
if(kbhit()){ // si on appuie sur une touche alors on arrete les credits
break;
}
printf("Développement du jeu ::: Albin Parou, Gabriel Delepine \n");
Sleep(500);
if(kbhit()){ // si on appuie sur une touche alors on arrete les credits
break;
}
}
getch();
}
void init(){ // Affiche le menu principal
printf("\n\n ~* Jeu du 421 *~");
printf("\n\n ___________________\n\n");
printf(" | 1- Jouer | \n\n");
printf(" | 2- Regles |\n\n");
printf(" * 3- Scoreboard *\n\n");
printf(" * 4- Credits *\n\n");
printf(" | 5- Réglages |\n\n");
printf(" | Echap - Quitter |\n");
printf(" ___________________\n");
} // affiche le menu principal
void regles(){ //Partie du programme qui s'occupe des règles
system("cls");
ligne();
printf(" _____________ \n\n");
printf(" Règles du jeu \n");
printf(" _____________ \n\n\n\n");
printf("Le joueur lancera une série de trois dés 5 fois. L'objectif est de réaliser le meilleur score possible sachant que :\n \n");
printf(" -réaliser deux chiffres identiques rapporte 2 points \n");
printf(" -réaliser trois chiffres identiques rapporte la somme des trois dés\n");
printf(" -réaliser un 4, un 2 et un 1 en un lancer rapporte 20 points\n\n");
getch();
system("cls");
} // affriche les règles
int alea(){ // retourne un nombre aléatoire entre 1 et 6
int value_return = rand()%6 + 1;
return value_return;
}
int result(int de1, int de2, int de3){ // Retourne le score en fonction des 3 dés
// On comence par tester si il y a des doubles
int score = 0;
if(de1 == de2){
if(de2 == de3){ // si on a un brelan
score = 12;
} else { // si on a juste une paire
score = 2;
}
} else if (de2 == de3){ // pour les paires on fait les tests restants
score = 2;
} else if (de1 == de3){ // le dernier
score = 2;
} else { // On test si on a un 421 -> il faut donc ne pas avoir de paire d'ou le else
if(de1*de2*de3 == 8){
if(de1 == 1 || de2 == 1 || de3 ==1){
if(de1 == 2 || de2 == 2 || de3 ==2){
if(de1 == 4 || de2 == 4 || de3 ==4){
score = 20;
}
}
}
}
}
return score;
}
void remplirfichier(int score){ // Remplis le ficher scores.txt avec les données : La date / heure et le score
FILE* fichier = NULL;
fichier = fopen("scores.txt", "a");
time_t heure = time(NULL);
if(fichier != NULL){
fprintf(fichier,"%s Score : %d par %s \n",asctime(localtime(&heure)),score, nom_du_joueur);
fclose(fichier);
}
}
void accueiljeu(){
ligne();
printf(" - Pour jouer appuyez sur J | Score precedent : %d\n", dernierscore);
printf(" - Pour quitter appuyez sur Echap | Meilleur score : %d\n\n", meilleurscore);
ligne();
} // Juste du texte
void printscore(int de1, int de2, int de3, int score){
printf("/---\\ /---\\ /---\\ \n");
printf("| %d | | %d | | %d | Votre score actuel : %d\n",de1,de2,de3,score);
printf("\\---/ \\---/ \\---/ \n");
}
void jeu(){ // Jeu solo
char touche;
int nbdee = 0, de1, de2, de3, score = 0;
while (touche != 27 && nbdee < 5){
de1 = alea(); // |-----------------------------------------------------------| //
de2 = alea(); // | On récupère la valeur des dés entre 1 et 6 pour le joueur | //
de3 = alea(); // |-----------------------------------------------------------| //
score = score + result(de1, de2, de3); // On calcule le score en fonction des résultats des dés
printscore(de1, de2, de3, score); // On affiche les résultats des dés et le score actuel
touche = getch(); // On attends une touche entre chaque lancé
nbdee++; // Compteur de lancés qui est incrémenté
}
dernierscore = score;
if (score > meilleurscore){
meilleurscore = score;
}
if (use_folder == 1){
remplirfichier(score);
}
if(use_server == 1){
sendscore(score,nom_du_joueur);
}
}
void jouer(){
char choix;
system("cls");
while (1){
accueiljeu();
choix = getch();
if(choix == 27){
break; // Si echap on quitte
} else if(choix == 106){
jeu(sockets);
system("cls"); // Quand on sort de la partie on efface l'écran et on réaffiche l'écran de jeu
}
}
system("cls");
}
int main(int argc, char *argv[]) {
setlocale(LC_ALL, "");
system("color 73");
WSADATA WSAData;
erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
initialisation();
while (1) {
system("cls");
init();
char choix = getch(); // fonctionnement propre -> recup touche
if (choix == '1') {
jouer();
} else if (choix == '2') {
regles();
} else if (choix == '3'){
scoreboardaff();
} else if (choix == '4'){
credits();
} else if (choix == '5'){
reglages();
} else if (choix == 27){
break;
}
}
/* On ferme la socket */
if(use_server){
closesocket(sockets.sock);
}
WSACleanup();
}
Raw
Server.c
#ifdef __cplusplus
#error Be sure you are using a C compiler...
#endif
#if defined (WIN32) || defined (_WIN32)
#include <winsock2.h>
#elif defined (linux) || defined (_POSIX_VERSION) || defined (_POSIX2_C_VERSION)\
|| defined (_XOPEN_VERSION)
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> /* close */
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(s) close (s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
#else
#error not defined for this platform
#endif
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
/* macros ============================================================== */
#define TELNET 23
/* we want to listen to the TELNET port */
#define PORT TELNET
#define ESC 27
/* constants =========================================================== */
int nombre_de_clients = 0;
/* types =============================================================== */
/* structures ========================================================== */
struct cli
{
pthread_t thread;
SOCKADDR_IN sin;
int recsize;
SOCKET sock;
int err;
};
struct player
{
char pseudo[16];
char pseudo_alonged[32];
int result;
int place;
};
typedef struct player player;
struct player_to //Liste des joueurs a trier -> BUFFER
{
char pseudo[16];
int score;
};
struct player_to buffer_player[50];
int bufferplace = 0;
struct player scores[10];
/* private data ======================================================== */
/* private functions =================================================== */
static void *wait_exit(void *p_data){
char touche;
do{
if(kbhit()){
touche = getch();
} else {
Sleep(100);
}
} while(touche != 27);
WSACleanup ();
exit(EXIT_SUCCESS);
}
static void *trier_scoreboard(void *p_data){
int place = 0, i;
while(1){
if(place != bufferplace){
place++;
if(place > 49) { place = 0;}
if(buffer_player[place].score > scores[9].result){
if(buffer_player[place].score > scores[8].result){
if(buffer_player[place].score > scores[7].result){
if(buffer_player[place].score > scores[6].result){
if(buffer_player[place].score > scores[5].result){
if(buffer_player[place].score > scores[4].result){
if(buffer_player[place].score > scores[3].result){
if(buffer_player[place].score > scores[2].result){
if(buffer_player[place].score > scores[1].result){
if(buffer_player[place].score > scores[0].result){
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = scores[4].result;
scores[4].result = scores[3].result;
scores[3].result = scores[2].result;
scores[2].result = scores[1].result;
scores[1].result = scores[0].result;
scores[0].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, scores[4].pseudo);
strcpy(scores[4].pseudo, scores[3].pseudo);
strcpy(scores[3].pseudo, scores[2].pseudo);
strcpy(scores[2].pseudo, scores[1].pseudo);
strcpy(scores[1].pseudo, scores[0].pseudo);
strcpy(scores[0].pseudo, buffer_player[place].pseudo);
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = scores[4].result;
scores[4].result = scores[3].result;
scores[3].result = scores[2].result;
scores[2].result = scores[1].result;
scores[1].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, scores[4].pseudo);
strcpy(scores[4].pseudo, scores[3].pseudo);
strcpy(scores[3].pseudo, scores[2].pseudo);
strcpy(scores[2].pseudo, scores[1].pseudo);
strcpy(scores[1].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = scores[4].result;
scores[4].result = scores[3].result;
scores[3].result = scores[2].result;
scores[2].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, scores[4].pseudo);
strcpy(scores[4].pseudo, scores[3].pseudo);
strcpy(scores[3].pseudo, scores[2].pseudo);
strcpy(scores[2].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = scores[4].result;
scores[4].result = scores[3].result;
scores[3].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, scores[4].pseudo);
strcpy(scores[4].pseudo, scores[3].pseudo);
strcpy(scores[3].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = scores[4].result;
scores[4].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, scores[4].pseudo);
strcpy(scores[4].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = scores[5].result;
scores[5].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, scores[5].pseudo);
strcpy(scores[5].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = scores[6].result;
scores[6].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, scores[6].pseudo);
strcpy(scores[6].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = scores[7].result;
scores[7].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, scores[7].pseudo);
strcpy(scores[7].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = scores[8].result;
scores[8].result = buffer_player[place].score;
strcpy(scores[9].pseudo, scores[8].pseudo);
strcpy(scores[8].pseudo, buffer_player[place].pseudo);
}
} else {
scores[9].result = buffer_player[place].score;
strcpy(scores[9].pseudo, buffer_player[place].pseudo);
}
}
} else {
Sleep(50);
}
}
}
static void *affichage(void *p_data){
int i;
while(1){
for(i = 0; i < 10; i++){
strcpy(scores[i].pseudo_alonged,scores[i].pseudo);
while(16 > strlen(scores[i].pseudo_alonged)){
strcat(scores[i].pseudo_alonged, " ");
}
}
system("cls");
printf("/-----------------------------------------------------------------------------\\\n");
printf("| Echap pour quitter |\n");
printf("| |\n");
printf("| |\n");
printf("| 421 Serveur - Alb & Gab |\n");
printf("| |\n");
printf("| |\n");
printf("| |\n");
printf("|-----------------------------------------------------------------------------|\n");
printf("| |\n");
printf("| Il y a : %d clients %s |\n", nombre_de_clients, nombre_de_clients > 9 ? "":" ");
printf("| |\n");
printf("| %der : %s -> %d %s |\n",scores[0].place,scores[0].pseudo_alonged,scores[0].result, scores[0].result > 9 ? "" : " ");
for(i=1;i < 10; i++){
printf("| %de %s : %s -> %d %s |\n", scores[i].place,scores[i].place != 10 ? " " : "", scores[i].pseudo_alonged,scores[i].result, scores[i].result > 9 ? "" : " ");
}
printf("| |\n");
printf("\\-----------------------------------------------------------------------------/\n");
Sleep(2000);
}
}
static void initscores(){
int i, j = 0;
for(i=0; i<10; i++){
strcpy(scores[i].pseudo, "Null");
scores[i].result = 0;
scores[i].place = i + 1;
}
}
/* thread client function */
static void *client (void *p_data)
{
nombre_de_clients++;
struct cli *p_cli = p_data;
if (p_cli != NULL)
{
int end = 0;
do
{
/* wait for the receive of a data block */
unsigned char data[128];
int sock_err = recv (p_cli->sock, data, (sizeof data - 1), 0);
if (sock_err != SOCKET_ERROR)
{
size_t nb_rec = sock_err;
if (nb_rec > 0)
{
/* convert to string */
data[nb_rec] = 0;
fflush (stdout);
if (data[0] == ESC){
end = 1;
} else if (data != ESC){
if(data[0] == 83 && //Si la requette est score -- on controle bit a bit suite a des erreurs liées a du bit-flopping de fin de string
data[1] == 99 &&
data[2] == 111 &&
data[3] == 114 &&
data[4] == 101 &&
data[5] == 115 ){
/* send some YES-TO-ALL answer */
int i;
char buff[128];
for(i = 0; i < 10; i++){
send(p_cli->sock, &scores[i], sizeof(player), 0);
}
} else {
char data2[128];
strcpy(data2, data);
char* pseudo = strtok (data,":");
char *scoree = data2 + (strlen(pseudo) + 1);
bufferplace++;
if(bufferplace > 49) { bufferplace = 0;}
strcpy(buffer_player[bufferplace].pseudo, pseudo);
buffer_player[bufferplace].score = atoi(scoree);
}
}
}
else
{
end = 1;
}
}
else
{
p_cli->err = 1;
end = 1;
}
}
while (!end);
shutdown (p_cli->sock, 2);
closesocket (p_cli->sock), p_cli->sock = INVALID_SOCKET;
/* the memory is now under the control of the thread */
free (p_cli), p_cli = NULL;
}
nombre_de_clients--;
return NULL;
}
static int clients (SOCKET sock)
{
int err = 0;
int end = 0;
do
{
{
/* create a new client context */
struct cli *p_cli = malloc (sizeof *p_cli);
if (p_cli != NULL)
{
p_cli->recsize = (int) sizeof p_cli->sin;
p_cli->sock =
accept (sock, (SOCKADDR *) &p_cli->sin, &p_cli->recsize);
if (p_cli->sock != INVALID_SOCKET)
{
/* send ...*/
pthread_create (&p_cli->thread, NULL, client, p_cli);
/* ... and forget */
p_cli = NULL;
}
else
{
perror ("socket.accept");
err = 1;
}
}
else
{
fprintf (stderr, "client creation failed : memory error\n");
}
}
}
while (!end);
return err;
}
/* ---------------------------------------------------------------------
--------------------------------------------------------------------- */
static int app (void)
{
int err = 0;
/* open a socket in TCP/IP mode. */
SOCKET sock = socket (AF_INET, SOCK_STREAM, 0);
if (sock != INVALID_SOCKET)
{
//printf ("socket %d is now opened in TCP/IP mode\n", sock);
/* we want to listen on the TELNET port */
{
int sock_err;
/* assign the listening port */
SOCKADDR_IN sin = { 0 };
/* automatic IP address */
sin.sin_addr.s_addr = htonl (INADDR_ANY);
/* protocol family (IP) */
sin.sin_family = AF_INET;
/* listening port */
sin.sin_port = htons (PORT);
/* bind */
sock_err = bind (sock, (SOCKADDR *) &sin, sizeof sin);
if (sock_err != SOCKET_ERROR)
{
/* start listening (server mode) */
sock_err = listen (sock, 5);
if (sock_err != SOCKET_ERROR)
{
err = clients (sock);
}
else
{
err = 1;
}
}
else
{
perror ("socket.bind");
err = 1;
}
/* close the socket. */
sock_err = closesocket (sock), sock = INVALID_SOCKET;
if (sock_err)
{
perror ("socket.close");
err = 1;
}
}
}
else
{
perror ("socket.open");
err = 1;
}
return err;
}
/* entry point ========================================================= */
/* ---------------------------------------------------------------------
--------------------------------------------------------------------- */
int main (void)
{
int ret;
WSADATA wsa_data;
int err = WSAStartup (MAKEWORD (2, 2), &wsa_data);
pthread_t exit_t, aff_t, tri_t;
pthread_create(&exit_t, NULL, wait_exit, NULL);
pthread_create(&aff_t, NULL, affichage, NULL);
pthread_create(&tri_t, NULL, trier_scoreboard, NULL);
initscores();
if (!err)
{
puts ("WIN: winsock2: OK");
err = app ();
WSACleanup ();
}
if (err)
{
ret = EXIT_FAILURE;
}
else
{
ret = EXIT_SUCCESS;
}
system ("pause");
return ret;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment