Comment servir des pintes de Guinness "over Internet" ;)
Reprise/Fork d'un très ancien code d'un pilier de f.m.b.l : http://tnemeth.free.fr/projets/guinness-server.html
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
586 lines
17 KiB
586 lines
17 KiB
/* |
|
* guinnessd |
|
* architecture clients/serveur guinness |
|
* Thomas Nemeth -- le 15 juin 2001 |
|
* |
|
*/ |
|
|
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <unistd.h> |
|
#include <time.h> |
|
#include <errno.h> |
|
#include <signal.h> |
|
#include <pthread.h> |
|
#include <fcntl.h> |
|
#include <getopt.h> |
|
#include <sys/types.h> |
|
#include <sys/socket.h> |
|
#include <netinet/in.h> |
|
#include <string.h> |
|
#include <strings.h> |
|
#include <locale.h> |
|
#include "defines.h" |
|
#include "xmem.h" |
|
#include "tools.h" |
|
#include "printlog.h" |
|
#include "lists.h" |
|
#include "broadcast.h" |
|
#include "drinks.h" |
|
#include "clients.h" |
|
#include "guinnessd.h" |
|
#include "commands.h" |
|
#include "config.h" |
|
|
|
/* Config specifique serveur */ |
|
char *adr_ip = NULL; |
|
int port = 0; |
|
int online = TRUE; |
|
char *fichierlog = NULL; |
|
char *fichiercfg = NULL; |
|
char *chemin = NULL; |
|
char *admin_passwd = NULL; |
|
FILE *logfile = NULL; |
|
FILE *outerr = NULL; |
|
Elt *clients_list = NULL; |
|
Elt *drinks_list = NULL; |
|
|
|
/* Config specifique connexion des clients */ |
|
char *pseudo = NULL; |
|
char *drink = NULL; |
|
char *logout = NULL; |
|
|
|
|
|
#ifdef SunOS |
|
char *crypt(const char *key, const char *salt); |
|
#else |
|
extern char *crypt __P ((__const char *__key, __const char *__salt)); |
|
#endif |
|
|
|
|
|
void install_handler (); |
|
|
|
|
|
/* |
|
* Gestionnaire de signal SIGPIPE, SIGTERM, SIGQUIT et SIGINT |
|
* |
|
*/ |
|
void handler_signaux (int sig) { |
|
switch (sig) { |
|
case SIGPIPE: |
|
printlog (LOG_NOTIFY, "Signal SIGPIPE recu...\n"); |
|
install_handler (); |
|
break; |
|
case SIGTERM: |
|
case SIGQUIT: |
|
case SIGINT: |
|
online = FALSE; |
|
printlog (LOG_NOTIFY, "Signal de terminaison recu...\n"); |
|
break; |
|
default: |
|
printlog (LOG_NOTIFY, "Signal recu...\n"); |
|
} |
|
} |
|
|
|
|
|
/* |
|
* Lecture du fichier de config : recuperation des valeurs |
|
* |
|
*/ |
|
char *get_string_from_token (char *line) { |
|
char *result = line; |
|
char *tmp; |
|
int keyval = 0; |
|
|
|
while ( (keyval != 1) && (result [0] != 0) ) { |
|
if (result [0] == '=') keyval = 1; |
|
if (keyval == 0) result++; |
|
} |
|
tmp = result++; |
|
while (tmp [0] != 0) { |
|
if (tmp [0] == '\n') tmp [0] = 0; |
|
tmp++; |
|
} |
|
return result; |
|
} |
|
|
|
|
|
/* |
|
* Lecture du fichier de config |
|
* |
|
*/ |
|
void load_config () { |
|
FILE *file; |
|
char tmpstr[MAXSTRLEN + 1]; |
|
char *value; |
|
|
|
/* Ouverture du fichier */ |
|
if ( (file = fopen (fichiercfg?fichiercfg:CONFIG_FILE, "r") ) != NULL) { |
|
/* Lecture du fichier */ |
|
while (! feof (file) ) { |
|
memset (tmpstr, 0, MAXSTRLEN + 1); |
|
fgets (tmpstr, (int) MAXSTRLEN, file); |
|
value = get_string_from_token (tmpstr); |
|
if ( (strncmp (tmpstr, "port=", 5) == 0) && (port == 0) ) |
|
port = atoi (value); |
|
if ( (strncmp (tmpstr, "passwd=", 7) == 0) && |
|
(admin_passwd == NULL) ) |
|
admin_passwd = xstrdup (crypt (value, "Gs") + 2); |
|
if ( (strncmp (tmpstr, "rep=", 4) == 0) && (chemin == NULL) ) |
|
chemin = xstrdup (value); |
|
if ( (strncmp (tmpstr, "pseudo=", 7) == 0) && (pseudo == NULL) ) |
|
pseudo = xstrdup (value); |
|
if ( (strncmp (tmpstr, "drink=", 6) == 0) && (drink == NULL) ) |
|
drink = xstrdup (value); |
|
if ( (strncmp (tmpstr, "logout=", 7) == 0) && (logout == NULL) ) |
|
logout = xstrdup (value); |
|
} |
|
fclose (file); |
|
#ifdef DEBUG |
|
} else { |
|
fprintf (stderr, "Pas de fichier de config (%s).\n", CONFIG_FILE); |
|
#endif |
|
} |
|
} |
|
|
|
|
|
/* |
|
* Aide |
|
* |
|
*/ |
|
void Usage (int help) { |
|
printf ("guinnessd by Thomas Nemeth - v %s (compilation %s : %s)\n", |
|
VERSION, OS_TYPE, COMPIL_DATE); |
|
if (help) |
|
printf ("Usage : guinnessd [-h] [-v] [-b] [-p port] " |
|
"[-s passwd] [-d chemin] [-l fichier] [-f fichier]\n" |
|
" -h : aide sur les parametres\n" |
|
" -v : affiche la version\n" |
|
" -b : detache le serveur du terminal\n" |
|
" -a adresse : specifie l'adresse du serveur\n" |
|
" -p port : specifie le numero du port\n" |
|
" -s passwd : specifie le mot de passe d'aministration\n" |
|
" -d chemin : indique le chemin ou se" |
|
" trouvent les ascii-arts\n" |
|
" -l fichier : fichier de log\n" |
|
" -f fichier : fichier de configuration\n\n"); |
|
exit (1); |
|
} |
|
|
|
|
|
/* |
|
* Traitement des arguments |
|
* |
|
*/ |
|
int traite_argv (int argc, char *argv[]) { |
|
int option; |
|
int detach = FALSE; |
|
|
|
/* Verification des parametres */ |
|
while ((option = getopt (argc, argv, "hvba:p:s:d:l:f:")) != -1) { |
|
switch (option) { |
|
case 'h' : |
|
Usage (TRUE); |
|
break; |
|
case 'v' : |
|
Usage (FALSE); |
|
break; |
|
case 'b' : |
|
detach = TRUE; |
|
break; |
|
case 'a' : |
|
adr_ip = optarg; |
|
break; |
|
case 'p' : |
|
port = atoi (optarg); |
|
break; |
|
case 's' : |
|
admin_passwd = xstrdup (crypt (optarg, "Gs") + 2); |
|
break; |
|
case 'd' : |
|
if (! chemin) { |
|
if (optarg[0] == '/') { |
|
chemin = xstrdup (optarg); |
|
} else { |
|
char *Pwd; |
|
Pwd = xmalloc ((MAXSTRLEN + 1) * sizeof (char)); |
|
getcwd (Pwd, MAXSTRLEN); |
|
chemin = xmalloc ( (strlen (Pwd) + strlen (optarg) + 2) |
|
* sizeof (char) ); |
|
snprintf (chemin, MAXSTRLEN, "%s/%s", |
|
Pwd, optarg); |
|
} |
|
} |
|
break; |
|
case 'l' : |
|
if (! fichierlog) { |
|
fichierlog = xstrdup (optarg); |
|
} |
|
break; |
|
case 'f' : |
|
if (! fichiercfg) { |
|
fichiercfg = xstrdup (optarg); |
|
} |
|
break; |
|
default: |
|
Usage (TRUE); |
|
break; |
|
} |
|
} |
|
if (optind < argc) { |
|
if (argc - optind == 1) |
|
fprintf (stderr, "%s: option inconnue --", argv[0]); |
|
else |
|
fprintf (stderr, "%s: options inconnues --", argv[0]); |
|
for ( ; optind < argc ; optind++) |
|
fprintf (stderr, " %s", argv[optind]); |
|
fprintf (stderr, "\n"); |
|
Usage (TRUE); |
|
} |
|
|
|
return detach; |
|
} |
|
|
|
|
|
/* |
|
* Fonction initiant la connexion. |
|
* |
|
*/ |
|
int initiate (int socket_service, userinfos *infos) { |
|
int cont = TRUE; |
|
char userdatas[MAXSTRLEN]; |
|
char *datas, *token, *saveptr; |
|
char delim[] = "\n\r"; |
|
char *nom_distant = NULL; |
|
char *ip_distant = NULL; |
|
int port_distant = 0; |
|
int port_local = 0; |
|
time_t now; |
|
struct tm *today; |
|
|
|
memset (userdatas, 0, MAXSTRLEN); |
|
|
|
/* Recuperation des infos sur le connecte */ |
|
get_sock_infos (socket_service, |
|
&nom_distant, &ip_distant, |
|
&port_local, &port_distant); |
|
if (ip_distant) { |
|
snprintf (infos->ip, MAXSTRLEN, "%s", ip_distant); |
|
free (ip_distant); |
|
} else sprintf (infos->ip, "0.0.0.0"); |
|
if (nom_distant) { |
|
snprintf (infos->host, MAXSTRLEN, "%s", nom_distant); |
|
free (nom_distant); |
|
} else sprintf (infos->host, "none"); |
|
infos->port = port_distant; |
|
|
|
printlog (LOG_NOTIFY, "Connexion entrante : %s %s\n", |
|
infos->ip, infos->host ? infos->host : ""); |
|
printlog (LOG_NOTIFY, "Ports (loc/dist) : %d / %d\n", |
|
port_local, infos->port); |
|
|
|
/* PROTOCOLE DE CONNEXION */ |
|
/* 1. envoi des commandes du serveur */ |
|
if ( (cont = send_servercmds (socket_service)) == FALSE) |
|
return cont; |
|
|
|
/* 2. attente des donnees du connecte */ |
|
if ( (cont = read_infos (socket_service, userdatas)) == FALSE) |
|
return cont; |
|
|
|
/* FIN DU PROTOCOLE : Vericifations / ajout dans la liste / affichage */ |
|
datas = xstrdup (userdatas); |
|
|
|
/* Nom d'utilisateur */ |
|
token = strtok_r (datas, delim, &saveptr); |
|
snprintf (infos->nom, MAXSTRLEN, "%s", token ? token : pseudo); |
|
|
|
/* Boisson preferee */ |
|
token = strtok_r (NULL, delim, &saveptr); |
|
snprintf (infos->prefb, MAXSTRLEN, "%s", token ? token : drink); |
|
|
|
/* Message d'au-revoir */ |
|
token = strtok_r (NULL, delim, &saveptr); |
|
snprintf (infos->logout, MAXSTRLEN, "%s", token ? token : logout); |
|
|
|
/* Date de connexion */ |
|
time (&now); |
|
today = localtime (&now); |
|
strftime (infos->cxdate, MAXSTRLEN, "%a %d %b %Y %T", today); |
|
|
|
printlog (LOG_NOTIFY, "Utilisateur : [%s]\n", infos->nom); |
|
printlog (LOG_NOTIFY, "Boisson preferee : [%s]\n", infos->prefb); |
|
printlog (LOG_NOTIFY, "Message de logout : [%s]\n", infos->logout); |
|
printlog (LOG_NOTIFY, "Date de connexion : [%s]\n", infos->cxdate); |
|
|
|
pthread_mutex_lock (&mutex_clients); |
|
if (exist_elt (clients_list, infos->nom)) { |
|
char nick_ok[MAXSTRLEN+1]; |
|
snprintf (nick_ok, MAXSTRLEN, "@%s", infos->nom); |
|
snprintf (infos->nom, MAXSTRLEN, "%s", nick_ok); |
|
send_infos (socket_service, "@Pseudo deja utilise !\n"); |
|
printlog (LOG_NOTIFY, "Pseudo deje utilise => %s\n", infos->nom); |
|
pthread_mutex_unlock (&mutex_clients); |
|
return FALSE; |
|
} |
|
send_infos (socket_service, "Bienvenue sur le serveur de Guinness.\n"); |
|
add_client (infos); |
|
pthread_mutex_unlock (&mutex_clients); |
|
|
|
if (! exist_elt (drinks_list, infos->prefb)) |
|
send_infos (socket_service, |
|
"Votre boisson preferee n'est pas disponible sur ce" |
|
" serveur !\nVous aurez des Guinness a la place.\n"); |
|
|
|
/* Passage en mode non bloquant */ |
|
fcntl (socket_service, F_SETFL, O_NONBLOCK); |
|
|
|
return cont; |
|
} |
|
|
|
|
|
/* |
|
* Fonction de traitement de la connexion avec les clients |
|
* |
|
*/ |
|
void thread_service (int *sock_serv) { |
|
pthread_t tid = pthread_self (); |
|
long old_id = get_broadcastid (); |
|
int socket_service = (int) *sock_serv; |
|
int cont = TRUE; |
|
int nb; |
|
userinfos infos; |
|
char commande[MAXSTRLEN + 1]; |
|
|
|
pthread_detach (tid); |
|
|
|
memset (infos.nom, 0, MAXSTRLEN + 1); |
|
memset (infos.prefb, 0, MAXSTRLEN + 1); |
|
memset (infos.logout, 0, MAXSTRLEN + 1); |
|
infos.admin = FALSE; |
|
infos.cold = FALSE; |
|
|
|
cont = initiate (socket_service, &infos); |
|
|
|
if (cont) { |
|
snprintf (commande, MAXSTRLEN, |
|
"%s a rejoint le serveur de Guinness.\n", infos.nom); |
|
broadcast (MESSAGE, NULL, commande); |
|
} |
|
|
|
#ifdef DEBUG |
|
printlog (LOG_NOTIFY, "Pret a recevoir des commandes.\n"); |
|
#endif |
|
|
|
while (cont == TRUE) { |
|
memset (commande, 0, MAXSTRLEN + 1); |
|
|
|
/* Lecture des caracteres recus */ |
|
do { |
|
sleep (1); |
|
nb = read (socket_service, commande, MAXSTRLEN); |
|
if ( (nb == -1) || (nb == 0) ) { |
|
if ( (errno == EAGAIN) && (nb == -1) ) continue; |
|
if ( (errno == EPIPE) || (nb == 0) ) { |
|
cont = FALSE; |
|
} else { |
|
printlog (LOG_ERROR, "Erreur de connexion reception !\n"); |
|
} |
|
} |
|
} while ( (cont != FALSE) && |
|
(nb < 0) && |
|
(new_message (old_id) != TRUE) ); |
|
|
|
#ifdef DEBUG |
|
printlog (LOG_NOTIFY, "Commande recue.\n"); |
|
#endif |
|
if (cont == TRUE) { |
|
/* Traitement de la commande */ |
|
if (nb > 0) |
|
cont = reply (socket_service, commande, &infos); |
|
/* Broadcast */ |
|
if (new_message (old_id) == TRUE) { |
|
old_id = get_broadcastid (); |
|
cont = send_broadcast (socket_service, &infos); |
|
#ifdef DEBUG |
|
printlog (LOG_ERROR, "Emission broadcast pour %s (id = %ld)\n", |
|
infos.nom, old_id); |
|
#endif |
|
} |
|
} |
|
} |
|
printlog (LOG_NOTIFY, "Bye bye %s...\n", infos.nom); |
|
|
|
if (infos.nom[0] != '@') { |
|
pthread_mutex_lock (&mutex_clients); |
|
remove_client (&infos); |
|
pthread_mutex_unlock (&mutex_clients); |
|
|
|
broadcast (QUITTER, infos.nom, infos.logout); |
|
} |
|
|
|
close (socket_service); |
|
} |
|
|
|
|
|
/* |
|
* Installation du gestionnaire de signal SIGPIPE et autres... |
|
* |
|
*/ |
|
void install_handler () { |
|
signal (SIGPIPE, handler_signaux); |
|
signal (SIGTERM, handler_signaux); |
|
signal (SIGQUIT, handler_signaux); |
|
signal (SIGINT, handler_signaux); |
|
} |
|
|
|
|
|
/* |
|
* Initialisation generale |
|
* |
|
*/ |
|
void guinnessd_init (int argc, char *argv[]) { |
|
pthread_mutexattr_t mutex_attr; |
|
char *cptr; |
|
|
|
setlocale (LC_ALL, ""); |
|
install_handler (); |
|
|
|
/* Valeurs par defaut */ |
|
logfile = stdout; |
|
outerr = stderr; |
|
|
|
/* est-ce bien la place pour initialiser des trucs avant le parsing de |
|
la ligne de commande ? Eg: la variable d'environnement DRINKS_DIR |
|
*/ |
|
|
|
if (NULL!=(cptr=getenv("DRINKS_DIR"))) { |
|
chemin = xstrdup(cptr); |
|
} |
|
|
|
|
|
/* Traitement des parametres */ |
|
if (traite_argv (argc, argv) == TRUE) { |
|
switch (fork()) { |
|
case -1: /* erreur */ |
|
perror ("fork()"); |
|
exit (-1); |
|
case 0: /* le fils */ |
|
setsid (); |
|
break; |
|
default: /* le pere */ |
|
exit (0); |
|
} |
|
} |
|
|
|
/* Lecture du fichier de configuration */ |
|
load_config (); |
|
|
|
/* Initialisation des semaphores */ |
|
pthread_mutexattr_init (&mutex_attr); |
|
pthread_mutex_init (&mutex_broadcast, &mutex_attr); |
|
pthread_mutex_init (&mutex_clients, &mutex_attr); |
|
|
|
/* Affectation des parametres */ |
|
if (IS_NOT_GOOD (pseudo)) SET_STRING (pseudo, DEFAULT_PSEUDO); |
|
if (IS_NOT_GOOD (drink)) SET_STRING (drink, DEFAULT_DRINK); |
|
if (IS_NOT_GOOD (logout)) SET_STRING (logout, DEFAULT_LOGOUT); |
|
if (port == 0) port = DEFAULT_SERVER_PORT; |
|
if (fichierlog) { |
|
if ((logfile = fopen (fichierlog, "a"))) { |
|
outerr = logfile; |
|
} else { |
|
fprintf (stderr, "Impossible d'ouvrir le fichier %s : %s\n", |
|
fichierlog, strerror(errno)); |
|
} |
|
} |
|
|
|
/* Option pour le buffer de logs */ |
|
setvbuf (logfile, NULL, _IOLBF, 0); |
|
|
|
/* Creation de la liste de boissons par defaut*/ |
|
add_elt (&drinks_list, "guinness"); |
|
|
|
if (! chemin) chemin = xstrdup (DRINKS_DIR); |
|
drinks_list_files (chemin); |
|
drinks_display_list (); |
|
} |
|
|
|
|
|
/* |
|
* Fonction principale |
|
* |
|
*/ |
|
int main (int argc, char *argv[]) { |
|
int socket_ecoute; |
|
int socket_service; |
|
socklen_t lg_adresse = sizeof (struct sockaddr_in); |
|
struct sockaddr_in adresse; |
|
pthread_t pthread_id; |
|
|
|
guinnessd_init (argc, argv); |
|
|
|
/* Installation de l'ecoute du serveur */ |
|
if ( (socket_ecoute = install_server (port, adr_ip, NULL)) == -1) { |
|
printlog (LOG_ERROR, "Impossible d'installer le service.\n"); |
|
return -1; |
|
} |
|
|
|
/* Passage en mode non-bloquant */ |
|
fcntl (socket_ecoute, F_SETFL, O_NONBLOCK); |
|
|
|
/* Boucle d'attente et d'ouverture de connexions */ |
|
printlog (LOG_NOTIFY, "Serveur en attente de connexions (port %d)...\n", |
|
port); |
|
while (online == TRUE) { |
|
sleep (1); |
|
|
|
/* Attente d'une connexion */ |
|
socket_service = accept (socket_ecoute, (struct sockaddr *) &adresse, |
|
&lg_adresse); |
|
|
|
/* SIGPIPE */ |
|
if ( (socket_service == -1) && (errno == EINTR) ) continue; |
|
|
|
/* PAS DE CONNEXION => mode non bloquant pour attendre un ordre de |
|
* terminaison |
|
*/ |
|
if ( (socket_service == -1) && (errno == EAGAIN) ) continue; |
|
|
|
/* Autre erreur socket */ |
|
if (socket_service == -1) { |
|
/* Erreur */ |
|
printlog (LOG_ERROR, |
|
"Erreur d'acceptation de socket, errno = %d.\n", |
|
errno); |
|
perror (__FILE__ " accept"); |
|
close (socket_ecoute); |
|
return -1; |
|
} |
|
|
|
/* Ici connexion acceptee */ |
|
printlog (LOG_NOTIFY, "Connexion acceptee...\n"); |
|
|
|
/* Lancement d'une activite de traitement */ |
|
if (pthread_create (&pthread_id, NULL/*pthread_attr_default*/, |
|
(void *) thread_service, |
|
(void *) &socket_service) == -1) { |
|
printlog (LOG_ERROR, "Erreur creation thread de service.\n"); |
|
close (socket_service); |
|
} |
|
/* fflush (logfile); */ |
|
sleep (2); |
|
} |
|
|
|
printlog (LOG_NOTIFY, "Arret du serveur demande.\n"); |
|
/* fflush (logfile); */ |
|
close (socket_ecoute); |
|
|
|
free_list (&clients_list); |
|
free_list (&drinks_list); |
|
|
|
pthread_mutex_destroy (&mutex_broadcast); |
|
pthread_mutex_destroy (&mutex_clients); |
|
|
|
return 0; |
|
}
|
|
|