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

/*
* 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;
}