CV
Langages
- C
- PHP
- Java
- Perl
- Ruby
- Javascript
- Flex 3
- Python
- GO
- C#
- TCL
- Bash
Liens
Articles
Contact

Langage C

Expertise (5/5)

Je développe en C depuis 14 ans. Je m’oriente de plus en plus vers des langages qui possèdent des trousses à outils plus riches et qui sont plus demandés sur le marché du travail (PHP, Java, C#, en particulier).

L'analyse syntaxique en C, avec Flex - Utilisation basique
L'analyse syntaxique en C, avec Flex - Utilisation depuis une socket
L'analyse syntaxique en C, avec Flex - Utilisation avec des tampons
L'analyse syntaxique en C, avec Flex - Un serveur SMTP
Flex et problème de "réentrance" - utilisation du C++
Un serveur DHCP spécialement adapté aux besoins d'un FAI
Développement système sous UNIX
Bison: Interpréteur RPC
GNU G++ (GCC) vs Visual C++ (VCC)
Berkeley DB 1
Berkeley DB 2
Berkeley DB 3

L'analyse syntaxique en C, avec Flex - Utilisation basique

Descrition

Ce code est extrait d'un logiciel que j'ai développé et dont la fonction tait d'assurer la répartition de charge entre plusieurs serveurs.

Le fichier de configuration du logiciel contient, entre autres choses, des lignes qui ressemblent à ça :

Remarque: Veuillez noter que cet exemple de fichier de configuration ne contient pas de caractère "espace". Il n'y a que des tabulations.

L'analyseur syntaxique - loadb.lex

Remarque: Notez l'utilisation des contextes.

%{

/* Author: Denis BEURIVE */

/************************************************************************/
/* Code section                                                         */
/*                                                                      */
/* This part will be included as is into the parser code.               */
/************************************************************************/


#include <stdio.h>

char *chomp (char* line)
{
  if (line[strlen(line)-1] == '\n') { line[strlen(line)-1] = 0; }
  return line;
}

%}

/************************************************************************/
/* Definition section                                                   */
/*                                                                      */
/* Remark: the rule '^[ \t]+\n' is not the same as '^[ \t]+$'. In the   */
/* first case the string 'yytext' will contain the character            */
/* '\n'. On the other hand, the string 'yytext' that matches            */
/* second rule won't include the trailing character '\n'.               */
/*                                                                      */
/* Remark: The rule 'DST_CONFIG' will be matched only if the statement  */
/* tag 'dst_rules' is activated. All the other rules will be            */
/* evalutated whether 'dst_rules' is activated or not.                  */
/************************************************************************/

FIELD_SEPARATOR \t
BLANK_LINE ^[ \t]+\n
EMPTY_LINE ^\n

IP_JOKER @
IP_NUMBER [0-9]+|{IP_JOKER}
IP_ADRESS {IP_NUMBER}\.{IP_NUMBER}\.{IP_NUMBER}\.{IP_NUMBER}
PORT [0-9]+
SRC_CONFIG ^{IP_ADRESS}{FIELD_SEPARATOR}+{PORT}\n
DST_CONFIG ^{FIELD_SEPARATOR}+{IP_ADRESS}{FIELD_SEPARATOR}+{PORT}\n

%s dst_rules

/************************************************************************/
/* Rules section                                                        */
/************************************************************************/

%%
BEGIN(src_rules);

{SRC_CONFIG} {
                 fprintf (stdout, "SRC: [%s]\n", chomp(yytext));
                 BEGIN(dst_rules);
              }

<dst_rules>{DST_CONFIG} { fprintf (stdout, "DST: [%s]\n", chomp(yytext)); }

{BLANK_LINE} { fprintf (stdout, "Blank line\n"); }
{EMPTY_LINE} { fprintf (stdout, "Empty line\n"); }

.* { return 1; }

%%

/* No extra C code */

Note: Pour accepter les fins de lignes sous UNIX ou sous Windows:

Intégration de l'analyseur au code du logiciel - loadb.c

/* Author: Denis BEURIVE */

#include <stdio.h>

extern int yylex();
extern FILE *yyin;
extern int yyrestart(FILE*);

int main (int argc, char *argv[])
{
  int parser_status, error;

  /********************************************************/
  /** Check command line arguments **/
  /********************************************************/

  if (argc != 2)
  {
    fprintf (stderr, "\nUsage: %s config_file\n", argv[0]);
    return 1;
  }

  /********************************************************/
  /** Open file for the flex parser                      **/
  /********************************************************/

  yyin = fopen (argv[1], "r");
  if (yyin == NULL)
  {
    fprintf (stderr, "\nCan not open file %s\n", argv[1]);
    return 1;
  }

  /********************************************************/
  /** Call the flex parser using 'yyin' as input         **/
  /********************************************************/
  
  parser_status = yylex();
  fclose (yyin);

  switch (parser_status)
  {
    case 0: {
              fprintf (stdout, "\n-- OK --\n");
              error = 0; }; break;
    case 1: {
              fprintf (stderr, "Internal parser error");
              error = 1; }; break;
    default:{
              fprintf (stderr, "Internal error (unexpected return value from the parser)");
              error = 3; };
  }

  /********************************************************/
  /** Try with another file ...                          **/
  /********************************************************/

  yyin = fopen (argv[1], "r");
  if (yyin == NULL)
  {
    fprintf (stderr, "\nCan not open file %s\n", argv[1]);
    return 1;
  }

  yyrestart(yyin);

  parser_status = yylex();
  fclose (yyin);

  switch (parser_status)
  {
    case 0: {
              fprintf (stdout, "\n-- OK --\n");
              error = 0; }; break;
    case 1: {
              fprintf (stderr, "Internal parser error");
              error = 1; }; break;
    default:{
              fprintf (stderr, "Internal error (unexpected return value from the parser)");
              error = 3; };
  }

  return error;
}

Makefile

Sources

Veuillez cliquer sur le lien pour télécharger les sources de l'analyseur.

L'analyse syntaxique en C, avec Flex - Utilisation depuis une socket

Descrition

Cet exemple crée un petit serveur sur lequel il est possible de se connecter via Telnet. Ce serveur reçoit des chaînes de caractères, censées contenir des tags "${TAG}" (exemples "${NAME}", "${ADDRESS}",...). Ce serveur extrait les noms des tags envoyés et il les affiche simplement.

Remarque: Ce code est inspiré d'un serveur beaucoup plus complexe que j'ai développé.

L'analyseur syntaxique - fdscan.lex

%{

/* Author: Denis BEURIVE */

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int hashwrap() { return 1; }

/* ------------------------------------------------ */
/* This global variable represents the socket des-  */
/* -criptor used by the parser as input.            */
/* ------------------------------------------------ */

extern int sockin;

/* ------------------------------------------------ */
/* Instead of reading data from a file, we redefine */
/* YY_INPUT, so we read data from the socket des-   */
/* -criptor 'sockin'.                               */
/* ------------------------------------------------ */

#define YY_INPUT(buf,result,max_size) \
{ \
  size_t nb_bytes; \
                                                                   \
  nb_bytes = read(sockin, (void*)buf, (size_t)max_size); \
                                                                   \
  if ((nb_bytes == 0) || (nb_bytes == -1)) { result = YY_NULL; } \
  else { result = nb_bytes; } \
}


%}

ALPHA ([A-Z]|[a-z])
NUMERIC [0-9]
ALPHANUM ({ALPHA}|{NUMERIC})
CARACTER ({ALPHANUM}|[_\-])
TAG \{{CARACTER}+\}

%%

{TAG} {
          fprintf (stdout, "\ntag: %s", yytext);
          fflush (stdout);
        }
\n { /* Do nothing - ignore input */ }
. { /* Do nothing - ignore input */ }

%%

Intégration de l'analyseur au code du logiciel - fdscan.c

/* -------------------------------------------------------------- */
/* This simple program illustrate the use of flex to parser data  */
/* from a socket descriptor.                                      */
/* Author: Denis BEURIVE                                          */
/* -------------------------------------------------------------- */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/param.h>
#include <arpa/inet.h>
#include <errno.h>

extern int hashlex();
int sockin;

int main (int argc, char *argv[])
{
   int server_socket, i, port, longueur, res;
   struct sockaddr_in server_address, client_address;


   /* ----------------------------------------------------------- */
   /* Check command line                                          */
   /* ----------------------------------------------------------- */

   if (argc != 2)
   {
     fprintf (stderr, "\n\nUsage: fltest <port number>\n\n");
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* configuration                                               */
   /* ----------------------------------------------------------- */

   port = atoi(argv[1]);

   /* ----------------------------------------------------------- */
   /* Open server socket                                          */
   /* ----------------------------------------------------------- */

   server_socket = socket (AF_INET, SOCK_STREAM, 0);
   if (server_socket == -1)
   {
     fprintf (stderr, "\n\nERROR: Can not create socket - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Bind socket to internet address                             */
   /* ----------------------------------------------------------- */

   server_address.sin_family = AF_INET;
   server_address.sin_port = htons((unsigned short)port);
   server_address.sin_addr.s_addr = INADDR_ANY;

   for (i=0; i<8; i++) { server_address.sin_zero[i] = 0; }

   if (bind (server_socket, (struct sockaddr*)&server_address, sizeof(struct sockaddr_in)) == -1)
   {
     fprintf (stderr, "\n\nERROR: Can not bind socket to Internet address - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Configure this socket, so it will listen for connexion re-  */
   /* -quests.                                                    */
   /* ----------------------------------------------------------- */

   if (listen (server_socket, 50) == -1)
   {
     fprintf (stderr, "\n\nERROR: System call listen() failed - %s.\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* now wait for connexions                                     */
   /* ----------------------------------------------------------- */

   longueur = sizeof(struct sockaddr);

   sockin = accept (server_socket, (struct sockaddr*)&client_address, &longueur);

   if (sockin == -1)
   {
     fprintf (stderr, "\n\nERROR: System call accept() failed - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Parse socket's stream                                       */
   /* ----------------------------------------------------------- */

   res = hashlex();


   fprintf (stdout, "\n\nThe parser returned the value %d\n\n", res);
   fflush (stdout);

   return 0;
}

Instructions de compilation

Sources

Veuillez cliquer sur le lien pour télécharger les sources de l'analyseur.

L'analyse syntaxique en C, avec Flex - Utilisation avec des tampons

Descrition

Cet exemple illustre les points suivants :

Anayse syntaxique de tampons stockés en mémoire.
Utilisation de deux analyseurs syntaxiques au sein d'un même logiciel.

Premier analyseur syntaxique - hasher.lex

Second analyseur syntaxique - hasher1.lex

Intégration des deux analyseurs au logiciel - test_hasher.c

Instructions de compilation

Sources

Veuillez cliquer sur le lien pour télécharger les sources de l'analyseur.

L'analyse syntaxique en C, avec Flex - Un serveur SMTP

If a start condition is inclusive, then rules with no start conditions at all will also be active.
If a start condition is exclusive, then only rules qualified with the start condition will be active.
Exclusive start conditions are not executed at startup. They are executed when you call BEGIN(condition).
A BEGIN(COMMAND) at the begining of all rules says that we start the parser in the COMMAND start condition. But BEGIN is executed whenever you call yylex() ! Not only first time.
If the parser finds more than one match, it takes the one matching the most text.
If the finds two or more matches of the same length, the rule listed first in the flex input file is chosen.

Cet exemple est tiré du code d'un serveur SMTP très spécifique (pour une utilisation spécialisée) que j'ai développé. Ce serveur simple affiche le contenu des sections "DATA" des emails envoyés par les clients.

L'analyseur syntaxique - smtpd.lex

%{

/* Author: Denis BEURIVE */

/* ------------------------------------------------ */
/* SMTP parser                                      */
/* ------------------------------------------------ */

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include "dstring.h"
#include "smtpd.h"



int hashwrap() { return 1; }

/* ------------------------------------------------ */
/* This global variable represents the socket des-  */
/* -criptor used by the parser as input.            */
/* ------------------------------------------------ */

extern int sockin;

/* ------------------------------------------------ */
/* Dynamic string used to store the data section of */
/* the e-mail. This variable MUST be initialized    */
/* before you call the parser.                      */
/* ------------------------------------------------ */

extern dstring data;

/* ------------------------------------------------ */
/* Instead of reading data from a file, we redefine */
/* YY_INPUT, so we read data from the socket des-   */
/* -criptor 'sockin'.                               */
/* ------------------------------------------------ */

#define YY_INPUT(buf,result,max_size) \
{ \
  size_t nb_bytes; \
                                                                   \
  nb_bytes = read(sockin, (void*)buf, (size_t)max_size); \
                                                                   \
  if ((nb_bytes == 0) || (nb_bytes == -1)) { result = YY_NULL; } \
  else { result = nb_bytes; } \
}

/* ------------------------------------------------ */
/* The foloowing section defines actions to be exe- */
/* -cuted for each section of the SMTP stream.      */
/*                                                  */
/* Notes about start conditions:                    */
/*                                                  */
/* o If the start condition is inclusive, then      */
/* rules with no start conditions at all will       */
/* also be active.                                  */
/* o If it is exclusive, then only rules qualified  */
/* with the start condition will be active.         */
/* o Exclusive start conditions are not executed at */
/* startup. They are executed when you call         */
/* BEGIN(condition).                                */
/* o The BEGIN says that we start the parser in the */
/* COMMAND start condition. But BEGIN is executed   */
/* -- whenever -- you call yylex() !!! Not only     */
/* first time.                                      */
/*                                                  */
/* Notes about rules matching:                      */
/*                                                  */
/* o If it finds more than one match, it takes the  */
/* one matching the most text.                      */
/* o If it finds two or more matches of the same    */
/* length, the rule listed first in the flex        */
/* input file is chosen.                            */
/* ------------------------------------------------ */

/*
    NOTE:

    You could add the following line to tell the parser (yylex()) to start in a given start condition:

    BEGIN(start_condition);

    Note that you must write spaces between the word BEGIN and the start of the line. Otherwise flex will take it for a rule's definition.
*/

%}

CRLF \r\n
END_OF_DATA ^\.{CRLF}

%x DATA_PART

%%

  
  

^(HELO|EHLO).*{CRLF} {
                       fprintf (stdout, "\n>> HELO");
                       fflush (stdout);
                       return SMTP_HELO;
                     }

^QUIT{CRLF} {
              fprintf (stdout, "\n>> QUIT");
              fflush (stdout);
              return SMTP_QUIT;
            }

^DATA{CRLF} {
              fprintf (stdout, "\n>> DATA");
              fflush (stdout);
              BEGIN(DATA_PART);
              return SMTP_DATA;
            }

^.+{CRLF} {
            fprintf (stdout, "\n>> OTHER");
            fflush (stdout);
            return SMTP_OTHER;
          }

<DATA_PART>{END_OF_DATA} {
                           if (dstring_add (&data, yytext, strlen(yytext)) == 1) { return SMTP_OUT_OF_MEM; }
                           BEGIN(INITIAL);
                           return SMTP_END_OF_DATA;
                         }

<DATA_PART>^.*\n {
                   if (dstring_add (&data, yytext, strlen(yytext)) == 1) { return SMTP_OUT_OF_MEM; }
                 }


%%

Intégration de l'analyseur au code du logiciel - smtpd.c et smtpd.h

/* -------------------------------------------------------------- */
/* This simple program illustrate the use of flex to parser data  */
/* from a socket descriptor.                                      */
/* Author: Denis BEURIVE                                          */
/* -------------------------------------------------------------- */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/param.h>
#include <arpa/inet.h>
#include <errno.h>

#include "dstring.h"
#include "smtpd.h"


#define DYNAMIC_STRING_INIT_SIZE 2048



#define CONNEXION_RESPONSE 0
#define HELO_RESPONSE 1
#define OK_RESPONSE 2
#define DATA_RESPONSE 3
#define QUIT_RESPONSE 4

char *responses[] = {
                      "220 newsletter.tiscali.fr Simple Mail Transfer Service Ready\r\n",
                      "250 newsletter.tiscali.fr\r\n",
                      "250 OK\r\n",
                      "354 Start mail input; end with <CRLF>.<CRLF>\r\n",
                      "221 newsletter.tiscali.fr Service closing transmission channel\r\n"
                    };




/* -------------------------------------------------------------- */
/* The following function is the flex parser itself               */
/* -------------------------------------------------------------- */

extern int hashlex();

/* -------------------------------------------------------------- */
/* These 2 variables are used by the flew parser                  */
/* -------------------------------------------------------------- */

int sockin;
dstring data;

/* -------------------------------------------------------------- */
/* Main entry point for the SMTP deamon                           */
/* -------------------------------------------------------------- */

int main (int argc, char *argv[])
{
   int server_socket, i, port, longueur, res;
   struct sockaddr_in server_address, client_address;
   char *pt;
   size_t size;


   /* ----------------------------------------------------------- */
   /* Check command line                                          */
   /* ----------------------------------------------------------- */

   if (argc != 2)
   {
     fprintf (stderr, "\n\nUsage: fltest <port number>\n\n");
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* configuration                                               */
   /* ----------------------------------------------------------- */

   port = atoi(argv[1]);

   /* ----------------------------------------------------------- */
   /* Open server socket                                          */
   /* ----------------------------------------------------------- */

   server_socket = socket (AF_INET, SOCK_STREAM, 0);
   if (server_socket == -1)
   {
     fprintf (stderr, "\n\nERROR: Can not create socket - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Bind socket to internet address                             */
   /* ----------------------------------------------------------- */

   server_address.sin_family = AF_INET;
   server_address.sin_port = htons((unsigned short)port);
   server_address.sin_addr.s_addr = INADDR_ANY;

   for (i=0; i<8; i++) { server_address.sin_zero[i] = 0; }

   if (bind (server_socket, (struct sockaddr*)&server_address, sizeof(struct sockaddr_in)) == -1)
   {
     fprintf (stderr, "\n\nERROR: Can not bind socket to Internet address - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Configure this socket, so it will listen for connexion re-  */
   /* -quests.                                                    */
   /* ----------------------------------------------------------- */

   if (listen (server_socket, 50) == -1)
   {
     fprintf (stderr, "\n\nERROR: System call listen() failed - %s.\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Now wait for connexions                                     */
   /* ----------------------------------------------------------- */

   longueur = sizeof(struct sockaddr);

   sockin = accept (server_socket, (struct sockaddr*)&client_address, &longueur);
   if (sockin == -1)
   {
     fprintf (stderr, "\n\nERROR: System call accept() failed - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Send the initial welcome                                    */
   /* ----------------------------------------------------------- */

   if (write (sockin, responses[CONNEXION_RESPONSE], strlen(responses[CONNEXION_RESPONSE])) == -1)
   {
     fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Initialize the dynamic string                               */
   /* ----------------------------------------------------------- */

   if (dstring_init (&data, DYNAMIC_STRING_INIT_SIZE) == 1)
   {
     fprintf (stderr, "\n\nERROR: Can not allocate memory!\n\n");
     return 1;
   }

   /* ----------------------------------------------------------- */
   /* Parse socket's stream                                       */
   /* ----------------------------------------------------------- */

   do {
        res = hashlex();

        switch (res)
        {
          case SMTP_HELO:
               {
                 if (write (sockin, responses[HELO_RESPONSE], strlen(responses[HELO_RESPONSE])) == -1)
                 {
                   fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
                   return 1;
                 }
               }; break;

          case SMTP_QUIT:
               {
                 if (write (sockin, responses[QUIT_RESPONSE], strlen(responses[QUIT_RESPONSE])) == -1)
                 {
                   fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
                   return 1;
                 }
                 close (sockin);
               }; break;

          case SMTP_DATA:
               {
                 if (write (sockin, responses[DATA_RESPONSE], strlen(responses[DATA_RESPONSE])) == -1)
                 {
                   fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
                   return 1;
                 }
               }; break;

          case SMTP_END_OF_DATA:
               {
                 if (write (sockin, responses[OK_RESPONSE], strlen(responses[OK_RESPONSE])) == -1)
                 {
                   fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
                   return 1;
                 }
               }; break;

          case SMTP_OTHER:
               {
                 if (write (sockin, responses[OK_RESPONSE], strlen(responses[OK_RESPONSE])) == -1)
                 {
                   fprintf (stderr, "\n\nERROR: System call write() failed - %s\n\n", strerror(errno));
                   return 1;
                 }
               }; break;

          case SMTP_OUT_OF_MEM:
               {
                 fprintf (stderr, "\n\nERROR: Can not allocate memory!\n\n");
                 return 1;
               }
        }
      }
      while (res != 0);


   fprintf (stdout, "\n\nThe parser returned the value %d\n\n", res);
   fflush (stdout);

   /* ----------------------------------------------------------- */
   /* Print out the data section                                  */
   /* ----------------------------------------------------------- */

   pt = dstring_get_data (&data, &size);
   if (pt == NULL)
   {
     fprintf (stderr, "\n\nERROR: Can not allocate memory!\n\n");
     return 1;
   }

   fprintf (stdout, "\n\nDATA:\n\n%s\n\n", pt);

   /* ----------------------------------------------------------- */
   /* Free all allocated memory                                   */
   /* ----------------------------------------------------------- */

   dstring_free (&data);
   free (pt);

   return 0;
}

Makefile

Flex et problème de "réentrance" - utilisation du C++

Les analyseurs Flex "en C" utilisent des variables globales. Ces variables sont utilisées pour stocker des états internes à la fonction yylex(). Par conséquent, il est impossible d'utiliser un analyseur Flex "en C" pour analyser deux flux en même temps.

Pour générer un analyseur Flex qui soit capable d'analyser plusieurs flux simultanément, il faut passer par l'utilisation du C++. Les variables utilisées pour stocker les états de l'analyseur sont "encapsulées" dans des classes.

L'analyseur syntaxique - file.lex

Intégration de l'analyseur dans un outil destiné à lire des fichiers - file.cc

// -------------------------------------------------------------------------
// Author: Denis BEURIVE
//
// This program shows how to interface a C++ generated Flex parser in order
// to parse the content of a file.
//
// The key point is that the parser's constructor (yyFlexLexer(...)) takes
// a pointer to an 'istream' object as input for the parser.
//
// yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
//
// You should first create an 'ifstream' object in order to associate an
// input stream to a given file (the file to parse). Then you create an
// 'istream' object from the 'streambuf' object associated with the
// previously created 'ifstream' object.
//
// Keep in mind that the class 'ifstream' inherites from the class 'io',
// which contains a pointer to the object 'streambuf' used by the object
// of the class 'ifstream'.
//
// ifstream::open() associates a stream to a given input file.
// ios::fail() test the status of the previous aperation.
// ios::rdbuf() returns a pointer to the 'streambuf' object used by
// the stream associated with the input file.
// -------------------------------------------------------------------------


#include <fstream.h>
#include "FlexLexer.h"




int main(int argc, char *argv[])
{

  // -----------------------------------------------------------------------
  // Check command line
  // -----------------------------------------------------------------------

  if (argc != 2)
  {
    cerr << endl << "Usage: " << argv[0] << " <file name>" << endl << endl;
    return 1;
  }

  // -----------------------------------------------------------------------
  // Open input file
  // -----------------------------------------------------------------------

  ifstream input_file(argv[1], ios::in);

  if (input_file.fail())
  {
    cerr << endl << "ERROR: Can not open file " << argv[1] << endl;
    return 1;
  }

  // -----------------------------------------------------------------------
  // Create the input stream for the parser
  // -----------------------------------------------------------------------

  istream input_parser(input_file.rdbuf());

  // -----------------------------------------------------------------------
  // Create a parser
  // -----------------------------------------------------------------------

  yyFlexLexer parser(&input_parser);

  // -----------------------------------------------------------------------
  // Now parser the content of the input file
  // -----------------------------------------------------------------------

  parser.yylex();

  // -----------------------------------------------------------------------
  // Close input file
  // -----------------------------------------------------------------------

  input_file.close();

  return 0;
}

Intégration de l'analyseur dans un outil destiné à lire des tampons (en mémoire) - string.cc

// -------------------------------------------------------------------------
// Author: Denis BEURIVE
//
// This program shows how to interface a C++ generated Flex parser in order
// to parse an in-memory buffer.
//
// The key point is that the parser's constructor (yyFlexLexer(...)) takes
// a pointer to an 'istream' object as input for the parser.
//
// yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
//
// You should first create a 'istrstream' object in order to associate an
// inpout stream to a in-memory buffer. Then you create an 'istream' object
// from the 'streambuf' object associated with the previously created
// 'ifstream' object.
//
// ios::rdbuf() returns a pointer to the 'streambuf' object used by the
// stream associated with the input file.
// -------------------------------------------------------------------------

#include <strstream.h>
#include <iostream.h>
#include <string.h>
#include "FlexLexer.h"


static char TO_PARSE[] = "Ceci est un test ${TEST1}\n${TEST2}\n";



int main(int argc, char *argv[])
{

  // -----------------------------------------------------------------------
  // Create a string stream
  // -----------------------------------------------------------------------

  istrstream mem_buff(TO_PARSE, strlen(TO_PARSE));

  // -----------------------------------------------------------------------
  // Create the 'istream' object
  // -----------------------------------------------------------------------

  istream mem_input(mem_buff.rdbuf());

  // -----------------------------------------------------------------------
  // Create a parser
  // -----------------------------------------------------------------------

  yyFlexLexer parser(&mem_input);

  // -----------------------------------------------------------------------
  // Now parser the content of the input file
  // -----------------------------------------------------------------------

  parser.yylex();

  return 0;
}

Makefile

##############################################################
# Tools configuration                                        #
##############################################################

CC = g++
CCFLAGS =
FLEX = flex
FLEXFLAGS = -+

##############################################################
# Compile the flex parser                                    #
##############################################################

file.lex.cc: file.lex
        ${FLEX} ${FLEXFLAGS} -ofile.lex.cc file.lex

file.lex.o: file.lex.cc
        ${CC} -c file.lex.cc

##############################################################
# Build the file parser                                      #
##############################################################

pfile: file.cc \
        file.lex.o
        ${CC} ${CCFLAGS} -o $@ file.cc file.lex.o -lfl

##############################################################
# Build the in-memory parser                                 #
##############################################################

pstring: string.cc \
         file.lex.o
        ${CC} ${CCFLAGS} -o $@ string.cc file.lex.o -lfl

##############################################################
# Generic rules                                              #
##############################################################

all: pfile pstring

clean:
        rm -f file.lex.cc
        rm -f file.lex.o
        rm -f pfile
        rm -f pstring

Un serveur DHCP spécialement adapté aux besoins d'un FAI

Ce serveur DHCP a été développé pour répondre aux besoins spécifiques d’un gros fournisseur d’accès Internet.

Il utilise une base MySql dans laquelle sont stockées toutes les adresses IP de tous les clients.
Un cliet se voit associer deux adresses IP: une adresse IP pour son routeur ADSL et une adresse IP pour son décodeur TV.
Une adresse IP est associée à un ensemble de 5 valeurs : 4 valeurs issues de l’option 82 du paquet DHCP, et le numéro de VLAN.
Ce serveur s’intègre à des systèmes d’information qu’il met à jour en temps réel.
Le serveur intègre des greffons («.so») fonctionnels. Ces greffons permettent d’étendre les fonctions du serveur, sans toucher au code de ce dernier.

Remarque: Ce serveur a supporté environ 1 500 000 clients DHCP pendant 3 trois, sans interruption. Aucun problème n’a été constaté.

Les fichiers d'entête

ack_codes.h

/*! \file ack_codes.h
          This file defines all the dummy IP addresses used to fill the dummy ACK responses.
    \remark These constants are used with the function packets_send_dummy_ack() _ONLY_.
    \author Denis BEURIVE
 */

#ifndef ACK_CODES_HEADER_FILE
#define ACK_CODES_HEADER_FILE

#define UNEXPECTED_PACKET_DECLINE            "127.0.0.2"  /* Request is DECLINE (unexpected)                  */
#define DB_DHCP_CONNECT_LOST                 "127.0.0.3"  /* Connection lost with DHCP database               */
#define DB_DHCP_REC_NOT_FOUND                "127.0.0.4"  /* Option 82 not found in DHCP database             */
#define DB_LOGISTIC_CONNECT_LOST             "127.0.0.5"  /* Connection lost with LOGISTIC database           */
#define DB_LOGISTIC_REC_NOT_FOUND            "127.0.0.6"  /* Data not found in LOGISTIC database              */
#define UNEXPECTED_PACKET_UNKNOWN_TYPE       "127.0.0.7"  /* Unknown DHCP message type                        */
#define DB_OPTIONS_REC_NOT_FOUND             "127.0.0.8"  /* Data not found in table "options"                */

#endif

config.h

/*! \file config.h
    Header file for config.c.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONFIG_HD

  /*! \brief Maximum number of modems' configuration records.
   */

  #define MODEM_CONF_MAX_ENTRY            256

  /*! \brief Maximum number of bytes (including the final 0) for the buffer used to store the constructor's signature.
   */

  #define MODEM_CONF_IDENTIFIER_SIZE      7

  /*! \brief Maximum number of bytes (including the final 0) for the label that represents the constructor.
   */

  #define MODEM_CONF_TAG_NAME_SIZE        256

  /*! \brief Maximum number of bytes (including the final 0) for the auto-configuration tag ("yes" or "no").
   */

  #define MODEM_CONF_AUTOCONF_SIZE        4

  /*! \brief Maximum number of bytes (including the final 0) for the path to the dinamically loadable module
             that implements the calculation of the MAC address.
   */

  #define MODEM_CONF_ACTION_SIZE          256

  /*! \brief Maximum number of VCIs' configuration records.
   */

  #define VCI_CONF_MAX_ENTRY              256

  /*! \brief Maximum number of bytes (including the final 0) for the VCI's value.
   */

  #define VCI_CONF_IDENTIFIER_SIZE        7

  /*! \brief Maximum number of bytes (including the final 0) for the VCI's description.
   */

  #define VCI_CONF_TAG_NAME_SIZE          256

  /*! \brief Maximum number of bytes (including the final 0) for the path to the dinamically loadable module
             that implements IP calculation for this VCI.
   */

  #define VCI_CONF_ACTION_SIZE            256

  /*! \brief This structure contains the modems' configuration data.
   */

  struct modem_conf_struct {
                              /*! \brief Modem's ID (this is the index in the array).
                               */

                              int id;

                              /*! \brief 6 first bytes of the modem's MAC address. This is called the manufacturor's sugnature.
                               */

                              char identifier[MODEM_CONF_IDENTIFIER_SIZE];

                              /*! \brief VCI value.
                               */

                              char vci[VCI_CONF_IDENTIFIER_SIZE];

                              /*! \brief Arbitrary string that represents the modem's constructor. This is the trademark.
                               */

                              char tag_name[MODEM_CONF_TAG_NAME_SIZE];

                              /*! \brief This string represents the auto-configuration capability. Value can be:
                                         <ul>
                                           <li>"yes": the modem suports auto-configuration.
                                           <li>"no": the modem does not support auto-configuration.
                                         </ul>
                               */

                              char autoconf[MODEM_CONF_AUTOCONF_SIZE];

                              /*! \brief Path to the dinamically loadable module used to process the MAC address.
                               */

                              char action[MODEM_CONF_ACTION_SIZE];

                              /*! \brief Handle to the dinamically loadable module.
                               */

                              void *dll;

                              /*! \brief Pointer to the function (within the dinamically loadable module) that is called to
                                         process the MAC address.
                               */

                              char* (*calculate_mac_address)(char*);
                           }; 

  /*! \brief This structure contains the VCI's configuration.
   */

  struct vci_conf_struct {
                           /*! \brief VCI's ID (this is the index in the array).
                            */

                           int id;

                           /*! \brief VCI value.
                            */

                           char identifier[VCI_CONF_IDENTIFIER_SIZE];

                           /*! \brief Arbitrary string that represents the VCI's usage.
                            */

                           char tag_name[VCI_CONF_TAG_NAME_SIZE];

                           /*! \brief Path to the dinamically loadable module used to process this MAC address.
                            */

                           char action[VCI_CONF_ACTION_SIZE];

                           /*! \brief Handle to the dinamically loadable module.
                            */

                           void *dll;

                           /*! \brief Pointer to the function (within the dinamically loadable module) that is called to
                                      calculate the gateway from the CIDR.
                            */

                           char* (*calculate_gateway)(char*);

                           /*! \brief Pointer to the function (within the dinamically loadable module) that is called to
                                      calculate the network from the CIDR.
                            */

                           char* (*calculate_network)(char*);

                           /*! \brief Flag that indicates if the server should update MyDns for this VCI.
                                      Value can be:
                                      <ul>
                                         <li>0: do not update.
                                         <li>1: update.
                                      </ul>
                            */

                           int mydns;

                           /*! \brief Flag that indicates if the server should update Radonline for this VCI.
                                      Value can be:
                                      <ul>
                                         <li>0: do not update.
                                         <li>1: update.
                                      </ul>
                            */

                           int radonline;
                         };

  #ifdef PRIVATE_CODE_ONLY

     /*! \brief Thei FLEX configuration file is not valid.
      */

     #define CONF_PARSER_SYNTAX_ERROR   -1

     /*! \brief The FLEX configuration parser could not allocate memory.
      */

     #define CONF_PARSER_NO_MEM         -2

     /*! \brief The FLEX configuration parser found a duplicated tag in the configuration file.
      */

     #define CONF_PARSER_DUPLICATED_TAG -3

     /*! \brief The FLEX configuration parser found a modem's manufacturor MAC signature that is too long.
      */

     #define CONF_PARSER_MODEM_IDENTIFIER_TOO_LONG  -4

     /*! \brief The FLEX configuration parser found a modem's manufacturor label that is too long.
      */

     #define CONF_PARSER_MODEM_TAG_NAME_TOO_LONG    -5

     /*! \brief The FLEX configuration parser found a modem's autoconfiguration tag that is too long.
      */

     #define CONF_PARSER_MODEM_AUTOCONF_TOO_LONG    -6

     /*! \brief The FLEX configuration parser found a modem's plugins that is too long.
      */

     #define CONF_PARSER_MODEM_ACTION_TOO_LONG      -7  

     /*! \brief the configuration file contains too many modem's information.
      */

     #define CONF_PARSER_MODEM_TOO_MANY_ENTRIES     -8

     /*! \brief the configuration file contains too many VCI information.
      */

     #define CONF_PARSER_VCI_TOO_MANY_ENTRIES       -9

     /*! \brief The FLEX configuration parser found a VCI that ID is too long.
      */

     #define CONF_PARSER_VCI_ID_TOO_LONG            -10

     /*! \brief The FLEX configuration parser found a VCI label that is too long.
      */

     #define CONF_PARSER_VCI_TAG_NAME_TOO_LONG      -11

     /*! \brief The FLEX configuration parser found a VCI action that is too long.
      */

     #define CONF_PARSER_VCI_ACTION_TOO_LONG        -12

     /*! \brief The VCI value, in the modem configuration section is not valid (too long).
      */

     #define CONF_PARSER_MODEM_VCI_TOO_LONG         -13

     /*! \brief The configuration file has been successfully parsed.
      */

     #define CONF_PARSER_OK             0

     /*! \brief Data structure used to store the couples (tag, value).
      */

     struct user_data {
                         char *tag;
                         char *value;
                      };

  #endif

  /*! \brief configuration parser could not open the configuration file.
   */

  #define PARSE_CONFIGURATION_FILE_NOT_FOUND    -1

  /*! \brief configuration parser could not allocate memory.
   */

  #define PARSE_CONFIGURATION_NO_MEM            -2

  /*! \brief configuration parser found an invalid line.
   */

  #define PARSE_CONFIGURATION_SYNTAX_ERROR      -3

  /*! \brief configuration parser found a duplicated tag.
   */

  #define PARSE_CONFIGURATION_DUPLICATED_TAG    -4

  /*! \brief Could not load the DLL.
   */

  #define PARSE_CONFIGURATION_DLL_OPEN_ERROR    -5

  /*! \brief The DLL is not valid.
   */

  #define PARSE_CONFIGURATION_DLL_INVALID       -6

  /*! \brief One record that represents a modem's configuration is not valid.
   */ 

  #define PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID -7

  /*! \brief One record that represents a VCI's configuration is not valid.
   */

  #define PARSE_CONFIGURATION_VCI_CONF_NOT_VALID   -8

  /*! \brief configuration parser terminated successfully.
   */

  #define PARSE_CONFIGURATION_OK                0


  int parse_configuration_file (char *path, int *err);
  void free_all_configuration_data();
  int get_value (char *tag, char **value);
  char* dummy_mac_processor (char* addr);
  char* conf_get_last_error();

  int get_number_of_modem_conf();
  int modem_conf_get_id (char *mac, unsigned short int vci);
  char* modem_conf_get_tag_name (int id);
  char* modem_conf_get_vci (int id);
  int modem_conf_is_autoconf (int id);
  void* modem_conf_get_function (int id);

  int get_number_of_vci_conf();
  int vci_conf_get_id (unsigned int vci);
  char* vci_conf_get_tag_name (int id);
  void* vci_conf_get_gateway_calculator (int id);
  void* vci_conf_get_network_calculator (int id);
  int vci_update_mydns (int id);
  int vci_update_radonline (int id);

  #define CONFIG_HD

#endif

#ifdef __cplusplus
}
#endif

conversion.h

/*! \file conversion.h
          Header file fot the conversion facilities (conversion.c).
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONVERSION_HEADER_FILE
#define CONVERSION_HEADER_FILE

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdarg.h>

#include "strings_utils.h"  /* EXT */
#include "logging.h"        /* INT */

char int_to_char (unsigned char c);
unsigned char char_to_int (char c);
unsigned char* haddr_to_hexa (char *haddr, int *length);
unsigned long int get_network_ip (char *ip);
char *get_doted_ip (unsigned long int ip);
int uint32_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out);
int ip_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out);
int hexa_to_binary (char *buffer_in, char *buffer_out, int len_out);
int ascii_to_binary (char *buffer_in, char *buffer_out, int len_in, int len_out);
int uint16_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out);
int raw_ips_to_string (unsigned char *buffin, char *buffout, int lenin, int lenout);
void radius2mydns (char *radius, char *mydns, int mydns_size);

#endif

#ifdef __cplusplus
}
#endif

dhcp.h

find_ip_and_reply.h

/*! \file find_ip_and_reply.h
          Header file for the big functionnality that finds the IP address and reply to the client.
          Return values start from -100.
 */

#ifndef FIND_IP_AND_REPLY_HEADER_FILE
#define FIND_IP_AND_REPLY_HEADER_FILE

#include <netinet/in.h>
#include "packets_data.h"
#include "mysql_interface.h"

/*! \brief Return value for the function find_ip_and_reply(). Invailid DHCP message type.
 */

#define DHCP_INVALID_MESSAGE_TYPE              -100

/*! \brief Return value for the function find_ip_and_reply(). An unexpected error occured while trying
           to retrieve the lease value.
 */

#define DHCP_LEASE_INCONSTANCY                 -101

/*! \brief Return value for the function find_ip_and_reply(). Could not send a (START or STOP) ticket to
           Radonline. Some SQL error occured.
 */

#define DHCP_RADONLINE_MYSQL_SQL_PROBLEM       -102

/*! \brief Return value for the function find_ip_and_reply(). Could not send a (START or STOP) ticket to
           Radonline. An unexpected SQL error occured.
 */

#define DHCP_RADONLINE_MYSQL_UNEXPECTED_ERROR  -103

/*! \brief Return value for the function find_ip_and_reply(). Could not send a (START or STOP) ticket to
           MyDqs database. Some SQL error occured.
 */

#define DHCP_MYDNS_MYSQL_SQL_PROBLEM           -104

/*! \brief Return value for the function find_ip_and_reply(). Could not send a (START or STOP) ticket to
           MyDqs database. An unexpected SQL error occured.
 */

#define DHCP_MYDNS_MYSQL_UNEXPECTED_ERROR      -105

/*! \brief Return value for the function find_ip_and_reply(). The VCI extracted from the packet is not listed
           in the configuration file.
 */

#define DHCP_UNEXPECTED_VCI                    -106

/*! \brief Return value for the function find_ip_and_reply(). An error occured while the serveur was calculating
           the gateway from the CIRD.
 */

#define DHCP_GATEWAY_ERROR                     -107

/*! \brief Return value for the function find_ip_and_reply(). An error occured while the serveur was calculating
           the network from the CIDR.
 */

#define DHCP_NETWORK_ERROR                     -108


int find_ip_and_reply (struct smysql        *mysql_info,
                       struct smysql        *mysql_radonline,
                       struct smysql        *mysql_mydns,
                       struct mysql_tables  *mysql_tables,
                       struct dhcp_packet   *packet,
                       struct global_config *config,
                       int                  sck,
                       unsigned long int    broadcast,
                       unsigned long int    server_ip,
                       struct sockaddr_in   *client_address);


#endif

flock.h

libhttp.h

#ifdef __cplusplus
extern "C" {
#endif

#ifndef LIBHTTP_HEADER
#define LIBHTTP_HEADER

#include <curl/curl.h>

/**/
/**/
/**/

/**/

#define CURL_LAST_ERROR_SIZE 2048 

/**/

#define CURL_URL_SIZE          1024

/**/

#define CURL_HTTP_BODY_SIZE    61440

/**/

#define CURL_HTTP_PARAMS_SIZE  1024

/**/

#define CURL_OK              0

/**/

#define CURL_INIT_ERROR     -1

/**/

#define CURL_REQUEST_ERROR  -2

/**/

struct http_body
{
  /**/

  char body[CURL_HTTP_BODY_SIZE];

  /**/

  size_t nbbytes;
};

/**/ 

struct request_data
{
  /**/

  char url[CURL_URL_SIZE];

  /**/

  char params[CURL_HTTP_PARAMS_SIZE];

  /**/

  long request_timeout;

  /**/

  long connect_timeout;

  /**/

  struct http_body body;
};

/**/
/**/
/**/

/**/

#define DATA_NAME_SIZE    64

/**/

#define DATA_VALUE_SIZE   128

/**/

#define DATA_MAX_COUPLES  20

/**/

#define DATA_MAX_ROWS     20

/**/

struct data_couple
{
  /**/

  char name[DATA_NAME_SIZE];

  /**/

  char value[DATA_VALUE_SIZE];
};

/**/

#define LOGISTIC_STATUS_SIZE  8

/**/

#define LOGISTIC_INTEGER_SIZE 32

/**/ 

struct logistic_xml
{
  /**/

  char status[LOGISTIC_STATUS_SIZE];

  /**/

  char num_rows[LOGISTIC_INTEGER_SIZE];

  /**/

  char num_columns[LOGISTIC_INTEGER_SIZE];

  /**/

  struct data_couple couples[DATA_MAX_ROWS][DATA_MAX_COUPLES]; 

  /**/

  int rows;

  /**/

  int columns; 
};

/**/
/**/
/**/

     /**/
     /**/
     /**/

char* web_get_last_error();
char* web_get_body(struct request_data *reqdata);
size_t web_get_body_size(struct request_data *reqdata);
int web_get(struct request_data *reqdata);
int web_format_params (char *couples[][2], int n, char *dst, int size);

     /**/
     /**/
     /**/

int web_logistic_parser(char *response, struct logistic_xml *data);
char* web_logistic_get_data (struct logistic_xml *data, int line, char *name);



#endif

#ifdef __cplusplus
}
#endif

libip.h

/*! \file libip.h
          Header file for the library "libip".
 */

#ifndef LIBIP_HEADER_FILE
#define LIBIP_HEADER_FILE

#define MAX_IP_SIZE 16

/*! \brief This structure is used to store the result of the function ipcalc().
 */

struct ipresult 
{
  /*! \brief First IP address of the CIDR. */
  char firt_ip_address[MAX_IP_SIZE];

  /*! \brief Last IP address of the CIDR. */
  char last_ip_address[MAX_IP_SIZE];

  /*! \brief CIDR netmask. */
  char netmask[MAX_IP_SIZE];

  /*! \brief CIDR network. */
  char network[MAX_IP_SIZE];

  /*! \brief CIDR broadcast. */
  char broadcast[MAX_IP_SIZE];

  /*! \brief This flag indicates if the CIDR is a private IP range.
             <ul>
               <li>0: the CIDR is not private.
               <li>1: the CIDR is private.
             <ul>
   */
  int  private;

  /*! \brief This is the slash value. */
  int  slash;

  /*! \brief This is the class (A,B,C,...). */
  char class;
};

char* libip_get_last_error();
int ipcalc(char *addr, struct ipresult *result);


#endif

logging.h

/*! \file logging.h
          Header file for the logging module 'logging.c'.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef LOGGING_HEADER
#define LOGGING_HEADER

  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <unistd.h>
  #include <stdio.h>
  #include <stdarg.h>
  #include <string.h>
  #include <errno.h>
  #include <time.h>






  /* -------------------------------------------------------- */
  /*                    Section "LOG LEVELS"                  */
  /*                                                          */
  /* Note: Hexa     <=> Binary                                */
  /*       01           0000 0001                             */
  /*       02           0000 0010                             */
  /*       04           0000 0100                             */
  /*       08           0000 1000                             */
  /*       10           0001 0000                             */
  /*       ...          ...                                   */
  /*                                                          */
  /* Please note that:                                        */
  /*                                                          */
  /* LEVEL_FULL_VERBOSE < LEVEL_VERBOSE < LEVEL_DEBUG <       */
  /* LEVEL_INFO < LEVEL_WARNING < LEVEL_ERROR < LEVEL_FATAL   */
  /* -------------------------------------------------------- */

  /*! \brief Numerical value for FULL_VERBOSE level. */

  #define LEVEL_FULL_VERBOSE  0x00000001

  /*! \brief Numerical value for VERBOSE level. */

  #define LEVEL_VERBOSE       0x00000002

  /*! \brief Numerical value for DEBUG level. */ 

  #define LEVEL_DEBUG         0x00000004

  /*! \brief Numerical value for INFO level. */

  #define LEVEL_INFO          0x00000008

  /*! \brief Numerical value for WARNING level. */

  #define LEVEL_WARNING       0x00000010

  /*! \brief Numerical value for ERROR level. */

  #define LEVEL_ERROR         0x00000020

  /*! \brief Numerical value for FATAL level. */

  #define LEVEL_FATAL         0x00000040

  /*! \brief Numerical value for endding caller. */

  #define ENDING_ONLY         0x80000000

  /* -------------------------------------------------------- */
  /*              End of section "LOG LEVELS"                 */
  /* -------------------------------------------------------- */

  /*! brief This macro specifies that this log is a terminal one.
   */

  #define TERMINAL_LEVEL 1

  /*! brief This macro specifies that this log is not a terminal one.
   */

  #define HIGH_LEVEL 0





  void logger_init(unsigned long int size, char* pref, unsigned int level, char *path);
  int my_syslog (unsigned int level, unsigned int terminal, char *src, int line, const char * fmt,...);
  int my_syslog_skip_line();

  char* logger_get_last_logger_error();
  void logger_new_tag();
  char* logger_get_tag();

  void logger_set_error (char* mess);
  char* logger_get_error();
  void logger_reset_error();

  void logger_set_mac (char *m);
  void clear_mac_address();

#endif

#ifdef __cplusplus
}
#endif

logistic.h

modem.h

mysql_header.h

/*! \file mysql_header.h
          Header file for the MySql module 'mysql.c'.
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef MY_MYSQL_HEADER_FILE_
#define MY_MYSQL_HEADER_FILE_

#include <time.h>
#include "mysql.h"         /* EXT (MySql distribution) */

  /*! \brief Number of configuration tags for MySql in a configuration file.
   */

  #define MYSQL_CONFIGURATION_TAG_NUMBER  10

  /* ------------------------------------------------- */
  /* Radonline actions                                 */
  /* ------------------------------------------------- */

  /*! \brief This constant is used by the function send_to_radonline(). It tells the function that a
             START ticket should be inserted into the Radonline database.
   */

  #define RADONLINE_START      0

  /*! \brief This constant is used by the function send_to_radonline(). It tells the function that a
             STOP ticket should be inserted into the Radonline database.
   */

  #define RADONLINE_STOP       1

  /* ------------------------------------------------- */
  /* MyDns actions                                     */
  /* ------------------------------------------------- */

  /*! \brief This constant is used by the function send_to_mydns(). It tells the function that a
             START ticket should be inserted into the MyDns database.
   */

  #define MYDNS_START      0

  /*! \brief This constant is used by the function send_to_mydns(). It tells the function that a
             STOP ticket should be inserted into the MyDns database.
   */

  #define MYDNS_STOP       1

  /* ------------------------------------------------- */
  /* Sizes for all MySql data                          */
  /* ------------------------------------------------- */

  /*! \brief Maximum number of characters for the buffer that hold the message associated with the
             last MySql error.
   */

  #define MYSQL_MAX_ERROR_SIZE 4096

  /*! \brief Maximum number of characters for a SQL request.
   */

  #define MAX_SQL_REQUEST_SIZE 4096

  /*! \brief Maximum number of characters for the database host name.
   */

  #define DB_HOST_MAX_SIZE 256

  /*! \brief Maximum number of characters for a database user login.
   */

  #define DB_USER_MAX_SIZE 256

  /*! \brief Maximum number of characters for a database name.
   */

  #define DB_NAME_MAX_SIZE 256

  /*! \brief Maximum number of characters for a database password.
   */

  #define DB_PASSWD_MAX_SIZE 256

  /*! \brief Maximum number of characters for the path to the MySql UNIX socket.
   */

  #define MYSQL_SOCKET_FILE_MAX_SIZE 256

  /* ------------------------------------------------- */
  /* MySql configuration handler                       */
  /* ------------------------------------------------- */

  /*! \brief Data structure used to store the configuration for MySql connection.
   */

  struct smysql {

                  /* ------------------------------------ */
                  /* Mysql management variables           */
                  /* ------------------------------------ */

                  /*! \brief Handler to the MySql session. */

                  MYSQL *handler;

                  /*! \brief Timestamp of the last connection attempt. */

                  time_t last_connection_timestamp;

                  /*! \brief This flag indicates whether the connection to the MySql server is alive or not.
                             <UL>
                                <LI>0: the connection to the MySql server is down.
                                <LI>1: the connection to the MySql server is up.
                             </UL>
                   */

                  int connected;

                  /* ------------------------------------ */
                  /* Data for SELECT requests             */
                  /* ------------------------------------ */

                  /*! \brief For SELECT queries, this pointer points to selected data. */

                  MYSQL_RES     *result;

                  /*! \brief For SELECT queries, number of lines. */

                  unsigned int  num_fields;

                  /*! \brief For SELECT queries, number of columns. */

                  unsigned int  num_rows;

                  /* ------------------------------------ */
                  /* Configuration                        */
                  /* ------------------------------------ */

                  /*! \brief Name of the host that runs the MySql server. */

                  char          host[DB_HOST_MAX_SIZE];

                  /*! \brief Login used to log to the MySql server. */

                  char          user[DB_USER_MAX_SIZE];

                  /*! \brief Password used to access the MySql server. */

                  char          passwd[DB_PASSWD_MAX_SIZE];

                  /*! \brief Mane of the database. */

                  char          db[DB_NAME_MAX_SIZE];

                  /*! \brief Port number used by the MySql server. */

                  unsigned int  port;

                  /*! \brief UNIX socket used by the MySql server. */

                  char          socket[MYSQL_SOCKET_FILE_MAX_SIZE];

                  /*! \brief Maximum number of retries for MySql connections. */

                  int           connect_retry;

                  /*! \brief Timeout (in seconds) for the connection to the MySql server. */

                  unsigned int  connect_timeout;

                  /*! \brief Number of seconds netween 2 connnection atsemps. */

                  unsigned int  connect_sleep;

                  /*! \brief Delay between two reconnection attempts. */

                  time_t        reconnection_delay;

                  /* ------------------------------------ */
                  /* Error reporting                      */
                  /* ------------------------------------ */

                  /*! \brief Error code for the last MySql error. */

                  int           last_error_int;

                  /*! \brief Literal description of the last MySql error. */

                  char          last_error_str[MYSQL_MAX_ERROR_SIZE];

                  /*! \brief Pointer to a function used to log debug information, if necessary.
                            The signature of the function must be: <P>
                            int my_syslog (const char *file, const char * fmt,...)<P>
                            Upon successful completion, the function must return the value 0.
                            Otherwize, the function returns the value 1.<P>
                            If you set this field to the value NULL, then no output is done.
                   */

                   int (*my_syslog) (const char *file, const char * fmt,...);
                };

  /* ------------------------------------------------- */
  /* Return values                                     */
  /* ------------------------------------------------- */

  /*! \brief Return value for the functions:
             <UL>
                <LI>standard_query
                <LI>sql_update
                <LI>sql_insert
                <LI>sql_delete
                <LI>sql_select
                <LI>get_unix_timestamp
             </UL>
             The SQL request was skiped because the reconnection delay did not expired.
   */

  #define MYSQL_REQUEST_SKIPED        -1

  /*! \brief Return value for the functions:
             <UL>
                <LI>standard_query
                <LI>sql_update
                <LI>sql_insert
                <LI>sql_delete
                <LI>sql_select
                <LI>get_unix_timestamp
             </UL>
      The connection to the MySql server was lost.
   */

  #define MYSQL_CONNECTION_LOST       -2

  /*! \brief Return value for the functions:
             <UL>
                <LI>standard_query
                <LI>sql_update
                <LI>sql_insert
                <LI>sql_delete
                <LI>sql_select
                <LI>get_unix_timestamp
             </UL>
      The reconnection process to the MySql server failed.
   */

  #define MYSQL_RECONNECTION_FAILED   -3

  /*! \brief Return value for the functions:
             <UL>
                <LI>standard_query
                <LI>sql_update
                <LI>sql_insert
                <LI>sql_delete
                <LI>sql_select
                <LI>get_unix_timestamp
             </UL>
      A SQL error occured.
   */

  #define MYSQL_SQL_PROBLEM           -4

  /*! \brief Return value for the functions:
             <UL>
                <LI>standard_query
                <LI>sql_update
                <LI>sql_insert
                <LI>sql_delete
                <LI>sql_select
                <LI>get_unix_timestamp
             </UL>
      Unexpected error.
   */

  #define MYSQL_UNEXPECTED_ERROR      -5

  /*! \brief Return value for the functions:
             <UL>
                <LI>get_unix_timestamp
             </UL>
      For some strange reasons, the MySql could not return the current timestamp.
   */ 

  #define MYSQL_NO_TIMESTAMP          -6

  /* ------------------------------------------------- */
  /* Functionnal interface                             */
  /* ------------------------------------------------- */

  int load_mysql_configuration_from_file (
                                           char *path,
                                           struct smysql *mysql_info,
                                           char *tags[MYSQL_CONFIGURATION_TAG_NUMBER]
                                         );

  void init_mysql_structure (struct smysql *mysql_info);
  int connect_to_mysql (struct smysql *mysql_info);
  void disconnect_from_mysql(struct smysql *mysql_info);
  int sql_update (struct smysql *mysql_info, char* query);
  int sql_insert (struct smysql *mysql_info, char* query);
  int sql_delete (struct smysql *mysql_info, char* query);
  int sql_replace (struct smysql *mysql_info, char* query);
  int sql_select (struct smysql *mysql_info, char* query);
  time_t get_unix_timestamp (struct smysql *mysql_info, int *error);

#endif

#ifdef __cplusplus
}
#endif

mysql_interface.h

/*! \file mysql_interface.h
          Header file for the MySql module 'mysql_interface.c'.
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef MY_MYSQL_INTERFACE_HEADER_FILE_
#define MY_MYSQL_INTERFACE_HEADER_FILE_

  #include "mysql_header.h"
  #include "tables.h"
  #include "server_config.h"
  #include "packets_data.h"

  /* ------------------------------------------------- */
  /* Return values                                     */
  /* ------------------------------------------------- */

  /*! \brief The SQL request was skiped because the reconnection delay did not expire.
   */

  #define MYSQL_INTERFACE_REQUEST_SKIPED         -1

  /*! \brief Connection with the MySql server was lost.
   */

  #define MYSQL_INTERFACE_CONNECTION_LOST        -2

  /*! \brief Could not reconnect to the MySql server.
   */

  #define MYSQL_INTERFACE_RECONNECTION_FAILED    -3

  /*! \brief An SQL error occured.
   */

  #define MYSQL_INTERFACE_SQL_PROBLEM            -4

  /*! \brief An unexpected error occured.
   */

  #define MYSQL_INTERFACE_UNEXPECTED_ERROR       -5

  /*! \brief Could not found the requested data in the database (no row matched the WHERE statement).
  */

  #define MYSQL_INTERFACE_NOT_FOUND              -6

  /*! \brief Find more than one data in the database (several rows row matched the WHERE statement).
      \remark This error should not happen due to database constraints.
   */

  #define MYSQL_INTERFACE_MORE_THAN_ONE          -7

  /*! \brief Find more options than the maximum allowed.
      \remark This error should not happen due to database constraints.
   */

  #define MYSQL_INTERFACE_TOO_MANY_ITEMS         -8

  /*! \brief Return value for the all functions that need to get the UNIX timestamp from the MySql server.
      \remark This error should not happen since the timestamp should always be accessible.
   */

  #define MYSQL_INTERFACE_NO_TIMESTAMP           -9

  /*! \brief Found a MAC address in table 'LOGISTIC_RADIUS' while deleting it.
   */

  #define MYSQL_INTERFACE_MAC_ADDRESS_FOUND      -10

  /*! \brief Could not found a given optionnal profile in the option's table ('options').
   */

  #define MYSQL_INTERFACE_NO_OPTION_FOUND        -11

  /* ------------------------------------------------- */
  /* Functionnal interface                             */
  /* ------------------------------------------------- */

  int load_context (struct smysql        *mysql_info,
                    struct mysql_tables  *mysql_tables,
                    struct global_config *config);
  int load_abonnes (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config);
  int load_options (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config);
  int send_to_radonline (
                           struct smysql        *mysql_info,
                           struct mysql_tables  *mysql_tables,
                           char                 *ip,
                           int                  action,
                           struct global_config *config);
  int mydns_init (struct smysql *mysql_info);
  int send_to_mydns (
                       struct smysql        *mysql_info,
                       struct mysql_tables  *mysql_tables,
                       char                 *ip,
                       int                  action,
                       struct global_config *config);
  int load_logistic (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config);
  int set_flag_check_radius (struct smysql *mysql_info,
                             struct mysql_tables *mysql_tables,
                             struct global_config *config);
  int signal_unknown_mac_address (struct smysql *mysql_info,
                                  struct mysql_tables *mysql_tables,
                                  struct global_config *config);
  int nack_flag_abonne (struct smysql          *mysql_info,
                        struct mysql_tables    *mysql_tables,
                        struct global_config   *config,
                        unsigned long int      new_value);
  int blackhole_abonne (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config);
  int remove_autoconf_bh (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config);
  void clear_tables (struct mysql_tables *mysql_tables);


  #endif

#ifdef __cplusplus
}
#endif

packets.h

/*! \file packets.h
    Header file for the low level DHCP packet manipulation module (packet.c).
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef PACKETS_HEADER_FILE
#define PACKETS_HEADER_FILE

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdarg.h>

#include "packets_data.h" 
#include "conversion.h"
#include "tables.h"


/*! \brief Maximum number of characters used to represent a hardware address in standard ':' notation
           (HH:HH:HH:HH:HH:HH). Maximum size is 16*2 + 15 + 1 = 48
           <UL>
              <LI>The binary representation is 16 bytes long (maximum).
                  1 byte is represented by 2 hexa characters. So, we have 16*2 hexa characters.
              <LI>Each couple of 2 hexa characters is separated by a ':' character. So we need 15 characters ':'.
              <LI>We add 1 byte for the terminal zero.
           </UL>
 */

#define DHCP_P_STR_HADDR_SIZE 48

/*! \brief Maximum number of characters used to represent a hardware address in hexa (without ':' separators).
           Maximum size is 16*2 + 1 = 33
           <UL>
              <LI>The binary representation is 16 bytes long (maximum).
                  1 byte is represented by 2 hexa characters. So, we have 16*2 hexa characters.
              <LI>We add 1 byte for the terminal zero.
           </UL>
 */

#define DHCP_P_STR_HADDR_SIZE_EXACT 33

/*! \brief Maximum number of characters used to represent the field 'sname' of a DHCP packet.
           The size of the field 'sname' of a DHCP packet is 64 bytes. We add one byte for the terminal zero.
 */

#define DHCP_P_STR_SNAME_SIZE 65

/*! \brief Maximum number of characters used to represent the field 'file' of a DHCP packet.
           The size of the field 'file' of a DHCP packet is 128 bytes. We add one byte for the terminal zero.
 */

#define DHCP_P_STR_FILE_SIZE  129

/*! \brief Size, in bytes, for the option's value. */

#define OPTIONS_OPTION_VALUE_SIZE         256





void packet_logging_service (int dbg,
                             char *logfile,
                             int (*logger) (const char *file, const char * fmt,...));

void packets_clear (struct dhcp_packet *p);

void packets_set_op (struct dhcp_packet *p, int op);
void packets_set_htype (struct dhcp_packet *p, int htype);
void packets_set_hlen (struct dhcp_packet *p, int hlen);
void packets_set_hops (struct dhcp_packet *p, int hops);
void packets_set_xid (struct dhcp_packet *p, unsigned long int xid);
void packets_set_secs (struct dhcp_packet *p, unsigned short int secs);
void packets_set_flags (struct dhcp_packet *p, unsigned short int flags);
int packets_set_ciaddr (struct dhcp_packet *p, char *ciaddr);
void packets_set_bin_ciaddr (struct dhcp_packet *p, unsigned long int ciaddr);
int packets_set_yiaddr (struct dhcp_packet *p, char *yiaddr);
int packets_set_siaddr (struct dhcp_packet *p, char *siaddr);
int packets_set_giaddr (struct dhcp_packet *p, char *giaddr);
void packets_set_bin_giaddr (struct dhcp_packet *p, unsigned long int giaddr);
void packets_set_chaddr (struct dhcp_packet *p, char *chaddr);
void packets_set_sname (struct dhcp_packet *p, char *sname);
void packets_set_file (struct dhcp_packet *p, char *file);

unsigned char packets_get_op (struct dhcp_packet *p);
unsigned char packets_get_htype (struct dhcp_packet *p);
unsigned char packets_get_hlen (struct dhcp_packet *p);
unsigned char packets_get_hops (struct dhcp_packet *p);
unsigned long int packets_get_xid (struct dhcp_packet *p);
unsigned short int packets_get_secs (struct dhcp_packet *p);
unsigned short int packets_get_flags (struct dhcp_packet *p);
char* packets_get_ciaddr (struct dhcp_packet *p);
unsigned long int packets_get_bin_ciaddr (struct dhcp_packet *p);
char* packets_get_yiaddr (struct dhcp_packet *p);
char* packets_get_siaddr (struct dhcp_packet *p);
char* packets_get_giaddr (struct dhcp_packet *p);
unsigned long int packets_get_bin_giaddr (struct dhcp_packet *p);
char* packets_get_chaddr (struct dhcp_packet *p);
char* packets_get_chaddr_no_separator (struct dhcp_packet *p);
char* packets_get_bin_chaddr (struct dhcp_packet *p);
char* packets_get_sname (struct dhcp_packet *p);
char* packets_get_file (struct dhcp_packet *p);

char* packets_get_node_id (struct dhcp_packet *p);
unsigned char packets_get_shelf (struct dhcp_packet *p);
unsigned char packets_get_numero_slot (struct dhcp_packet *p);
unsigned char packets_get_numero_port (struct dhcp_packet *p);
unsigned short int packets_get_vci (struct dhcp_packet *p);
unsigned short int packets_get_vlan_id (struct dhcp_packet *p);

void packets_init_option_writer (struct dhcp_packet *p);
void packets_options_clear (struct dhcp_packet *p);
int packets_set_option (struct dhcp_packet *p, unsigned char option, char *value, int len);
void packets_close_option (struct dhcp_packet *p);

void packets_init_option_reader (struct dhcp_packet *p);
int packets_parse_options (struct dhcp_packet *p);
int packets_get_option (struct dhcp_packet *p, int option, int *len, unsigned char **value);
int packets_get_message_type (struct dhcp_packet *p);
char* packets_get_subnet_mask (struct dhcp_packet *p);

void packet_init_dump_service();
int packet_dump (struct dhcp_packet *p, struct dhcp_packet *pin, struct mysql_tables *mysql_tables, char *file, char *csv, struct sockaddr_in *from, struct sockaddr_in *to);
int check_packet_size (int size);
void packet_set_taille (struct dhcp_packet *p, int taille);

char* packets_type_to_char (int type);

#endif




#ifdef __cplusplus
}
#endif

packets_data.h

	/*! \file packets_data.h
	    This file contains all definitions for DHCP packets data storage.
	 */


	#ifdef __cplusplus
	extern "C" {
	#endif

	#ifndef PACKETS_DATA_HEADER
	#define PACKETS_DATA_HEADER

        /*! \brief The constants is used to represent a unknown DSLAM's vendor. */

        #define DSLAM_UNKNOWN       -1

        /*! \brief The constants represents an UT STARCOM DSLAM. */

        #define DSLAM_UTSTARCOM     0

        /*! \brief The constants represents an ALCATEL DSLAM. */

        #define DSLAM_ALCATEL       1

        /*! \brief Number of bytes used to store the Node ID (including the final nul character).
            \remark <ul>
                        <li>Alcatel's DSLAMs need up to 20 bytes to represent the node ID.
                        <li>Utstarcom's DSLAMs need up to 5 bytes (maximum value is "65535" - unsigned shot int).
                    </ul>
            \warning If you modify the value of this constant, you must also modify the value of the constant
                     NODE_ID_SIZE (see file "tables.h").
         */

        #define NODE_BUFFER_SIZE    21

	/*! \brief This structure contains the option 82 values.
	 */

	struct dhcp82   {
			  /*! \brief Remote ID sub-option. */

			  unsigned char       sub_option;

			  /*! \brief Total length of the value fields. */

			  unsigned char       length;

			  /*! \brief UTStarcom vendor ID. */

			  unsigned long int   vendor_id;

			  /*! \brief ATM port. */

			  unsigned char       port_type;

			  /*! \brief Version number. */

			  unsigned char       version;

			  /*! \brief Port VLAN ID. 
                              \remark For UtStarCom, an 'unsigned short int is enough'. */

			  unsigned int        vlan_id;

			  /*! \brief MAC address of line card Ethernet port. */

			  unsigned char       nas_mac[6];

			  /*! \brief GIADDR (0x00 not used by a bridge). */

			  unsigned long int   nas_ip;

			  /*! \brief DSLAM's node ID. 
                              \remark <ul>
                                      <li>Alcatel's DSLAMs need up to 20 bytes to represent the node ID.
                                      <li>Utstarcom's DSLAMs need up to 5 bytes (maximum value is "65535" - unsigned shot int).
                                      </ul>
                           */

			  char  node_id[NODE_BUFFER_SIZE];

			  /*! \brief DSLAM's shelf ID. */

			  unsigned char        shelf;

			  /*! \brief Slot number. */

			  unsigned char        numero_slot;

			  /*! \brief Port number. */

			  unsigned char        numero_port;

			  /*! \brief VPI of port. */

			  unsigned short int   vpi;

			  /*! \brief VCI of port. */

			  unsigned short int   vci;

                          /*! \brief DSLAM's constructor (Alcatel or UtStarcom). */

                          int constructor;
			};

	/*! \brief For alignement problem, we must use a "per byte" structure.
		   'unsigned long int' and 'unsigned short int' can not be anywhere in memory.
            \warning The structure is used ONLY for "UTSTARCOM" DSLAMs. Do NOT use it fot other DSLAMs.
	 */

	struct m_dhcp82   {
			    /*! \brief Remote ID sub-option. */

			    unsigned char       sub_option;

			    /*! \brief Total length of the value fields. */

			    unsigned char       length;

			    /*! \brief UTStarcom vendor ID. */

			    unsigned char   vendor_id[4];

			    /*! \brief ATM port. */

			    unsigned char       port_type;

			    /*! \brief Version number. */

			    unsigned char       version;

			    /*! \brief Port VLAN ID. */

			    unsigned char       vlan_id[2];

			    /*! \brief MAC address of line card Ethernet port. */

			    unsigned char       nas_mac[6];

			    /*! \brief GIADDR (0x00 not used by a bridge). */

			    unsigned char       nas_ip[4];

			    /*! \brief DSLAM's node ID. */

			    unsigned char       node_id[2];

			    /*! \brief DSLAM's shelf ID. */

			    unsigned char        shelf;

			    /*! \brief Slot number. */

			    unsigned char        numero_slot;

			    /*! \brief Port number. */

			    unsigned char        numero_port;

			    /*! \brief VPI of port. */

			    unsigned char        vpi;

			    /*! \brief VCI of port. */

			    unsigned char        vci[2];
			  };

	/*! \brief Maximum number of bytes for a DHCP option value.
	 */

	#define VALUE_MAX_SIZE 2048

	/*! \brief This structure is associated with all packets. It is used to store a packet option.
	 */

	struct opt
	{
	  /*! \brief Option's code, as defined in RFCs. */

	  unsigned char code;

	  /*! \brief Size of the option's value. */

	  unsigned char len;

	  /*! \brief Option's value. */

	  unsigned char value[VALUE_MAX_SIZE];
	};

	/*! \brief This structure is associated with all packets. It contains information about the packets.
	    \warning When a packet is received (via the incoming socket), you must initialize the size of the packet
		     by calling the function packet_set_taille() (this sets the field 'taille').
	 */

	struct op_control
	{
  	  /*! \brief Pointer used to read the option's part of a given DHCP packet. */ 

  	  char             *opt_pointer;

  	  /*! \brief Pointer used to write packet's options. */

  	  unsigned char    *opt_pointer_reader;

  	  /*! \brief Total size (in bytes) of the DHCP packet (this include the UDP payload only). */

  	  int              taille;

  	  /*! \brief List of options for the DHCP packet. */

	  struct opt       list[256];

	  /*! \brief Parsed option 82 from DSLAM. */

	  struct dhcp82    dslam_data;
	};

/*! \brief Maximum size for the option's part. This size includes the magic number (4 bytes).
 */

#define OPTION_SIZE 2048

/*! \brief Maximum size (in bytes) of a packets.
          A packet contains:
          <UL>
             <LI>A fixed part (which size is 236 bytes). See structure <I>'struct dhcp_packet'</I>.
             <LI>A variable lenght part, for the options (maximum of OPTION_SIZE bytes).
          </UL>
 */

#define PACKET_SIZE (236 + OPTION_SIZE)

/*! \brief Structure of a DHCP packet.
 */

struct dhcp_packet
{
  /*! \brief opcode. */
  unsigned char op;

  /*! \brief Hardware type. */
  unsigned char htype;

  /*! \brief Hardware address length. */
  unsigned char hlen;

  /*! \brief Hop count (used only by gateway, otherwise 0). */
  unsigned char hops;

  /*! \brief Transaction ID (random number). */
  unsigned long int xid;

  /*! \brief Number of seconds since first request. */
  unsigned short int secs;

  /*! \brief See RFC 1542. */
  unsigned short int flags;

  /*! \brief Client IP address. */
  unsigned long int ciaddr;

  /*! \brief Your IP address. */
  unsigned long int yiaddr;

  /*! \brief Server IP address. */
  unsigned long int siaddr;

  /*! \brief Gateway IP address. */
  unsigned long int giaddr;

  /*! \brief Client hardware address. */
  char  chaddr[16];

  /*! \brief Server host name. */
  char  sname[64];

  /*! \brief Boot file name. Form 'op' to 'file' (included), there are 236 bytes. */
  char  file[128];

  /*! \brief options part (4 bytes magic number + raw options). */
  char  options[OPTION_SIZE];

  /*! \brief Operation data. */
  struct op_control ctrl;
};

/*! \brief Value for the option 53 (DHCP Message Type): Identifies the DHCP DISCOVER.
 */

#define DHCPDISCOVER   1

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP OFFER.
 */

#define DHCPOFFER      2

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP REQUEST.
 */

#define DHCPREQUEST    3

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP DECLINE.
 */

#define DHCPDECLINE    4

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP ACK.
 */

#define DHCPACK        5

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP NACK.
 */

#define DHCPNAK        6

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP RELEASE.
 */

#define DHCPRELEASE    7

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP INFORM.
 */

#define DHCPINFORM     8

/*! \brief Value for the option 53 (DHCP Message Type): Identifies the DHCP DISCOVER in string notation.
 */

#define DHCPDISCOVER_BYTE   "\x01"

/*! \brief Value for the option 53 (DHCP Message Type): Identifies the DHCP DISCOVER in hexa.
 */

#define DHCPDISCOVER_HEXA   "01"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP OFFER in string notation.
 */

#define DHCPOFFER_BYTE      "\x02"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP OFFER in hexa.
 */

#define DHCPOFFER_HEXA      "02"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP REQUEST in string notation.
 */

#define DHCPREQUEST_BYTE    "\x03"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP REQUEST in hexa.
 */

#define DHCPREQUEST_HEXA    "03"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP DECLINE in string notation.
 */

#define DHCPDECLINE_BYTE    "\x04"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP DECLINE in hexa.
 */

#define DHCPDECLINE_HEXA    "04"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP ACK in string notation.
 */

#define DHCPACK_BYTE        "\x05"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP ACK in hexa.
 */

#define DHCPACK_HEXA        "05"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP NACK in string notation.
 */

#define DHCPNAK_BYTE        "\x06"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP NACK in hexa.
 */

#define DHCPNAK_HEXA        "06"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP RELEASE in string notation.
 */

#define DHCPRELEASE_BYTE    "\x07"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP RELEASE in hexa.
 */

#define DHCPRELEASE_HEXA    "07"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP INFORM in string notation.
 */

#define DHCPINFORM_BYTE     "\x08"

/*! \brief Value for the option 53 (DHCP Message Type): dentifies the DHCP INFORM in hexa.
 */

#define DHCPINFORM_HEXA     "08"

/*! \brief Value for field 'op' of a DHCP packet. If 'op' is set to 'BOOTREQUEST', it means that the packet comes from the client
           (to the server).
 */

#define BOOTREQUEST 1

/*! \brief Value for field 'op' of a DHCP packet. If 'op' is set to 'BOOTREPLY', it means that the packet comes from the server
           (to the client).
 */ 

#define BOOTREPLY   2




#endif

#ifdef __cplusplus
}
#endif

packets_operations.h

/*! \file packets_operations.h
          Header file for the high level DHCP packet manipulation module (packets_operations.c).
 */


#ifdef __cplusplus
extern "C" {
#endif

#ifndef PACKETS_OPERATIONS_HEADER
#define PACKETS_OPERATIONS_HEADER

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#include "tables.h"
#include "packets.h" 
#include "logging.h"

/*! \brief This value defines a dynamic IP address (that should be tacken from the dynamic pool).
 */

#define DYNAMIC_IP  0

/*! \brief This value defines a static IP address (that should be tacken from the static pool).
 */

#define STATIC_IP   1


int packets_send_offer (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address);

int packets_send_ack (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address);

int packets_send_nack (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address);

int packets_send_dummy_nak (
                             struct dhcp_packet    *p,
                             struct mysql_tables   *mysql_tables,
                             char                  *ip,
                             unsigned long int     broadcast,
                             unsigned long int     server_ip,
                             int                   socket_desc,
                             struct sockaddr_in    *client_address);

int packets_send_dummy_ack (
                             struct dhcp_packet    *p,
                             struct mysql_tables   *mysql_tables,
                             char                  *dummy_ip,
                             unsigned long int     broadcast,
                             unsigned long int     server_ip,
                             int                   socket_desc,
                             struct sockaddr_in    *client_address);

int reply_to_inform (
                      struct dhcp_packet    *p,
                      struct mysql_tables   *mysql_tables,
                      unsigned long int     broadcast,
                      unsigned long int     server_ip,
                      int                   socket_desc,
                      struct sockaddr_in    *client_address);

int log_profile (const char *file, const char *mes, const struct opt *profile);

#endif

#ifdef __cplusplus
}
#endif

server_config.h

/*! \file server_config.h
          Header file for the logging module 'server_config.c'.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONFIG_HEADER
#define CONFIG_HEADER

  #include "config.h"


  /*! \brief Maximum number of characters for a file name.
   */

  #define FILE_NAME_SIZE     256

  /*! \brief Maximum number of characters for a host name (or IP address).
   */

  #define HOST_NAME_MAX_SIZE 256

  /*! \brief Maximum number of characters for an IP address.
   */

  #define MAX_IP_ADDRESS_STR_SIZE 16

  /*! \brief Maximum number of characters for user ID.
   */

  #define MAX_UID_SIZE 128

  /*! \brief Maximum number of characters for group ID.
   */

  #define MAX_GID_SIZE 128

  /*! \brief Maximum number of characters for the list of manufacturer's IDs.
   */

  #define MAX_MANUFACTURER_ID_LIST_SIZE 1024

  /*! \brief Maximum number of characters for a manufacturer's ID.
   */

  #define MAX_MANUFACTURER_ID_SIZE   128

  /*! \brief This structure contains the main server's configuration.
   */

  struct global_config
  {
    /*! \brief Some SQL functions requires a security delay. This delay assures that the operation has enough
               time to complete. This value represents the security delay for all SQL functions that requires
               this security. Functions are:
               <UL>
                   <LI>try_reserve_ip_from_pool
               </UL>
     */ 

    unsigned long int sql_expiration_security_delay;

    /*! \brief Path to the server's main log file.
     */ 

    char log_file[FILE_NAME_SIZE];

    /*! \brief Path to the server's CSV file.
     */

    char csv_file[FILE_NAME_SIZE];

    /*! \brief Path to the file used by the server to log incoming and outcomming DHCP packets.
               Only welle formated packets are logged.
     */

    char debug_file[FILE_NAME_SIZE];

    /*! \brief Path to the file used to synchronize access to the dump file.
     */

    char sync_dump[FILE_NAME_SIZE];

    /*! \brief This flag represents the verbosity level.
     */

    unsigned int debug;

    /*! \brief Path to the process' working directory.
     */ 

    char working_dir[FILE_NAME_SIZE];

    /*! \brief Host name (or IP address) associated to the network interface used by the DHCP server.
     */

    char dhcp_bind_ip[HOST_NAME_MAX_SIZE];

    /*! \brief Path to the process' PID file.
     */

    char pid_file[FILE_NAME_SIZE];

    /*! \brief Flag that tells the server wether it should log incoming and outcoming DHCP packets.
               Values could be:
                   <UL>
                      <LI>0: Do not log any packets.
                      <LI>1: Log all incoming and outcoming DHCP packets.
                      <LI>2: High verbosity debug.
                   </UL>
    */

    int dumper_mode;

    /*! \brief IP address of the DHCP server, as seen by the client.
     */

    char server_ip_seen_by_client[MAX_IP_ADDRESS_STR_SIZE];

    /*! \brief This flag defines whether the server uses broadcats for responses.
               <UL>
                 <LI>0: The server does not use broadcasts (always unicats).
                 <LI>1: The server always yse broadcats.
               </UL>
     */

    int broadcast_mode;

    /*! \brief Deamon's user ID.
     */

    char deamon_user_id[MAX_UID_SIZE];

    /*! \brief Deamon's group ID.
     */

    char deamon_group_id[MAX_GID_SIZE];

    /*! \brief IP address sent to the client whenever the DHCP can not respond.
     */

    char dummy_ip[MAX_IP_ADDRESS_STR_SIZE];

    /*! \brief This flag defines wether the server must manage the size of the log file.
     */

    int log_size_management;
  }; 


int configuration_load (char *path, char **error);
char *configuration_last_error();

#endif

#ifdef __cplusplus
}
#endif

sockets.h

/*! \file sockets.h
    Header file for socket management module (sockets.c).
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef SOCKETS_H
#define SOCKETS_H

#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/param.h>
#include <netdb.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <linux/if.h>
#include <linux/sockios.h>
#include <sys/ioctl.h>

#include "logging.h"   /* INT */

/*! \brief Maximum number of characters for an IP address (XXX.XXX.XXX.XXX), including the terminal zero.
 */ 

#define MAX_IP_ADDRESS_STR_SIZE   16

int create_socket (
                     int port,
                     struct sockaddr_in *add,
                     char *host,
                     char *interface,
                     int len,
                     unsigned long int *broadcast,
                     unsigned long int *netmask,
                     unsigned long int *myip
                  );

char *get_last_socket_error();
void get_remote_address (struct sockaddr_in *sender, char *ip, int *port);

#endif

#ifdef __cplusplus
}
#endif

tables.h

/*! \file tables.h
          Header that difines all the tables structure.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef TABLES_HEADER
#define TABLES_HEADER


/*! \brief Maximum number of characters for a radius login.
 */

#define LOGIN_RADIUS_SIZE 51

/*! \brief Maximum number of characters for a MyDns login = radius2mydns(login).
           You MUST set MYDNS_LOGIN_SIZE > 2*LOGIN_RADIUS_SIZE
 */

#define MYDNS_LOGIN_SIZE  128

/*! \brief Maximum number of characters for an IP address (XXX.XXX.XXX.XXX).
 */ 

#define IP_ADDRESS_STR_SIZE 16

/*! \brief Maximum number of characters for the optionnal profile ID.
 */

#define OPTIONNAL_PROFILE_SIZE 256

/*! \brief Maximum number of characters for the radius 'ACCT' identifier.
 */

#define ACCT_IDENTIFIER_SIZE 36

/*! \brief Maximum number of characters for the field 'NASIDENTIFIER' (RADONLINE).
 */

#define NASIDENTIFIER_SIZE  128

/*! \brief Maximum number of characters for a comment.
 */

#define COMMENT_SIZE 256

/*! \brief Maximum number of characters for a CIDR (XXX.XXX.XXX.XXX/N).

	#define CIDR_SIZE 256
 */

/*! \brief Size, in bytes, for the option's type.
 */

#define OPTION_TYPE_SIZE 20

/*! \brief Size, in bytes, for the option's value.
 */

#define OPTION_VALUE_SIZE 256

/*! \brief Maximum number of options for a DHCP packet's profile.
 */

#define MAX_PROFILE_OPTIONS 256

/*! \brief Size of the buffer used to store the field 'MAC_ADDRESS' of the table 'LOGISTIC_RADIUS'.
 */

#define LOGISTIC_MAC_ADDRESS_SIZE 256

/*! \brief Size of the buffer used to store the field 'RADIUS_LOGIN' of the table 'LOGISTIC_RADIUS'.
 */

#define LOGISTIC_RADIUS_LOGIN_SIZE 256

/*! \brief Size of the buffer used to store the field 'LOGIN_MODEM' of the table 'LOGISTIC_RADIUS'.
 */

#define LOGISTIC_LOGIN_MODEM_SIZE 256

/*! \brief Size of the buffer used to store the field 'LOGIN_MODEM' of the table 'RADONLINE'.
 */ 

#define LOGIN_MODEM_SIZE 128

/*! \brief Number of bytes used to represent a node ID.
    \remark <ul>
                <li>Alcatel's DSLAMs need up to 20 bytes to represent the node ID.
                <li>Utstarcom's DSLAMs need up to 5 bytes (maximum value is "65535" - unsigned shot int).
            </ul>
    \warning If you modify the value of this constant, you must also modify the value of the constant
             NODE_BUFFER_SIZE (see file "packets_data.h"). 
 */

#define NODE_ID_SIZE     20

/*! \brief Number of bytes used to represents a subnet (XXX.XXX.XXX.XXX/YYY = 3*5 + 4 + 1 = 20).
 */

#define SUBNET_SIZE      20

/*! \brief Number of bytes used to represents the radius identifiant.
 */

#define RADIUS_IDENTIFIANT_SIZE 256

/*! \brief This data structure represents the table 'abonnes'.
 */

struct table_abonnes
{
    /*! \brief Auto incremented ID. */

    unsigned long int      id;

    /*! \brief DSLAM's node ID. */

    char                   node[NODE_ID_SIZE];

    /*! \brief DSLAM's shelf number. */

    unsigned char          shelf;

    /*! \brief DSLAM's port number. */

    unsigned char          port;

    /*! \brief DSLAM's slot number. */

    unsigned char          slot;

    /*! \brief VCI's value. */ 

    unsigned int           vci;

    /*! \brief Client's radius login. */

    char                   login_radius[LOGIN_RADIUS_SIZE];

    /*! \brief Radius identifiant. */

    char                   radius_identifiant[RADIUS_IDENTIFIANT_SIZE];

    /*! \brief First connection flag. */

    unsigned char          first_connection;

    /*! \brief This flag is used if the client should be assigned a specific list of DHCP options.
               The value could be:
               <ul>
                   <li>standard: the used profile is the one stored in the field "standard_profile".
                   <li>autoconf_blackhole: the used profile is the one stored in the field "autoconf_blackhole_profile".
                   <li>blackhole: the used profile is the one stored in the field "blackhole_profile".
               </ul>
     */

    char                   profile[OPTIONNAL_PROFILE_SIZE];

    /*! \brief This profile represents the standard options (for SURF, IPTV, or other services).
     */
 
    char                   standard_profile[OPTIONNAL_PROFILE_SIZE];

    /*! \brief This profile represents the options for the auto-configuration blackhole.
     */

    char                   autoconf_blackhole_profile[OPTIONNAL_PROFILE_SIZE];

    /*! \brief This profile represents the standard blackhole.
     */

    char                   blackhole_profile[OPTIONNAL_PROFILE_SIZE]; 

    /*! \brief Field 'nack' of the table 'line'. 
               This flag is used to tell the DHCP to send a NAK.
     */

    unsigned long int     nack_flag;

    /*! \brief IP address to send to the client.
     */

    char                  ip[IP_ADDRESS_STR_SIZE];

    /*! \brief Network subnet ("X.X.X.X/Y").
     */

    char                  subnet[SUBNET_SIZE];

    /*! \brief String that will be sent to RADONLINE (field NASIDENTIFIER).
     */

    char                  nasidentifer[NASIDENTIFIER_SIZE];

    /*! \brief String that contains the gateway=function(CIDR,VCI).
        \warning This data is not part of the database! It is calculated.
     */

    char                  gateway[IP_ADDRESS_STR_SIZE];

    /*! \brief String that contains the network=function(CIDR).
        \warning This data is not part of the database! It is calculated.
     */

    char                  network[IP_ADDRESS_STR_SIZE];
};

/*! \brief This table represents the table 'options'.
 */

struct table_options
{
  /*! \brief "Auto incremented" ID. */

  unsigned long int      options_id;

  /*! \brief Profile's ID. */

  char                   profile_optionnel[OPTIONNAL_PROFILE_SIZE];

  /*! \brief Option's code. */

  unsigned char          option_code;

  /*! \brief Option's type. */

  char                   option_type[OPTION_TYPE_SIZE];

  /*! \brief Option's value. */

  char                   option_value[OPTION_VALUE_SIZE];

  /*! \brief Comment. */

  char                   comment[COMMENT_SIZE];
};

/*! \brief This structure represents the table 'LOGISTIC_RADIUS' of the database 'autoconf'.
 */

struct table_logistic_radius
{
  /*! \brief Field 'MAC_ADDRESS'. */

  char MAC_ADDRESS[LOGISTIC_MAC_ADDRESS_SIZE];

  /*! \brief Field 'RADIUS_LOGIN'. */

  char RADIUS_LOGIN[LOGISTIC_RADIUS_LOGIN_SIZE];

  /*! \brief Field 'LOGIN_MODEM'. */

  char LOGIN_MODEM[LOGISTIC_LOGIN_MODEM_SIZE];

  /*! \brief Field 'FLAG_CHECK_RADIUS'. */

  int FLAG_CHECK_RADIUS;

  /* -------------------------------------------------------- */
  /* The following fields are not part of the DB tables       */
  /* -------------------------------------------------------- */

  /*! \brief This field is not part of the table 'LOGISTIC_RADIUS'. But it will be used when
             the server update the Radonline database.
             If this string is not empty, then the Radonline ACCT_IDENTIFIER inserted in the 
             Radonline table will be the value of this string.
   */

  char radonline_acct_identifier[ACCT_IDENTIFIER_SIZE];

  /*! \brief This field is not part of the table 'LOGISTIC_RADIUS'. But it will be used when
             the server update the Radonline database.
             If this string is not empty, then the USERNAME inserted in the Radonline table
             will be the value of this string.
   */

  char radonline_user_name[LOGIN_RADIUS_SIZE];

  /*! \brief This field is not part of the table 'LOGISTIC_RADIUS'. But it will be used when
             the server update the Radonline database.
             If this string is not empty, then the LOGIN_MODEM inserted in the Radonline table
             will be the value of this string.
   */

  char login_modem[LOGISTIC_LOGIN_MODEM_SIZE];

  /*! \brief This field is not part of the table 'LOGISTIC_RADIUS'.
             This fields identifies the modem's manufacturor.
   */

  int modem_manufacturor;
};

/*! \brief This structure contains all the database description.
 */

struct mysql_tables
{
  /*! \brief Table 'line'. */

  struct table_abonnes abonnes;

  /*! \brief Table 'options'. */

  struct table_options options[MAX_PROFILE_OPTIONS];

  /*! \brief Table 'logistic'. */

  struct table_logistic_radius logistic;

  /*! \brief Number of elements in the array of options (field 'options').
   */

  int option_number;
};

#endif

#ifdef __cplusplus
}
#endif

Les fichiers C et Flex

config.c

/*! \file config.c
          Configuration parser interface.
 */

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <dlfcn.h>
#include "chtbl.h"

#define PRIVATE_CODE_ONLY
#include "config.h"
#undef PRIVATE_CODE_ONLY

/*! \brief Number of characters for the buffer used to store the last error message.
 */

#define CONFIG_H_ERROR_SIZE 2048

/*! \brief Buffer that contains the last error message.
 */

static char last_error[CONFIG_H_ERROR_SIZE];

/*! \brief Return the last error message.
    \author Denis BEURIVE
    \return The function returns a zero terminated, statically allocated, string of characters that represents the last
            error message.
 */

char* conf_get_last_error() { return last_error; }

/*! \brief This flag indicates wether the memory allocated for the hash table is freed or not.
 */

static int allochtab = 0;

/*! \brief Hash function used by the hash table module.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

int config_hash_function (const void *key)
{
  struct user_data *data;
  int              index, i;

  data = (struct user_data*)key;
  index = 0;

  for (i=0; i<strlen(data->tag); i++) { index *= (int)(data->tag[i]); }

  if (index < 0) { index *= - 1; }

  return index;
}

/*! \brief Function used to free allocated memory in the hash table.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

void config_free_user_data (void *d)
{
  struct user_data *data;

  data = (struct user_data*)d;
  free (data->tag);
  free (data->value);
  free (data);

  return;
}

/*! \brief Function used to compare 2 elements in the hash table.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

int config_compare_user_data (const void *d1, const void *d2)
{
  struct user_data *data1, *data2;

  data1 = (struct user_data*)d1;
  data2 = (struct user_data*)d2;

  return !strcmp(data1->tag, data2->tag);
}

/*! \brief Handler to the hash table.
 */

CHTbl htab;

/*! \brief This array contains the modems' configuration.
           The first record is associated with the default configuration.
 */

struct modem_conf_struct modem_configuration_list[MODEM_CONF_MAX_ENTRY];

/*! \brief This array contains the VCIs' configuration.
 */

struct vci_conf_struct vci_configuration_list[VCI_CONF_MAX_ENTRY];

/*! \brief Number of configured modems. This integer represents the number of records in the array
           "modem_configuration_list".
 */

int nb_modem;

/*! \brief Number of configured VCI. This integer represents the number of records in the array
           "vci_configuration_list".
 */

int nb_vci;

/*! \brief Return the number of records in the modems' configuration file.
    \author Denis BEURIVE
    \return The function returns the number of modems' configuration records.
 */

int get_number_of_modem_conf() { return nb_modem; } 

/*! \brief Return the number of records in the VCI's configuration file.
    \author Denis BEURIVE
    \return The function returns the number of VCI's configuration records.
 */

int get_number_of_vci_conf() { return nb_vci; }

/*! \brief Dummy MAC address calculator.
    \author Denis BEURIVE
    \param addr Pointer to a zero terminated string of characters that represents the original MAC address.
    \return The function returns a pointer to a zero terminated, statically allocated, string of characters. This
            string contains a copy of the original MAC address.
    \remark Make sure that the buffer "mac" is big enough.
 */

char* dummy_mac_processor (char* addr)
{
  static char mac[128];

  memset((void*)mac, 0, 128);
  strncpy (mac, addr, 127);
  return mac;
}

/*! \brief Flex generated parser.
 */

extern int configlex();

/*! \brief Flex input file descriptor.
 */

extern FILE *configin;

/*! \brief Load a given configuration file.
    \author Denis BEURIVE
    \param path Path to the configuration file to load.
    \param err Pointer to an integer that will be used to store the value of 'errno' if an error occured.
    \return Upon successful completion, the function returns tha value PARSE_CONFIGURATION_OK.
            Otherwise the function may return one of the following values:
            <UL>
               <LI>PARSE_CONFIGURATION_NO_MEM: Could not allocate memory.
               <LI>PARSE_CONFIGURATION_FILE_NOT_FOUND: Could not open configuration file. "errno' is set. 
               <LI>PARSE_CONFIGURATION_SYNTAX_ERROR: Syntax error in configuration file.
               <LI>PARSE_CONFIGURATION_DUPLICATED_TAG: Configuration contains a duplicated tag.
               <LI>PARSE_CONFIGURATION_DLL_OPEN_ERROR: Could not load DLL.
               <LI>PARSE_CONFIGURATION_DLL_INVALID: DLL is not valid.
               <LI>PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID: Modem's configuration record is not valid.
               <LI>PARSE_CONFIGURATION_VCI_CONF_NOT_VALID: VCI configuration is not valid.
               <LI>PARSE_CONFIGURATION_OK: Success.
            </UL>
    \warning <UL>
               <LI>If the returned value is PARSE_CONFIGURATION_NO_MEM, the module does not free
                   allocated memory. You should abort the program.
               <LI>If the returned value is PARSE_CONFIGURATION_FILE_NOT_FOUND, PARSE_CONFIGURATION_SYNTAX_ERROR,
                   PARSE_CONFIGURATION_DUPLICATED_TAG, PARSE_CONFIGURATION_DLL_OPEN_ERROR,
                   PARSE_CONFIGURATION_DLL_INVALID, PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID, 
                   PARSE_CONFIGURATION_VCI_CONF_NOT_VALID, the module free all allocated memory.
             </UL>
    \remark In case you think that the same DLL is loaded multiple times, consider this:
            Only a single copy of an shared library file is brought into the address space, even if dlopen is
            invoked multiple times in reference to the file, and even if different pathnames are used to reference
            the file. 
 */

int parse_configuration_file (char *path, int *err)
{
  int rc, i;

  *err   = 0;

  memset((void*)last_error, 0, CONFIG_H_ERROR_SIZE);

  memset ((void*)&modem_configuration_list, 0, sizeof(struct modem_conf_struct)*MODEM_CONF_MAX_ENTRY);

  modem_configuration_list[0].id = 0;
  strncpy (modem_configuration_list[0].identifier, "XXXXXX",   MODEM_CONF_IDENTIFIER_SIZE-1);
  strncpy (modem_configuration_list[0].vci,        "00",       VCI_CONF_IDENTIFIER_SIZE-1);
  strncpy (modem_configuration_list[0].tag_name,   "UNKNOWN",  MODEM_CONF_TAG_NAME_SIZE-1);
  strncpy (modem_configuration_list[0].autoconf,   "no",       MODEM_CONF_AUTOCONF_SIZE-1);
  strncpy (modem_configuration_list[0].action,     "dummy",    MODEM_CONF_ACTION_SIZE-1);
  modem_configuration_list[0].dll = NULL;
  modem_configuration_list[0].calculate_mac_address = dummy_mac_processor;

  nb_modem = 1;
  nb_vci   = 0;

  /* ------------------------------------------------ */
  /* Initialize the hash table                        */
  /* ------------------------------------------------ */

  if (
       chtbl_init (
                    &htab,
                    10,
                    config_hash_function,
                    config_compare_user_data,
                    config_free_user_data
                  ) == -1
     )
  { return PARSE_CONFIGURATION_NO_MEM; }

  allochtab = 1;
 
  /* ------------------------------------------------ */
  /* Parse configuration file                         */
  /* ------------------------------------------------ */

  configin = fopen (path, "r");
  if (configin == NULL) { *err = errno; return PARSE_CONFIGURATION_FILE_NOT_FOUND; }

  rc = configlex();
  switch (rc)
  {
    case CONF_PARSER_SYNTAX_ERROR:              free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_SYNTAX_ERROR; 
    case CONF_PARSER_DUPLICATED_TAG:            free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_DUPLICATED_TAG;
    case CONF_PARSER_NO_MEM:                    fclose (configin);
                                                return PARSE_CONFIGURATION_NO_MEM;
    case CONF_PARSER_MODEM_IDENTIFIER_TOO_LONG: free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_MODEM_VCI_TOO_LONG:        free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID; 
    case CONF_PARSER_MODEM_TAG_NAME_TOO_LONG:   free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_MODEM_AUTOCONF_TOO_LONG:   free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_MODEM_ACTION_TOO_LONG:     free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_MODEM_TOO_MANY_ENTRIES:    free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_VCI_TOO_MANY_ENTRIES:      free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_VCI_CONF_NOT_VALID;
    case CONF_PARSER_VCI_ID_TOO_LONG:           free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_VCI_CONF_NOT_VALID;
    case CONF_PARSER_VCI_TAG_NAME_TOO_LONG:     free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_VCI_CONF_NOT_VALID;
    case CONF_PARSER_VCI_ACTION_TOO_LONG:       free_all_configuration_data();
                                                fclose (configin);
                                                return PARSE_CONFIGURATION_VCI_CONF_NOT_VALID;
  }

  fclose (configin);

  /* ------------------------------------------------ */
  /* Load all plugins                                 */
  /* ------------------------------------------------ */

  for (i=1; i<get_number_of_modem_conf(); i++)
  {
    if (strcasecmp(modem_configuration_list[i].action, "dummy") == 0)
    { modem_configuration_list[i].calculate_mac_address = dummy_mac_processor; }
    else {
           modem_configuration_list[i].dll = dlopen (modem_configuration_list[i].action, RTLD_LAZY);
           if (modem_configuration_list[i].dll == NULL)
           {
             if (dlerror() != NULL) { strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1); }
             free_all_configuration_data();
             return PARSE_CONFIGURATION_DLL_OPEN_ERROR;
           }

           modem_configuration_list[i].calculate_mac_address = dlsym (modem_configuration_list[i].dll, "calculate_mac");
           if (dlerror() != NULL) {
                                    strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1);
                                    free_all_configuration_data();
                                    return PARSE_CONFIGURATION_DLL_INVALID;
                                  }
         }

  }

  for (i=0; i<get_number_of_vci_conf(); i++)
  {
     vci_configuration_list[i].dll = dlopen (vci_configuration_list[i].action, RTLD_LAZY);
     if (vci_configuration_list[i].dll == NULL)
     {
        if (dlerror() != NULL) { strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1); }
        free_all_configuration_data();
        return PARSE_CONFIGURATION_DLL_OPEN_ERROR;
     }

     vci_configuration_list[i].calculate_gateway = dlsym (vci_configuration_list[i].dll, "calculate_gateway");
     if (dlerror() != NULL) {
                              strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1);
                              free_all_configuration_data();
                              return PARSE_CONFIGURATION_DLL_INVALID;
                            }

     vci_configuration_list[i].calculate_network = dlsym (vci_configuration_list[i].dll, "calculate_network");
     if (dlerror() != NULL) {
                              strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1);
                              free_all_configuration_data();
                              return PARSE_CONFIGURATION_DLL_INVALID;
                            }
  }

  return PARSE_CONFIGURATION_OK;
}

/*! \brief Returns the ID of a given MAC address.
    \author Denis BEURIVE
    \param mac Pointer to a zero terminated string of characters that represents the modem's MAC address.
    \param vci VCI value as extracted from the DHCP packet.
    \return The function returns a integer that represents the modem's ID.
 */

int modem_conf_get_id (char *mac, unsigned short int vci)
{
  int   i;
  char  svci[32];

  memset ((void*)svci, 32, 0);
  snprintf (svci, 32, "%u", vci);

  for (i=0; i<get_number_of_modem_conf(); i++)
  { 
    if (
         (strncmp(modem_configuration_list[i].identifier, mac, 6) == 0)
         &&
         (strcmp(modem_configuration_list[i].vci, svci) == 0)
       )
    { return i; }
  }

  return 0;
}

/*! \brief Returns the ID of a given VCI.
    \author Denis BEURIVE
    \param vci Value of the VCI.
    \return The function returns a integer that represents the VCI's ID.
            If the function can not find the specified VCI, it returns the value -1.
 */

int vci_conf_get_id (unsigned int vci)
{
  int  i;
  char svci[VCI_CONF_IDENTIFIER_SIZE];

  memset ((void*)svci, 0, VCI_CONF_IDENTIFIER_SIZE);
  snprintf (svci, VCI_CONF_IDENTIFIER_SIZE, "%u", vci);

  for (i=0; i<get_number_of_vci_conf(); i++)
  { if (strcmp(vci_configuration_list[i].identifier, svci) == 0) { return i; } }

  return -1;
}

/*! \brief Returns the tag name associated with a given modem configuration entry.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a zero terminated string of characters that represents the tag name.
 */

char* modem_conf_get_tag_name (int id) { return modem_configuration_list[id].tag_name; }

/*! \brief Returns the VCI associated with a given modem configuration entry.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a zero terminated string of characters that represents the VCI number.
 */

char* modem_conf_get_vci (int id) { return modem_configuration_list[id].vci; }

/*! \brief Returns the tag name of a given VCI, representd by its ID.
    \author Denis BEURIVE
    \param id ID of the VCI (as returned by the function vci_conf_get_id()).
    \return The function returns a pointer to a zero terminated string of characters that represents the tag name.
 */

char* vci_conf_get_tag_name (int id) { return vci_configuration_list[id].tag_name; }

/*! \brief Returns the MyDns flag associated with the given VCI.
    \author Denis BEURIVE
    \param id ID of the VCI (as returned by the function vci_conf_get_id()).
    \return The function returns an integer that indicates if MyDns should be updated.
            Value can be 1 (update MyDns) or 0.
 */

int vci_update_mydns (int id) { return vci_configuration_list[id].mydns; }

/*! \brief Returns the Radonline flag associated with the given VCI.
    \author Denis BEURIVE
    \param id ID of the VCI (as returned by the function vci_conf_get_id()).
    \return The function returns an integer that indicates if Radonline should be updated.
            Value can be 1 (update Radonline) or 0.
 */

int vci_update_radonline (int id) { return vci_configuration_list[id].radonline; }

/*! \brief Returns a value that indicates if a given modem supports auto-configuration.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns one of the following values:
            <UL>
                <li>1: The modem supports auto-configuration.
                <li>0: The modem does not support auto-configuration.
            </UL>
 */

int modem_conf_is_autoconf (int id)
{
  if (strcasecmp (modem_configuration_list[id].autoconf, "yes") == 0) { return 1; }
  return 0;
}

/*! \brief Returns the MAC processor for a given MAC address.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a function used to calculate the new MAC address.
 */

void* modem_conf_get_function (int id)
{
  return modem_configuration_list[id].calculate_mac_address;
}

/*! \brief Returns a pointer to the function used to calculate the gateway associated to the VCI.
    \author Denis BEURIVE
    \param id ID of the VCI (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a function used to calculate the VCI's gateway.
 */

void* vci_conf_get_gateway_calculator (int id)
{
  return vci_configuration_list[id].calculate_gateway;
}

/*! \brief Returns a pointer to the function used to calculate the network associated to the VCI.
    \author Denis BEURIVE
    \param id ID of the VCI (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a function used to calculate the VCI's network.
 */

void* vci_conf_get_network_calculator (int id)
{
  return vci_configuration_list[id].calculate_network;
}

/*! \brief Free all data allocated for the hash table.
    \author Denis BEURIVE
 */

void free_all_configuration_data() { if (allochtab == 1) { chtbl_destroy (&htab); allochtab = 0; } }

/*! \brief Return the value associated with a given tag.
    \author Denis BEURIVE
    \param tag Pointer to a zero terminated string of characters that represents the tag to look for.
    \param value Pointer that will point to the corresponding value (if the tag was found).
    \return <UL>
              <LI>If the tag could not be find, the function returns the value 0. 'value' is NULL.
              <LI>If the tag has been found, the function returns the value 1.
              <LI>If the function ran out of memory, the function returns the value -1. 'value' is NULL.
            </UL> 
 */

int get_value (char *tag, char **value)
{
  struct user_data *ud, sud;
  int              cr, retval;

  /* ------------------------------------------------ */
  /* Initialise values                                */
  /* ------------------------------------------------ */

  *value  = NULL;
  retval  = 0;
 
  /* ------------------------------------------------ */
  /* Prepare user data for lookup                     */
  /* ------------------------------------------------ */

  sud.tag   = tag;
  sud.value = NULL;

  ud = &sud;

  /* ------------------------------------------------ */
  /* Lookup hash table                                */
  /* ------------------------------------------------ */

  cr = chtbl_lookup (&htab, (void**)&ud);

  if (cr == 0) { retval = 1; *value = ud->value; }

  return retval;
}

config.lex

%{

#include <stdio.h>
#include <string.h>
#include "strings_utils.h"
#include "chtbl.h"

#define PRIVATE_CODE_ONLY
#include "config.h"
#include "logging.h"
#undef PRIVATE_CODE_ONLY



int configwrap() { return 1; }



static struct fields    fd;
static int              n;
static struct user_data *ud;
extern CHTbl htab;
extern int nb_modem;
extern int nb_vci;
extern struct modem_conf_struct modem_configuration_list[MODEM_CONF_MAX_ENTRY];
extern struct vci_conf_struct   vci_configuration_list[VCI_CONF_MAX_ENTRY];

%}

SPACE         \x20
TABUL         \t
BLANK         [\x20\t]
NUMBER        [0-9]
INTEGER       {NUMBER}+
BLANK_LINE    ^{BLANK}+\n
COMMENT       ^{BLANK}*#.+\n
EMPTY_LINE    ^\n

LEVELS        FULL_VERBOSE|VERBOSE|DEBUG|INFO|WARNING|ERROR|FATAL
RESPONSE      yes|no
TERMINAL      &{BLANK}*TERMINAL{BLANK}*
TAG           [0-9a-zA-Z\-_]+
CONF          ^{TAG}{BLANK}*=.+$

IDENTIFIER    [0-9A-F]{6}
TAG_NAME      [A-Za-z0-9_\-\.]+
AUTOCONF      (yes|no)
ACTION        [A-Za-z0-9\/_\-\.]+

%%


^VCI{SPACE}+{NUMBER}{1,6}{SPACE}+{TAG_NAME}{SPACE}+{ACTION}{SPACE}+{RESPONSE}{SPACE}+{RESPONSE}{SPACE}*$ {

  int i;

  if (nb_vci > VCI_CONF_MAX_ENTRY) { return CONF_PARSER_VCI_TOO_MANY_ENTRIES; }

  /* --------------------------------------------- */
  /* Split the line (separator is "blank")         */
  /* --------------------------------------------- */

  n = s_split (yytext, " ", &fd);
  if (n == -1) { return CONF_PARSER_NO_MEM; }

  if (n != 6) { return CONF_PARSER_SYNTAX_ERROR; }

  /* --------------------------------------------- */
  /* Remove spaces                                 */
  /* --------------------------------------------- */

  for (i=0; i<n; i++) { if (chop(fd.tabs[i]) == NULL) { return CONF_PARSER_NO_MEM; } }

  /* --------------------------------------------- */
  /* Add the element to the list                   */
  /* --------------------------------------------- */

  if (strlen(fd.tabs[1]) >= VCI_CONF_IDENTIFIER_SIZE) { return CONF_PARSER_VCI_ID_TOO_LONG;   }
  if (strlen(fd.tabs[2]) >= VCI_CONF_TAG_NAME_SIZE)   { return CONF_PARSER_VCI_TAG_NAME_TOO_LONG;   }
  if (strlen(fd.tabs[3]) >= VCI_CONF_ACTION_SIZE)     { return CONF_PARSER_VCI_ACTION_TOO_LONG;     }

  strcpy (vci_configuration_list[nb_vci].identifier, fd.tabs[1]);
  strcpy (vci_configuration_list[nb_vci].tag_name,   fd.tabs[2]);
  strcpy (vci_configuration_list[nb_vci].action,     fd.tabs[3]);

  if (strcmp(fd.tabs[4], "yes") == 0) { vci_configuration_list[nb_vci].mydns = 1; }
  else                                { vci_configuration_list[nb_vci].mydns = 0; }

  if (strcmp(fd.tabs[5], "yes") == 0) { vci_configuration_list[nb_vci].radonline = 1; }
  else                                { vci_configuration_list[nb_vci].radonline = 0; }

  vci_configuration_list[nb_vci].dll                 = NULL;
  vci_configuration_list[nb_vci].calculate_gateway   = NULL;
  vci_configuration_list[nb_vci].calculate_network   = NULL;

  /* --------------------------------------------- */
  /* One more VCI has been hadded                  */
  /* --------------------------------------------- */

  vci_configuration_list[nb_vci].id = nb_vci;

  nb_vci += 1;
}

^{IDENTIFIER}{SPACE}+{NUMBER}{1,6}{SPACE}+{TAG_NAME}{SPACE}+{AUTOCONF}{SPACE}+{ACTION}{SPACE}*$ {

  int i;

  if (nb_modem >= MODEM_CONF_MAX_ENTRY) { return CONF_PARSER_MODEM_TOO_MANY_ENTRIES; }

  /* --------------------------------------------- */
  /* Split the line (separator is "blank")         */
  /* --------------------------------------------- */

  n = s_split (yytext, " ", &fd);
  if (n == -1) { return CONF_PARSER_NO_MEM; }

  if (n != 5) { return CONF_PARSER_SYNTAX_ERROR; }

  /* --------------------------------------------- */
  /* Remove spaces                                 */
  /* --------------------------------------------- */

  for (i=0; i<n; i++) { if (chop(fd.tabs[i]) == NULL) { return CONF_PARSER_NO_MEM; } }

  /* --------------------------------------------- */
  /* Add the element to the list                   */
  /* --------------------------------------------- */

  if (strlen(fd.tabs[0]) >= MODEM_CONF_IDENTIFIER_SIZE) { return CONF_PARSER_MODEM_IDENTIFIER_TOO_LONG; }
  if (strlen(fd.tabs[1]) >= VCI_CONF_IDENTIFIER_SIZE)   { return CONF_PARSER_MODEM_VCI_TOO_LONG;        }
  if (strlen(fd.tabs[2]) >= MODEM_CONF_TAG_NAME_SIZE)   { return CONF_PARSER_MODEM_TAG_NAME_TOO_LONG;   }
  if (strlen(fd.tabs[3]) >= MODEM_CONF_AUTOCONF_SIZE)   { return CONF_PARSER_MODEM_AUTOCONF_TOO_LONG;   }
  if (strlen(fd.tabs[4]) >= MODEM_CONF_ACTION_SIZE)     { return CONF_PARSER_MODEM_ACTION_TOO_LONG;     }

  strcpy (modem_configuration_list[nb_modem].identifier, fd.tabs[0]);
  strcpy (modem_configuration_list[nb_modem].vci,        fd.tabs[1]);
  strcpy (modem_configuration_list[nb_modem].tag_name,   fd.tabs[2]);
  strcpy (modem_configuration_list[nb_modem].autoconf,   fd.tabs[3]);
  strcpy (modem_configuration_list[nb_modem].action,     fd.tabs[4]);

  modem_configuration_list[nb_modem].dll                   = NULL;
  modem_configuration_list[nb_modem].calculate_mac_address = NULL;

  /* --------------------------------------------- */
  /* One more modem has been hadded                */
  /* --------------------------------------------- */

  modem_configuration_list[nb_modem].id = nb_modem;

  nb_modem += 1;
}

^debug-level{BLANK}*={BLANK}*{LEVELS}{BLANK}*&{BLANK}*(TERMINAL|ALL){BLANK}*$ {

               char           data[256];
               unsigned int   terminal, level;
               unsigned char  val[4];         /* ___MUST___ BE sizeof(unsigned int) !!!!! */

               memset ((void*)data, 0, 256); 

               /* ---------------------------------------------- */
               /* Split couple (tag = value)                     */
               /* ---------------------------------------------- */

               n = s_split_exact (yytext, "=", &fd);
               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (fd.number_of_fields != 2) { return CONF_PARSER_SYNTAX_ERROR; }

               /* ---------------------------------------------- */
               /* Remove spaces and copy the value into data     */
               /* ---------------------------------------------- */

               if (chop(fd.tabs[0]) == NULL) { return CONF_PARSER_NO_MEM; }
               if (chop(fd.tabs[1]) == NULL) { return CONF_PARSER_NO_MEM; }

               strncpy (data, fd.tabs[1], 256-1);

               free_fields(&fd);

               /* ---------------------------------------------- */
               /* Split again the value                          */
               /* ---------------------------------------------- */

               n = s_split_exact (data, "&", &fd);
               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (fd.number_of_fields != 2) { return CONF_PARSER_SYNTAX_ERROR; }

               if (chop(fd.tabs[0]) == NULL) { return CONF_PARSER_NO_MEM; }
               if (chop(fd.tabs[1]) == NULL) { return CONF_PARSER_NO_MEM; }

               if (strcmp (fd.tabs[1], "TERMINAL") == 0) { terminal = ENDING_ONLY; }
               else                                      { terminal = 0x0;         }

               level = 0;
               if (strcmp(fd.tabs[0], "FULL_VERBOSE") == 0) { level = LEVEL_FULL_VERBOSE; }
               if (strcmp(fd.tabs[0], "VERBOSE")      == 0) { level = LEVEL_VERBOSE;      }
               if (strcmp(fd.tabs[0], "DEBUG")        == 0) { level = LEVEL_DEBUG;        }
               if (strcmp(fd.tabs[0], "INFO")         == 0) { level = LEVEL_INFO;         }
               if (strcmp(fd.tabs[0], "WARNING")      == 0) { level = LEVEL_WARNING;      }
               if (strcmp(fd.tabs[0], "ERROR")        == 0) { level = LEVEL_ERROR;        }
               if (strcmp(fd.tabs[0], "FATAL")        == 0) { level = LEVEL_FATAL;        }

               free_fields(&fd);

               if (level == 0) { return CONF_PARSER_SYNTAX_ERROR; }
               level = level | terminal;

               /* ---------------------------------------------- */
               /* Allocate hash table element                    */
               /* ---------------------------------------------- */

               ud = malloc(sizeof(struct user_data));
               if (ud == NULL) { return CONF_PARSER_NO_MEM; }

               ud->tag = malloc(strlen("debug-level")+1);
               if (ud->tag == NULL) { return CONF_PARSER_NO_MEM; }

               ud->value = malloc(sizeof(unsigned int));
               if (ud->value == NULL) { return CONF_PARSER_NO_MEM; }

               /* ---------------------------------------------- */
               /* Set hash table element                         */
               /* ---------------------------------------------- */

               strcpy (ud->tag, "debug-level");

               val[0] = (level >> 24) & 0x000000FF;
               val[1] = (level >> 16) & 0x000000FF;
               val[2] = (level >> 8)  & 0x000000FF;
               val[3] = level         & 0x000000FF;

               memcpy ((void*)ud->value, (void*)val, 4);

               /* ---------------------------------------------- */
               /* Add element to the hash                        */
               /* ---------------------------------------------- */

               n = chtbl_insert (&htab, (void*)ud);

               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (n ==  1) { return CONF_PARSER_DUPLICATED_TAG; }
}

{CONF}       {
               /* ---------------------------------------------- */
               /* Split couple (tag = value)                     */
               /* ---------------------------------------------- */

               n = s_split_exact (yytext, "=", &fd); 
               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (fd.number_of_fields != 2) { return CONF_PARSER_SYNTAX_ERROR; }

               /* ---------------------------------------------- */
               /* Remove spaces                                  */
               /* ---------------------------------------------- */

               if (chop(fd.tabs[0]) == NULL) { return CONF_PARSER_NO_MEM; }
               if (chop(fd.tabs[1]) == NULL) { return CONF_PARSER_NO_MEM; }

               /* ---------------------------------------------- */
               /* debug-level should be rejected here (see       */
               /* previous rule).                                */
               /* ---------------------------------------------- */

               if (strcmp (fd.tabs[0], "debug-level") == 0) { return CONF_PARSER_SYNTAX_ERROR; }

               /* ---------------------------------------------- */
               /* Allocate hash table element                    */
               /* ---------------------------------------------- */

               ud = malloc(sizeof(struct user_data));
               if (ud == NULL) { return CONF_PARSER_NO_MEM; }

               ud->tag = malloc(strlen(fd.tabs[0])+1);
               if (ud->tag == NULL) { return CONF_PARSER_NO_MEM; }

               ud->value = malloc(strlen(fd.tabs[1])+1);
               if (ud->value == NULL) { return CONF_PARSER_NO_MEM; }

               /* ---------------------------------------------- */
               /* Set hash table element                         */
               /* ---------------------------------------------- */

               strcpy (ud->tag,   fd.tabs[0]);
               strcpy (ud->value, fd.tabs[1]);

               free_fields(&fd);

               /* ---------------------------------------------- */
               /* Add element to the hash                        */
               /* ---------------------------------------------- */

               n = chtbl_insert (&htab, (void*)ud);

               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (n ==  1) { return CONF_PARSER_DUPLICATED_TAG; } 
             }


{BLANK_LINE} {  }
{EMPTY_LINE} {  }
{COMMENT}    {  }
\n           {  }
.*           { return CONF_PARSER_SYNTAX_ERROR; }

%%

configuration.c

/*! \file configuration.c
    This file implements the configuration loader.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "server_config.h"
#include "strings_utils.h"

/*! \brief Maximum number of characters for the error message associated with the error message.
 */

#define CONFIGURATION_ERROR_SIZE 4096

/*! \brief Global DHCP configuration handler.
 */

struct global_config configuration_globale;

/*! \brief Buffer used to store the last error message.
 */

static char last_error[CONFIGURATION_ERROR_SIZE];

/*! \brief return a pointer to a zero terminated string of characters that represents the last
           error message.
    \author Denis BEURIVE
    \warning The string is returned in a statically allocated buffer, which subsequent calls
             will overwrite.
 */

char *configuration_last_error() { return last_error; }

/*! \author Denis BEURIVE
    \brief Load the DHCP server configuration from a given file.
    \param path Pointer to a zero terminated string of characters that represents the path to the
                configuration file to load.
    \param error pointer to a pointer that will point to the error message if an error occured.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int configuration_load (char *path, char **error)
{
  int           res, e, rc;
  char          *value;
  unsigned char cint[4];
  unsigned int  vint;

  /* -------------------------------------------------- */
  /* Initialize variables                               */
  /* -------------------------------------------------- */

  memset ((void*)last_error, 0, CONFIGURATION_ERROR_SIZE);
  *error = last_error;

  /* -------------------------------------------------- */
  /* Load the configuration file into memory            */
  /* -------------------------------------------------- */

  rc = parse_configuration_file (path, &e);
  if (rc != PARSE_CONFIGURATION_OK)
  {
    switch (rc)
    {
      case PARSE_CONFIGURATION_NO_MEM:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - Could not allocate memory!",
                        path); 
           }; break;
      case PARSE_CONFIGURATION_FILE_NOT_FOUND:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - %s",
                        path, strerror(e));
           }; break;
      case PARSE_CONFIGURATION_SYNTAX_ERROR:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - Found syntax error.",
                        path);
           }; break;
      case PARSE_CONFIGURATION_DUPLICATED_TAG:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - Duplicated tag found.",
                        path);
           }; break;
      case PARSE_CONFIGURATION_DLL_OPEN_ERROR:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - Could not open DLL. %s.",
                        path, conf_get_last_error());
           }; break;
      case PARSE_CONFIGURATION_DLL_INVALID:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - DLL is not valid. %s.",
                        path, conf_get_last_error());
           }; break;
      case PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - Modem's configuration is not valid.",
                        path);
           }; break;
      case PARSE_CONFIGURATION_VCI_CONF_NOT_VALID:
           {
              snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                        "Could not load the configuration file <%s> - VCI's configuration is not valid.",
                        path);
           }; break;
    } 

    return 1;   
  }

  /* -------------------------------------------------- */
  /* Check configuration                                */
  /* -------------------------------------------------- */

    /* --- */

  res = get_value ("sql-expiration-security-delay", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'sql-expiration-security-delay' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'sql-expiration-security-delay'",
             path);

    return 1;
  }

  configuration_globale.sql_expiration_security_delay = atoi(value);

    /* --- */

  res = get_value ("log-file", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'log-file' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'log-file'",
             path);

    return 1;
  }

  if (strlen(value) >= FILE_NAME_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'log-file' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.log_file, value);

    /* --- */

  res = get_value ("csv-file", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'csv-file' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'csv-file'",
             path);

    return 1;
  }

  if (strlen(value) >= FILE_NAME_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'csv-file' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.csv_file, value);

    /* --- */

  res = get_value ("dumper-file", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'dumper-file' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'dumper-file'",
             path);

    return 1;
  }

  if (strlen(value) >= FILE_NAME_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'dumper-file' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.debug_file, value);

    /* --- */

  res = get_value ("deamon-working-directory", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'deamon-working-directory' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'deamon-working-directory'",
             path);

    return 1;
  }

  if (strlen(value) >= FILE_NAME_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'deamon-working-directory' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.working_dir, value);

    /* --- */

  res = get_value ("bind-ip", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'bind-ip' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'bind-ip'",
             path);

    return 1;
  }

  if (strlen(value) >= HOST_NAME_MAX_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'bind-ip' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.dhcp_bind_ip, value);

    /* --- */

  res = get_value ("debug-level", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'debug-level' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'debug-level'",
             path);

    return 1;
  }

  cint[0] = (unsigned char)*value;
  cint[1] = (unsigned char)*(value+1);
  cint[2] = (unsigned char)*(value+2);
  cint[3] = (unsigned char)*(value+3);

  vint = (cint[0] << 24) | (cint[1] << 16) | (cint[2] << 8) | cint[3];

  configuration_globale.debug =  vint;

    /* --- */

  res = get_value ("activate-logfile-size-support", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'activate-logfile-size-support' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'activate-logfile-size-support'",
             path);

    return 1;
  }

  if (strcmp(value, "yes") == 0) { configuration_globale.log_size_management = 1; }
  else                           { configuration_globale.log_size_management = 0; } 

    /* --- */

  res = get_value ("pid-file", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'pid-file' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'pid-file'",
             path);

    return 1;
  }

  if (strlen(value) >= HOST_NAME_MAX_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'pid-file' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.pid_file, value);

    /* --- */

  res = get_value ("dumper-mode", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'dumper-mode' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'dumper-mode'",
             path);

    return 1;
  }

  configuration_globale.dumper_mode = -1;

  if (strcasecmp(value, "no")     == 0) { configuration_globale.dumper_mode = 0; }
  if (strcasecmp(value, "normal") == 0) { configuration_globale.dumper_mode = 1; }
  if (strcasecmp(value, "total")  == 0) { configuration_globale.dumper_mode = 2; } 

  if (configuration_globale.dumper_mode == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: Invalid value for tag 'dumper-mode' (%s) - possible values are 'no', 'normal' or 'total'",
              path,
              value);
  }

    /* --- */

  res = get_value ("server-ip-address-as-seen-by-client", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'server-ip-address-as-seen-by-client' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'server-ip-address-as-seen-by-client'",
             path);

    return 1;
  }

  if (strlen(value) >= MAX_IP_ADDRESS_STR_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'server-ip-address-as-seen-by-client' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.server_ip_seen_by_client, value);

    /* --- */

  res = get_value ("enable-broadcast-responses", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'enable-broadcast-responses' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'enable-broadcast-responses'",
             path);

    return 1;
  }


  if (strcasecmp(value, "yes") == 0)
  { configuration_globale.broadcast_mode = 1; }
  else {
         if (strcasecmp(value, "no") == 0)
         { configuration_globale.broadcast_mode = 0; }
         else {
                snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
                          "<%s>: Invalid value for tag 'broadcast_mode' (%s) - possible values are ('yes' or 'no' - no matter the case)",
                          path,
                          value);
              }
       }

    /* --- */

  res = get_value ("deamon-user-id", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'deamon-user-id' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'deamon-user-id'",
             path);

    return 1;
  }

  if (strlen(value) >= MAX_UID_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'deamon-user-id' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.deamon_user_id, value);

    /* --- */

  res = get_value ("deamon-group-id", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'deamon-group-id' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'deamon-group-id'",
             path);

    return 1;
  }

  if (strlen(value) >= MAX_GID_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'deamon-group-id' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.deamon_group_id, value);

    /* --- */

  res = get_value ("dummy-ip-address", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'dummy-ip-address' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'dummy-ip-address'",
             path);

    return 1;
  }

  if (strlen(value) >= MAX_IP_ADDRESS_STR_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'dummy-ip-address' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.dummy_ip, value);

    /* --- */

  res = get_value ("sync-dump-file", &value);

  if (res == 0)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
              "<%s>: tag 'sync-dump-file' is missing",
              path);

    return 1;
  }

  if (res == -1)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Unexpected error while checking tag 'sync-dump-file'",
             path);

    return 1;
  }

  if (strlen(value) >= FILE_NAME_SIZE)
  {
    snprintf (last_error, CONFIGURATION_ERROR_SIZE-1,
             "<%s>: Tag 'sync-dump-file' is too long (buffer overflow avoided!)",
             path);

    return 1;
  }

  strcpy (configuration_globale.sync_dump, value);



  return 0;
}

conversion.c

/*! \file conversion.c
    This file contains various functions for converting data from one format to another.
 */

#include "logging.h"
#include "conversion.h"








/*! \brief Convert an integer (between 0 and 15 included) into the corresponding hexa character (from 0 to F).
    \author Denis BEURIVE
    \param c Integer value to convert (between 0 and 15 included).
    \return The function returns the corresponding hexa character.
 */

char int_to_char (unsigned char c)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling int_to_char(%u).",
             c);

  switch (c)
  {
    case 0:  return '0';
    case 1:  return '1';
    case 2:  return '2';
    case 3:  return '3';
    case 4:  return '4';
    case 5:  return '5';
    case 6:  return '6';
    case 7:  return '7';
    case 8:  return '8';
    case 9:  return '9';
    case 10: return 'A';
    case 11: return 'B';
    case 12: return 'C';
    case 13: return 'D';
    case 14: return 'E';
    case 15: return 'F';
  }

  return 0;
}

/*! \brief Convert a given hexa character (from '0' to 'F') into the corresponding integer value
           (from 0 to 15 included).
    \author Denis BEURIVE
    \param c Hexa character to convert (from '0' to 'F'). Note the c could be [0-9a-fA-F].
    \return The function returns the corresponding integer value.
 */

unsigned char char_to_int (char c)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling char_to_int(%c).",
             c);

  switch (c)
  {
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;

    case 'A': return 10;
    case 'B': return 11;
    case 'C': return 12;
    case 'D': return 13;
    case 'E': return 14;
    case 'F': return 15;

    case 'a': return 10;
    case 'b': return 11;
    case 'c': return 12;
    case 'd': return 13;
    case 'e': return 14;
    case 'f': return 15;
  }

  return 0xFF;
}

/*! \brief Convert a hardware address in standard ':' notation into its RAW representation.
    \author Denis BEURIVE
    \param haddr Pointer to a zero terminated string of characters that represents the hardware address in
           standard ':' notation.
    \param length Pointer to an integer that will be used to store the size (in bytes) of the RAW representation.
    \return Upon successful completion, the function returns a pointer to the RAW representation.
            The value pointed by 'lenght' is the number of bytes of the representation.
            Otherwize, the function returns the value NULL.
    \warning <UL>
               <LI>The buffer (which contains the RAW representation) is returned in a statically allocated
                   buffer,
                   which subsequent calls will overwrite. Do not try to free it!
               <LI>The maximum lenth for the RAW representation is 16 bytes.
             </UL>
 */

unsigned char* haddr_to_hexa (char *haddr, int *length)
{
  int                  len, hex, i;
  static unsigned char hexa[17];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling haddr_to_hexa(%s).",
             haddr);



  memset ((void*)hexa, 0, 17);
  len = strlen(haddr) + 1;

  if ((len % 3) != 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "haddr_to_hexa: Strlen(%s) not multiple of 3!",
               haddr);
    return NULL;
  }

  hex = len / 3;

  if (hex >= *length)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "haddr_to_hexa: String \"%s\" is too long! (strlen(%s)=%d!)",
               haddr,
               haddr,
               len);
    return NULL;
  }

  *length = hex;

  for (i=0; i<hex; i++) { hexa[i] = (char_to_int(haddr[3*i]) << 4) | char_to_int(haddr[3*i+1]); }

  return hexa;
}

/*! \brief Convert IP address in standard numbers-and-dots notation into binary data
           (4 bytes in network byte order).
    \author Denis BEURIVE
    \param ip Pointer to a zero terminated string of characters that represents the IP address to convert.
    \return The function returns the binary representation of the IP address (in network byte order).
 */

unsigned long int get_network_ip (char *ip)
{
  struct in_addr inp;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_network_ip(%s).",
             ip);

  inet_aton (ip, &inp);
  return inp.s_addr;
}

/*! \brief Convert IP address in binary representation (4 bytes in network byte order)
           into standard numbers-and-dots notation.
    \author Denis BEURIVE
    \param ip Binary representation of the IP address to convert (4 bytes in network byte order).
    \return The function returns a zero terminated string that represents the IP address in standard
            numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
             Do not try to free it!
 */

char *get_doted_ip (unsigned long int ip)
{
  struct in_addr     add;
  static char        sip[16];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_doted_ip(%X).",
             ip);

  add.s_addr = ip;
  memset ((void*)sip, 0, 16);
  strncpy (sip, inet_ntoa(add), 15);
  return sip;
}

/*! \brief Convert a list of RAW IP addresses (4 bytes in network IP order) into a string representation
           (standard numbers-and-dots notation separated by characters ':').
    \author Denis BEURIVE
    \param buffin Input buffer that contains the list of RAW IP addresses.
    \param buffout Output buffer that will receive the string representation.
    \param lenin Size (in bytes) in the input buffer.
    \param lenout Size (in bytes) in the output buffer.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int raw_ips_to_string (unsigned char *buffin, char *buffout, int lenin, int lenout)
{
  unsigned long int *ip;
  int               nip, i;
  char              *sip;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling raw_ips_to_string().");

  memset ((void*)buffout, 0, lenout);

  if (lenin % 4 != 0) { return 1; }
  nip = lenin / 4;

  if (lenout < 16 * nip) { return 1; }

  ip = (unsigned long int*)buffin;

  for (i=0; i<nip; i++)
  {
    sip = get_doted_ip (*ip);
    strcat (buffout, sip);
    if (i != nip-1) { strcat (buffout, ":"); }
    ip += 1;  
  } 

  return 0;
}

/*! \brief Convert a list of UINT32 into a succession of 4 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of UINT32
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 4 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value. Otherwize,
            the function returns the value -1.
            If success, the returned value represents the number of UINT32.
    \remark If an error occured, look at the log file.
 */

int uint32_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned long int   v;
  int                 n, i, err;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling uint32_to_network_byte_order(%s).",
             buffer_in);

  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  my_syslog (
              LEVEL_FULL_VERBOSE,
              TERMINAL_LEVEL,
              __FILE__,
              __LINE__,
              "uint32_to_network_byte_order(): Calling s_split(\"%s\", \":\").", buffer_in);

  n = s_split(buffer_in, ":", &fd);

  my_syslog (
              LEVEL_FULL_VERBOSE,
              TERMINAL_LEVEL,
              __FILE__,
              __LINE__,
              "uint32_to_network_byte_order(): s_split return value is %d.", n);

  if (n == -1)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "uint32_to_network_byte_order(): Could not allocate memory! (this should not happen).");
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "uint32_to_network_byte_order(): No value to convert (this should not happen).");
    return 0;
  }

  my_syslog (
              LEVEL_VERBOSE,
              TERMINAL_LEVEL,
              __FILE__,
              __LINE__,
              "Number of integer to convert is %d.",
              n);

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 4 bytes          */
  /* ---------------------------------------------------- */

  if (n*4 > len_out)
  {
    free_fields(&fd);

    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "uint32_to_network_byte_order(): Size of ouput buffer is too short! (this should not happen) %d > %d.",
                n*4,
                len_out);
    return -1;
  } 

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 4 bytes                  */
  /* ---------------------------------------------------- */
 
  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = string2unsigned_int (fd.tabs[i], &err);
    if (err)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "uint32_to_network_byte_order(): Invalid integer (%s) (this should not happen).",
                 fd.tabs[i]);
      n -= 1;
      continue;
    }

    v = htonl (v);

    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "uint32_to_network_byte_order(%s) = %X.",
               fd.tabs[i],
               v);

    memcpy ((void*)pt_out, (void*)&v, 4);
    pt_out += 4;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert a list of IP addresses into a succession of 4 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of IP addresses
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 4 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value. Otherwize,
            the function returns the value -1.
            If success, the returned value represents the number of IP addresses.
    \remark If an error occured, look at the log file.
 */

int ip_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned long int   v;
  int                 n, i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling ip_to_network_byte_order(%s).",
             buffer_in);

  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  n = s_split(buffer_in, ":", &fd);
  if (n == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "ip_to_network_byte_order(): Could not allocate memory! (this should not happen)");
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "ip_to_network_byte_order(): No value to convert! (this should not happen)");
    return 0;
  }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "ip_to_network_byte_order(): Number of IP addresses to convert is %d.",
             n);

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 4 bytes          */
  /* ---------------------------------------------------- */

  if (n*4 > len_out)
  {
    free_fields(&fd);

    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "ip_to_network_byte_order(): Size of ouput buffer is too short! (this should not happen) %d > %d.",
               n*4,
               len_out);
    return -1;
  }

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 4 bytes                  */
  /* ---------------------------------------------------- */

  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = get_network_ip (fd.tabs[i]);
    memcpy ((void*)pt_out, (void*)&v, 4);

    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "%s => %X.",
               fd.tabs[i],
               v);
    pt_out += 4;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert hexa representation into bytes.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents a succession of bytes in hexa.
    \param buffer_out Pointer to a buffer that will receive the binary representation.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of bytes.
    \remark If an error occured, look at the log file.
 */

int hexa_to_binary (char *buffer_in, char *buffer_out, int len_out)
{
  int    len_in, i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling ip_to_network_byte_order(%s).",
             buffer_in);

  len_in = strlen(buffer_in);

  /* ---------------------------------------------------- */
  /* Sanity check                                         */
  /* Note: 2 hexa characters represent 1 byte.            */
  /* ---------------------------------------------------- */

  if (len_in == 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "hexa_to_binary(): No value to convert (this might bo OK).");
    return 0;
  }

  if (len_in % 2 != 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "hexa_to_binary(): Invalid size for input buffer - %d not multiple of 2 (this should not happen).",
               len_in);
    return -1;
  }

  if (len_in/2 > len_out)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "hexa_to_binary(): Size of output buffer is too short - %d > %d (this should not happen).",
               len_in/2,
               len_out);
    return -1;
  }

  /* ---------------------------------------------------- */
  /* Convert couples of hexa characters into binary       */ 
  /* ---------------------------------------------------- */

  memset ((void*)buffer_out, 0, len_out);

  for (i=0; i<len_in/2; i++) { buffer_out[i] = (char_to_int(buffer_in[2*i]) << 4) | char_to_int(buffer_in[2*i+1]); }

  return len_in/2;
}

/*! \brief Convert ASCII representation into bytes.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents a succession of bytes in ASCII.
    \param buffer_out Pointer to a buffer that will receive the binary representation.
    \param len_in Size, in bytes, of the buffer buffer_in.
           <UL>
               <LI>If you set the value of len_in to 0, then the function will consider the exact size
                   of the zero terminated string pointed by buffer_in. In other words, len_in will be set
                   to strlen(buffer_in).
               <LI>If you set the value of len_in to any positive value, then the function will consider
                   the exact number of characters specified by len_in. This feature can be used to add the
                   terminal zero.
           </UL> 
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of bytes.
    \remark If an error occured, look at the log file.
 */

int ascii_to_binary (char *buffer_in, char *buffer_out, int len_in, int len_out)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling ascii_to_binary(<some ASCII data>).");


  if (len_in <= 0) { len_in = strlen(buffer_in); }

  /* ---------------------------------------------------- */
  /* Sanity check                                         */
  /* ---------------------------------------------------- */

  if (len_in == 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "ascii_to_binary(): No value to convert (this might be OK).");
    return 0;
  }

  if (len_in >= len_out)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "ascii_to_binary(): Size of output buffer is too short - %d > %d (this should not happen).",
               len_in,
               len_out);
    return -1;
  }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "\"%s\" => %d bytes.",
             buffer_in,
             len_in);


  /* ---------------------------------------------------- */
  /* Convert couples of hexa characters into binary       */
  /* ---------------------------------------------------- */

  memset ((void*)buffer_out, 0, len_out);
  memcpy ((void*)buffer_out, buffer_in, len_in);

  return len_in;
}


/*! \brief Convert a list of UINT16 into a succession of 2 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of UINT16
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 2 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of UINT16.
    \remark If an error occured, look at the log file.
 */

int uint16_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned short int  v;
  int                 n, i, err;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling uint16_to_network_byte_order(%s).",
             buffer_in);


  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  n = s_split(buffer_in, ":", &fd);
  if (n == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "uint16_to_network_byte_order(): Could not allocate memory!");
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "uint16_to_network_byte_order(): No value to convert (this might happen).");
    return 0;
  }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Number of UINT16 to convert is %d.",
             n);

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 2 bytes          */
  /* ---------------------------------------------------- */

  if (n*2 > len_out)
  {
    free_fields(&fd);
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "uint16_to_network_byte_order(): Size of ouput buffer is too short - %d > %d (this should not happen).",
               n*2,
               len_out);
    return -1;
  }

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 2 bytes                  */
  /* ---------------------------------------------------- */

  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = (unsigned short int) ((string2unsigned_int (fd.tabs[i], &err)) & 0x0000FFFF);
    v = htons(v);
    memcpy ((void*)pt_out, (void*)&v, 2);

    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "%s => %d",
               fd.tabs[i],
               v);

    pt_out += 2;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert a radius login into mydns ID. The conversion is :
           <ul>
 	     <li>s/-/--/g
 	     <li>s/@/-a/g
 	     <li>s/\./-p/g
 	     <li>s/_/-u/g
 	     <li>s/[^a-zA-Z0-9-]/-n/g
             <li>Keep only the 63 first characters.
           </ul>
    \author Denis BEURIVE
    \param radius Pointer to a zero terminated string of characters that represents the radius login to
                  convert into MyDns ID.
    \param mydns Pointer to a memory buffer used to store the converted radius login.
    \param mydns_size Number of bytes reserved for the buffer pointed by 'mydns'.
    \remark Make sure that the size of 'mydns' is long enough. You should have:
            mydns_size > 2*strlen(radius)
    
 */

void radius2mydns (char *radius, char *mydns, int mydns_size)
{
  char c;
  int  i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling radius2mydns(%s).",
             radius);

  memset ((void*)mydns, 0, mydns_size);

  for (i=0; i<strlen(radius); i++)
  {
    c = radius[i];

    switch (c)
    {
      case '-': strcat  (mydns, "--"); break;
      case '@': strcat  (mydns, ".");  break;
      case '_': strcat  (mydns, "-."); break;
      default : strncat (mydns, radius+i, 1);
    }
  }
}

dhcp.c

/*! \file dhcp.c
    Main entry point for the DHCP server.
 */


#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>



#include "dhcp.h"
#include "modem.h"
#include "sockets.h"
#include "ack_codes.h"
#include "server_config.h"
#include "mysql_header.h"
#include "mysql_interface.h"
#include "logging.h"
#include "deamon.h"
#include "logistic.h"
#include "packets_data.h"
#include "conversion.h"
#include "packets.h"
#include "find_ip_and_reply.h"
#include "packets_operations.h"


/*! \brief Last MySql error message. This variable is defined in the file 'mysql.c'.
 */

extern char mysql_error_str[MYSQL_MAX_ERROR_SIZE];

/*! \brief Last MySql error code. This variable is defined in the file 'mysql.c'.
 */

extern int mysql_error_errno;

/*! \brief This structure contains the global server configuration.
           It is defined in the C file 'configuration.c'.
 */

extern struct global_config configuration_globale;

/*! \brief This structure contains the configuration for the connection to the local DHCP database.
           This database is access only for READ operations.
 */

static struct smysql conf_mysql_dhcp_read_only;

/*! \brief This structure contains the configuration for the connection to the Radonline database.
 */

static struct smysql conf_mysql_radonline;

/*! \brief This structure contains the configuration for the connection to the Mydns database.
 */

static struct smysql conf_mysql_mydns;

/*! \brief This structure contains the configuration for the connection to the Logistic database.
 */

static struct smysql conf_mysql_logistic;

/*! \brief This array contains the configuration tags associated to the local DHCP database
           (read only database).
 */

static char *tags_read[MYSQL_CONFIGURATION_TAG_NUMBER] =
       {
         "mysql-host-dhcp",
         "mysql-user-dhcp",
         "mysql-passwd-dhcp",
         "mysql-db-dhcp",
         "mysql-port-dhcp",
         "mysql-socket-dhcp",
         "mysql-retry-dhcp",
         "mysql-timeout-dhcp",
         "mysql-sleep-dhcp",
         "mysql-reconnection-delay-dhcp"
       };

/*! \brief This array contains the configuration tags associated to the radonline database.
 */

static char *tags_radonline[MYSQL_CONFIGURATION_TAG_NUMBER] =
       {
         "mysql-host-radonline",
         "mysql-user-radonline",
         "mysql-passwd-radonline",
         "mysql-db-radonline",
         "mysql-port-radonline",
         "mysql-socket-radonline",
         "mysql-retry-radonline",
         "mysql-timeout-radonline",
         "mysql-sleep-radonline",
         "mysql-reconnection-delay-radonline"
       };

/*! \brief This array contains the configuration tags associated to the mydns database.
 */

static char *tags_mydns[MYSQL_CONFIGURATION_TAG_NUMBER] =
       {
         "mysql-host-mydns",
         "mysql-user-mydns",
         "mysql-passwd-mydns",
         "mysql-db-mydns",
         "mysql-port-mydns",
         "mysql-socket-mydns",
         "mysql-retry-mydns",
         "mysql-timeout-mydns",
         "mysql-sleep-mydns",
         "mysql-reconnection-delay-mydns"
       };

/*! \brief This array contains the configuration tags associated to the Logistic database.
 */

static char *tags_logistic[MYSQL_CONFIGURATION_TAG_NUMBER] =
       {
         "mysql-host-logistic",
         "mysql-user-logistic",
         "mysql-passwd-logistic",
         "mysql-db-logistic",
         "mysql-port-logistic",
         "mysql-socket-logistic",
         "mysql-retry-logistic",
         "mysql-timeout-logistic",
         "mysql-sleep-logistic",
         "mysql-reconnection-delay-logistic"
       };

/*! \brief Build information. The tags __DATE__ and __HOST__ will be replaced by the output of commands
           'date' and 'uname -a'.
 */

#define BUILD "This binary was build the __DATE__ on __HOST__"

/*! \brief CVS tags for all sources.
 */

#define CVS_TAGS "__CVSTAGS__"

/*! \brief Maximum size for the log file (if the size management is activated).
 */

#define MAXLOGSIZE 1048576

/*! \brief Maximum number of characters used to store the prefix.
 */

#define LOGPREFIX_SIZE 512

/*! \brief Pointer to the buffer used to store the log prefix.
 */

static char logprefix[LOGPREFIX_SIZE];


static void dump_packet_hexa (void* packet, int size, char* file);

/*! \brief File descriptor associated to the file used to synchronize access to the dump file.
 */

int dump_sync_fd = 0;

/*! \brief Main entry point for the DHCP server.
    \author Denis BEURIVE
 */

int main (int argc, char **argv)
{
  int                    sck, mess_size, adress_size, rc;
  struct dhcp_packet     packet_in;
  char                   interface[IFNAMSIZ], *error;
  struct sockaddr_in     addr_server, addr_original;
  unsigned long int      broadcast, netmask, server_ip;
  FILE                   *pid_file;
  pid_t                  pid;
  struct passwd          *passwords;
  struct group           *groups;
  gid_t                  grp_id;
  uid_t                  user_id;
  struct mysql_tables    mysql_tables;
  int                    modem_manufacturor;


  fprintf (stdout, "%s\n\n", BUILD);
  fprintf (stdout, "%s\n\n", CVS_TAGS);

  /* ------------------------------------------------ */
  /* Check the command line                           */
  /* ------------------------------------------------ */

  if (argc != 2)
  {
    fprintf (stderr, "Usage: mydhcpd <path to configuration file>\n");
    fprintf (stderr, "       Log tag is [session ID] [mac address] [DSLAM's ID]\n");
    fprintf (stderr, "       session ID: Refers to a client's request.\n");
    fprintf (stderr, "       mac address: Mac address sent by the modem.\n");
    fprintf (stderr, "       DSLAM's ID: node/shelf/slot/port/vci/vlanID/gateway.\n\n");
    fprintf (stderr, "       CSV structure is:\n\n");

    fprintf (stderr, "       1  Date\n");
    fprintf (stderr, "       2  Auto increment\n");
    fprintf (stderr, "       3  Host name\n");
    fprintf (stderr, "       4  Direction (IN or OUT)\n");
    fprintf (stderr, "       5  Sender's IP address (if direction is IN)\n");
    fprintf (stderr, "       6  Sender's TCP port (if direction is IN)\n");
    fprintf (stderr, "       7  Receiver's IP address (if direction is OUT)\n");
    fprintf (stderr, "       8  Receiver's TCP port (if direction is OUT)\n");
    fprintf (stderr, "       9  Type of DHCP request\n");
    fprintf (stderr, "       10 Number of bytes of the UDP packet\n");
    fprintf (stderr, "       11 Opcode\n");
    fprintf (stderr, "       12 Hardware address type\n");
    fprintf (stderr, "       13 Hardware address length\n");
    fprintf (stderr, "       14 Hop count\n");
    fprintf (stderr, "       15 Transaction ID\n");
    fprintf (stderr, "       16 Ellapsed time\n");
    fprintf (stderr, "       17 Flags\n");
    fprintf (stderr, "       18 Client's IP address, as defined in the DHCP packet\n");
    fprintf (stderr, "       19 Your IP address, as defined in the DHCP packet\n"); 
    fprintf (stderr, "       20 Server IP address, as defined in the DHCP packet\n");
    fprintf (stderr, "       21 Gateway IP address, as defined in the DHCP packet\n");
    fprintf (stderr, "       22 Client's hardware address\n"); 
    fprintf (stderr, "       23 Server's host name\n");
    fprintf (stderr, "       24 Boot file name\n");
    fprintf (stderr, "       25 Modem's constructor\n");
    fprintf (stderr, "       26 82\n");
    fprintf (stderr, "       27 vendor ID\n");
    fprintf (stderr, "       28 port type\n");
    fprintf (stderr, "       29 version\n");
    fprintf (stderr, "       30 vlan ID\n");
    fprintf (stderr, "       31 nas mac\n");
    fprintf (stderr, "       32 nas IP\n");
    fprintf (stderr, "       33 node ID\n");
    fprintf (stderr, "       34 shelf\n");
    fprintf (stderr, "       35 slot\n");
    fprintf (stderr, "       36 port\n");
    fprintf (stderr, "       37 VPI\n");
    fprintf (stderr, "       38 VCI\n");
    fprintf (stderr, "       39 vendor\n");
    fprintf (stderr, "       40 Subnet (option 1)\n");
    fprintf (stderr, "       41 Router (option 3)\n");
    fprintf (stderr, "       42 Domain name (option 15)\n");
    fprintf (stderr, "       43 DNS (option 6)\n");
    fprintf (stderr, "       44 Option code|Literal description|Option value\n");
    fprintf (stderr, "       45 Option code|Literal description|Option value\n");
    fprintf (stderr, "       ...\n\n");
    return 1;
  }

  /* ------------------------------------------------ */
  /* Load configuration file                          */
  /* ------------------------------------------------ */

  if (configuration_load (argv[1], &error) == 1)
  {
    fprintf (stderr, "[FATAL] %s\n", error);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Test access to the log file                      */
  /* ------------------------------------------------ */

  memset ((void*)logprefix, 0, LOGPREFIX_SIZE);
  snprintf (logprefix, LOGPREFIX_SIZE, "-");

  if (configuration_globale.log_size_management == 0)
  {
    logger_init (0,
                 logprefix,
                 configuration_globale.debug,
                 configuration_globale.log_file);
  } else {
           logger_init (MAXLOGSIZE,
                        logprefix,
                        configuration_globale.debug,
                        configuration_globale.log_file);
         }
  
  if (my_syslog (
                 LEVEL_INFO,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Starting MyDhcp server (%s)",
                 BUILD) == 1)
  {
    fprintf (stderr, "[FATAL] Could not access my log file <%s> : %s\n",
             configuration_globale.log_file,
             logger_get_last_logger_error());
    return 1;
  }

  /* ------------------------------------------------ */
  /* Give access to anybody for all logs              */
  /* ------------------------------------------------ */

  if (chmod(configuration_globale.log_file, S_IROTH | S_IWOTH | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1)
  {
    fprintf (stderr, "[FATAL] Could not change access rights for log file <%s>. Please check permissions\n",
             configuration_globale.log_file);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not change access rights for log file <%s>. Please check permissions.",
               configuration_globale.log_file);
    return 1;
  }

  if (access (configuration_globale.debug_file, F_OK) == 0)
  {
    if (chmod(configuration_globale.debug_file, S_IROTH | S_IWOTH | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1)
    {
      fprintf (stderr, "[FATAL] Could not change access rights for dumper file <%s>. Please check permissions\n",
               configuration_globale.debug_file);
      my_syslog (
                 LEVEL_FATAL,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Could not change access rights for dumper file <%s>. Please check permissions",
                 configuration_globale.debug_file);
      return 1;
    }
  }

  /* ------------------------------------------------ */
  /* Open synchronization files, create if necessary  */
  /* ------------------------------------------------ */

  dump_sync_fd = -1;

  if (strcmp (configuration_globale.sync_dump, "Desactivate synchronisation") != 0)
  {
      my_syslog (
                 LEVEL_INFO,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Get synchronization file <%s> for dump access",
                 configuration_globale.sync_dump);
     
     dump_sync_fd = open (configuration_globale.sync_dump, O_CREAT);
   
     if (dump_sync_fd == -1)
     {
       fprintf (stderr, "[FATAL] Could not open sybchronization gile (%s) for dump access.",
                configuration_globale.sync_dump);
       my_syslog (
                  LEVEL_FATAL,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Could not open synchronization file <%s> for dump access.",
                  configuration_globale.sync_dump);
       return 1;
     }
  }

  /* ------------------------------------------------ */
  /* Convert symbolic UID and GID into system IDs     */
  /* ------------------------------------------------ */

  passwords = getpwnam (configuration_globale.deamon_user_id);

  if (passwords == NULL)
  {
    fprintf (stderr, "[FATAL] Could not find UNIX user <%s> into /etc/passwd! Make sure that this UNIX user exists\n",
                     configuration_globale.deamon_user_id);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not find UNIX user <%s> into /etc/passwd! Make sure that this UNIX user exists",
               configuration_globale.deamon_user_id);
    return 1;
  }

  groups = getgrnam (configuration_globale.deamon_group_id);

  if (groups == NULL)
  {
    fprintf (stderr, "[FATAL] Could not find group <%s> into /etc/group!",
                     configuration_globale.deamon_group_id);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not find group <%s> into /etc/group!",
               configuration_globale.deamon_group_id);
    return 1;
  }

  grp_id   = groups->gr_gid;
  user_id  = passwords->pw_uid;

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "User \"%s\" -> %d and Group \"%s\" -> %d.",
             configuration_globale.deamon_user_id,
             (int)user_id,
             configuration_globale.deamon_group_id,
             (int)grp_id);

  /* ------------------------------------------------ */
  /* Some security tests                              */
  /* ------------------------------------------------ */

  if (configuration_globale.dumper_mode == 2)
  {
    fprintf (stdout, "WARNING: You selected 'dumper-mode = total' in configuration file '%s'.\n", argv[1]);
    fprintf (stdout, "The server will __NOT__ respond to any incoming request.\n");
    fprintf (stdout, "Is it realy what you want ?\n\n");

    fprintf (stdout, "ALERTE: Vous avez selectionne 'dumper-mode = total' dans le fichier de configuration '%s'",
                     argv[1]);
    fprintf (stdout, "Le server ne repondra __PAS__ aux requetes en provenances des clients.\n");
    fprintf (stdout, "Est-ce vraiment ce que vous voulez?\n\n");
  }

  /* ------------------------------------------------ */
  /* Create socket                                    */
  /* ------------------------------------------------ */

  sck = create_socket (
                        SERVER_PORT,
                        &addr_server,
                        configuration_globale.dhcp_bind_ip,
                        interface,
                        IFNAMSIZ,
                        &broadcast,
                        &netmask,
                        &server_ip);

  if (sck == -1)
  {
    fprintf (stderr, "[FATAL] %s\n", get_last_socket_error());
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "%s",
               get_last_socket_error());
    return 1;
  }

  /* ------------------------------------------------ */
  /* Load configuration for the connection to the     */
  /* local DHCP database (READ only).                 */
  /* ------------------------------------------------ */

  rc = load_mysql_configuration_from_file (argv[1], &conf_mysql_dhcp_read_only, tags_read);

  if (rc)
  {
    fprintf (stderr, "[FATAL] Error while loading configuration for local DHCP database connection - %s",
                     conf_mysql_dhcp_read_only.last_error_str);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not load configuration for local DHCP database connection - %s",
               conf_mysql_dhcp_read_only.last_error_str);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Load configuration for the connection to the     */
  /* radonline database.                              */
  /* ------------------------------------------------ */

  rc = load_mysql_configuration_from_file (argv[1], &conf_mysql_radonline, tags_radonline);

  if (rc)
  {
    fprintf (stderr, "[FATAL] Error while loading configuration for connection to Radonline - %s",
                     conf_mysql_radonline.last_error_str);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not load configuration for connection to Radonline - %s",
               conf_mysql_radonline.last_error_str);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Load configuration for the connection to the     */
  /* mydns database.                                  */
  /* ------------------------------------------------ */

  rc = load_mysql_configuration_from_file (argv[1], &conf_mysql_mydns, tags_mydns);

  if (rc)
  {
    fprintf (stderr, "[FATAL] Error while loading configuration for connection to Mydns - %s",
                     conf_mysql_mydns.last_error_str);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not load configuration for connection to Mydns - %s",
               conf_mysql_mydns.last_error_str);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Load configuration for the Logistic database.    */
  /* ------------------------------------------------ */

  rc = load_mysql_configuration_from_file (argv[1], &conf_mysql_logistic, tags_logistic);
 
  if (rc)
  {
    fprintf (stderr, "[FATAL] Error while loading configuration for connection to Logistic - %s",
                     conf_mysql_logistic.last_error_str);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not load configuration for connection to Mydns - %s",
               conf_mysql_logistic.last_error_str);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Connect to local DHCP database                   */
  /* ------------------------------------------------ */

  init_mysql_structure (&conf_mysql_dhcp_read_only);

  rc = connect_to_mysql (&conf_mysql_dhcp_read_only);

  if (rc != 0)
  {
    fprintf (stderr, "[FATAL] Could not connect to local DHCP database - %s (%d).\n",
             conf_mysql_dhcp_read_only.last_error_str,
             conf_mysql_dhcp_read_only.last_error_int);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not connect to local DHCP database - %s (%d).",
               conf_mysql_dhcp_read_only.last_error_str,
               conf_mysql_dhcp_read_only.last_error_int);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Connect to Radonline database                    */
  /* ------------------------------------------------ */

  init_mysql_structure (&conf_mysql_radonline);

  rc = connect_to_mysql (&conf_mysql_radonline);

  if (rc != 0)
  {
    fprintf (stderr, "[FATAL] Could not connect to Radonline database - %s (%d).\n",
             conf_mysql_radonline.last_error_str,
             conf_mysql_radonline.last_error_int);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not connect to Radonline database - %s (%d).",
               conf_mysql_radonline.last_error_str,
               conf_mysql_radonline.last_error_int);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Connect to MyDns database                        */
  /* ------------------------------------------------ */

  init_mysql_structure (&conf_mysql_mydns);

  rc = connect_to_mysql (&conf_mysql_mydns);

  if (rc != 0)
  {
    fprintf (stderr, "[FATAL] Could not connect to Mydns database - %s (%d).\n",
             conf_mysql_mydns.last_error_str,
             conf_mysql_mydns.last_error_int);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not connect to Mydns database - %s (%d).",
               conf_mysql_mydns.last_error_str,
               conf_mysql_mydns.last_error_int);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Connect to Logistic database                     */
  /* ------------------------------------------------ */

  init_mysql_structure (&conf_mysql_logistic);
  
  rc = connect_to_mysql (&conf_mysql_logistic);
  
  if (rc != 0)
  {
    fprintf (stderr, "[FATAL] Could not connect to Logistic database - %s (%d).\n",
             conf_mysql_logistic.last_error_str,
             conf_mysql_logistic.last_error_int);
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not connect to Logistic database - %s (%d).",
               conf_mysql_mydns.last_error_str,
               conf_mysql_mydns.last_error_int);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Turn into deamon now                             */
  /* ------------------------------------------------ */

  rc = deamonizer (&pid, configuration_globale.working_dir);

  if (pid < 0)
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not fork! The system may run out of resources!");
    return 1;
  }

  if (pid > 0)
  {
    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Father: PID of my child is %d.",
               (int)pid);
    return 0;
  }

  if (rc == 1)
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Can not become a deamon (should never happen).");
    return 1;
  }

  /* ------------------------------------------------ */
  /* Change user into deamon user                     */
  /* ------------------------------------------------ */

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Change group ID to %s (%d) (Make sure the server is started as 'root' user).",
             configuration_globale.deamon_group_id,
             (int)grp_id);

  if (setgid(grp_id) == -1)
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not change GID to %d (%s) (Make sure the server is started as 'root' user).",
               (int)grp_id,
               configuration_globale.deamon_group_id);
    return 1;
  }

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__, 
             "Change user ID to %s (%d) (Make sure the server is started as 'root' user).",
             configuration_globale.deamon_user_id,
             (int)user_id);

  if (setuid(user_id) == -1)
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not change UID to %d (%s) (Make sure the server is started as 'root' user).",
               (int)user_id,
               configuration_globale.deamon_user_id);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Create PID file                                  */
  /* ------------------------------------------------ */

  if (access (configuration_globale.pid_file, F_OK) == 0)
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "PID file <%s> already exists, abort. The server should be running. Please check.",
               configuration_globale.pid_file);
    return 1;
  }

  pid_file = fopen (configuration_globale.pid_file, "w");

  if (pid_file == NULL)
  {
    int e = errno;
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not create my PID file '%s' - %s (check file permissions).",
               configuration_globale.pid_file, strerror(e));
    return 1;
  }

  fprintf (pid_file, "%d", getpid());

  fclose (pid_file);

  /* ------------------------------------------------ */
  /* Initialize the MyDns interface                   */
  /* ------------------------------------------------ */

  if (mydns_init (&conf_mysql_mydns))
  {
    my_syslog (
               LEVEL_FATAL,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "mydns_init() - Could not get id from 'soa' where origin='user.' (What's wrong with MyDns?).");
    unlink (configuration_globale.pid_file);
    return 1;
  }

  /* ------------------------------------------------ */
  /* Initialize the dump service for packets          */
  /* ------------------------------------------------ */
 
  packet_init_dump_service();

  /* ------------------------------------------------ */
  /* Listen for packets                               */
  /* ------------------------------------------------ */

  while (1)
  {
    memset ((void*)logprefix, 0, LOGPREFIX_SIZE);
    clear_mac_address();
    snprintf (logprefix, LOGPREFIX_SIZE, "-");

    my_syslog_skip_line();
    logger_new_tag();

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Waiting for DHCP request.");

    /* ---------------------------------------------- */
    /* Get the packet                                 */
    /* o If READ_PACKET_FROM_FILE is defined, the the */
    /*   server reads packets from the directory      */
    /*   defined by INPUT_PACKET_DIRECTORY.           */
    /*   Packets are stored in the files packetXXX.   */
    /* o Otherwize, the server reads packets from the */
    /*   socket.                                      */
    /* ---------------------------------------------- */

    packets_clear (&packet_in);
    adress_size = sizeof (struct sockaddr);

    mess_size = recvfrom (
                           sck,
                           (char*)&packet_in,
                           PACKET_SIZE,
                           0,
                           (struct sockaddr*)&addr_original,
                           (size_t*)&adress_size
                         );
  
    if (mess_size == -1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Recvfrom() failed - %s (continue).",
                 strerror(errno));
      continue;
    }

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Got a request (%d bytes).",
               mess_size);

    /* ---------------------------------------------- */
    /* Set the size of the packet                     */
    /* ---------------------------------------------- */

    packet_set_taille (&packet_in, mess_size);

    /* ---------------------------------------------- */
    /* Sanity check                                   */
    /* ---------------------------------------------- */

    if (check_packet_size(mess_size) == 0)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Invalid DHCP packet (only %d bytes!). Drop this packet.",
                 mess_size);
      dump_packet_hexa ((void*)&packet_in, mess_size, configuration_globale.log_file);
      continue;
    }

    /* ---------------------------------------------- */
    /* Parse the packet's options                     */
    /* ---------------------------------------------- */

    if (packets_parse_options(&packet_in) == 1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Invalid DHCP packet: option's part is not well formatted. Drop this packet.");
      dump_packet_hexa ((void*)&packet_in, mess_size, configuration_globale.log_file);
      continue;
    }

    /* ---------------------------------------------- */
    /* At this point, the packet's data should be OK. */
    /* Format the prefix.                             */
    /* ---------------------------------------------- */

    logger_set_mac (packets_get_chaddr(&packet_in));

    /* ---------------------------------------------- */
    /* If dumper mode selected, then dump the packet  */
    /* but do not reply.                              */
    /* dumper_mode = 0 => No dump at all.             */
    /* dumper_mode = 1 => Dump all packets.           */
    /* dumper_mode = 3 => Dump only (no response)     */
    /* ---------------------------------------------- */

    if (configuration_globale.dumper_mode > 0)
    { packet_dump (&packet_in, &packet_in, &mysql_tables, configuration_globale.debug_file,
                   configuration_globale.csv_file, &addr_original, NULL); }

    if (configuration_globale.dumper_mode > 1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Dumper mode value is 'total' (see DHCP configuration file) - !!! DO NOT REPLY !!! to DHCP clients.");
      continue;
    }

    /* ---------------------------------------------- */
    /* If DHCP DECLINE write WARNING and process next */
    /* packet.                                        */
    /* ---------------------------------------------- */

    if (packets_get_message_type(&packet_in) == DHCPDECLINE)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Got DECLINE.");
      #ifdef SEND_DUMMY_ACK
      packets_send_dummy_ack (
                               &packet_in,
                               &mysql_tables,
                               UNEXPECTED_PACKET_DECLINE,
                               broadcast,
                               server_ip,
                               sck,
                               &addr_original
                             );
      #else
      packets_send_dummy_nak (
                               &packet_in,
                               &mysql_tables,
                               configuration_globale.dummy_ip,
                               broadcast,
                               server_ip,
                               sck,
                               &addr_original
                             );
      #endif
      continue;
    }

    /* ---------------------------------------------- */
    /* Extract the folowing data: node, port, slot,   */
    /* shelf, vci.                                    */
    /* ---------------------------------------------- */

    clear_tables(&mysql_tables);

    strncpy (mysql_tables.abonnes.node, packets_get_node_id(&packet_in), NODE_BUFFER_SIZE-1);
    mysql_tables.abonnes.shelf = packets_get_shelf(&packet_in);
    mysql_tables.abonnes.port  = packets_get_numero_port(&packet_in);
    mysql_tables.abonnes.slot  = packets_get_numero_slot(&packet_in);
    mysql_tables.abonnes.vci   = packets_get_vci(&packet_in);


    if ((*(mysql_tables.abonnes.node) == 0) && 
        (mysql_tables.abonnes.shelf   == 0) &&
        (mysql_tables.abonnes.port    == 0) &&
        (mysql_tables.abonnes.slot    == 0) &&
        (mysql_tables.abonnes.vci     == 0)) { continue; }


    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Packet received from (node=%s,shelf=%u,port=%u,slot=%u,vci=%u).",
               (mysql_tables.abonnes).node,
               (mysql_tables.abonnes).shelf,
               (mysql_tables.abonnes).port,
               (mysql_tables.abonnes).slot,
               (mysql_tables.abonnes).vci);

    snprintf (logprefix, LOGPREFIX_SIZE, "node=%s,shelf=%u,port=%u,slot=%u,vci=%u",
              (mysql_tables.abonnes).node,
              (mysql_tables.abonnes).shelf,
              (mysql_tables.abonnes).port,
              (mysql_tables.abonnes).slot,
              (mysql_tables.abonnes).vci);

    /* ---------------------------------------------- */
    /* Update logger sub-system and load context      */
    /* ---------------------------------------------- */


    rc = load_context (&conf_mysql_dhcp_read_only,
                       &mysql_tables,
                       &configuration_globale);

    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Request skiped.");
           #ifdef SEND_DUMMY_ACK
           packets_send_dummy_ack (
                                     &packet_in,
                                     &mysql_tables,
                                     DB_DHCP_CONNECT_LOST,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #else
           packets_send_dummy_nak (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #endif
           continue;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Connection lost.");
           #ifdef SEND_DUMMY_ACK
           packets_send_dummy_ack (
                                     &packet_in,
                                     &mysql_tables,
                                     DB_DHCP_CONNECT_LOST,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #else
           packets_send_dummy_nak (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #endif
           continue;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Could not reconnect.");
           #ifdef SEND_DUMMY_ACK
           packets_send_dummy_ack (
                                     &packet_in,
                                     &mysql_tables,
                                     DB_DHCP_CONNECT_LOST,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #else
           packets_send_dummy_nak (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #endif
           continue;

      case MYSQL_INTERFACE_NO_OPTION_FOUND:
           my_syslog (
                       LEVEL_INFO,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: can not find optionnal profile!");


           /*** NOTE 15 novembre 2006:
            *   Si le profil optionnel n'est pas trouv�, on continue comme si de rien n'�tait.
            *   Cela a pour objectif d'autoriser le "de-blackholage" automatique dans le cas de modems
            *   qui ne sont pas "autoconf".
            *   ATTENTION: Tous les profils dans la table "abonnes" doivent exister dans le table "options".
            *   Sinon, dans le cas d'un modem "autoconf" qui aurait un profil standard qui ne serait pas
            *   dans la table "options", on enverrait un profil "all zeros".
            ***/


           #ifdef SEND_NAK_IF_NO_PROFILE
           #ifdef SEND_DUMMY_ACK
           packets_send_dummy_ack (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #else
           packets_send_dummy_nak (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #endif
           continue;
           #endif
	   break;

      case MYSQL_INTERFACE_NOT_FOUND:
           my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: User not found in database.");
           #ifdef SEND_DUMMY_ACK
           packets_send_dummy_ack (
                                     &packet_in,
                                     &mysql_tables,
                                     DB_DHCP_REC_NOT_FOUND,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #else
           packets_send_dummy_nak (
                                     &packet_in,
                                     &mysql_tables,
                                     configuration_globale.dummy_ip,
                                     broadcast,
                                     server_ip,
                                     sck,
                                     &addr_original
                                  );
           #endif
           continue;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                       LEVEL_FATAL,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Some SQL syntax error.");
           unlink (configuration_globale.pid_file);
           return 1;

      case MYSQL_INTERFACE_MORE_THAN_ONE:
           my_syslog (
                       LEVEL_FATAL,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: More than one record found. This should never happen because of database constraints! Something impossible happens! Abort server's execution now. This is an emergency!");
           unlink (configuration_globale.pid_file);
           return 1;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                       LEVEL_FATAL,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Unexpected error (%s). Please investigate!",
                       mysql_error_str);
           unlink (configuration_globale.pid_file);
           return 1;

      case MYSQL_INTERFACE_TOO_MANY_ITEMS:
           my_syslog (
                       LEVEL_FATAL,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Could not load context: Too many profile's option loaded. This should never happen since the buffer is really oversized. Something impossible happen! Abort server's execution now. This is an emergency!");
           unlink (configuration_globale.pid_file);
           return 1;
    }

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Context successfully loaded.");

    /* ---------------------------------------------- */
    /* Find out the modem's manufacturor... If the    */
    /* modem supports "autoconf", then look up the    */
    /* logistic database.                             */ 
    /* ---------------------------------------------- */

    modem_manufacturor = get_modem_manufacturor (&packet_in);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Modem's manufacturor is %s.",
               id_manufacturor_to_string(modem_manufacturor)); 

    mysql_tables.logistic.modem_manufacturor = modem_manufacturor;

    /* ---------------------------------------------- */
    /* If the modem supports "autoconf", then lookup  */
    /* the table LOGISTIC_RADIUS.                     */
    /* If not, then make sure that the user's profile */
    /* is not "autoconfblackhole". If so, remove the  */
    /* autoconf blackhole.                            */
    /* ---------------------------------------------- */

    if (modem_conf_is_autoconf(modem_manufacturor))
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "This modem supports auto-configuration - search LOGISTIC_RADIUS.");

      rc = look_up_logistic (&conf_mysql_logistic,
                             &conf_mysql_dhcp_read_only,
                             &mysql_tables,
                             &configuration_globale,
                             &packet_in);

      switch (rc)
      {
        case MYSQL_INTERFACE_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: Connection lost."); 
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                      &packet_in,
                                      &mysql_tables,
                                      DB_DHCP_CONNECT_LOST,
                                      broadcast,
                                      server_ip,
                                      sck,
                                      &addr_original
                                   );
             #else
             packets_send_dummy_nak (
                                      &packet_in,
                                      &mysql_tables,
                                      configuration_globale.dummy_ip,
                                      broadcast,
                                      server_ip,
                                      sck,
                                      &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_NOT_FOUND:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: Data not found.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_LOGISTIC_REC_NOT_FOUND,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: Could not reconnect.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_DHCP_CONNECT_LOST,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: Request skiped.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_DHCP_CONNECT_LOST,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_MORE_THAN_ONE:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: More than one record found. This should never happen! Something impossible happens! Abort server's execution now!");
             unlink (configuration_globale.pid_file);
             return 1;

        case MYSQL_INTERFACE_SQL_PROBLEM:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: SQL error. This should never happen! Something impossible happens! Abort server's execution now!");
             unlink (configuration_globale.pid_file);
             return 1;

        case MYSQL_INTERFACE_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not lookup LOGISTIC: Unexpected SQL error. This should never happen! Something impossible happens! Abort server's execution now!");
             unlink (configuration_globale.pid_file);
             return 1;
      }

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "LOGISTIC successfully searched.");

      /* -------------------------------------------- */
      /* Reload options (if blackholed)               */
      /* -------------------------------------------- */

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Reload (overwrite) profile's options (client may have been blackholed).");

      rc = load_options (&conf_mysql_dhcp_read_only, &mysql_tables, &configuration_globale);
    
      if (rc != 0)
      {
        switch (rc)
        {
          case MYSQL_INTERFACE_REQUEST_SKIPED:
               my_syslog (
                          LEVEL_WARNING,
                          HIGH_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Request skiped.");
               #ifdef SEND_DUMMY_ACK
               packets_send_dummy_ack (
                                         &packet_in,
                                         &mysql_tables,
                                         DB_DHCP_CONNECT_LOST,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #else
               packets_send_dummy_nak (
                                         &packet_in,
                                         &mysql_tables,
                                         configuration_globale.dummy_ip,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #endif
               continue;

          case MYSQL_INTERFACE_CONNECTION_LOST:
               my_syslog (
                          LEVEL_WARNING,
                          HIGH_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Connection lost.");
               #ifdef SEND_DUMMY_ACK
               packets_send_dummy_ack (
                                         &packet_in,
                                         &mysql_tables,
                                         DB_DHCP_CONNECT_LOST,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #else
               packets_send_dummy_nak (
                                         &packet_in,
                                         &mysql_tables,
                                         configuration_globale.dummy_ip,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #endif
               continue;

          case MYSQL_INTERFACE_RECONNECTION_FAILED:
               my_syslog (
                          LEVEL_WARNING,
                          HIGH_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Could not reconnect.");
               #ifdef SEND_DUMMY_ACK
               packets_send_dummy_ack (
                                         &packet_in,
                                         &mysql_tables,
                                         DB_DHCP_CONNECT_LOST,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #else
               packets_send_dummy_nak (
                                         &packet_in,
                                         &mysql_tables,
                                         configuration_globale.dummy_ip,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #endif
               continue;

          case MYSQL_INTERFACE_NOT_FOUND:
               my_syslog (
                          LEVEL_WARNING,
                          HIGH_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': No record found... This should never happen!");
               #ifdef SEND_DUMMY_ACK
               packets_send_dummy_ack (
                                         &packet_in,
                                         &mysql_tables,
                                         DB_OPTIONS_REC_NOT_FOUND,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #else
               packets_send_dummy_nak (
                                         &packet_in,
                                         &mysql_tables,
                                         configuration_globale.dummy_ip,
                                         broadcast,
                                         server_ip,
                                         sck,
                                         &addr_original
                                      );
               #endif
               continue;

          case MYSQL_INTERFACE_SQL_PROBLEM:
               my_syslog (
                          LEVEL_FATAL,
                          TERMINAL_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Some SQL problem. This should never happen. Something impossible happens! Abort server's execution now!");
               unlink (configuration_globale.pid_file);
               return 1;

          case MYSQL_INTERFACE_UNEXPECTED_ERROR:
               my_syslog (
                          LEVEL_FATAL,
                          TERMINAL_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Unexpected SQL error. This should never happen. Something impossible happens! Abort server's execution now!");
               unlink (configuration_globale.pid_file);
               return 1;

          case MYSQL_INTERFACE_TOO_MANY_ITEMS:
               my_syslog (
                          LEVEL_FATAL,
                          TERMINAL_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Could not reload 'options': Too many options... This should never happen. Something impossible happens! Abort server's execution now!");
               unlink (configuration_globale.pid_file);
               return 1;
        }
      }
    }
    else
    {
      /* -------------------------------------------- */
      /* This is not an autoconf modem, make sure     */
      /* that the modem is not "autoconf" blackholed. */
      /* -------------------------------------------- */

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "This modem does NOT support auto-configuration. Make sure that it is not 'autoconf' blackholed.");

      rc = remove_autoconf_bh (&conf_mysql_dhcp_read_only,
                               &mysql_tables,
                               &configuration_globale);

      switch (rc)
      {
        case MYSQL_INTERFACE_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: Request skiped.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_DHCP_CONNECT_LOST,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: Connection lost.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_DHCP_CONNECT_LOST,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: Could not reconnect.");
             #ifdef SEND_DUMMY_ACK
             packets_send_dummy_ack (
                                       &packet_in,
                                       &mysql_tables,
                                       DB_DHCP_CONNECT_LOST,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #else
             packets_send_dummy_nak (
                                       &packet_in,
                                       &mysql_tables,
                                       configuration_globale.dummy_ip,
                                       broadcast,
                                       server_ip,
                                       sck,
                                       &addr_original
                                    );
             #endif
             continue;

        case MYSQL_INTERFACE_SQL_PROBLEM:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: Some SQL problem. This should nerver happen. Something impossible happens! Aboert server's execution now!.");
             unlink (configuration_globale.pid_file);
             return 1;

        case MYSQL_INTERFACE_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: Unexpected SQL error. This should nerver happen. Something impossible happens! Aboert server's execution now!.");
             unlink (configuration_globale.pid_file);
             return 1;

        case MYSQL_INTERFACE_MORE_THAN_ONE:
             my_syslog (
                        LEVEL_FATAL,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not remove autoconf blackhole: More than one record found. This should nerver happen. Something impossible happens! Aboert server's execution now!.");
             unlink (configuration_globale.pid_file);
             return 1;
      }
      
    } 

    /* ---------------------------------------------- */
    /* The context is loaded, find the IP address and */
    /* send the response to the client.               */
    /* ---------------------------------------------- */

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Find the IP address and reply.");

    rc = find_ip_and_reply (&conf_mysql_dhcp_read_only,
                            &conf_mysql_radonline,
                            &conf_mysql_mydns,
                            &mysql_tables,
                            &packet_in,
                            &configuration_globale,
                            sck,
                            broadcast,
                            server_ip,
                            &addr_original);

    switch (rc)
    {
     case MYSQL_INTERFACE_REQUEST_SKIPED:
          my_syslog (
                     LEVEL_WARNING,
                     HIGH_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Request skiped.");
          #ifdef SEND_DUMMY_ACK
          packets_send_dummy_ack (
                                    &packet_in,
                                    &mysql_tables,
                                    DB_DHCP_CONNECT_LOST,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #else
          packets_send_dummy_nak (
                                    &packet_in,
                                    &mysql_tables,
                                    configuration_globale.dummy_ip,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #endif
          continue;

     case MYSQL_INTERFACE_CONNECTION_LOST:
          my_syslog (
                     LEVEL_WARNING,
                     HIGH_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Connexion lost.");
          #ifdef SEND_DUMMY_ACK
          packets_send_dummy_ack (
                                    &packet_in,
                                    &mysql_tables,
                                    DB_DHCP_CONNECT_LOST,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
                                 );
          #else
          packets_send_dummy_nak (
                                    &packet_in,
                                    &mysql_tables,
                                    configuration_globale.dummy_ip,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #endif
          continue;

     case MYSQL_INTERFACE_RECONNECTION_FAILED:
          my_syslog (
                     LEVEL_WARNING,
                     HIGH_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Could not reconnect.");
          #ifdef SEND_DUMMY_ACK
          packets_send_dummy_ack (
                                    &packet_in,
                                    &mysql_tables,
                                    DB_DHCP_CONNECT_LOST,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #else
          packets_send_dummy_nak (
                                    &packet_in,
                                    &mysql_tables,
                                    configuration_globale.dummy_ip,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #endif
          continue;

     case MYSQL_INTERFACE_SQL_PROBLEM:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Some SQL error occured. This should never happen. Something impossible happen! Abort server's execution now - %d (%d).",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case MYSQL_INTERFACE_MORE_THAN_ONE:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): More than one result for SQL query. This should never happen. Something impossible happen! Abort server's execution now.");
          unlink (configuration_globale.pid_file);
          return 1;

     case MYSQL_INTERFACE_NOT_FOUND:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): A record specified by a given ID not found in the database. This should never happen. Something impossible happen! Abort server's execution now.");
          unlink (configuration_globale.pid_file);
          return 1;

     case MYSQL_INTERFACE_UNEXPECTED_ERROR:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Unexpected SQL error - %s (%d). This should never happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case MYSQL_INTERFACE_NO_TIMESTAMP:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Could not get MySql server's timestamp. %s (%d). This should never happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case DHCP_INVALID_MESSAGE_TYPE:
          my_syslog (
                     LEVEL_WARNING,
                     HIGH_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Unknown DHCP message type!");
          #ifdef SEND_DUMMY_ACK
          packets_send_dummy_ack (
                                    &packet_in,
                                    &mysql_tables,
                                    UNEXPECTED_PACKET_UNKNOWN_TYPE,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #else
          packets_send_dummy_nak (
                                    &packet_in,
                                    &mysql_tables,
                                    configuration_globale.dummy_ip,
                                    broadcast,
                                    server_ip,
                                    sck,
                                    &addr_original
                                 );
          #endif
          continue;

     case DHCP_LEASE_INCONSTANCY:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): Could not get lease. This should not happen. Something impossible happen! Abort server's execution now.");
          unlink (configuration_globale.pid_file);
          return 1;

     case DHCP_RADONLINE_MYSQL_SQL_PROBLEM:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): An SQL error occured while sending ticket to Radonline - %s (%d). This should not happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case DHCP_RADONLINE_MYSQL_UNEXPECTED_ERROR:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): An unexpected SQL error occured while sending ticket to Radonline - %s (%d). This should not happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case DHCP_MYDNS_MYSQL_SQL_PROBLEM:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): An SQL error occured while sending ticket to MyDns - %s (%d). This should not happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;

     case DHCP_MYDNS_MYSQL_UNEXPECTED_ERROR:
          my_syslog (
                     LEVEL_FATAL,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "find_ip_and_reply(): An unexpected SQL error occured while sending ticket to MyDns - %s (%d). This should not happen. Something impossible happen! Abort server's execution now.",
                     mysql_error_str,
                     mysql_error_errno);
          unlink (configuration_globale.pid_file);
          return 1;
    }

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Packet successfully processed.");
  }

  unlink (configuration_globale.pid_file);
  return 0;
}


















/*! \brief Dump a packet into hexa. This function is called when it is not possible to 
           parse the packet (invalid size ot invalid organisation).
    \param packet Pointer to the packet as received by the server.
    \param size Size, in bytes of the packet.
    \param file Path to the log file.
 */

static void dump_packet_hexa (void* packet, int size, char* file)
{
   char *buffer;
   int  bsize;

   bsize  = (2*size) + 1;
   buffer = (char*) malloc (bsize * sizeof(char));

   if (buffer == NULL)
   {
     my_syslog (
                LEVEL_ERROR,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Can not allocate memory (dump_packet_hexa() failed).");
     return;
   }
 
   if (bin2hex_binary ((unsigned char*)packet, (unsigned char*)buffer, size, bsize) == 0)
   {
     my_syslog (
                LEVEL_ERROR,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Could not convert packet into hexa (bin2hex_binary() failed). This should _NEVER_ happen. What's wrong?");
     free (buffer); 
     return;
   }

   my_syslog (
              LEVEL_VERBOSE, 
              TERMINAL_LEVEL,
              __FILE__,
              __LINE__,
              "Packet is (in hexa) [%s].",
              buffer);

   free (buffer);
   return;
}





/*! \mainpage Documentation for the DHCP server
 *
 *  \section code_sec Auto-generated documentation
 *
 *  To consult the auto-generated documentation, use the links at the top of the page.
 *  <ul>
 *    <li>Globals : Alphabetical list of all functions, variables and constants. This is the main index.
 *    <li>Data Fields : All data structure fields.
 *    <li>File List : All source's files.
 *    <li>Data Structures : All data structures.
 *  </ul>
 *
 */

find_ip_and_reply.c

/*! \file find_ip_and_reply.c
          This file implements the most important part of the algorithm. It uses all the other modules.
          It is reponsible for searching client's IP and sending DHCP requests.
 */

#include <stdio.h>
#include "find_ip_and_reply.h"
#include "packets_operations.h" 
#include "logging.h"
#include "packets.h"
#include "strings_utils.h"
#include "packets.h"
#include "config.h"

/*! \brief Extract the ACK lease from a loaded context.
    \author Denis BEURIVE
    \param mysql_tables Pointer to a 'mysql_tables' dtat structure that contains the loaded context.
    \return Upon successfull completion, the function returns the lease value.
            Otherwize, the function returns the value (unsigned int)(-1).
    \remark Make sure that the context has been loaded! Otherwize you will have unpredictable
            consequences.
 */

static unsigned int get_lease_from_context (struct mysql_tables *mysql_tables)
{
  int           option_number, e, i;
  unsigned int  lease;
  char          *option_value;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_lease_from_context().");
  
  /* ----------------------------------------------------- */
  /* Lookup the list of options                            */
  /* ----------------------------------------------------- */

  option_number = mysql_tables->option_number;
  if (option_number > MAX_PROFILE_OPTIONS) { return (unsigned int)(-1); }

  option_value = NULL;

  for (i=0; i<option_number; i++)
  {
    if (((mysql_tables->options)[i]).option_code == 51)
    { option_value = ((mysql_tables->options)[i]).option_value; break; }
  }

  if (option_value == NULL)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Can not find lease into the loaded list of options (Please check the database). This should not happen.");
 
    return (unsigned int)(-1);
  }

  /* ----------------------------------------------------- */
  /* Convert string into numerical value                   */
  /* ----------------------------------------------------- */

  lease = string2unsigned_int (option_value, &e);

  if (e) { return (unsigned int)(-1); }

  return lease;
}

/*! \brief Try to find an IP address for the client and send a DHCP response. 
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration
           for the DHCP database.
    \param mysql_radonline Pointer to a 'smysql' data structure that contains the MySql
           configuration for the 'Radonline' database.
    \param mysql_mydns Pointer to a 'smysql' data structure that contains the MySql configuration
           for the 'MyDns' database.
    \param mysql_tables pointer to a structure that contains the client's context (all tables).
    \param packet Pointer to a 'dhcp_packet' data structure that contains the DHCP packet.
    \param config Pointer to a 'global_config' data structure that contains the main configuration
           for the server.
    \param sck Descriptor og the socket used by the server to receive requests, and reply to
           these requests.
    \param broadcast 4 bytes long integer that contains the binary representation (in network
           byte order) of the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network
           byte order) of the server IP address.
    \param client_address client_address Pointer to a 'sockaddr_in' data structure that contains
           the internet address of the incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the
           parameter 'client_address' is never used (since the server always send broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <UL>
                <LI>MYSQL_INTERFACE_REQUEST_SKIPED
                <LI>MYSQL_INTERFACE_CONNECTION_LOST
                <LI>MYSQL_INTERFACE_RECONNECTION_FAILED
                <LI>MYSQL_INTERFACE_SQL_PROBLEM
                <LI>MYSQL_INTERFACE_MORE_THAN_ONE
                <LI>MYSQL_INTERFACE_UNEXPECTED_ERROR
                <LI>MYSQL_INTERFACE_NOT_FOUND
                <LI>DHCP_INVALID_MESSAGE_TYPE
                <LI>DHCP_LEASE_INCONSTANCY
                <LI>DHCP_MYDNS_MYSQL_SQL_PROBLEM
                <LI>DHCP_RADONLINE_MYSQL_UNEXPECTED_ERROR
                <LI>DHCP_RADONLINE_MYSQL_SQL_PROBLEM
                <LI>DHCP_MYDNS_MYSQL_UNEXPECTED_ERROR
                <LI>DHCP_UNEXPECTED_VCI
                <LI>DHCP_GATEWAY_ERROR
                <LI>DHCP_NETWORK_ERROR
                <LI>MYSQL_INTERFACE_NO_OPTION_FOUND
            </UL>
    \remark <UL>
               <LI>Make sure to call the function packets_parse_options() before (see documentation
                   for function packets_parse_options(), which needs some initialisations).
               <LI>This function loads the user's context by calling the function load_context(). 
               <LI>A fix has been made in order to avoid MyDns manipulation for the VIDEO VCI. 
                   The VCI number is hard coded.
                   If VCI is 37, then we don't update MyDns database (no START or STOP).
            </UL>
 */

int find_ip_and_reply (struct smysql        *mysql_info,
                       struct smysql        *mysql_radonline,
                       struct smysql        *mysql_mydns,
                       struct mysql_tables  *mysql_tables,
                       struct dhcp_packet   *packet,
                       struct global_config *config,
                       int                  sck,
                       unsigned long int    broadcast,
                       unsigned long int    server_ip,
                       struct sockaddr_in   *client_address)
{
  int    rc, request_type, vci_idx;
  char   *vci_tag, *gateway, *network;
  char*  (*gateway_calculator)(char* cidr);
  char*  (*network_calculator)(char* cidr);


  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling find_ip_and_reply().");

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Find IP for abonne which ID is %lu.",
             (mysql_tables->abonnes).id);
 
  /* ----------------------------------------------------- */
  /* Load the context associated with this abonne:         */
  /*   o IP, profile, CIDR,...                             */
  /*   o The list of all options.                          */
  /* ----------------------------------------------------- */

  rc = load_context (mysql_info,
                     mysql_tables,
                     config);

  switch (rc)
  {
    case MYSQL_INTERFACE_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): Request SKIPED.",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_INTERFACE_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): Connection lost.",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_CONNECTION_LOST; 

    case MYSQL_INTERFACE_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): Could not reconnect.",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_INTERFACE_SQL_PROBLEM:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): Unexpected error.",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_INTERFACE_MORE_THAN_ONE:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): More than one record found!",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_MORE_THAN_ONE; 

    case MYSQL_INTERFACE_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load context(node=%s,shelf=%u,port=%u,slot=%u,vci=%u): Unexpected error.",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case MYSQL_INTERFACE_NOT_FOUND:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not find the client in the table 'abonnes' (node=%s,shelf=%u,port=%u,slot=%u,vci=%u)",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_NOT_FOUND;

    case MYSQL_INTERFACE_NO_OPTION_FOUND:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not find the optionnal profile in the table 'option' (node=%s,shelf=%u,port=%u,slot=%u,vci=%u)",
                    (mysql_tables->abonnes).node,
                    (mysql_tables->abonnes).shelf,
                    (mysql_tables->abonnes).port,
                    (mysql_tables->abonnes).slot,
                    (mysql_tables->abonnes).vci);
         return MYSQL_INTERFACE_NO_OPTION_FOUND;
  }

  /* ----------------------------------------------------- */
  /* Now that we have the list of options, calculate the   */
  /* gateway and the subnet.                               */
  /* Then add the info tp the table "abonnes".             */
  /* ----------------------------------------------------- */

  vci_idx = vci_conf_get_id((mysql_tables->abonnes).vci);
  if (vci_idx == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Unexpected VCI value %u (not listed in my configuration file)... Don't know what to do, skip this request.",
               (mysql_tables->abonnes).vci);
    return DHCP_UNEXPECTED_VCI;
  }

  vci_tag = vci_conf_get_tag_name(vci_idx);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "VCI=%u tag=\"%s\".",
             (mysql_tables->abonnes).vci,
             vci_tag);

  gateway_calculator = vci_conf_get_gateway_calculator(vci_idx);
  network_calculator = vci_conf_get_network_calculator(vci_idx);

  gateway = gateway_calculator((mysql_tables->abonnes).subnet);
  if (gateway == NULL)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Error while calculating gateway for VCI=%u (%s)... This may come from the libip library. This is an emergency!",
               (mysql_tables->abonnes).vci,
               vci_tag);
    return DHCP_GATEWAY_ERROR; 
  }

  network = network_calculator((mysql_tables->abonnes).subnet);
  if (network == NULL)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Error while calculating network for VCI=%u (%s)... This may come from the libip library. This is an emergency!",
               (mysql_tables->abonnes).vci,
               vci_tag);
    return DHCP_NETWORK_ERROR;
  }

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "VCI=%u tag=\"%s\" gateway=%s network=%s.",
             (mysql_tables->abonnes).vci,
             vci_tag,
             gateway,
             network);

  strncpy ((mysql_tables->abonnes).gateway, gateway, IP_ADDRESS_STR_SIZE-1);
  strncpy ((mysql_tables->abonnes).network, network, IP_ADDRESS_STR_SIZE-1);

  /* ----------------------------------------------------- */
  /* What kind of DHCP request is it?                      */
  /* ----------------------------------------------------- */

  request_type = packets_get_message_type (packet);

  if (request_type == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Invalid message type for (node=%s,shelf=%u,port=%u,slot=%u,vci=%u), skip.",
               (mysql_tables->abonnes).node,
               (mysql_tables->abonnes).shelf,
               (mysql_tables->abonnes).port,
               (mysql_tables->abonnes).slot,
               (mysql_tables->abonnes).vci);
    return DHCP_INVALID_MESSAGE_TYPE;
  }

  /* ----------------------------------------------------- */
  /* DHCP DISCOVER => Send OFFER                           */
  /* ----------------------------------------------------- */

  if (request_type == DHCPDISCOVER)
  {
    char *ip;

    ip = (mysql_tables->abonnes).ip;

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Got DISCOVER => Send OFFER to %s.",
               ip);

    rc = packets_send_offer (
                               packet,               /* Incoming DHCP request                     */
                               mysql_tables,         /* Loaded data from database                 */
                               ip,                   /* IP address of the client                  */
                               broadcast,            /* Broadcast address for the server's socket */
                               server_ip,            /* IP address of the server                  */
                               sck,                  /* Socket descriptor of the server           */
                               client_address        /* Internet address of the client            */
                            );
  }

  /* ----------------------------------------------------- */
  /* DHCP REQUEST => Send Ack or Nack                      */
  /* ----------------------------------------------------- */

  if (request_type == DHCPREQUEST)
  {
    unsigned int lease;
    char         *ip;

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Got REQUEST => Send Ack or Nak.");

    /* --------------------------------------------------- */
    /* Get the lease associated with this profile          */
    /* --------------------------------------------------- */

    lease = get_lease_from_context (mysql_tables);

    if (lease == (unsigned int)(-1))
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Something wrong with the loaded profile (can not decode lease, option 51). Please check the database, this error should not happen (it may come from a provisionning error).");
      return DHCP_LEASE_INCONSTANCY;
    }

    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Lease is %u seconds.",
               lease);

    ip = (mysql_tables->abonnes).ip;

    if ((mysql_tables->abonnes).nack_flag == 0)
    {
      /* ------------------------------------------------- */
      /* nack_flag is 0, send ACK                          */
      /* ------------------------------------------------- */

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Got REQUEST => nack_flag=0, therefore, send ACK to %s.",
                 ip);

      rc = packets_send_ack (
                               packet,               /* Incoming DHCP request                     */
                               mysql_tables,         /* Loaded data from database                 */
                               ip,                   /* IP address of the client                  */
                               broadcast,            /* Broadcast address for the server's socket */
                               server_ip,            /* IP address of the server                  */
                               sck,                  /* Socket descriptor of the server           */
                               client_address        /* Internet address of the client            */
                            );

      if (rc == 1)
      {
        my_syslog (
                   LEVEL_ERROR,
                   TERMINAL_LEVEL,
                   __FILE__,
                   __LINE__,
                   "ACK not sent !!! packets_send_ack() failed !!!");
      }
    } 
    else
    {
      /* ------------------------------------------------- */
      /* nack_flag is NOT 0, send NAK                      */
      /* ------------------------------------------------- */

      unsigned long int new_nack_flag_value;

      new_nack_flag_value = (mysql_tables->abonnes).nack_flag - 1; 

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Got REQUEST => nack_flag=%lu, therefore, send NAK to %s.",
                 (mysql_tables->abonnes).nack_flag,
                 ip);


            /* ------------------------------------------- */
            /* Step 1: Send the UDP packet                 */
            /* ------------------------------------------- */

      rc = packets_send_nack (
                               packet,
                               mysql_tables,
                               ip,
                               broadcast,
                               server_ip,
                               sck,
                               client_address
                             );

      if (rc == 1)
      {
        my_syslog (
                   LEVEL_WARNING,
                   TERMINAL_LEVEL,
                   __FILE__,
                   __LINE__,
                   "NAK not sent !!! packets_send_nack() failed !!! What's wrong with the system? Please investigate.");
      }

            /* ------------------------------------------- */
            /* Step 2: Update the database                 */
            /* ------------------------------------------- */

      my_syslog (
                 LEVEL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Update value of nack_flag (new value is %lu).",
                 new_nack_flag_value);

      rc = nack_flag_abonne (mysql_info,
                             mysql_tables,
                             config,
                             new_nack_flag_value);

      switch (rc)
      {
        case MYSQL_INTERFACE_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: Request skiped.");
             return MYSQL_INTERFACE_REQUEST_SKIPED;

        case MYSQL_INTERFACE_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: Connection lost.");
             return MYSQL_INTERFACE_CONNECTION_LOST;

        case MYSQL_INTERFACE_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: Could not reconnect.");
             return MYSQL_INTERFACE_RECONNECTION_FAILED;

        case MYSQL_INTERFACE_SQL_PROBLEM:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: Some SQL syntax error.");
             return MYSQL_INTERFACE_SQL_PROBLEM;

        case MYSQL_INTERFACE_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: Unexpected error.");
             return MYSQL_INTERFACE_UNEXPECTED_ERROR;

        case MYSQL_INTERFACE_MORE_THAN_ONE:
             my_syslog (
                        LEVEL_ERROR,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: More than one record id='%lu' (login radius='%s'). This should _NEVER_ happen since the is is a primary key. Please investigate, this is an emergency!",
                        mysql_tables->abonnes.id,
                        mysql_tables->abonnes.login_radius);
             return MYSQL_INTERFACE_MORE_THAN_ONE;

        case MYSQL_INTERFACE_NOT_FOUND:
             my_syslog (
                        LEVEL_ERROR,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not update nack_flag: No record found with id='%lu' (login radius='%s'). This should NOT happen unless somebody just deleted the record. Please investigate, this is an emergency!",
                        mysql_tables->abonnes.id,
                        mysql_tables->abonnes.login_radius);
             return MYSQL_INTERFACE_NOT_FOUND;
      }

            /* ------------------------------------------- */
            /* Return (NAK does not impact Radonline)      */
            /* ------------------------------------------- */

      return 0;
    }

    /* --------------------------------------------------- */
    /* Send START ticket to Radonline                      */
    /* --------------------------------------------------- */


    if (vci_update_radonline(vci_idx))
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u Radonline(start).",
                 mysql_tables->abonnes.vci);
  
      rc = send_to_radonline (mysql_radonline,
                              mysql_tables,
                              ip,
                              RADONLINE_START,
                              config);
  
      switch (rc)
      {
        case MYSQL_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to Radonline: Request skiped.");
             break;
  
        case MYSQL_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to Radonline: Connection lost.");
             break;
  
        case MYSQL_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to Radonline: Could not reconnect.");
             break;
  
        case MYSQL_SQL_PROBLEM:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to Radonline: Some SQL syntax error.");
             return DHCP_RADONLINE_MYSQL_SQL_PROBLEM;
  
        case MYSQL_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to Radonline: Unexpected error.");
             return DHCP_RADONLINE_MYSQL_UNEXPECTED_ERROR;
      }
    }
    else
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u Do not send START to Radonline.",
                 mysql_tables->abonnes.vci);
    }

    /* --------------------------------------------------- */
    /* Send START ticket to MyDns                          */
    /* --------------------------------------------------- */

    if (vci_update_mydns(vci_idx)) 
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u, MyDns(start).",
                 (mysql_tables->abonnes).vci);

      rc = send_to_mydns (mysql_mydns,
                          mysql_tables,
                          ip,
                          MYDNS_START,
                          config);
  
      switch (rc)
      {
        case MYSQL_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to MyDns: Request skiped.");
             break;

        case MYSQL_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to MyDns: Connection lost.");
             break;

        case MYSQL_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to MyDns: Could not reconnect.");
             break;

        case MYSQL_SQL_PROBLEM:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to MyDns: Some SQL problem.");
             return DHCP_MYDNS_MYSQL_SQL_PROBLEM;

        case MYSQL_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not START to MyDns: Unexpected error.");
             return DHCP_MYDNS_MYSQL_UNEXPECTED_ERROR;
      }
    }
    else
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u - Do not send START to MyDns!",
                 (mysql_tables->abonnes).vci); 
    }
  }

  /* ----------------------------------------------------- */
  /* DHCP RELEASE                                          */
  /* ----------------------------------------------------- */

  if (request_type == DHCPRELEASE)
  {
    char *ip;

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Got RELEASE.");

    ip = (mysql_tables->abonnes).ip; 

    /* --------------------------------------------------- */
    /* Send STOP ticket to Radonline                       */
    /* --------------------------------------------------- */

    if (vci_update_radonline(vci_idx))
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u Radonline(stop) for IP %s.",
                 mysql_tables->abonnes.vci,
                 ip);
  
      rc = send_to_radonline (mysql_radonline,
                              mysql_tables,
                              ip,
                              RADONLINE_STOP,
                              config);
  
      switch (rc)
      {
        case MYSQL_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to Randonline: Request skiped.");
             break;
  
        case MYSQL_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to Randonline: Connexion lost.");
             break;
  
        case MYSQL_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to Randonline: Could not reconnect.");
             break;
  
        case MYSQL_SQL_PROBLEM:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to Randonline: Some SQL problem. This should NOT happen. Please investigate!");
             return DHCP_RADONLINE_MYSQL_SQL_PROBLEM;
  
        case MYSQL_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to Randonline: Unexpected error.");
             return DHCP_RADONLINE_MYSQL_UNEXPECTED_ERROR;
      }
    }
    else
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u Do not send STOP to Radonline.",
                 mysql_tables->abonnes.vci);
    }

    /* --------------------------------------------------- */
    /* Send STOP ticket to MyDns                           */
    /* --------------------------------------------------- */

    if (vci_update_mydns(vci_idx))
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u, MyDns(stop).",
                 (mysql_tables->abonnes).vci);

      rc = send_to_mydns (mysql_mydns,
                          mysql_tables,
                          ip,
                          MYDNS_STOP,
                          config);
  
      switch (rc)
      {
        case MYSQL_REQUEST_SKIPED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to MyDns: Request skiped.");
             break;

        case MYSQL_CONNECTION_LOST:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to MyDns: Connection lost.");
             break;

        case MYSQL_RECONNECTION_FAILED:
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to MyDns: Reconnection failed.");
             break;

        case MYSQL_SQL_PROBLEM:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to MyDns: Some SQL problem. This should NOT happen, please investigate!");
             return DHCP_MYDNS_MYSQL_SQL_PROBLEM;

        case MYSQL_UNEXPECTED_ERROR:
             my_syslog (
                        LEVEL_ERROR,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Could not STOP to MyDns: Unexpected error.");
             return DHCP_MYDNS_MYSQL_UNEXPECTED_ERROR;
      }
    }
    else
    {
      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "VCI=%u - Do not send STOP to MyDns.",
                 (mysql_tables->abonnes).vci); 
    }
  }

  /* ----------------------------------------------------- */
  /* DHCP INFORM                                           */
  /* ----------------------------------------------------- */

  if (request_type == DHCPINFORM)
  {
    char *ip; 

    ip = (mysql_tables->abonnes).ip; 

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Got INFORM => Send Ack to IP %s.",
               ip);

    rc =  reply_to_inform (
                            packet,               /* Incoming DHCP request                     */
                            mysql_tables,         /* Loaded data from database                 */
                            broadcast,            /* Broadcast address for the server's socket */
                            server_ip,            /* IP address of the server                  */
                            sck,                  /* Socket descriptor of the server           */
                            client_address        /* Internet address of the client            */
                          );
  }

  return 0;
}

flock.c

hitachi.c

/*! \file hitachi.c
    This file implements special Hitachi's MAC address processing.
 */


#include <string.h>

/*! \brief Subtract 4 from a given digit.
    \author Denis BEURIVE
    \param car Hexadecimal character that represents the digit.
    \param carry Pointer to an integer that will be used to signal a possible crry. The value
                 pointed by "carry" can be:
                 <ul>
                    <li>0: no carry.
                    <li>1: carry.
                 </ul>
    \return The function returns the value "car-4" in hexadecimal.
 */


static char minus4 (char car, int *carry)
{
  switch (car)
  {
    case 'F': *carry=0; return 'B';
    case 'E': *carry=0; return 'A';
    case 'D': *carry=0; return '9';
    case 'C': *carry=0; return '8';
    case 'B': *carry=0; return '7';
    case 'A': *carry=0; return '6';
    case '9': *carry=0; return '5';
    case '8': *carry=0; return '4';
    case '7': *carry=0; return '3';
    case '6': *carry=0; return '2';
    case '5': *carry=0; return '1';
    case '4': *carry=0; return '0';
    case '3': *carry=1; return 'F';
    case '2': *carry=1; return 'E';
    case '1': *carry=1; return 'D';
    case '0': *carry=1; return 'C';
  }

  *carry=0;
  return 'X';
}

/*! \brief Subtract 1 from a given digit.
    \author Denis BEURIVE
    \param car Hexadecimal character that represents the digit.
    \param carry Pointer to an integer that will be used to signal a possible crry. The value
                 pointed by "carry" can be:
                 <ul>
                    <li>0: no carry.
                    <li>1: carry.
                 </ul>
    \return The function returns the value "car-1" in hexadecimal.
 */

static char minus1 (char car, int *carry)
{
  switch (car)
  {
    case 'F': *carry=0; return 'E';
    case 'E': *carry=0; return 'D';
    case 'D': *carry=0; return 'C';
    case 'C': *carry=0; return 'B';
    case 'B': *carry=0; return 'A';
    case 'A': *carry=0; return '9';
    case '9': *carry=0; return '8';
    case '8': *carry=0; return '7';
    case '7': *carry=0; return '6';
    case '6': *carry=0; return '5';
    case '5': *carry=0; return '4';
    case '4': *carry=0; return '3';
    case '3': *carry=0; return '2';
    case '2': *carry=0; return '1';
    case '1': *carry=0; return '0';
    case '0': *carry=1; return 'F';
  }

  *carry=0;
  return 'X';
}

/*! \brief Subtract 4 from a given number writen in hexadecimal.
    \author Denis BEURIVE
    \param haddr Pointer to a zero terminated string of characters that represents the number
                 writen in hexadecimal base.
    \return The function returns a pointer to "haddr". The string "haddr" now represents the
            value "haddr-4".
    \warning This function modifies the content of the string pointed by "haddr"). If macro "USE_PLUGINS" is defined, then
             the function returns a pointer to a statically allocated buffer. Otherwize, the function returns "haddr" itself.
    \remark This function should be used to calculate the MAC address of an HITACHI modem.
 */

char* calculate_mac (char *haddr)
{
  int  i, carry, lastid;
  char r;

  #ifdef USE_PLUGINS
     static char new_mac[128];
     memset((void*)new_mac, 0, 128*sizeof(char));
  #endif

  lastid = strlen(haddr)-1;

  r = minus4 (haddr[lastid], &carry);
  haddr[lastid] = r;

  lastid--;
  for (i=lastid; ((i>=0) && carry); i--)
  {
    r = minus1 (haddr[i], &carry);
    haddr[i] = r;
  }

  #ifndef USE_PLUGINS
     return haddr;
  #else
     strncpy (new_mac, haddr, 127);
     return new_mac;
  #endif
}

libhttp.c

/*! \file libhttp.c
    This file implements the HTTP protocol used by the DHCP server.
 */

#include <string.h>
#include "libhttp.h"
#include "strings_utils.h"
#include "logging.h"

/* ----------------------------------------------------- */
/* Private API                                           */
/* ----------------------------------------------------- */

static void set_last_error(char *error);
static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream);
static void reset_handler(struct request_data *reqdata);

/*! \brief Buffer used to store the last CURL error message.
    \remark <ul>
              <li>Use the function set_last_error() to update this variable.
              <li>Use the function web_get_last_error() to retrieve this variable.
            </ul>
 */

static char last_error[CURL_LAST_ERROR_SIZE];

/*! \brief Set the last error message.
    \param error Pointer to a zero terminated string of characters that represents the last CIRL error message.
 */

static void set_last_error(char *error)
{
  memset ((void*)last_error, 0, CURL_LAST_ERROR_SIZE);
  memcpy ((void*)last_error, (void*)error, CURL_LAST_ERROR_SIZE - 1); 
}

/*! \brief Callback function used by ithe CURL library.
           This function is calles whenever data is read via HTTP.
    \param ptr Pointer to the buffer that contains the data read via HTTP.
           This buffer is zero terminated.
    \param size The total number of bytes read is (size * nmemb).
    \param nmemb The total number of bytes read is (size * nmemb).
    \param stream This refer to the location where to write data.
    \return The function returns the total number of bytes received from the HTTP request.
    \warning If the incoming data size is too long, the function returns the value 0.
 */

static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
{
  struct http_body *where_to_write;
  size_t           data_size;

  where_to_write = (struct http_body*)stream;
  data_size      = size * nmemb;

  /*
  fprintf (stdout, "\n\n-- DEBUG --\n\n");
  fprintf (stdout, "size  = %u\n",   size);
  fprintf (stdout, "nmemb = %u\n",   nmemb);
  fprintf (stdout, "total = %u\n\n", data_size);
  */

  if (data_size + where_to_write->nbbytes >= CURL_HTTP_BODY_SIZE-1) { return 0; }
  strncat(where_to_write->body, ptr, data_size);
  where_to_write->nbbytes += data_size;
  
  return data_size;
}

/*! \brief Clear the body container.
           Set buffer to all zeros.
           Set body' size to 0.
    \param reqdata Pointer to a 'request_data' data structure that contains the HTTP parameters.
 */

static void reset_handler(struct request_data *reqdata)
{
  memset ((void*)reqdata->body.body, 0, CURL_HTTP_BODY_SIZE);
  reqdata->body.nbbytes = 0;
}

/* ----------------------------------------------------- */
/* Public API                                            */
/* ----------------------------------------------------- */

/*! \brief Return a pointer to the last CURL error message.
    \return The function returns a pointer to statically allocated (zero terminated) string of characters
            that represents the last error message.
 */

char* web_get_last_error() { return last_error; }

/*! \brief Return the HTTP body from a HTTP context.
    \param reqdata Pointer to a 'request_data' data structure that contains the HTTP parameters.
    \return The function returns a pointer to a zero terminated buffer that contains the
            body extracted via HTTP.
 */

char* web_get_body(struct request_data *reqdata) { return reqdata->body.body; }

/*! \brief Return the number of bytes of the HTTP body.
    \param reqdata Pointer to a 'request_data' data structure that contains the HTTP parameters.
    \return The function returns the size, in bytes, of the HTTP body.
 */

size_t web_get_body_size(struct request_data *reqdata) { return reqdata->body.nbbytes; }

/*! \brief Number of bytes for the full URL: [url] + [cgi parameters].
 */

#define FULL_URL_SIZE 2048

/*! \brief Perform a HTTP request.
    \param reqdata Pointer to a 'request_data' data structure that contains the resquest's parameters.
    \return Upon successfull completion, the function returns the value CURL_OK.
            Otherwize, the function returns one of the fillowing values:
            <ul>
               <li>CURL_INIT_ERROR
               <li>CURL_REQUEST_ERROR
               <li>CURL_OK 
            </ul>
 */

int web_get(struct request_data *reqdata)
{
  CURL     *curl;
  CURLcode rc;
  char     curlerror[CURL_ERROR_SIZE];
  char     url[FULL_URL_SIZE]; 

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling web_get().");

  curl = curl_easy_init();
  if (curl == NULL)
  {
    set_last_error("Could not initialize the CURL handle. Function curl_easy_init() failed.");
    return CURL_INIT_ERROR;
  }

  reset_handler(reqdata);
  memset ((void*)curlerror, 0, CURL_ERROR_SIZE);
  memset ((void*)url,       0, FULL_URL_SIZE);

  snprintf (url, FULL_URL_SIZE, "%s?%s", reqdata->url, reqdata->params);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "URL = %s",
             url);

  curl_easy_setopt (curl, CURLOPT_ERRORBUFFER,    curlerror);                 /* Where to write errors          */
  curl_easy_setopt (curl, CURLOPT_MUTE,           1);                         /* No output                      */
  curl_easy_setopt (curl, CURLOPT_NOPROGRESS,     1);                         /* No process meter               */
  curl_easy_setopt (curl, CURLOPT_URL,            url);                       /* Set the URL                    */
  curl_easy_setopt (curl, CURLOPT_TIMEOUT,        reqdata->request_timeout);  /* Set request timeout            */ 
  curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, reqdata->connect_timeout);  /* Set connection timeout         */
  curl_easy_setopt (curl, CURLOPT_WRITEDATA,      (void*)&(reqdata->body));   /* Where to save the body         */
  curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION,  write_data);                /* Send all data to this function */

  rc = curl_easy_perform(curl);
  if (rc != 0)
  {
    curl_easy_cleanup(curl);
    set_last_error(curlerror);
    return CURL_REQUEST_ERROR;
  }

  curl_easy_cleanup(curl);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "WEB service responded:\n---START---\n%s\n---END---\n",
             web_get_body(reqdata));

  return CURL_OK;
}

/*! \brief Format the couples "name=value" for the CGI.
    \param couples Array that contains the couples "name=value".
           This array contains 'n' rows (see below) and 2 columns.
           <ul>
              <li>First column (indice 0) is the name.
              <li>Second column (indice 1) is the value.
           </ul>
    \param n Number of line in the array 'couples'.
    \param dst Pointer to a buffer used to sore the resulting string of characters.
           The resulting string will be zero terminated.
    \param size Size, in bytes of the buffer pointed by 'dst'.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int web_format_params (char *couples[][2], int n, char *dst, int size)
{
  CURL  *curl;
  int   total_size;
  int   ligne;

  curl = curl_easy_init();
  if (curl == NULL)
  {
    set_last_error("Could not initialize the CURL handle. Function curl_easy_init() failed.");
    return 1;
  }

  memset((void*)dst, 0, size);
  total_size = 0;

  for (ligne=0; ligne<n; ligne++)
  {
    char *name,  *url_encoded_name;
    char *value, *url_encoded_value;

    name  = couples[ligne][0];
    value = couples[ligne][1];

    /* ------------------------------------------------- */
    /* URL Encode the name and the value                 */
    /* ------------------------------------------------- */

    url_encoded_name = curl_easy_escape(curl, name, 0);
    if (url_encoded_name == NULL)
    {
      set_last_error("Could not URL escape CGI name. Function curl_easy_escape() failed.");
      curl_easy_cleanup(curl); 
      return 1;
    }

    url_encoded_value = curl_easy_escape(curl, value, 0);
    if (url_encoded_value == NULL)
    {
      set_last_error("Could not URL escape CGI value. Function curl_easy_escape() failed.");
      curl_free(url_encoded_name);
      curl_easy_cleanup(curl);
      return 1;
    }

    /* ------------------------------------------------- */
    /* Catenate all couple to a single line              */
    /* ------------------------------------------------- */

    total_size += strlen(url_encoded_name);   /* the name  */
    total_size += 1;                          /* the '='   */
    total_size += strlen(url_encoded_value);  /* the value */
    total_size += 1;                          /* the '&'   */

    if (total_size >= size)
    {
      set_last_error("Could no URL escape CGI value. Buffer is too small (overflow avoided).");
      curl_free(url_encoded_name);
      curl_free(url_encoded_value);
      curl_easy_cleanup(curl);
      return 1;
    }

    strcat (dst, url_encoded_name);
    strcat (dst, "=");
    strcat (dst, url_encoded_value);
    strcat (dst, "&");

    /* ------------------------------------------------- */
    /* Free all allocated ressources (memory leak!!!)    */
    /* ------------------------------------------------- */

    curl_free(url_encoded_name);
    curl_free(url_encoded_value);
  }

  curl_easy_cleanup(curl);
  return 0;
}

/* ----------------------------------------------------- */
/* LOGISTIC web service related functions                */
/* ----------------------------------------------------- */

/*! \brief Extract data from the response of the LOGISTI  CGI.
    \param response Pointer to a zero terminated string of characters that represents the response
           from the CGI.
    \param data Pointer to a "logistic_xml" data structure that will be used to store the extracted
           data.
    \return Upon successful completion the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int web_logistic_parser(char *response, struct logistic_xml *data)
{
  struct fields   fd, token;
  int             total_line, n, total_rows, l, bsize;
  char            *line, *buffer;
  CURL            *curl;


  bsize = strlen(response);
  buffer = (char*)malloc((bsize+1) * sizeof(char));
  if (buffer == NULL)
  { 
    set_last_error("Could not extract data from CGI response. Not enough memory.");
    return 1;
  }
  memset((void*)buffer, 0, bsize+1);
  memcpy ((void*)buffer, (void*)response, bsize);

  /* --------------------------------------------------- */
  /* Split text into lines                               */
  /* --------------------------------------------------- */

  total_line = s_split (buffer, "\n", &fd);
  if (total_line == -1)
  {
    set_last_error("Could not extract data from CGI response. Not enough memory.");
    free(buffer);
    return 1;
  }

  if (total_line < 4)
  {
    set_last_error("Could not extract data from CGI response. Not enough line in response.");
    free_fields(&fd);
    free(buffer);
    return 1; 
  }

  #ifdef DEBUG_PARSING
  fprintf (stdout, "total_line = %d\n", total_line);
  fflush (stdout);
  #endif

  /* --------------------------------------------------- */
  /* First line should be the status                     */
  /* --------------------------------------------------- */

  #ifdef DEBUG_PARSING
  fprintf (stdout, "First line is: %s\n", fd.tabs[0]);
  fflush (stdout);
  #endif

  line = fd.tabs[0];
  
  n = s_split (line, ":", &token);
  if (n == -1)
  {
    set_last_error("Could not extract data from CGI response. Not enough memory.");
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  if (n != 2)
  {
    set_last_error("Could not extract data from CGI response. Invalid token.");
    free_fields(&token);
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  if (strcmp (token.tabs[0], "status") != 0)
  {
    set_last_error("Could not extract data from CGI response. First line should be the status.");
    free_fields(&token);
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  #ifdef DEBUG_PARSING
  fprintf (stdout, "status = %s\n", token.tabs[1]);
  fflush (stdout);
  #endif

  strncpy (data->status, token.tabs[1], LOGISTIC_STATUS_SIZE);
  free_fields(&token);

  /* --------------------------------------------------- */
  /* Second line should be the number of rows            */
  /* --------------------------------------------------- */

  #ifdef DEBUG_PARSING
  fprintf (stdout, "Second line is: %s\n", fd.tabs[1]);
  fflush (stdout);
  #endif

  line = fd.tabs[1];

  n = s_split (line, ":", &token);
  if (n == -1)
  {
    set_last_error("Could not extract data from CGI response. Not enough memory.");
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  if (n != 2)
  {
    set_last_error("Could not extract data from CGI response. Invalid token.");
    free_fields(&token);
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  if (strcmp (token.tabs[0], "num_rows") != 0)
  {
    set_last_error("Could not extract data from CGI response. Second line should be the number of rows.");
    free_fields(&token);
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  #ifdef DEBUG_PARSING
  fprintf (stdout, "num_rows = %s\n", token.tabs[1]);
  fflush (stdout);
  #endif

  strncpy (data->num_rows, token.tabs[1], LOGISTIC_INTEGER_SIZE);
  free_fields(&token);

  /* --------------------------------------------------- */
  /* Third line should be the comment                    */
  /* Fourth line should be the description               */
  /* But we don't care about it...                       */ 
  /* Look at the rows, if exist.                         */  
  /* --------------------------------------------------- */

  total_rows    = total_line - 4;
  data->rows    = total_rows;
  data->columns = 0;

  curl = curl_easy_init();
  if (curl == NULL)
  {
    set_last_error("Could not initialize the CURL handle. Function curl_easy_init() failed.");
    free_fields(&fd);
    free(buffer);
    return 1;
  }

  for (l=0; l<total_rows; l++)
  {
    struct fields items;
    int           idx, nitems;

    line = fd.tabs[4+l];

    #ifdef DEBUG_PARSING
    fprintf (stdout, "line = %s\n", line);
    fflush (stdout);
    #endif

    n = s_split (line, ":", &token);
    if (n == -1)
    {
      set_last_error("Could not extract data from CGI response. Not enough memory.");
      free_fields(&fd);
      curl_easy_cleanup(curl);
      free(buffer);
      return 1;
    }
  
    if (n != 2)
    {
      set_last_error("Could not extract data from CGI response. Invalid token.");
      free_fields(&token);
      free_fields(&fd);
      curl_easy_cleanup(curl);
      free(buffer);
      return 1;
    }
  
    if (strcmp (token.tabs[0], "line") != 0)
    {
      set_last_error("Could not extract data from CGI response. This line should a 'line'.");
      free_fields(&token);
      free_fields(&fd);
      curl_easy_cleanup(curl);
      free(buffer);
      return 1;
    }

    /* ------------------------------------------------- */
    /* Split the row into elements                       */
    /* ------------------------------------------------- */

    nitems = s_split (token.tabs[1], ";", &items);
    data->columns = nitems;

    if (nitems == -1)
    {
      set_last_error("Could not extract data from CGI response. Not enough memory.");
      free_fields(&token);
      free_fields(&fd);
      curl_easy_cleanup(curl);
      free(buffer);
      return 1;
    }

    #ifdef DEBUG_PARSING
    fprintf (stdout, "Fields number: %d\n", nitems);
    fflush (stdout);
    #endif

    /* ------------------------------------------------- */
    /* For each "name=value" of the row, proceed         */
    /* ------------------------------------------------- */

    for (idx=0; idx<nitems; idx++)
    {
      struct fields couple;
      int           ncouple;
      char          *esc_name, *esc_value;

      ncouple = s_split (items.tabs[idx], "=", &couple);

      if (ncouple == -1)
      {
        set_last_error("Could not extract data from CGI response. Not enough memory.");
        free_fields(&token);
        free_fields(&items);
        free_fields(&fd);
        curl_easy_cleanup(curl);
        free(buffer);
        return 1;
      }

      if (ncouple == 0)
      {
        set_last_error("Could not extract data from CGI response. Invalid database item.");
        free_fields(&couple);
        free_fields(&token);
        free_fields(&items);
        free_fields(&fd);
        curl_easy_cleanup(curl);
        free(buffer);
        return 1;
      }

      esc_name = curl_easy_unescape (curl, couple.tabs[0], 0, NULL);
      if (esc_name == NULL)
      {
        set_last_error("Could not extract data from CGI response. No memory.");
        free_fields(&couple);
        free_fields(&token);
        free_fields(&items);
        free_fields(&fd);
        curl_easy_cleanup(curl);
        free(buffer);
        return 1;
      }

      strncpy((data->couples[l][idx]).name, esc_name, DATA_NAME_SIZE);
      curl_free(esc_name);

      if (ncouple == 1) { ((data->couples[l][idx]).value)[0] = 0; }
      else              {
                          esc_value = curl_easy_unescape (curl, couple.tabs[1], 0, NULL);
                          if (esc_value == NULL)
                          {
                            set_last_error("Could not extract data from CGI response. No memory.");
                            free_fields(&couple);
                            free_fields(&token);
                            free_fields(&items);
                            free_fields(&fd);
                            curl_easy_cleanup(curl);
                            free(buffer);
                            return 1;
                          } 
                          strncpy((data->couples[l][idx]).value, esc_value, DATA_VALUE_SIZE);
                          curl_free(esc_value);
                        }


      #ifdef DEBUG_PARSING
      fprintf (stdout, "\tname   = %s\n", (data->couples[l][idx]).name);
      fprintf (stdout, "\tvalue  = %s\n", (data->couples[l][idx]).value);
      fflush (stdout);
      #endif

      free_fields(&couple);
    }

    free_fields(&items); 
    free_fields(&token);
  }

  curl_easy_cleanup(curl);
  free_fields(&fd);
  free(buffer);
  return 0;
}

/*! \brief Returns a value associated with a given name.
    \param data Pointer to a 'logistic_xml' data sructure that contains the response from the CGI.
    \param line Number of the line to search in.
    \param name Pointer to a zero terminated string of characters that represents the name to look up.
    \return If the function finds the name, then it returns a pointer to a zero terminated string of
            characters that represents the associated value.
            Otherwize, the function returns the value NULL.
 */

char* web_logistic_get_data (struct logistic_xml *data, int line, char *name)
{
  int i;

  if (line > data->rows) { return NULL; }
  for (i=0; i<data->columns; i++)
  if (strcmp (data->couples[line][i].name, name) == 0) { return data->couples[line][i].value; }
  return NULL;
}





/* ----------------------------------------------------- */
/* Unitary test program                                  */
/* Define token 'TESTCURL' to generate this test program */
/* ----------------------------------------------------- */





#ifdef TESTCURL

#define PMAX 1024
#define UMAX 2048




static char test1[] = "status:OK\nnum_rows:5\ncomment:\ndescription:\nline:ID=2;MAC_ADDRESS=00%3A98%3A88%3A77%3A44%3A0f;LOGIN_MODEM=0003C996CFDE%40auto.hautdebit;PASSWD_MODEM=wxCzw3BE;RADIUS_LOGIN=test_3%40tiscali;FLAG_CHECK_RADIUS=0;FLAG_CHECK_MODEM=3;DATE_MODIF=20060802162642;DATE_CREATE=20050711163708;CODE_ACTION=BH;COMMENTAIRE=;\nline:ID=3;MAC_ADDRESS=00%3A98%3A88%3A77%3A44%3A0f;LOGIN_MODEM=0003C996CFDF%40auto.hautdebit;PASSWD_MODEM=wxCzw3BF;RADIUS_LOGIN=test_3%40tiscali;FLAG_CHECK_RADIUS=0;FLAG_CHECK_MODEM=0;DATE_MODIF=20060802162642;DATE_CREATE=20050711163708;CODE_ACTION=BH;COMMENTAIRE=;\nline:ID=4;MAC_ADDRESS=00%3A98%3A88%3A77%3A44%3A0f;LOGIN_MODEM=0003C996CFDG%40auto.hautdebit;PASSWD_MODEM=wxCzw3BG;RADIUS_LOGIN=test_3%40tiscali;FLAG_CHECK_RADIUS=0;FLAG_CHECK_MODEM=0;DATE_MODIF=20060802162642;DATE_CREATE=20050711163708;CODE_ACTION=BH;COMMENTAIRE=;\nline:ID=5;MAC_ADDRESS=00%3A98%3A88%3A77%3A44%3A0f;LOGIN_MODEM=0003C996CFDH%40auto.hautdebit;PASSWD_MODEM=wxCzw3BH;RADIUS_LOGIN=test_3%40tiscali;FLAG_CHECK_RADIUS=0;FLAG_CHECK_MODEM=0;DATE_MODIF=20060802162642;DATE_CREATE=20050711163708;CODE_ACTION=BH;COMMENTAIRE=;\nline:ID=6;MAC_ADDRESS=00%3A98%3A88%3A77%3A44%3A0f;LOGIN_MODEM=0003C996CFDI%40auto.hautdebit;PASSWD_MODEM=wxCzw3BI;RADIUS_LOGIN=test_3%40tiscali;FLAG_CHECK_RADIUS=0;FLAG_CHECK_MODEM=0;DATE_MODIF=20060802162642;DATE_CREATE=20050711163708;CODE_ACTION=BH;COMMENTAIRE=;\n\n";





/*! \brief Test program for this library.
    \remark Sample command line (search the word 'toto' on Google):
            ./bin/curl.test 'http://www.google.fr/search' 'hl' 'fr' 'q' 'toto' 'btnG' 'Recherche Google' 'meta' ''
 */

int main (int argc, char *argv[])
{
  struct request_data data;
  struct logistic_xml xml;
  int                 rc, i, j;
  int                 c, l;
  char                *url;
  char                *params[PMAX][2];
  char                p[UMAX];


  if (argc == 1) { goto TEST_UNITAIRE_1; }

  /* --------------------------------------------------- */
  /* Command line checking                               */
  /* --------------------------------------------------- */

  if (argc < 2)
  {
    fprintf (stderr, "Usage: %s <url> [<name1> <value1> [<name2> <value2> [...]]]\n\n", argv[0]);
    return 0;
  }

  if (argc % 2 != 0)
  {
    fprintf (stderr, "Error: You must specify one value per name\n");
    return 0;
  }

  if (argc - 2 > PMAX)
  {
    fprintf (stderr, "Error: Too many couples (name=value)\n");
    return 0;
  }

  url = argv[1];

  /* --------------------------------------------------- */
  /* Build the parameters array                          */
  /* --------------------------------------------------- */

  c = 0;
  l = 0;
  for (i=2; i<argc; i++)
  {
    params[l][c] = argv[i];
    c =  (c+1) % 2;
    l += i%2;
  }

  /* --------------------------------------------------- */
  /* Build the parameter's list                          */
  /* --------------------------------------------------- */

  if (web_format_params (params, (argc-2)/2, p, UMAX))
  {
    fprintf (stderr, "Error: Can not build parameter list, no memory.\n" );
    return 1;
  }

  fprintf (stdout, "CGI parameters list is:\n\n%s\n\n", p);

  /* --------------------------------------------------- */
  /* GET the URL                                         */
  /* --------------------------------------------------- */

  strncpy (data.url,    url,  CURL_URL_SIZE-1);
  strncpy (data.params, p,    CURL_HTTP_PARAMS_SIZE-1);
  data.request_timeout = 1;
  data.connect_timeout = 1;

  rc = web_get(&data);
  switch (rc)
  {
    case CURL_INIT_ERROR:    fprintf (stderr, "%s\n", web_get_last_error()); return 1;
    case CURL_REQUEST_ERROR: fprintf (stderr, "%s\n", web_get_last_error()); return 1;
    case CURL_OK:            fprintf (stdout, "OK\n\n\n");
  }

  fprintf (stdout, "%s, HTTP body is:\n\n%s\n\n", url, web_get_body(&data));

  if (web_logistic_parser (web_get_body(&data), &xml))
  {
    fprintf (stderr, "Error: Can not extract data from XML - %s.\n", web_get_last_error());
    return 1;
  }

  return 0;

  TEST_UNITAIRE_1:

  while (1)
  {
      if (web_logistic_parser (test1, &xml))
      {
        fprintf (stderr, "Error: Can not extract CGI data.\n\n");
        return 1;
      }
   
      #ifdef MEMORY_LEAK
      fprintf (stdout, "Result is:\n\n\n");
    
      fprintf (stdout, "Status   = %s\n", xml.status);
      fprintf (stdout, "num_rows = %s\n", xml.num_rows);
   
      for (i=0; i<xml.rows; i++)
      {
        for (j=0; j<xml.columns; j++)
        {
          fprintf (stdout, "Name  = %s\n", xml.couples[i][j].name);
          fprintf (stdout, "Value = %s\n", xml.couples[i][j].value);
        }
        fprintf (stdout, "\n---\n\n");
      }
      
      fprintf (stdout, "\n\n\n\n\n");
    
      fprintf (stdout, "Line 3, name='MAC_ADDRESS', value=%s\n", web_logistic_get_data(&xml, 3, "MAC_ADDRESS"));
      #endif
  }

  return 0;
}

#endif

libip.c


/*! \file libip.c
    This file implements the IP library. 
    The code comes from "http://www.geo.unizh.ch/~uruetsch/software/ipcalc.html".
    Modified by Denis BEURIVE
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "libip.h"

#define ERROR_SIZE 256
static char last_error[ERROR_SIZE]; 
typedef unsigned long uint32;

static int powoftwo(uint32 val);
static int makemask(int oc[4], uint32 *netmask);
static int rfc1918(uint32 ipaddr);
static char *fmtip(uint32 val);
static char *net_to_firstip (uint32 net);
static char* broadcast_to_lastip (uint32 broadcast);

/*! \brief Returns a message that represents the last error.
    \return The function returns a pointer to a zero terminated string of characters that represents the last error
            message.
 */

char* libip_get_last_error() { return last_error; }

/*! \brief Calculate the following data from a given CIDR ("X.X.X.X/Y"):
           <ul>
              <li>The first IP address.
              <li>The last IP address.
              <li>The netmask.
              <li>The network.
              <li>The broadcast address.
              <li>The class (A,B,C,D,E,F).
              <li>The slash value.
           <ul>
    \param addr Pointer to a zero terminated string of characters that represents the CIDR.
    \param result Pointer to a "ipresult" data structure used to store the result. 
    \return Upon successfull completion, the function returns the value 0.
            Otherwize, the function returns the value 1. In this case, please look at the last error message.
 */

int ipcalc(char *addr, struct ipresult *result)
{
  uint32 ipaddr=0, netmask, network, bcast;
  int    oc[4], slash, cla, isnw, isbc, i;
  char   *p;

  memset ((void*)last_error, 0, ERROR_SIZE);
  memset ((void*)result,     0, sizeof(struct ipresult));

  /* --------------------------------------- */
  /* Extract the IP components               */ 
  /* --------------------------------------- */

  i = sscanf(addr, "%d.%d.%d.%d", &oc[0], &oc[1], &oc[2], &oc[3]);
  if (i != 4)
  {
    snprintf (last_error, ERROR_SIZE, "Invalid IP address (%s)", addr);
    return 1;
  }

  /* --------------------------------------- */
  /* Sanity check                            */
  /* --------------------------------------- */

  for (i = 0; i < 4; i++)
  {
    if (oc[i] < 0 || oc[i] > 255)
    {
      snprintf (last_error, ERROR_SIZE, "Invalid IP address (%s) - Octet out of range (%d)",
                addr, oc[i]);
      return 1;
    }
  }

  /* --------------------------------------- */
  /* Build binary representation             */
  /* --------------------------------------- */

  for (i = 0; i < 4; i++) { ipaddr |= oc[i] << 8*(3-i); }

  /* --------------------------------------- */
  /* Is there a "/" ?                        */
  /* --------------------------------------- */

  if ((p = strchr(addr, '/')))
  { 
    if (strchr(p, '.'))
    { 
      i = sscanf(p, "/%d.%d.%d.%d", &oc[0], &oc[1], &oc[2], &oc[3]);
      if (i != 4)
      {
        snprintf (last_error, ERROR_SIZE, "Invalid netmask (%s)  - It should be .../X.X.X.X", p); 
        return 1;
      }
      i = makemask(oc, &netmask);
      if (i == 0)
      {
        snprintf (last_error, ERROR_SIZE, "Invalid netmask (%s)", p);
        return 1;
      } 
      else { slash = 32 - i; }
    }
    else
    { 
      i = sscanf(p, "/%d", &slash);
      if (i != 1 || slash < 0 || slash > 32)
      {
        snprintf (last_error, ERROR_SIZE, "Invalid netmask (%s) - /Y (Y=%d) out of range", p, slash);
        return 1;
      }
      if (slash == 32) { netmask = 0xffffffff; }
      else {
             netmask = 1 << (31-slash);
             netmask = ~(netmask | (netmask - 1));
           }
    }

    switch(slash)
    {
       case  8: cla='A'; break;
       case 16: cla='B'; break;
       case 24: cla='C'; break;
       default: cla=0; 
    }
  }
  else
  { 
    /* ------------------------------------- */
    /* No netmask specified                  */
    /*                                       */ 
    /* Note:                                 */ 
    /*   0x8 = 1000                          */ 
    /*   0xC = 1100                          */
    /*   0xE = 1110                          */
    /*   0XF = 1111                          */
    /* ------------------------------------- */

    int first = (ipaddr >> 24) & 0xFF; /* Isolate the first octet */

    while (1)
    { 
      if ((first & 0x80) == 0x00) { cla='A'; slash=8;  netmask=0xFF000000; break; }
      if ((first & 0xC0) == 0x80) { cla='B'; slash=16; netmask=0xFFFF0000; break; }
      if ((first & 0xE0) == 0xC0) { cla='C'; slash=24; netmask=0xFFFFFF00; break; }
      if ((first & 0xF0) == 0xE0) { cla='D'; slash=-1; netmask=0;          break; }

      cla='E'; slash=-1; netmask=0; break;
    }
  }

  network = ipaddr & netmask;                  /* network address    */
  bcast   = ipaddr | (0xFFFFFFFF & ~netmask);  /* broadcast address  */
  isnw    = (ipaddr == network);               /* host or network?   */
  isbc    = (ipaddr == bcast);                 /* broadcast address? */


  result->class = (char)cla;
  result->slash = slash;

  if ((slash < 0) && (cla > 2))
  {
    snprintf (last_error, ERROR_SIZE, "Class D,E,F: don't known how to calculate");
    return 1;
  }

  result->private = rfc1918(ipaddr);

  snprintf (result->firt_ip_address, MAX_IP_SIZE, "%s", net_to_firstip(ipaddr));
  snprintf (result->last_ip_address, MAX_IP_SIZE, "%s", broadcast_to_lastip(bcast));
  snprintf (result->netmask,         MAX_IP_SIZE, "%s", fmtip(netmask));
  snprintf (result->network,         MAX_IP_SIZE, "%s", fmtip(network));
  snprintf (result->broadcast,       MAX_IP_SIZE, "%s", fmtip(bcast));

  return 0;
}

/*! \brief Convert the binary representation of an IP address into the corresponding string.
    \param val Binary representation of the IP address to convert.
    \return The function returns a pointer to a statically allocated, zero terminated, string of characters that
            represents the IP address.
 */ 

static char *fmtip(uint32 val)
{
  static char buf[16];  /* xxx.xxx.xxx.xxx\0 */
  snprintf(buf, 16, "%d.%d.%d.%d",
           (int)((val>>24)&0xff),
           (int)((val>>16)&0xff),
           (int)((val>>8)&0xff),
           (int)(val&0xff));
  return buf;
}

/*! \brief Calculate the last IP address of the CIDR from the broadcast address.
    \param broadcast Binary representation of the broadcast address.
    \return The function returns a pointer to a zero terminated, statically allocated, string of characters that
            represents the last IP address of the CIDR.
 */

static char* broadcast_to_lastip (uint32 broadcast)
{
  int    oc[4];
  static char ip[16];

  oc[0] = (int)((broadcast>>24) & 0xff);  /* "X.x.x.x" */
  oc[1] = (int)((broadcast>>16) & 0xff);  /* "x.X.x.x" */
  oc[2] = (int)((broadcast>>8)  & 0xff);  /* "x.x.X.x" */
  oc[3] = (int)(broadcast       & 0xff);  /* "x.x.x.X" */

  oc[3] -= 1;

  snprintf(ip, 16, "%d.%d.%d.%d", oc[0], oc[1], oc[2], oc[3]);
  return ip;
}

/*! \brief Calculate the first IP of the CIDR  from the network address.
    \param net The network address.
    \return The function returns a pointer to a zero terminated, statically allocated, string of characters that
            represents the first IP address of the CIDR.
 */

static char *net_to_firstip (uint32 net)
{
  int    oc[4];
  static char ip[16];

  oc[0] = (int)((net>>24) & 0xff);
  oc[1] = (int)((net>>16) & 0xff);
  oc[2] = (int)((net>>8)  & 0xff);
  oc[3] = (int)(net       & 0xff);

  oc[3] += 1;

  snprintf(ip, 16, "%d.%d.%d.%d", oc[0], oc[1], oc[2], oc[3]);
  return ip;
}

/*! \brief Find out if an IP address is private or not.
    \param ipaddr Binary representation of the IP address to test.
    \return If the IP address is provate, the function returns the value 1.
            Otherwise, the function returns the value 0.
    \ramark See RFC 1918 "Address Allocation for Private Internets"
            <ul>
              <li>10.0.0.0 - 10.255.255          10/8 prefix          1 class A network
              <li>172.16.0.0 - 172.31.255.255    172.16/12 prefix    16 class B networks
              <li>192.168.0.0 - 192.168.255.255  192.168/16 prefix  256 class C networks
            </ul>
 */

static int rfc1918(uint32 ipaddr)  /* see RFC 1918 */
{
  int ispriv; ipaddr >>= 16;
  ispriv = ((ipaddr & 0xff00) == (uint32) 10*256)     ||
           ((ipaddr & 0xfff0) == (uint32) 172*256+16) ||
           ((ipaddr & 0xffff) == (uint32) 192*256+168);
  if (ispriv) { return 1; }
  return 0;
}

/*! \brief Create net mask from octets and return slash value.
    \param oc Array that contains the 4 octets of a netmask.
    \param netmask Pointer to an integer that will be used to store the binary representation of the netmask.
    \return If an error occured, the function returns the value 0.
            Otherwise, the function returns a non zero value.
 */

static int makemask(int oc[4], uint32 *netmask)
{
  int    i;
  uint32 mask = 0;

  for (i = 0; i < 4; i++)
  {
    if (oc[i] < 0 || oc[i] > 255) { return 0; }
    else { mask |= oc[i] << 8*(3-i); }
  }

  if (netmask) { *netmask = mask; }
  return powoftwo((~mask)^(2*(~mask)+1));
}

/*! \brief Find out the power of 2 for a given value (ex: val=8, return 3).
    \param val Value to test.
    \return The function returns the power of 2 associated with the given value.
            If the given value is not a power of 2, the function returns the value 0.
 */

static int powoftwo(uint32 val)
{
  int i;

  if (val & (val-1)) { return 0; } /* val is not a power of 2 */

  for (i = 0; (val&1) == 0; i++) { val >>= 1; }
  return i; /* val == 2^i */
}

logging.c

/*! \file logging.c
          This file implements the logging facility.
 */

#include "logging.h"








/* ------------------------------------------------------------- */
/*                         PRIVATE API                           */
/* ------------------------------------------------------------- */


/*! \brief Maximum number of characters for a date.
 */

#define MAX_TIME_SIZE 512

/*! \brief Maximum number of characters for the error message.
 */

#define ERROR_SIZE 4096

/*! \brief Maximum number of characters for the log level.
 */

#define PRIORITY_SIZE 128

/*! \brief Maximum number of characters for the path to the log file.
 */

#define MAX_LOG_FILE_NAME 256

/*! \brief Maximum size (in bytes) for the log file.
    \remark 2147381248 bytes = 2Go - 100ko
 */

static unsigned long int MAXLOGFILESIZE = 0;

/*! \brief Numerical value of the current tag.
           This value is incremented by calling the function logger_new_tag().
 */

static unsigned int current_tag = 0;

/*! \brief Path to the log file.
 */

static char logfile[MAX_LOG_FILE_NAME];

/*! \brief Last error for the logging module (this module).
           This string is not used to store error message from other modules.
 */

static char last_error[ERROR_SIZE];

/*! \brief Last error message for the application (not the module itself).
 */

static char app_error[ERROR_SIZE];

/*! \brief Pointer to an (external) string buffer that contains the prefix to print at the beginning of each line.
 */

static char *prefix;

/*! \brief Mask that defines the levels of log to print.
           It is a combinaison of the binary values defined in the header file "logging.h" (see section "LOG LEVELS").
 */ 

static unsigned int loglevels;

/*! \brief This is the rank of the log level (loglevels & 0x7FFFFFFF).
 */

static unsigned int rank;

/*! \brief This flag indicates if the loglevel contains the terminal flag.
 */

static unsigned int endding;

/*! \brief This flag is used to ensure that empty lines are written only if necessary.
 */

static int wflag;

/*! \brief Maximum number of characters for a MAC address.
 */

#define MACSIZE 256

/*! \brief Buffer used to store the current MAC address.
 */

static char mac[MACSIZE];

/*! \brief Set the current MAC address.
    \param m Pointer to a zero terminated string of characters that represents the MAC address.
 */

void logger_set_mac (char *m) { strncpy (mac, m, MACSIZE); }

/*! \brief Initialize the current MAC address to all zeros.
 */

void clear_mac_address()
{
  memset ((void*)mac, 0, MACSIZE);
  strncpy (mac, "--:--:--:--:--:--", MACSIZE);
} 

/*! \brief Set the last error message.
    \param error Pointer to a string that represents the last error message.
 */

static void set_last_error (const char * fmt,...)
{
  va_list   list;

  memset ((void*)last_error, 0, ERROR_SIZE);
  va_start (list, fmt);
  vsnprintf (last_error, ERROR_SIZE - 1, fmt, list);
  va_end (list);
}

/*! \brief Clear the last error (set all zeros).
 */

static void clear_last_error()
{ memset ((void*)last_error, 0, ERROR_SIZE); }

/*! \brief Return the current tag (this is a numerical value).
    \author Denis BEURIVE
    \return The function returns a pointer to a statically allocated,
            zero terminated string of characters that represents the current tag.
 */

static char* log_tag()
{
  static char t[13];
  int         p;

  memset (t, 0, 13);
  snprintf (t, 13, "%12u", current_tag);
  for (p=0; p<13; p++) { if (t[p] == ' ') { t[p] = '0'; } }
  return t;
}

/*! \brief Return the current date as Apache's standard.
    \author Denis BEURIVE
    \return The function returns a pointer to a string of characters that contains the current date.
    \warning The string is returned in a statically allocated buffer, which subsequent calls
             will overwrite.
 */

static char* dater()
{
  static char  strtime[MAX_TIME_SIZE];
  time_t       tt;

  tt = time(NULL);
  strftime (strtime, 256, "%Y-%m-%d %k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Return a timestamp usable for file name.
    \author Denis BEURIVE
    \return The function returns a timestamp that can be used for file names.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
 */

static char* filetimestamp()
{
  static char  strtime[MAX_TIME_SIZE];
  time_t       tt;

  tt = time(NULL);
  strftime (strtime, 256, "%Y%m%d-%k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Get the size of a given file (in bytes).
    \param file Path to the file.
    \return Upon successful completion, the function returns the size of the file (in bytes).
            The value 0 can mean that:
            <ul>
              <li>The file is empty.
              <li>The file does not exist.
            </ul>
            If an error occures, the function returns the value (unsigned long int)(-1).
 */

static unsigned long int get_file_size (const char *file)
{
  struct stat s;

  clear_last_error();

  if (stat(file, &s) == -1)
  {
    int e = errno;
    if (e == ENOENT) { return 0; }
    set_last_error ("stat(%s) : %s (%s,%d)", file, strerror(e), __FILE__, __LINE__);
    return (unsigned long int)(-1);
  }

  return (unsigned long int)(s.st_size);
}



/* ------------------------------------------------------------- */
/*                         PUBLIC API                            */
/* ------------------------------------------------------------- */

/*! \brief Initialize the logging system.
    \param size This flag defines whether you want the module to control the size of the log file or not.
                Values can be:
                <ul>
                   <li>Zero: Do not control the size of the log file.
                   <li>Any other value (strictly greater than zero): the maximum size of the log file.
                </ul>
    \param pref Pointer to a buffer that will be used to print a prefix for all line of logs.
                If NULL, then this parameter will be ignored.
    \param level Mask that defines the log's levels to print.
                 See the header file for the list of levels.
    \param path Pointer to a zero terminated string of characters that represents the path to the log file.
    \author Denis BEURIVE
 */

void logger_init(unsigned long int size, char* pref, unsigned int level, char *path)
{
  static char noprefix[]="\0";
  loglevels = level;
  if (size > 0) { MAXLOGFILESIZE = size; } else { MAXLOGFILESIZE = 0; }
  clear_last_error();
  clear_mac_address();
  if (pref == NULL) { prefix = noprefix; } else { prefix = pref; }
  memset ((void*)logfile, 0, MAX_LOG_FILE_NAME);
  strncpy (logfile, path, MAX_LOG_FILE_NAME);
  wflag = 1;

  /* ---------------------------------- */
  /* Notes:                             */
  /*                                    */
  /*  o 0x80000000 = 10000000...0       */
  /*  o 0x7FFFFFFF = 01111111...1       */
  /* ---------------------------------- */

  endding = loglevels & 0x80000000;   /* We keep the left bit only (terminal flag) */
  rank    = loglevels & 0x7FFFFFFF;   /* We remove the left bit only               */
}

/*! \brief Record the last applicative error message.
    \param mess Pointer to a zero terminated string of characters that represents the error message to record.
    \warning You can only record one error message (the first one), until you call logger_get_error().
 */

void logger_set_error (char* mess)
{ if (*app_error == 0) { strncpy (app_error, mess, ERROR_SIZE-1); } }

/*! \brief Return the applicative error message.
    \return The function returns a pointer to a statically alocated string of characters
            that represents the applicative error message.
 */ 

char* logger_get_error()
{
  static char s[ERROR_SIZE];
  memset ((void*)s, 0, ERROR_SIZE);
  strncpy (s, app_error, ERROR_SIZE-1);
  memset ((void*)app_error, 0, ERROR_SIZE);
  return s;
}

/*! \brief Clear the applicative error.
 */

void logger_reset_error()
{ memset ((void*)app_error, 0, ERROR_SIZE); }

/*! \brief Return the last error message for the logging module (this module).
    \return The function returns a pointer to a statically alocated string of characters
            that represents the last error.
 */

char* logger_get_last_logger_error() { return last_error; }

/*! \brief Increment the value of the current tag.
    \author Denis BEURIVE
 */

void logger_new_tag() { current_tag++; wflag = 0; }

/*! \brief Return the current tag (this is a numerical value).
    \author Denis BEURIVE
    \return The function returns a pointer to a statically allocated,
            zero terminated string of characters that represents the current tag.
 */

char* logger_get_tag() { return log_tag(); }

/*! \brief Log one line in a given log file.
    \author Denis BEURIVE
    \param level Level of the log message.
           <ul>
               <li>LEVEL_FULL_VERBOSE
               <li>LEVEL_VERBOSE 
               <li>LEVEL_DEBUG
               <li>LEVEL_INFO
               <li>LEVEL_WARNING
               <li>LEVEL_ERROR
               <li>LEVEL_FATAL
           </ul>
    \param terminal This value indicates wether this log is a terminal one.
           Values could be:
           <ul> 
              <li>TERMINAL_LEVEL: This is a terminal log message.
              <li>HIGH_LEVEL: This is a non terminal log message.
           </ul> 
    \param src Pointer to the name of the source file (should be __FILE__).
    \param line Line number in the source file (should be __LINE__).
    \param ftm Pointer to a zero terminated string of characters that defines the output formats (same as printf()).
    \return Upon successful completion, the function returns the value 0. Otherwize, the function returns the value 1.
    \remark This function behaves just like the function printf().
    \warning This function uses the variable "prefix" that has been initialized by calling the function logger_init().
             You must ensure that the buffer "pointed" by prefix is a valid buffer!.
 */

int my_syslog (unsigned int level, unsigned int terminal, char *src, int line, const char * fmt,...)
{
  va_list            list;
  static char        mbuf[4097];
  FILE               *fd;
  unsigned long int  filesize;
  int                ifd;
  char               *priority;
  static char        lfullverbose[]="VERBOSE", lverbose[]="VERBOSE", ldebug[]="DEBUG", linfo[]="INFO", lwarning[]="WARNING", lerror[]="ERROR", lfatal[]="FATAL";


  /* ---------------------------------- */
  /* Should the level be printed?       */
  /* ---------------------------------- */

  if (level < rank)                               { return 0; }
  if ((endding != 0) && (terminal == HIGH_LEVEL)) { return 0; }

  switch (level)
  {
    case LEVEL_FULL_VERBOSE: priority = lfullverbose; break;
    case LEVEL_VERBOSE:      priority = lverbose;     break;
    case LEVEL_DEBUG:        priority = ldebug;       break;
    case LEVEL_INFO:         priority = linfo;        break; 
    case LEVEL_WARNING:      priority = lwarning;     break;
    case LEVEL_ERROR:        priority = lerror;       break;
    case LEVEL_FATAL:        priority = lfatal;       break;
  }

  /* ---------------------------------- */
  /* Format the message                 */
  /* ---------------------------------- */

  memset ((void*)mbuf, 0, 4097);
  clear_last_error();

  va_start (list, fmt);
  vsnprintf (mbuf, (sizeof mbuf) - 1, fmt, list);
  va_end (list);

  /* ---------------------------------- */
  /* Check the size of the file         */
  /* Rename it if necessary             */
  /* ---------------------------------- */

  if (MAXLOGFILESIZE > 0)
  {
    filesize = get_file_size (logfile);
    if (filesize != (unsigned long int)(-1))
    {
      if (filesize > MAXLOGFILESIZE)
      {
        char newpath[256];
        memset((void*)newpath, 0, 256);
        snprintf (newpath, 256, "%s.%s", logfile, filetimestamp());
        if (rename (logfile, newpath) == -1)
        {
          int e = errno;
          set_last_error ("rename(%s,%s) : %s (%s,%d)",
                           logfile, newpath ,strerror(e), __FILE__, __LINE__);
          return 1;
        }
      }
    }
    else { return 1; }
  }

  ifd = open (logfile, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
  if (ifd == -1)
  {
    int e = errno;
    set_last_error ("open(%s) : %s (%s,%d)", logfile, strerror(e), __FILE__, __LINE__);
    return 1;
  }

  fd = fdopen (ifd, "a");
  if (fd == NULL)
  {
    int e = errno;
    set_last_error ("fdopen(%d) : %s (%s,%d)", ifd, strerror(e), __FILE__, __LINE__);
    return 1;
  }

  /* ---------------------------------- */
  /* Note: You can print the auto-incre */
  /*       mented tag "log_tag()".      */
  /*       "%s", log_tag()              */
  /* ---------------------------------- */

  if (
       (rank == LEVEL_VERBOSE)
       ||
       (rank == LEVEL_FULL_VERBOSE)
     )
  {
    fprintf (fd, "[%s] [%s] [%s] [%s:%d] %s %s\n",
                 mac,
                 priority,
                 prefix,
                 src,
                 line,
                 dater(),
                 mbuf);
    wflag = 1;
  }
  else
  {
    if ((level == LEVEL_WARNING) || (level == LEVEL_ERROR) || (level == LEVEL_FATAL))
    {
      fprintf (fd, "[%s] [%s] %s %s (%s)\n",
                   mac,
                   priority,
                   dater(),
                   mbuf,
                   prefix);
      wflag = 1;
    }
    else
    {
      fprintf (fd, "[%s] [%s] %s %s\n",
                   mac,
                   priority,
                   dater(),
                   mbuf);
      wflag = 1;
    } 
  }

  fclose (fd);
  return 0;
}

/*! \brief Log 2 empty lines in a given log file.
    \author Denis BEURIVE
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int my_syslog_skip_line ()
{
  FILE  *fd;
  int   ifd;

  clear_last_error(); 
  if (wflag == 0) { return 0; }

  ifd = open (logfile, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
  if (ifd == -1)
  {
     int e = errno;
     set_last_error ("open(%s) : %s (%s,%d)", logfile, strerror(e), __FILE__, __LINE__);
     return 1;
  }

  fd = fdopen (ifd, "a");
  if (fd == NULL)
  {
     int e = errno;
     set_last_error ("fdopen(%s) : %s (%s,%d)", logfile, strerror(e), __FILE__, __LINE__);
     return 1;
  }
 
  fprintf (fd, "\n\n");
  fclose (fd);
  return 0;
}

logistic.c

/*! \file logistic.c
          This file implements high level MySql functionnalities for the LOGISTIC_RADIUS.
 */

#include <string.h>
#include <stdio.h>
#include "logistic.h"
#include "mysql_interface.h"
#include "modem.h"
#include "logging.h"


/*! \brief Lookup the table LOGISTIC and perform the required actions.
    \author Denis BEURIVE
    \param mysql_info_logistic Pointer to a 'smysql' data structure that contains the MySql configuration
                               for the LOGISTIC_RADIUS table.
    \param mysql_info_abonnes Pointer to a 'smysql' data structure that contains the MySql configuration
                              for the 'abonnes' table.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The context must have been loaded.
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \param packet_in Pointer to a 'dhcp_packet' data structure that contains the incoming DHCP packet.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
              <li>MYSQL_INTERFACE_CONNECTION_LOST
              <li>MYSQL_INTERFACE_MORE_THAN_ONE
              <li>MYSQL_INTERFACE_NOT_FOUND
              <li>MYSQL_INTERFACE_RECONNECTION_FAILED
              <li>MYSQL_INTERFACE_REQUEST_SKIPED
              <li>MYSQL_INTERFACE_SQL_PROBLEM
              <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
            </ul>
 */

int look_up_logistic (struct smysql        *mysql_info_logistic,
                      struct smysql        *mysql_info_abonnes,
                      struct mysql_tables  *mysql_tables,
                      struct global_config *config,
                      struct dhcp_packet   *packet_in)
{
  char                  *mac_address;
  int                   rc, mcaddress_found;
  int                   request_type;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling look_up_logistic().");

  request_type = packets_get_message_type(packet_in);

  /* ----------------------------------------------------- */
  /* Calculate the real MAC address, depending on the      */
  /* modem's manufacturor.                                 */
  /* ----------------------------------------------------- */

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Modem's manufacturor is = '%s'.",
             id_manufacturor_to_string(mysql_tables->logistic.modem_manufacturor));

  mac_address = calculate_modem_mac_address (packet_in, mysql_tables->logistic.modem_manufacturor);
  strncpy (mysql_tables->logistic.MAC_ADDRESS, mac_address, LOGISTIC_MAC_ADDRESS_SIZE-1);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calculated MAC address is '%s'.",
             mac_address);

  /* ----------------------------------------------------- */
  /* Prepare the LOGIN_MODEM                               */
  /* ----------------------------------------------------- */

  snprintf (mysql_tables->logistic.LOGIN_MODEM,
            LOGIN_MODEM_SIZE,
            "%s@auto.hautdebit",
            mysql_tables->logistic.MAC_ADDRESS);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Login modem is '%s'.",
             mysql_tables->logistic.LOGIN_MODEM);

  /* ----------------------------------------------------- */
  /* Load the LOGISTIC table                               */
  /* ----------------------------------------------------- */

  mcaddress_found = load_logistic (mysql_info_logistic, mysql_tables, config);

  switch (mcaddress_found)
  {
    case MYSQL_INTERFACE_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: Request skiped.");
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_INTERFACE_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: Connection lost.");
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_INTERFACE_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: Could not reconnect.");
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_INTERFACE_SQL_PROBLEM:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: Some SQL error.");
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_INTERFACE_MORE_THAN_ONE:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: More than one record MAC_ADDRESS='%s'.",
                    mysql_tables->logistic.MAC_ADDRESS);
         return MYSQL_INTERFACE_MORE_THAN_ONE;

    case MYSQL_INTERFACE_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not load LOGISTIC: Unexpected error.");
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case MYSQL_INTERFACE_NOT_FOUND: break;
  }

  /* ----------------------------------------------------- */
  /* If the MAC address was not found, signal it           */
  /* ----------------------------------------------------- */

  if (mcaddress_found == MYSQL_INTERFACE_NOT_FOUND)
  {
     my_syslog (
                LEVEL_ERROR,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Could not found MAC address '%s'. This MAC comes from: (node=%s, shelf=%u, port=%u, slot=%u, vci=%u). The Radius login is '%s'. This MAC comes from a '%s' modem.",
                mac_address,
                mysql_tables->abonnes.node,
                mysql_tables->abonnes.shelf,
                mysql_tables->abonnes.port,
                mysql_tables->abonnes.slot,
                mysql_tables->abonnes.vci,
                mysql_tables->abonnes.login_radius,
                id_manufacturor_to_string(mysql_tables->logistic.modem_manufacturor));

    /* --------------------------------------------------- */
    /* Insert (LOGIN_MODEM,MAC_ADDRESS) into               */
    /* LOGISTIC_RADIUS.                                    */
    /* --------------------------------------------------- */

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Insert new MAC address (%s) into LOGISTIC_RADIUS / LOGIN_MODEM=%s.",
               mac_address,
               mysql_tables->logistic.LOGIN_MODEM);

    rc = signal_unknown_mac_address (mysql_info_logistic,
                                     mysql_tables,
                                     config);

    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not update LOGISTIC: Request skiped.");
           return MYSQL_INTERFACE_REQUEST_SKIPED;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not update LOGISTIC: Connection lost.");
           return MYSQL_INTERFACE_CONNECTION_LOST;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not update LOGISTIC: Could not reconnect.");
           return MYSQL_INTERFACE_RECONNECTION_FAILED;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not update LOGISTIC: Some SQL error.");
           return MYSQL_INTERFACE_SQL_PROBLEM;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not update LOGISTIC: Unexpected SQL error.");
           return MYSQL_INTERFACE_UNEXPECTED_ERROR;
    }

    /* --------------------------------------------------- */
    /* Update table 'abonnes'                              */
    /* --------------------------------------------------- */

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Blackhole the client (node=%s, shelf=%u, port=%u, slot=%u, vci=%u, Radius login=%s).",
               mysql_tables->abonnes.node,
               mysql_tables->abonnes.shelf,
               mysql_tables->abonnes.port,
               mysql_tables->abonnes.slot,
               mysql_tables->abonnes.vci,
               mysql_tables->abonnes.login_radius);

    rc = blackhole_abonne (mysql_info_abonnes,
                           mysql_tables,
                           config);

    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: Request skiped.");
           return MYSQL_INTERFACE_REQUEST_SKIPED;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: Connexion lost.");
           return MYSQL_INTERFACE_CONNECTION_LOST;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: Could not reconnect.");
           return MYSQL_INTERFACE_RECONNECTION_FAILED;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: Some SQL problem.");
           return MYSQL_INTERFACE_SQL_PROBLEM;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: Unexpected SQL error.");
           return MYSQL_INTERFACE_UNEXPECTED_ERROR;

      case MYSQL_INTERFACE_MORE_THAN_ONE:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: More than one record abonnes.id=%u (Radius login=%s).",
                      mysql_tables->abonnes.id,
                      mysql_tables->abonnes.login_radius);
           return MYSQL_INTERFACE_MORE_THAN_ONE;

      case MYSQL_INTERFACE_NOT_FOUND:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not blackhole client: No record found with abonnes.id=%u (Radius login=%s).",
                      mysql_tables->abonnes.id,
                      mysql_tables->abonnes.login_radius);
           return MYSQL_INTERFACE_NOT_FOUND;
    }

    /* --------------------------------------------------- */
    /* Overwrite client's profile in global tables         */
    /* This is necessary because options will be reloaded. */
    /* --------------------------------------------------- */

    strncpy (mysql_tables->abonnes.profile,
             mysql_tables->abonnes.autoconf_blackhole_profile,
             OPTIONNAL_PROFILE_SIZE);

    /* --------------------------------------------------- */
    /* Set data for Radonline's update                     */
    /* --------------------------------------------------- */

    memset ((void*)mysql_tables->logistic.radonline_acct_identifier, 0, ACCT_IDENTIFIER_SIZE);
    memset ((void*)mysql_tables->logistic.radonline_user_name,       0, LOGIN_RADIUS_SIZE);
    memset ((void*)mysql_tables->logistic.login_modem,               0, LOGISTIC_LOGIN_MODEM_SIZE);

    strncpy (mysql_tables->logistic.radonline_acct_identifier,
             "Auth-BH-Autoconf",
             ACCT_IDENTIFIER_SIZE-1);

    strncpy (mysql_tables->logistic.radonline_user_name,
             mysql_tables->logistic.LOGIN_MODEM,
             LOGIN_RADIUS_SIZE-1);

    strncpy (mysql_tables->logistic.login_modem,
             mysql_tables->logistic.LOGIN_MODEM,
             LOGISTIC_LOGIN_MODEM_SIZE-1);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "radonline_acct_identifier='%s'.",
               mysql_tables->logistic.radonline_acct_identifier);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "radonline_user_name='%s'.",
               mysql_tables->logistic.radonline_user_name);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "login_modem='%s'.",
               mysql_tables->logistic.login_modem); 

    return 0;
  }

  /* ----------------------------------------------------- */
  /* The MAC address was found                             */
  /* ----------------------------------------------------- */

  if (mysql_tables->logistic.FLAG_CHECK_RADIUS == 1)
  {
    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Modem already checked, nothing to do (Radius login='%s').",
               mysql_tables->logistic.RADIUS_LOGIN);

    return 0;
  }

  /* ----------------------------------------------------- */
  /* This is the first time the modem starts               */
  /* ----------------------------------------------------- */

  if (strcmp (mysql_tables->logistic.RADIUS_LOGIN, mysql_tables->abonnes.login_radius) == 0)
  {
    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "First time modem check - Radius login identical (%s).",
               mysql_tables->abonnes.login_radius);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Set flag FLAG_CHECK_RADIUS to value 1.");

    rc = set_flag_check_radius (mysql_info_logistic,
                                mysql_tables,
                                config);

    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: Request skiped.");
           return MYSQL_INTERFACE_REQUEST_SKIPED;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: Connexion lost.");
           return MYSQL_INTERFACE_CONNECTION_LOST;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: Could not reconnect.");
           return MYSQL_INTERFACE_RECONNECTION_FAILED;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                     "Could not set Flag Check Radius: Some SQL error.");
           return MYSQL_INTERFACE_SQL_PROBLEM;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: Unexpected SQL error.");
           return MYSQL_INTERFACE_UNEXPECTED_ERROR;

      case MYSQL_INTERFACE_NOT_FOUND:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: Record MAC address='%s' not found.",
                      mysql_tables->logistic.MAC_ADDRESS);
           return MYSQL_INTERFACE_NOT_FOUND;

      case MYSQL_INTERFACE_MORE_THAN_ONE:
           my_syslog (
                      LEVEL_ERROR,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not set Flag Check Radius: More than one record found MAC address='%s'",
                      mysql_tables->logistic.MAC_ADDRESS);
           return MYSQL_INTERFACE_MORE_THAN_ONE;
    }

    return 0;
  }

  /* ----------------------------------------------------- */
  /* This is the first connection, but the Radius logins   */
  /* are not identical.                                    */ 
  /* ----------------------------------------------------- */

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Client (node=%s, shelf=%u, port=%u, slot=%u, vci=%u, Radius login=%s) with MAC address=%s : Radius login not identical (LOGISTIC_RADIUS='%s' and abonnes='%s' and Manufacturor is '%s')",
             mysql_tables->abonnes.node,
             mysql_tables->abonnes.shelf,
             mysql_tables->abonnes.port,
             mysql_tables->abonnes.slot,
             mysql_tables->abonnes.vci,
             mysql_tables->abonnes.login_radius,
             mac_address,
             mysql_tables->logistic.RADIUS_LOGIN,
             mysql_tables->abonnes.login_radius,
             id_manufacturor_to_string(mysql_tables->logistic.modem_manufacturor));

  /* ----------------------------------------------------- */
  /* Set data for Radonlinei's update                      */
  /* ----------------------------------------------------- */

  memset ((void*)mysql_tables->logistic.radonline_acct_identifier, 0, ACCT_IDENTIFIER_SIZE);
  memset ((void*)mysql_tables->logistic.radonline_user_name,       0, LOGIN_RADIUS_SIZE);

  strncpy (mysql_tables->logistic.radonline_acct_identifier,
           "Auth-BH-Autoconf",
           ACCT_IDENTIFIER_SIZE-1);

  strncpy (mysql_tables->logistic.radonline_user_name,
           mysql_tables->logistic.LOGIN_MODEM,
           LOGIN_RADIUS_SIZE-1);

  strncpy (mysql_tables->logistic.login_modem,
           mysql_tables->logistic.LOGIN_MODEM,
           LOGISTIC_LOGIN_MODEM_SIZE-1);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "radonline_acct_identifier='%s'.",
             mysql_tables->logistic.radonline_acct_identifier);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "radonline_user_name='%s'.",
             mysql_tables->logistic.radonline_user_name);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "login_modem='%s'.",
             mysql_tables->logistic.login_modem);

  /* ----------------------------------------------------- */
  /* Blackhole the client                                  */
  /* ----------------------------------------------------- */

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Blackhole the client.");

  rc = blackhole_abonne (mysql_info_abonnes,
                         mysql_tables,
                         config);

  switch (rc)
  {
    case MYSQL_INTERFACE_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: Request skiped.");
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_INTERFACE_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: Connexion lost.");
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_INTERFACE_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: Could not reconnect.");
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_INTERFACE_SQL_PROBLEM:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: Some SQL error.");
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_INTERFACE_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: Unexpected error.");
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case MYSQL_INTERFACE_MORE_THAN_ONE:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: More than one record abonnes.id='%lu' (Radius login='%s').",
                    mysql_tables->abonnes.id,
                    mysql_tables->abonnes.login_radius);
         return MYSQL_INTERFACE_MORE_THAN_ONE;

    case MYSQL_INTERFACE_NOT_FOUND:
         my_syslog (
                    LEVEL_ERROR,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not backhole client: No record found for abonnes.id='%lu' (Radius login='%s').",
                    mysql_tables->abonnes.id,
                    mysql_tables->abonnes.login_radius);
         return MYSQL_INTERFACE_NOT_FOUND;
  }


  /* ----------------------------------------------------- */
  /* Overwrite client's profile in global tables           */
  /* This is necessary because options will be reloaded.   */
  /* ----------------------------------------------------- */

  strncpy (mysql_tables->abonnes.profile,
           mysql_tables->abonnes.autoconf_blackhole_profile,
           OPTIONNAL_PROFILE_SIZE);

  return 0;
}

modem.c

/*! \brief modem.c
     This file contains all functionn associated with the modem's manipulation.
 */

#include <string.h>
#include "modem.h"
#include "logging.h"



/*! \author Denis BEURIVE
    \brief Returns the index (in the list of modem configuration tags) that corresponds to the received packet.
           The research uses the 6 first bytes of the MAC address and the VCI value.
    \param packet Pointer to a 'dhcp_packet' data structure that represents the incoming packet.
           associated with the interace.
    \return The function returns an integer that is the index (in the list of modem configuration tags) that corresponds
            to the received packet.
            The list of possible values is defined in the file 'modem.h'.
    \remark The returned value MODEM_UNKNOWN means that the modem is not in the list of 
            selected modems. This is not an error. 
 */

int get_modem_manufacturor (struct dhcp_packet *packet)
{
  char               *haddr;
  unsigned short int vci;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_modem_manufacturor().");

  /* ------------------------------------------------------------------ */
  /* Lookup MAC address                                                 */
  /* ------------------------------------------------------------------ */

  haddr = packets_get_chaddr_no_separator(packet);
  vci   = packets_get_vci(packet);
  return (modem_conf_get_id(haddr, vci));
}

/*! \author Denis BEURIVE
    \brief Calculate the modem's network MAC address from the modem mother board MAC address.
    \param packet Pointer to a 'dhcp_packet' data structure that represents the incoming packet.
    \param manufacturor Integer value that represents the modem's manufacturor (as returnrd by the
                        function get_modem_manufacturor()).
    \return The function returns a pointer to a statically allocated string of characters that represents
            the mac address in hexadecimal notation (without ':').
 */

char *calculate_modem_mac_address (struct dhcp_packet *packet, int manufacturor)
{
  char          *real_haddr;
  static char   haddr_hexa[DHCP_P_STR_HADDR_SIZE_EXACT];
  char          *new_haddr;
  char*         (*calculate_mac_address)(char*);

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling calculate_modem_mac_address().");

  real_haddr = packets_get_chaddr_no_separator(packet);
  memset ((void*)haddr_hexa, 0, DHCP_P_STR_HADDR_SIZE_EXACT);
  strncpy (haddr_hexa, real_haddr, DHCP_P_STR_HADDR_SIZE_EXACT-1);


  calculate_mac_address = (char*(*)(char*))modem_conf_get_function(manufacturor);
  new_haddr = (*calculate_mac_address)(haddr_hexa);

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calculate_modem_mac_address: MAC [%s] => [%s].",
             real_haddr,
             new_haddr);

  return new_haddr;
}

/*! \brief Return a string that represents the modem's manufacturor.
    \author Denis BEURIVE
    \param id Integer that represents the manufacturor (see file 'modem.h' for the list of IDs).
    \return The function returns a pointer to a zero terminated string of characters that represents
            the modem's manufacturor.
 */

char *id_manufacturor_to_string (int id)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling id_manufacturor_to_string().");

  return modem_conf_get_tag_name(id);
}

mysql.c

/*! \file mysql.c
          Simple interface to MySql.
 */ 

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <mysql/errmsg.h>
#include "mysqld_error.h"

#include "config.h"        /* EXT, from the common-c-lib   */ 
#include "strings_utils.h" /* EXT, from the common-c-lib   */
#include "mysql_header.h"  /* INT, header for _this_ file  */
#include "logging.h"       /* INT, specific LOG service    */ 






static void set_last_error (struct smysql *mysql_info);
static void clear_error_reporting (struct smysql *mysql_info);
static void copy_error (struct smysql *mysql_info, char *m);
static int standard_query (struct smysql *mysql_info, char* query);

/*! \brief Last MySql error message.
 */

char mysql_error_str[MYSQL_MAX_ERROR_SIZE];

/*! \brief Last MySql error code.
 */

int  mysql_error_errno;

/*! \brief Clear all error reporting data.
    \author Denis BEURIVE
 */

static void clear_error_reporting (struct smysql *mysql_info)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling clear_error_reporting().");

  mysql_info->last_error_int = 0;
  memset ((void*)mysql_info->last_error_str, 0, MYSQL_MAX_ERROR_SIZE);
  mysql_error_errno = 0;
  memset ((void*)mysql_error_str, 0, MYSQL_MAX_ERROR_SIZE);
}

/*! \brief Safely copy error message from MySql.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

static void set_last_error (struct smysql *mysql_info)
{
  const char *err;
  int        merror;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling set_last_error().");

  err    = NULL;
  merror = 0;

  clear_error_reporting (mysql_info);

  merror = mysql_errno(mysql_info->handler);
  err    = mysql_error(mysql_info->handler);
 
  mysql_info->last_error_int = merror;

  if (err != NULL) { strncpy (mysql_info->last_error_str, err, MYSQL_MAX_ERROR_SIZE); }
  else             { strncpy (mysql_info->last_error_str, "No error message available", MYSQL_MAX_ERROR_SIZE); }

  mysql_error_errno = mysql_info->last_error_int;
  strcpy (mysql_error_str, mysql_info->last_error_str);
 
  return;
}

/*! \brief Safely copy a specific error message to the error reporting system. This function is intended to
           set functional error message (that does not have MySql system error defined).
    \author Denis BEURIVE
    \param mysql_info mysql_info Pointer to a Mysql management structure.
    \param m Pointer to zero terminated string of characters that represents the error message to report.
 */

static void copy_error (struct smysql *mysql_info, char *m)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling copy_error().");

  clear_error_reporting (mysql_info);
  mysql_info->last_error_int = 0;
  mysql_error_errno          = 0;
  strncpy (mysql_info->last_error_str, m, MYSQL_MAX_ERROR_SIZE); 
  strcpy (mysql_error_str, mysql_info->last_error_str);
}


/*! \brief Initialise the Mysql management structure.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

void init_mysql_structure (struct smysql *mysql_info)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling init_mysql_structure().");

  mysql_info->handler                   = NULL;
  mysql_info->result                    = NULL;
  mysql_info->num_fields                = -1;
  mysql_info->num_rows                  = -1;
  mysql_info->last_connection_timestamp = 0;
  mysql_info->connected                 = 0;

  clear_error_reporting (mysql_info);
}

/*! \brief Connect to Mysql server.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure that contains all the configuration for the
           connection.
    \return Upon successful completion, the function returns the value 0. 
            Otherwise it returns the value 1.
    \warning <UL>
               <LI>You must call the function init_mysql_structure() first.
               <LI>Then you may:
                   <UL>
                      <LI>Call load_mysql_configuration_from_file() if you want to load the configuration
                          from a file.
                   </UL>
               <LI>Don't forget to call disconnect_from_mysql() in order to free the allocated memory.
               <LI>We use the option CLIENT_FOUND_ROWS which modify the behavior of the function
                   mysql_affected_raws(). With this option, the function mysql_affected_raws() returns the
                   number of rows that matched the "WHERE" statement. In standard mode, the function
                   mysql_affected_raws() returns the number of rows that have been changed.
             </UL>
 */

int connect_to_mysql (struct smysql *mysql_info)
{
  MYSQL *connect_res;
  int   retry;

  retry = 0;
  clear_error_reporting(mysql_info);

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling connect_to_mysql().");

  while (retry <= mysql_info->connect_retry)
  {
    /* ----------------------------------------------- */
    /* Free allocated memory, if necessary             */
    /* ----------------------------------------------- */

    if (mysql_info->handler != NULL) { mysql_close(mysql_info->handler); mysql_info->handler = NULL; }

    /* ----------------------------------------------- */
    /* Initialize the handler structure                */
    /* ----------------------------------------------- */

    mysql_info->handler = mysql_init(mysql_info->handler);
    if (mysql_info->handler == NULL)
    {
      set_last_error (mysql_info);
      mysql_info->connected = 0;

      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Could not connect to the MySql server - mysql_init() failed (%s). This should _NOT_ happen!",
                 mysql_error_str);

      return 1;
    } 

    /* ----------------------------------------------- */
    /* Set the connection timeout                      */
    /* ----------------------------------------------- */

    if (mysql_options(
                       mysql_info->handler,
                       MYSQL_OPT_CONNECT_TIMEOUT,
                       (char*)&(mysql_info->connect_timeout)) != 0)
    {
      set_last_error (mysql_info);
      mysql_info->connected = 0;

      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Could not connect to the MySql server - mysql_options() failed (%s). This should _NOT_ happen!",
                 mysql_error_str);

      return 1;
    }

    /* ----------------------------------------------- */
    /* Connect to mysql server                         */
    /* Note: the option CLIENT_FOUND_ROWS modify the   */
    /* behavior of function mysql_affected_rows().     */
    /* ----------------------------------------------- */

    connect_res = mysql_real_connect (  
                                       mysql_info->handler,
                                       mysql_info->host,
                                       mysql_info->user,
                                       mysql_info->passwd,
                                       mysql_info->db,
                                       mysql_info->port,
                                       mysql_info->socket,
                                       CLIENT_FOUND_ROWS
                                     );

    if (connect_res != NULL) { break; }

    /* ----------------------------------------------- */
    /* Could not connect to server, try again          */
    /* ----------------------------------------------- */

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Try to re-connect to MySql server (%d / %d).",
               retry,
               mysql_info->connect_retry);

    sleep (mysql_info->connect_sleep);

    retry++;
  }

  /* ------------------------------------------------- */
  /* We may not be connected ...                       */
  /* ------------------------------------------------- */

  if (retry > mysql_info->connect_retry)
  {
    set_last_error (mysql_info);
    mysql_info->connected = 0;

    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Could not open connection to the MySql server. Too many retries... I give up (%s).",
               mysql_error_str);

    return 1;
  } 

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Connection to the MySql server successfully established.");

  mysql_info->connected = 1;
  return 0;
}

/*! \brief Close the connection with the Mysql server and free allocated memory.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

void disconnect_from_mysql(struct smysql *mysql_info)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling disconnect_from_mysql().");

  if (mysql_info->handler != NULL) { mysql_close(mysql_info->handler); mysql_info->handler = NULL; }
}

/*! \brief Execute SQL statements that does not return data (UPDATE, DELETE, INSERT, REPLACE and otjer).
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE" statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning <UL>
                <LI>Keep in mind that the function does __NOT__ return the number of rows that have been changed
                    by the request. The function returns the number of rows that matched the "WHERE" statement
                    (which may be different).
                <LI>If the connection to the MySql server is lost, then the client tries to reconnect. If it
                    can not reconnect, then the function returns on failure.
             </UL>
 */

static int standard_query (struct smysql *mysql_info, char* query)
{
  int   cr, n, err;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling standard_query().");

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::standard_query()\n");
    fprintf (stdout, "  Next action: <1> Test the connection state (UP/DOWN).\n"); 
    fprintf (stdout, "  Next action: <2> If status is DOWN, test the delay since last disconnection.\n");
    fprintf (stdout, "  Next action: <3> If status is DOWN, skip request or try to reconnect.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  clear_error_reporting(mysql_info);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Execute SQL request [%s].",
             query);

  /* ------------------------------------------------- */
  /* If connection is down, skip request OR try to     */
  /* reconnect.                                        */
  /* ------------------------------------------------- */

  if (! mysql_info->connected)
  {
    time_t delta = time(NULL) - mysql_info->last_connection_timestamp;
    if (mysql_info->reconnection_delay == 0) { delta = 0; } 

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "MySql connection is down since %u seconds.",
               delta);

    if ((delta > mysql_info->reconnection_delay) || (mysql_info->reconnection_delay == 0))
    {
         my_syslog (
                    LEVEL_DEBUG,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Try to re-connect to MySql server (%d / %d).",
                    delta, 
                    mysql_info->reconnection_delay);

         /* ------------------------------------------ */
         /* Try to reconnect                           */
         /* ------------------------------------------ */

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (
                      LEVEL_DEBUG,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not re-connect to the MySql server.");

           /* ---------------------------------------- */
           /* Connection to the server is down         */
           /* ---------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to the MySql server."); 
           return MYSQL_RECONNECTION_FAILED;
         }
         else
         {
           mysql_info->last_connection_timestamp = 0;
           mysql_info->connected = 1;
         }
    }
    else {
           my_syslog (
                      LEVEL_DEBUG,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "%u < %u => Do not try to reconnect. Skip SQL request.",
                      delta,
                      mysql_info->reconnection_delay);

           copy_error (mysql_info, "SQL request skiped (this is normal, see configuration)");
           return MYSQL_REQUEST_SKIPED;
         }
  }

  /* ------------------------------------------------- */
  /* At this point, the connection should be up        */
  /* ------------------------------------------------- */

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::standard_query()\n");
    fprintf (stdout, "  Next action: <1> Perform the SQL query\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif



  while (1)
  {
     clear_error_reporting(mysql_info);
     
     /* ------------------------------------------------- */
     /* Make sure that we are connected                   */
     /* ------------------------------------------------- */
     
     if (mysql_info->handler == NULL)
     {
       set_last_error (mysql_info);

       my_syslog (
                  LEVEL_ERROR,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Connection is not established, as it should be (%s)! This should _NOT_ happen (it is REALLY strange)!",
                  mysql_error_str);

       return MYSQL_UNEXPECTED_ERROR;
     }
     
     /* ------------------------------------------------- */
     /* Send the request to mysql server                  */
     /* ------------------------------------------------- */
     
     cr = mysql_query(mysql_info->handler, query);
     if (cr != 0)
     {
       set_last_error (mysql_info);

       my_syslog (
                  LEVEL_DEBUG,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Query [%s] failed: %s (%d -- CR_SERVER_GONE_ERROR=%d, CR_SERVER_LOST=%d, CR_CONNECTION_ERROR=%d, ER_SERVER_SHUTDOWN=%d) (%s)",
                  query,
                  mysql_info->last_error_str,
                  mysql_info->last_error_int,
                  CR_SERVER_GONE_ERROR,
                  CR_SERVER_LOST,
                  CR_CONNECTION_ERROR,
                  ER_SERVER_SHUTDOWN,
                  mysql_error_str);

       /* ----------------------------------------------- */
       /* The server may have gone away...                */
       /* ----------------------------------------------- */
   
       err = mysql_errno(mysql_info->handler);
   
       if ((err == CR_SERVER_GONE_ERROR)
           ||
           (err == CR_SERVER_LOST)
           ||
           (err == CR_CONNECTION_ERROR)
           ||
           (err == ER_SERVER_SHUTDOWN))
       {
         my_syslog (
                    LEVEL_WARNING,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Connection lost with MySql server.");

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;
           set_last_error (mysql_info);

           my_syslog (
                      LEVEL_DEBUG,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not re-connect to the MySql server (%s).",
                      mysql_error_str);

           return MYSQL_CONNECTION_LOST;
         }

         my_syslog (
                    LEVEL_INFO,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Connection to the MySql server successfully established.");

         mysql_info->last_connection_timestamp = 0;
         mysql_info->connected = 1;

         continue;
       }
       else {
               set_last_error (mysql_info);

               my_syslog (
                          LEVEL_ERROR,
                          TERMINAL_LEVEL,
                          __FILE__,
                          __LINE__,
                          "Some SQL error occured, other that disconnection (%s). This should _NOT_ happen!",
                          mysql_error_str);

               return MYSQL_SQL_PROBLEM;
            }
     }

     break;
  }

  /* ------------------------------------------------- */
  /* Get the number of affected rows                   */
  /* ------------------------------------------------- */

  n = mysql_affected_rows(mysql_info->handler);

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Number of affected row(s) is %d.",
             n);

  return n;
}

/*! \brief Execute an UPDATE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_update (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute an INSERT SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_insert (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a REPLACE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different).
 */

int sql_replace (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a DELETE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_delete (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a SELECT SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of selected items.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Upon successful completion, the fonction stores results into the MySql data structure
             <I>mysql_info->result</I>.	You must call the function mysql_free_result() in order to
             free all allocated memory. Note that if an error occured, you must <B>__NOT__</B> call 
             mysql_free_result().
 */

int sql_select (struct smysql *mysql_info, char* query)
{
  int cr, err;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling sql_select().");
  
  clear_error_reporting (mysql_info);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Execute SQL request [%s].",
             query);

  /* ------------------------------------------------- */
  /* If connection is down, skip request OR try to     */
  /* reconnect.                                        */
  /* ------------------------------------------------- */

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::sql_select()\n");
    fprintf (stdout, "  Next action: <1> Test the connection state (UP/DOWN).\n");
    fprintf (stdout, "  Next action: <2> If status is DOWN, test the delay since last disconnection.\n");
    fprintf (stdout, "  Next action: <3> If status is DOWN, skip request or try to reconnect.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  if (! mysql_info->connected)
  {
    time_t delta = time(NULL) - mysql_info->last_connection_timestamp;
    if (mysql_info->reconnection_delay == 0) { delta = 0; }

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "MySql connection is down since %u seconds.",
               delta);

    if ((delta > mysql_info->reconnection_delay) || (mysql_info->reconnection_delay == 0))
    {
         my_syslog (
                    LEVEL_DEBUG,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Try to re-connect to MySql server (%d / %d).",
                    delta,
                    mysql_info->reconnection_delay);

         /* ------------------------------------------ */
         /* Try to reconnect                           */
         /* ------------------------------------------ */

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (
                      LEVEL_DEBUG,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not re-connect to the MySql server.");

           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to database");
           return MYSQL_RECONNECTION_FAILED;
         }
         else
         {
           mysql_info->last_connection_timestamp = 0;
           mysql_info->connected = 1;
         }
    }
    else {
           my_syslog (
                      LEVEL_DEBUG,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "%u < %u => Do not try to reconnect. Skip SQL request.",
                      delta,
                      mysql_info->reconnection_delay);

           copy_error (mysql_info, "SQL request skiped (this is normal - see configuration)");
           return MYSQL_REQUEST_SKIPED;
         }
  }

  /* ------------------------------------------------- */
  /* At this point, the connection should be up        */
  /* ------------------------------------------------- */

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::sql_select()\n");
    fprintf (stdout, "  Next action: <1> Perform the SQL query.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  while (1)
  {
    mysql_info->num_fields = -1;
    mysql_info->num_rows   = -1;

    clear_error_reporting(mysql_info);
  
    /* ------------------------------------------------- */
    /* Make sure that we are connected                   */
    /* ------------------------------------------------- */
  
    if (mysql_info->handler == NULL)
    {
      set_last_error (mysql_info);

      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Connection is not established, as it should be (%s)! This should _NOT_ happen (it is REALLY strange)!",
                 mysql_error_str);

      return MYSQL_UNEXPECTED_ERROR;
    }
  
    /* ------------------------------------------------- */
    /* Send the request to mysql server                  */
    /* ------------------------------------------------- */
  
    cr = mysql_query(mysql_info->handler, query);
    if (cr != 0)
    {
      set_last_error (mysql_info);

      my_syslog (
                 LEVEL_DEBUG,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Query [%s] failed: %s (%d -- CR_SERVER_GONE_ERROR=%d, CR_SERVER_LOST=%d, CR_CONNECTION_ERROR=%d, ER_SERVER_SHUTDOWN=%d) (%s)",
                  query,
                  mysql_info->last_error_str,
                  mysql_info->last_error_int,
                  CR_SERVER_GONE_ERROR,
                  CR_SERVER_LOST,
                  CR_CONNECTION_ERROR,
                  ER_SERVER_SHUTDOWN,
                  mysql_error_str);

      /* ----------------------------------------------- */
      /* The server may have gone away                   */
      /* ----------------------------------------------- */

      err = mysql_errno(mysql_info->handler);

      if ((err == CR_SERVER_GONE_ERROR)
          ||
          (err == CR_SERVER_LOST)
          ||
          (err == CR_CONNECTION_ERROR)
          ||
          (err == ER_SERVER_SHUTDOWN))
      {
         my_syslog (
                    LEVEL_WARNING,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Connection lost with the MySql server.");

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (
                      LEVEL_DEBUG,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not re-connect to the MySql server.");

           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to the database");
           return MYSQL_RECONNECTION_FAILED;
         }

         my_syslog (
                    LEVEL_INFO,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Connection to the MySql server successfully established.");

         mysql_info->last_connection_timestamp = time(NULL);
         mysql_info->connected = 0;

         continue;
      }
      else {
              set_last_error (mysql_info);

              my_syslog (
                         LEVEL_ERROR,
                         TERMINAL_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Some SQL error occured, other that disconnection (%s). This should _NOT_ happen!",
                         mysql_error_str);

              return MYSQL_SQL_PROBLEM;
           }
    }

    break;
  }

  /* ------------------------------------------------- */
  /* Get selected data                                 */
  /* ------------------------------------------------- */

  mysql_info->result = mysql_store_result(mysql_info->handler);
  if (mysql_info->result)
  {
    mysql_info->num_rows   = mysql_num_rows   (mysql_info->result);
    mysql_info->num_fields = mysql_num_fields (mysql_info->result);
  }
  else
  {
    set_last_error (mysql_info);

    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Some SQL error occured, other that disconnection (%s). This should _NOT_ happen!",
               mysql_error_str);

    return MYSQL_UNEXPECTED_ERROR;
  }

  return mysql_info->num_rows;
}

/*! \brief Load MySql configuration from a given configuration file.
    \author Denis BEURIVE
    \param path Path to the configuration file to parse.
    \param mysql_info Pointer to a MySql configuration data structure unsed to store the loaded configuration.
    \param tags Pointer to an array of zero terminated strinfs of characters. Each string represents one tag
           to load from the configuration file. Tags must be written in the following order:
           <UL>
              <LI>0  - Host name of the server that runs the database server.
              <LI>1  - User used to log to the database server.
              <LI>2  - Password used to log to the database server.
              <LI>3  - Name of the database.
              <LI>4  - TCP port number use to connect to the database server.
              <LI>5  - Path to the UNIX socket used for local connection to the database server.
              <LI>6  - Number of connection retry.
              <LI>7  - Connection timeout in seconds.
              <LI>8  - Delay of inactivity between 2 connection attempts.
              <LI>9  - Number of seconds between 2 reconnection attempts.
           </UL><P>
           The size of the array is MYSQL_CONFIGURATION_TAG_NUMBER.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
    \warning If you do not want to specify a log file in the configuration file, then set the value of the
             tag "log-file" (index 10 in the array 'tags') to "desactivate logs".
 */

int load_mysql_configuration_from_file (
                                         char *path,
                                         struct smysql *mysql_info,
                                         char *tags[MYSQL_CONFIGURATION_TAG_NUMBER]
                                       )
{
  int   res, e;
  char  *value;
  char  big_buffer[8000];

  /* ------------------------------------------------- */
  /* Clear error reporting service                     */
  /* ------------------------------------------------- */

  clear_error_reporting(mysql_info);

  /* ------------------------------------------------- */
  /* Load the configuration file into memory           */
  /* ------------------------------------------------- */

  if (parse_configuration_file (path, &e) != PARSE_CONFIGURATION_OK)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "Could not load the configuration file <%s> - %s",
              path,
              strerror(e));
    return 1;
  }

  /* ------------------------------------------------- */
  /* Set defaults                                      */
  /* ------------------------------------------------- */

  memset ((void*)mysql_info->host,      0, DB_HOST_MAX_SIZE);
  memset ((void*)mysql_info->user,      0, DB_USER_MAX_SIZE);
  memset ((void*)mysql_info->passwd,    0, DB_PASSWD_MAX_SIZE);
  memset ((void*)mysql_info->db,        0, DB_NAME_MAX_SIZE);
  memset ((void*)mysql_info->socket,    0, MYSQL_SOCKET_FILE_MAX_SIZE);

  mysql_info->port               = 0;
  mysql_info->connect_retry      = 0;
  mysql_info->connect_timeout    = 0;
  mysql_info->connect_sleep      = 0;
  mysql_info->reconnection_delay = 0;

  /* ------------------------------------------------- */
  /* Get the Host name                                 */
  /* ------------------------------------------------- */

  res = get_value (tags[0], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing.",
              path,
              tags[0]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'.",
             path,
             tags[0]);
    return 1;
  }

  if (strlen(value) >= DB_HOST_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!).",
             path,
             tags[0]);
    return 1;
  }

  strcpy (mysql_info->host, value);

  /* ------------------------------------------------- */
  /* Get the user name                                 */
  /* ------------------------------------------------- */

  res = get_value (tags[1], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing.",
              path,
              tags[1]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[1]);
    return 1;
  }

  if (strlen(value) >= DB_USER_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[1]);
    return 1;
  }

  strcpy (mysql_info->user, value);

  /* ------------------------------------------------- */
  /* Get the password                                  */
  /* ------------------------------------------------- */

  res = get_value (tags[2], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[2]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[2]);
    return 1;
  }

  if (strlen(value) >= DB_PASSWD_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[2]);
    return 1;
  }

  strcpy (mysql_info->passwd, value);

  /* ------------------------------------------------- */
  /* Get the database name                             */
  /* ------------------------------------------------- */

  res = get_value (tags[3], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[3]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[3]);
    return 1;
  }

  if (strlen(value) >= DB_NAME_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[3]);
    return 1;
  }

  strcpy (mysql_info->db, value);

  /* ------------------------------------------------- */
  /* Get the TCP port number                           */
  /* ------------------------------------------------- */

  res = get_value (tags[4], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[4]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[4]);
    return 1;
  }

  mysql_info->port = atoi(value);

  /* ------------------------------------------------- */
  /* Get the UNIX socket path                          */
  /* ------------------------------------------------- */

  res = get_value (tags[5], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[5]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[5]);
    return 1;
  }

  if (strlen(value) >= MYSQL_SOCKET_FILE_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[5]);
    return 1;
  }

  strcpy (mysql_info->socket, value);

  /* ------------------------------------------------- */
  /* Get number of connect retries                     */
  /* ------------------------------------------------- */

  res = get_value (tags[6], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[6]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[6]);
    return 1;
  }

  mysql_info->connect_retry = atoi(value);

  /* ------------------------------------------------- */
  /* Get the connect timout                            */
  /* ------------------------------------------------- */

  res = get_value (tags[7], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[7]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[7]);
    return 1;
  }

  mysql_info->connect_timeout = atoi(value);

  /* ------------------------------------------------- */
  /* Get the inactivity period between 2 connections   */
  /* ------------------------------------------------- */

  res = get_value (tags[8], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[8]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[8]);
    return 1;
  }

  mysql_info->connect_sleep = atoi(value);

  /* ------------------------------------------------- */
  /* Get the reconnection delay                        */
  /* ------------------------------------------------- */

  res = get_value (tags[9], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[11]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[11]);
    return 1;
  }

  mysql_info->reconnection_delay = atoi(value);

  /* ------------------------------------------------- */
  /* Log DEBUG data, if required                       */
  /* ------------------------------------------------- */

  memset ((void*)big_buffer, 0, 8000);

  snprintf (big_buffer,
            8000,
            "host='%s', user='%s', passwd='%s', dbname='%s', port='%u', socket='%s', connect_retry='%d', connect_timeout='%d', connect_sleep='%d', reconnection_delay='%lu'",
            mysql_info->host,
            mysql_info->user,
            mysql_info->passwd,
            mysql_info->db,
            mysql_info->port,
            mysql_info->socket,
            mysql_info->connect_retry,
            mysql_info->connect_timeout,
            mysql_info->connect_sleep,
            mysql_info->reconnection_delay);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "MySql configuration is: %s",
             big_buffer);

  return 0;
}

/*! \brief Return the UNIX timestamp of the MySql server.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'struct smysql' that contains the Mysql configuration.
    \param error Pointer to an integer used to store an error code.
           Upon successful completion, the value pointed by 'error' is set to 0. 
           Otherwise, the value pointed by 'error' could be:
           <UL>
              <LI>MYSQL_REQUEST_SKIPED
              <LI>MYSQL_CONNECTION_LOST
              <LI>MYSQL_RECONNECTION_FAILED
              <LI>MYSQL_SQL_PROBLEM
              <LI>MYSQL_UNEXPECTED_ERROR
              <LI>MYSQL_NO_TIMESTAMP
           </UL>
    \return Upon successful completion (the value pointed by 'error' is set to 0), then the function
            returns the current UNIX timestamp of the MySql server. Otherwize, the function returns the
            value 0.
 */

time_t get_unix_timestamp (struct smysql *mysql_info, int *error)
{
  char               sql[] = "select UNIX_TIMESTAMP(now())";
  char               integer1[32];
  int                n, e;
  MYSQL_ROW          row;
  unsigned long int  *length;
  time_t             ttstp;


  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_unix_timestamp().");

  *error = 0;

  /* ----------------------------------------------------- */
  /* Send request to MySql server                          */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Timestamp request skiped.");
         *error = MYSQL_REQUEST_SKIPED;
         return 0;
    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Connection lost with the MySql server.");
         *error = MYSQL_CONNECTION_LOST;
         return 0;
    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not re-connect to the MySql server.");
         *error = MYSQL_RECONNECTION_FAILED;
         return 0;
    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Some SQL error occured.");
         *error = MYSQL_SQL_PROBLEM; 
         return 0;
    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Unexpected SQL error");
         *error = MYSQL_UNEXPECTED_ERROR;
         return 0;
    case 0:
         my_syslog (
                    LEVEL_DEBUG,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Could not get UNIX timestamp (Request [%s]). Select returned no result.",
                    sql);
         *error = MYSQL_UNEXPECTED_ERROR;
         *error = MYSQL_NO_TIMESTAMP;
         mysql_free_result(mysql_info->result);
         return 0;
  }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Got %d result(s) (Request [%s])",
             n,
             sql);

  /* ----------------------------------------------------- */
  /* Copy the result                                       */
  /* ----------------------------------------------------- */

  row    = mysql_fetch_row (mysql_info->result);
  length = mysql_fetch_lengths (mysql_info->result);

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Lengthes are: timestamp[%d]",
             length[0]);

  memset ((void*)integer1, 0, 32);
  memcpy ((void*)integer1, (void*)row[0],
          (length[0] < 32) ? length[0] : 31);

  ttstp = (time_t)(string2unsigned_int (integer1, &e));

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Timestamp is %u.",
             ttstp);

  mysql_free_result(mysql_info->result);
  return ttstp;
}

mysql_interface.c

/*! \file mysql_interface.c
          This file implements high level MySql functionnalities.
 */

#include <string.h>
#include <stdio.h>
#include "mysql_interface.h"
#include "strings_utils.h"
#include "conversion.h"
#include "modem.h"
#include "logging.h"






/*! \brief This value is used for all transactions with MyDns. It comes from the following SQL request:
           SELECT id FROM soa WHERE origin='user.'
 */

static unsigned int mydns_id;

/*! \brief Initialize the table structure.
    \author Denis BEURIVE
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
 */

void clear_tables (struct mysql_tables *mysql_tables)
{ memset ((void*)(mysql_tables), 0, sizeof(struct mysql_tables)); }

/*! \brief Maximum number of characters for a SQL request (including the final zero).
 */

#define SQL_REQUEST_SIZE 2048

/*! \brief Maximum number of bytes for the "NASPORT" identifier.
           The "NASPORT" identifier is the following string : "node= shelf= port= slot= vci=",
           (that describes the exact location on the DSLAM).
 */

#define NASPORT_SIZE     512

/*! \brief Load the entire context associated with a user.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration for
           the DHCP database.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           Entry 'abonnes' must have the following definitions (that will be used for SQL query):
           <ul>
              <li>node
              <li>shelf
              <li>port
              <li>slot
              <li>vci
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following value:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
               <li>MYSQL_INTERFACE_TOO_MANY_ITEMS
               <li>MYSQL_INTERFACE_NO_OPTION_FOUND
            </UL>
    \remark <ul>
                <li>The result is copied into entries:
                    <ul>
                       <li>'abonnes'
                       <li>'options'
                    </ul>
                <li>MYSQL_INTERFACE_NOT_FOUND means that the client is not in the table 'abonnes'.
                <li>MYSQL_INTERFACE_NO_OPTION_FOUND means that the optionnal profile could not be found in the
                    table 'options'.
            </ul>
 */

int load_context (struct smysql        *mysql_info,
                  struct mysql_tables  *mysql_tables,
                  struct global_config *config)
{
  int                rc;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling load_context().");

  /* ----------------------------------------------------- */
  /* Load 'abonnes', using option 82 (node, shelf, port,   */
  /* slot, vci).                                           */
  /* ----------------------------------------------------- */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "load_abonnes (node=%s, shelf=%u, port=%u, slot=%u, vci=%u)",
             (mysql_tables->abonnes).node,
             (mysql_tables->abonnes).shelf,
             (mysql_tables->abonnes).port,
             (mysql_tables->abonnes).slot,
             (mysql_tables->abonnes).vci);

  rc = load_abonnes (mysql_info, mysql_tables, config);

  if (rc != 0)
  {
    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - Request skiped.");
           return MYSQL_INTERFACE_REQUEST_SKIPED;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - Connection lost.");
           return MYSQL_INTERFACE_CONNECTION_LOST;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - Could not reconnect.");
           return MYSQL_INTERFACE_RECONNECTION_FAILED;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - Some SQL syntax error.");
           return MYSQL_INTERFACE_SQL_PROBLEM;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - Unexpected error.");
           return MYSQL_INTERFACE_UNEXPECTED_ERROR;

      case MYSQL_INTERFACE_NOT_FOUND:
           my_syslog (
                      LEVEL_ERROR,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - No record found (node=%s,shelf=%u,port=%u,slot=%u,vci=%u)",
                      (mysql_tables->abonnes).node,
                      (mysql_tables->abonnes).shelf,
                      (mysql_tables->abonnes).port,
                      (mysql_tables->abonnes).slot,
                      (mysql_tables->abonnes).vci);
           return MYSQL_INTERFACE_NOT_FOUND;

      case MYSQL_INTERFACE_MORE_THAN_ONE:
           my_syslog (
                      LEVEL_ERROR,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'abonnes' - More than one record found (this should _NEVER_ happen!). Options 82 were : node=%s,shelf=%u,port=%u,slot=%u,vci=%u. Please investigate, this is an emergency.",
                      (mysql_tables->abonnes).node,
                      (mysql_tables->abonnes).shelf,
                      (mysql_tables->abonnes).port,
                      (mysql_tables->abonnes).slot,
                      (mysql_tables->abonnes).vci);
           return MYSQL_INTERFACE_MORE_THAN_ONE;
    }

    return rc;
  }

  /* ----------------------------------------------------- */
  /* Now load the options                                  */
  /* ----------------------------------------------------- */

  snprintf ((mysql_tables->options[0]).profile_optionnel,
            OPTIONNAL_PROFILE_SIZE,
            "%s",
            (mysql_tables->abonnes).profile);

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "load_options (%s)",
             (mysql_tables->abonnes).profile);

  rc = load_options (mysql_info, mysql_tables, config);

  if (rc != 0)
  {
    switch (rc)
    {
      case MYSQL_INTERFACE_REQUEST_SKIPED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Request skiped.");
           return MYSQL_INTERFACE_REQUEST_SKIPED;

      case MYSQL_INTERFACE_CONNECTION_LOST:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Connection lost.");
           return MYSQL_INTERFACE_CONNECTION_LOST;

      case MYSQL_INTERFACE_RECONNECTION_FAILED:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Could not reconnect.");
           return MYSQL_INTERFACE_RECONNECTION_FAILED;

      case MYSQL_INTERFACE_SQL_PROBLEM:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Some SQL syntax error.");
           return MYSQL_INTERFACE_SQL_PROBLEM;

      case MYSQL_INTERFACE_UNEXPECTED_ERROR:
           my_syslog (
                      LEVEL_WARNING,
                      HIGH_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Unexpected error.");
           return MYSQL_INTERFACE_UNEXPECTED_ERROR;

      case MYSQL_INTERFACE_NOT_FOUND:
           my_syslog (
                      LEVEL_ERROR,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - No record found. Options 82 were : node=%s,shelf=%u,port=%u,slot=%u,vci=%u.",
                      (mysql_tables->abonnes).node,
                      (mysql_tables->abonnes).shelf,
                      (mysql_tables->abonnes).port,
                      (mysql_tables->abonnes).slot,
                      (mysql_tables->abonnes).vci);
           return MYSQL_INTERFACE_NO_OPTION_FOUND;

      case MYSQL_INTERFACE_TOO_MANY_ITEMS:
           my_syslog (
                      LEVEL_ERROR,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Could not load 'options' - Too many records found. Options 82 were : node=%s,shelf=%u,port=%u,slot=%u,vci=%u. This should not happen. Please investigate, this is an emergency!",
                      (mysql_tables->abonnes).node,
                      (mysql_tables->abonnes).shelf,
                      (mysql_tables->abonnes).port,
                      (mysql_tables->abonnes).slot,
                      (mysql_tables->abonnes).vci);
           return MYSQL_INTERFACE_TOO_MANY_ITEMS;
    }

    return rc;
  }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Context successfully loaded for (node=%s,shelf=%u,port=%u,slot=%u,vci=%u)",
             (mysql_tables->abonnes).node,
             (mysql_tables->abonnes).shelf,
             (mysql_tables->abonnes).port,
             (mysql_tables->abonnes).slot,
             (mysql_tables->abonnes).vci);

  return 0;
}

/*! \brief Load the content of table 'abonnes'. 
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>abonnes.node
               <li>abonnes.shelf
               <li>abonnes.port
               <li>abonnes.slot
               <li>abonnes.vci
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
            </ul>
    \remark The result is copied into the entry 'abonnes' of the structure pointed by 'mysql_tables'.
 */

int load_abonnes (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE], integer1[32], integer2[32], integer3[32];
  int                n, e;
  MYSQL_ROW          row;
  unsigned long int  *length;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling load_abonnes().");

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql, 
            SQL_REQUEST_SIZE,
            "SELECT id, node, shelf, slot, port, vci, first_connection, radius_login, profile, standard_profile, autoconf_blackhole_profile, blackhole_profile, nack_flag, ip, subnet, radius_identifiant, nasidentifier FROM abonnes WHERE node='%s' AND shelf='%u' AND slot='%u' AND port='%u' AND vci='%u'",
            mysql_tables->abonnes.node,
            mysql_tables->abonnes.shelf,
            mysql_tables->abonnes.slot,
            mysql_tables->abonnes.port,
            mysql_tables->abonnes.vci);

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s].",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_WARNING,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Can not find (node=%s, shelf=%u, slot=%u, port=%u, vci=%u) in table 'abonnes'.",
                    sql,
                    mysql_tables->abonnes.node,
                    mysql_tables->abonnes.shelf,
                    mysql_tables->abonnes.slot,
                    mysql_tables->abonnes.port,
                    mysql_tables->abonnes.vci);

         mysql_free_result(mysql_info->result);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n != 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record for (node=%s, shelf=%u, slot=%u, port=%u, vci=%u) in table 'abonnes'. This should _NEVER_ happen since (node,shelf,slot,port,vci) should be unique. Please investigate, this is an emergency!",
               sql,
               mysql_tables->abonnes.node,
               mysql_tables->abonnes.shelf,
               mysql_tables->abonnes.slot,
               mysql_tables->abonnes.port,
               mysql_tables->abonnes.vci);

    mysql_free_result(mysql_info->result);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  /* ----------------------------------------------------- */
  /* Copy the result                                       */
  /* ----------------------------------------------------- */

  row    = mysql_fetch_row (mysql_info->result);
  length = mysql_fetch_lengths (mysql_info->result);





  memset ((void*)integer1,                                         0, 32);   /* id               */
  memset ((void*)integer2,                                         0, 32);   /* first_connection */
  memset ((void*)integer3,                                         0, 32);   /* nack_flag        */
  memset ((void*)mysql_tables->abonnes.login_radius,               0, LOGIN_RADIUS_SIZE);
  memset ((void*)mysql_tables->abonnes.profile,                    0, OPTIONNAL_PROFILE_SIZE);
  memset ((void*)mysql_tables->abonnes.standard_profile,           0, OPTIONNAL_PROFILE_SIZE); 
  memset ((void*)mysql_tables->abonnes.autoconf_blackhole_profile, 0, OPTIONNAL_PROFILE_SIZE);
  memset ((void*)mysql_tables->abonnes.blackhole_profile,          0, OPTIONNAL_PROFILE_SIZE);
  memset ((void*)mysql_tables->abonnes.ip,                         0, IP_ADDRESS_STR_SIZE);
  memset ((void*)mysql_tables->abonnes.subnet,                     0, SUBNET_SIZE);
  memset ((void*)mysql_tables->abonnes.radius_identifiant,         0, RADIUS_IDENTIFIANT_SIZE);
  memset ((void*)mysql_tables->abonnes.nasidentifer,               0, NASIDENTIFIER_SIZE);
  



  /* id (1) */

  memcpy ((void*)integer1, (void*)row[0],
          (length[0] < 32) ? length[0] : 31);

  /* first_connection (6) */

  memcpy ((void*)integer2, (void*)row[6],
          (length[6] < 32) ? length[6] : 31);

  /* radius_login (7) */

  memcpy ((void*)mysql_tables->abonnes.login_radius, (void*)row[7],
          (length[7] < LOGIN_RADIUS_SIZE) ? length[7] : LOGIN_RADIUS_SIZE-1);

  /* profile (8) */

  memcpy ((void*)mysql_tables->abonnes.profile, (void*)row[8],
          (length[8] < OPTIONNAL_PROFILE_SIZE) ? length[8] : OPTIONNAL_PROFILE_SIZE-1);

  /* standard_profile (9) */

  memcpy ((void*)mysql_tables->abonnes.standard_profile, (void*)row[9],
          (length[9] < OPTIONNAL_PROFILE_SIZE) ? length[9] : OPTIONNAL_PROFILE_SIZE-1);

  /* autoconf_blackhole_profile (10) */

  memcpy ((void*)mysql_tables->abonnes.autoconf_blackhole_profile, (void*)row[10],
          (length[10] < OPTIONNAL_PROFILE_SIZE) ? length[10] : OPTIONNAL_PROFILE_SIZE-1);

  /* blackhole_profile (11) */

  memcpy ((void*)mysql_tables->abonnes.blackhole_profile, (void*)row[11],
          (length[11] < OPTIONNAL_PROFILE_SIZE) ? length[11] : OPTIONNAL_PROFILE_SIZE-1);

  /* nack_flag (12) */

  memcpy ((void*)integer3, (void*)row[12],
          (length[12] < 32) ? length[12] : 31);

  /* ip (13) */

  memcpy ((void*)mysql_tables->abonnes.ip, (void*)row[13],
          (length[13] < IP_ADDRESS_STR_SIZE) ? length[13] : IP_ADDRESS_STR_SIZE-1);

  /* subnet (14) */

  memcpy ((void*)mysql_tables->abonnes.subnet, (void*)row[14],
          (length[14] < SUBNET_SIZE) ? length[14] : SUBNET_SIZE-1);

  /* radius_identifiant (15) */

  memcpy ((void*)mysql_tables->abonnes.radius_identifiant, (void*)row[15],
          (length[15] < RADIUS_IDENTIFIANT_SIZE) ? length[15] : RADIUS_IDENTIFIANT_SIZE-1);

  /* nasidentifer (16) */

  memcpy ((void*)mysql_tables->abonnes.nasidentifer, (void*)row[16],
          (length[16] < NASIDENTIFIER_SIZE) ? length[16] : NASIDENTIFIER_SIZE-1);


  mysql_tables->abonnes.id               = string2unsigned_int (integer1, &e);
  mysql_tables->abonnes.first_connection = string2unsigned_int (integer2, &e);
  mysql_tables->abonnes.nack_flag        = string2unsigned_int (integer3, &e);  

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Result is:\n\tid=%u\n\tnode=%s\n\tshelf=%u\n\tslot=%u\n\tport=%u\n\tvci=%u\n\tfirst_connection=%u\n\tradius_login=%s\n\tprofile=%s\n\tstandard_profile=%s\n\tautoconf_blackhole_profile=%s\n\tblackhole_profile=%s\n\tnack_flag=%u\n\tip=%s\n\tsubnet=%s\n\tradius_identifiant=%s\n\tnasidentifer=%s",
             mysql_tables->abonnes.id,
             mysql_tables->abonnes.node,
             mysql_tables->abonnes.shelf,
             mysql_tables->abonnes.slot,
             mysql_tables->abonnes.port,
             mysql_tables->abonnes.vci,
             mysql_tables->abonnes.first_connection,
             mysql_tables->abonnes.login_radius,
             mysql_tables->abonnes.profile,
             mysql_tables->abonnes.standard_profile,
             mysql_tables->abonnes.autoconf_blackhole_profile,
             mysql_tables->abonnes.blackhole_profile,
             mysql_tables->abonnes.nack_flag,
             mysql_tables->abonnes.ip,
             mysql_tables->abonnes.subnet,
             mysql_tables->abonnes.radius_identifiant,
             mysql_tables->abonnes.nasidentifer);

  mysql_free_result(mysql_info->result);

  return 0;
}

/*! \brief Load the content of table 'options'.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The first element of the entry 'options' must have the following definitions
           (that will be used for SQL query):
           <ul>
              <li>profile_optionnel
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_TOO_MANY_ITEMS
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
            </UL>
    \remark The result is copied into the entry 'options' of the structure pointed by 'mysql_tables'.
 */

int load_options (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE], integer1[32], integer2[32];
  int                n, e, i;
  MYSQL_ROW          row;
  unsigned long int  *length;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "Calling load_options().");

  mysql_tables->option_number = 0;

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "SELECT options_id, profile_optionnel, option_code, option_type, option_value, comment FROM options WHERE profile_optionnel='%s'",
            ((mysql_tables->options)[0]).profile_optionnel);

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s].",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Request skiped.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Can not find optionnal profile (%s) in table 'options'.",
                    sql,
                    ((mysql_tables->options)[0]).profile_optionnel);
         mysql_free_result(mysql_info->result);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n > MAX_PROFILE_OPTIONS)
  {
     my_syslog (
                LEVEL_ERROR,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Request [%s] Too many records (%s) found in database. This should _NRVER_ happen. Please investigate, this is an emergency!",
                sql,
                ((mysql_tables->options)[0]).profile_optionnel);

    mysql_free_result(mysql_info->result);
    return MYSQL_INTERFACE_TOO_MANY_ITEMS;
  }

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Got %d options.",
             n);

  /* ----------------------------------------------------- */
  /* Copy the result                                       */
  /* ----------------------------------------------------- */

  mysql_tables->option_number = n;

  for (i=0; i<n; i++)
  {
    row    = mysql_fetch_row (mysql_info->result);
    length = mysql_fetch_lengths (mysql_info->result);

    memset ((void*)integer1,                                       0, 32);
    memset ((void*)integer2,                                       0, 32);
    memset ((void*)((mysql_tables->options)[i]).profile_optionnel, 0, OPTIONNAL_PROFILE_SIZE);
    memset ((void*)((mysql_tables->options)[i]).option_type,       0, OPTION_TYPE_SIZE);
    memset ((void*)((mysql_tables->options)[i]).option_value,      0, OPTION_VALUE_SIZE);
    memset ((void*)((mysql_tables->options)[i]).comment,           0, COMMENT_SIZE);

    memcpy ((void*)integer1, (void*)row[0],
            (length[0] < 32) ? length[0] : 31);

    memcpy ((void*)((mysql_tables->options)[i]).profile_optionnel, (void*)row[1],
            (length[1] < OPTIONNAL_PROFILE_SIZE) ? length[1] : OPTIONNAL_PROFILE_SIZE-1);

    memcpy ((void*)integer2, (void*)row[2],
            (length[2] < 32) ? length[2] : 31);

    memcpy ((void*)((mysql_tables->options)[i]).option_type, (void*)row[3],
            (length[3] < OPTION_TYPE_SIZE) ? length[3] : OPTION_TYPE_SIZE-1);

    memcpy ((void*)((mysql_tables->options)[i]).option_value, (void*)row[4],
            (length[4] < OPTION_VALUE_SIZE) ? length[4] : OPTION_VALUE_SIZE-1);

    memcpy ((void*)((mysql_tables->options)[i]).comment, (void*)row[5],
            (length[5] < COMMENT_SIZE) ? length[5] : COMMENT_SIZE-1);

    ((mysql_tables->options)[i]).options_id  = string2unsigned_int (integer1, &e);
    ((mysql_tables->options)[i]).option_code = (unsigned char) string2unsigned_int (integer2, &e);

    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Result is:\n\toptions_id='%lu'\n\tprofile_optionnel='%s'\n\toption_code='%u'\n\toption_type='%s'\n\toption_value='%s'\n\tcomment='%s'",
               ((mysql_tables->options)[i]).options_id,
               ((mysql_tables->options)[i]).profile_optionnel,
               ((mysql_tables->options)[i]).option_code,
               ((mysql_tables->options)[i]).option_type,
               ((mysql_tables->options)[i]).option_value,
               ((mysql_tables->options)[i]).comment);
  }

  mysql_free_result(mysql_info->result);
  return 0;
}

/*! \brief Send a ticket (START or STOP) into the Radonline database.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
                      This structure points to the 'radonline' database.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that contains the loaded context.
    \param ip Pointer to a zero terminated string of characters that represents the IP address of the user.
    \param action This integer represents the action to execute. Its value could be:
           <ul>
                <li>RADONLINE_START
                <li>RADONLINE_STOP
           </ul>
    \param config Pointer to a 'global_config' data structure that represents the global server's
                  configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_REQUEST_SKIPED
               <li>MYSQL_CONNECTION_LOST
               <li>MYSQL_RECONNECTION_FAILED
               <li>MYSQL_SQL_PROBLEM
               <li>MYSQL_UNEXPECTED_ERROR
            </ul>
    \remark This function checks the values of the following records:
            <ul>
               <li>ogistic.radonline_acct_identifier
               <li>ogistic.login_modem
            </ul>
            If these records are defined, special values are assiged to ACCT_IDENTIFIER and LOGIN_MODEM.
 */

int send_to_radonline (
                         struct smysql        *mysql_info,
                         struct mysql_tables  *mysql_tables,
                         char                 *ip,
                         int                  action,
                         struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE], dslamid[NASPORT_SIZE];
  int                i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling send_to_radonline().");

  if (action == RADONLINE_START)
  {
    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Sending START to Radonline.");
  }

  if (action == RADONLINE_STOP)
  {
    my_syslog (
               LEVEL_DEBUG,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Sending STOP to Radonline.");
  }

  /* ----------------------------------------------------- */
  /* Prepare the "NASPORT" ID.                             */
  /* Note: The 8/6/2006, we decided to remove the value    */
  /*       'node_id' from the 'dslamid'.                   */
  /* ----------------------------------------------------- */

  memset ((void*)dslamid, 0, NASPORT_SIZE);

  snprintf (dslamid,
            NASPORT_SIZE,
            "%3u%3u%3u%5u",
            (mysql_tables->abonnes).shelf,
            (mysql_tables->abonnes).port,
            (mysql_tables->abonnes).slot,
            (mysql_tables->abonnes).vci);

  for (i=0; i<strlen(dslamid); i++) { if (dslamid[i] == ' ') { dslamid[i] = '0'; } }

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "dslamid=[shelf+port+slot+vci]=%s.",
             dslamid);

  /* ----------------------------------------------------- */
  /* Whether we have a START or a STOP ticket, we delete   */
  /* Radonline entry. Note that, for STOP ticket, that's   */
  /* all we do.                                            */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "DELETE FROM RADONLINE WHERE NASIDENTIFIER='%s' AND NASPORT='%s'",
            (mysql_tables->abonnes).nasidentifer,
            dslamid);

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  switch (sql_delete (mysql_info, sql))
  {
    case MYSQL_REQUEST_SKIPED:
         {
            my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] SKIPED.",
                       sql);

            return MYSQL_REQUEST_SKIPED;
         };

    case MYSQL_CONNECTION_LOST:
         {
            my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] Connection lost.",
                       sql);

            return MYSQL_CONNECTION_LOST;
         };

    case MYSQL_RECONNECTION_FAILED:
         {
            my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] Reconnection failed.",
                       sql);

            return MYSQL_RECONNECTION_FAILED;
         };

    case MYSQL_SQL_PROBLEM:
         {
            my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] Some SQL syntax error occured.",
                       sql);

            return MYSQL_SQL_PROBLEM;
         };

    case MYSQL_UNEXPECTED_ERROR:
         {
            my_syslog (
                       LEVEL_WARNING,
                       HIGH_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] Unexpected error.",
                       sql);

            return MYSQL_UNEXPECTED_ERROR;
         };

    default:
         {
            my_syslog (
                       LEVEL_VERBOSE,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "Request [%s] OK.",
                       sql);
         };
  }

  /* ----------------------------------------------------- */
  /* Process START tickets.                                */
  /* Radonline entry already deleted, insert new entry.    */
  /*                                                       */
  /* NOTE : Depending on the status of the logistic action */
  /*        we produce two different SQL requests.         */
  /* ----------------------------------------------------- */

  if (action == RADONLINE_START)
  {
    memset ((void*)sql, 0, SQL_REQUEST_SIZE);

    if ((mysql_tables->logistic).radonline_acct_identifier[0] == 0)
    {
      /* ------------------------------------------------- */
      /* Standard operation                                */
      /* ------------------------------------------------- */

      my_syslog (
                 LEVEL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "radonline_acct_identifier is empty.");

      snprintf (sql,
                SQL_REQUEST_SIZE,
                "INSERT INTO RADONLINE (USERNAME, NASIDENTIFIER, NASPORT, ACCTSESSIONID, TIME_STAMP, FRAMEDIPADDRESS, NASPORTTYPE, SERVICETYPE, CALLERID, CALLEDID, ACCT_IDENTIFIER) VALUES ('%s', '%s', '%s', '%s', '%lu', '%s', '%s', '%s', NULL, NULL, '%s')",

                (mysql_tables->abonnes).login_radius,
                (mysql_tables->abonnes).nasidentifer,
                dslamid,
                "adsl",
                (unsigned long int)(time(NULL)),
                ip,
                "adsl",
                "adsl",
                (mysql_tables->abonnes).radius_identifiant);

      my_syslog (
                 LEVEL_FULL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "SQL [%s].",
                 sql);
    }
    else
    {
      /* ------------------------------------------------- */
      /* Something weird occured while treating LOGISTIC   */
      /* ------------------------------------------------- */

      my_syslog (
                 LEVEL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "radonline_acct_identifier is not empty.");

      snprintf (sql,
                SQL_REQUEST_SIZE,
                "INSERT INTO RADONLINE (USERNAME, NASIDENTIFIER, NASPORT, ACCTSESSIONID, TIME_STAMP, FRAMEDIPADDRESS, NASPORTT
YPE, SERVICETYPE, CALLERID, CALLEDID, ACCT_IDENTIFIER, LOGIN_MODEM) VALUES ('%s', '%s', '%s', '%s', '%lu', '%s', '%s', '%s', N
ULL, NULL, '%s', '%s')",

                (mysql_tables->logistic).radonline_user_name,
                (mysql_tables->abonnes).nasidentifer,
                dslamid,
                "adsl",
                (unsigned long int)(time(NULL)),
                ip,
                "adsl",
                "adsl",
                (mysql_tables->logistic).radonline_acct_identifier,
                (mysql_tables->logistic).login_modem);

      my_syslog (
                 LEVEL_FULL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "SQL [%s].",
                 sql);
    }

    switch (sql_insert (mysql_info, sql))
    {
      case MYSQL_REQUEST_SKIPED:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] SKIPED.",
                        sql);

              return MYSQL_REQUEST_SKIPED;
           };

      case MYSQL_CONNECTION_LOST:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] Connection lost.",
                        sql);

              return MYSQL_CONNECTION_LOST;
           };

      case MYSQL_RECONNECTION_FAILED:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] Reconnection failed.",
                        sql);

              return MYSQL_RECONNECTION_FAILED;
           };

      case MYSQL_SQL_PROBLEM:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] Some SQL syntax error occured.",
                        sql);

              return MYSQL_SQL_PROBLEM;
           };

      case MYSQL_UNEXPECTED_ERROR:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] Unexpected error.",
                        sql);

              return MYSQL_UNEXPECTED_ERROR;
           };

      default:
           {
             my_syslog (
                        LEVEL_VERBOSE,
                        TERMINAL_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] OK.",
                        sql);
           };
    }
  }

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Ticket successfully sent to Radonline database.");

  return 0;
}

/*! \brief Initialize the MyDns service.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
                      This structure points to the 'mydns' database.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int mydns_init (struct smysql *mysql_info)
{
  static char        sql[SQL_REQUEST_SIZE], integer[32];
  MYSQL_ROW          row;
  unsigned long int  *length;
  int                n, e;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
            "Calling mydns_init().");

  memset((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql, SQL_REQUEST_SIZE, "SELECT id FROM soa WHERE origin='user.'");

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Execute the SQL query                                 */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return 1;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return 1;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return 1;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return 1;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return 1;

    case 0:
         my_syslog (
                    LEVEL_ERROR,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] No record found in MyDns database (what's wrong with this database?). This should _NEVER_ happen. Please investigate, this is an emergency!",
                    sql);
         mysql_free_result(mysql_info->result);
         return 1;
  }

  if (n != 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record (this should not be possible, what's wrong with this database?).",
               sql);
    mysql_free_result(mysql_info->result);
    return 1;
  }

  /* ----------------------------------------------------- */
  /* Extract the data                                      */
  /* ----------------------------------------------------- */

  row    = mysql_fetch_row (mysql_info->result);
  length = mysql_fetch_lengths (mysql_info->result);

  memset ((void*)integer, 0, 32);
  memcpy ((void*)integer, (void*)row[0], (length[0] < 32) ? length[0] : 31);
  mydns_id = string2unsigned_int (integer, &e);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Result is:\n\tid=%u",
             mydns_id);

  mysql_free_result(mysql_info->result);
  return 0;
}

/*! \brief Send a ticket (START or STOP) into the MyDns database.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
                      This structure points to the 'mydns' database.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that contains the loaded context.
    \param ip Pointer to a zero terminated string of characters that represents the IP address of the user.
    \param action This integer represents the action to execute. Its value could be:
           <ul>
                <li>MYDNS_START
                <li>MYDNS_STOP
           </ul>
    \param config Pointer to a 'global_config' data structure that represents the global server's
                  configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_REQUEST_SKIPED
               <li>MYSQL_CONNECTION_LOST
               <li>MYSQL_RECONNECTION_FAILED
               <li>MYSQL_SQL_PROBLEM
               <li>MYSQL_UNEXPECTED_ERROR
            </ul>
    \remark You must all the function mydns_init() first! This will set the variable mydns_id to the correct
            value.
 */

int send_to_mydns (
                     struct smysql        *mysql_info,
                     struct mysql_tables  *mysql_tables,
                     char                 *ip,
                     int                  action,
                     struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE], mydns_login[MYDNS_LOGIN_SIZE];

  my_syslog (
             LEVEL_WARNING,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "Calling send_to_mydns().");

  /* ----------------------------------------------------- */
  /* Calculate the MyDns ID                                */
  /* ----------------------------------------------------- */

  radius2mydns ((mysql_tables->abonnes).login_radius, mydns_login, MYDNS_LOGIN_SIZE);

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "<Radius login> = '%s' => <MyDns login> = '%s'.",
             (mysql_tables->abonnes).login_radius,
             mydns_login);

   if (action == MYDNS_START)
   {
     my_syslog (
                LEVEL_DEBUG,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Inserting START ticket into MyDns. Radius login (%s) => MyDns login (%s).",
                (mysql_tables->abonnes).login_radius,
                mydns_login);
   } 

   if (action == MYDNS_STOP)
   {
     my_syslog (
                LEVEL_DEBUG,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Inserting STOP ticket into MyDns. Radius Login (%s) => MyDns login (%s).",
                (mysql_tables->abonnes).login_radius,
                mydns_login);
   }

  /* ----------------------------------------------------- */
  /* Process STOP ticket                                   */
  /* ----------------------------------------------------- */

  if (action == MYDNS_STOP)
  {
    memset ((void*)sql, 0, SQL_REQUEST_SIZE);

    snprintf (sql,
              SQL_REQUEST_SIZE,
              "DELETE FROM rr_%u WHERE name='%s' AND zone='%u'",
              mydns_id,
              mydns_login,
              mydns_id);

   my_syslog (
              LEVEL_DEBUG,
              HIGH_LEVEL,
              __FILE__,
              __LINE__,
              "SQL [%s]",
              sql);

    switch (sql_delete (mysql_info, sql))
    {
      case MYSQL_REQUEST_SKIPED:
           {
             my_syslog (
                        LEVEL_WARNING,
                        HIGH_LEVEL,
                        __FILE__,
                        __LINE__,
                        "Request [%s] SKIPED.",
                        sql);
              return MYSQL_REQUEST_SKIPED;
           };

      case MYSQL_CONNECTION_LOST:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Connection lost.",
                         sql);
              return MYSQL_CONNECTION_LOST;
           };

      case MYSQL_RECONNECTION_FAILED:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Could not reconnect.",
                         sql);
              return MYSQL_RECONNECTION_FAILED;
           };

      case MYSQL_SQL_PROBLEM:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Some SQL syntax error occured.",
                         sql);
              return MYSQL_SQL_PROBLEM;
           };

      case MYSQL_UNEXPECTED_ERROR:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Unexpected error.",
                         sql);
              return MYSQL_UNEXPECTED_ERROR;
           };

      default:
           {
              my_syslog (
                         LEVEL_VERBOSE,
                         TERMINAL_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] OK.",
                         sql);
           };
    }
  }

  /* ----------------------------------------------------- */
  /* Process START tickets.                                */
  /* Radonline entry already deleted, insert new entry.    */
  /* ----------------------------------------------------- */

  if (action == MYDNS_START)
  {
    memset ((void*)sql, 0, SQL_REQUEST_SIZE);

    snprintf (sql,
              SQL_REQUEST_SIZE,
              "REPLACE INTO rr_%u (zone, name, type, data) VALUES ('%u', '%s', 'A', '%s')",
              mydns_id,
              mydns_id,
              mydns_login,
              ip);

    my_syslog (
               LEVEL_DEBUG,
               HIGH_LEVEL,
               __FILE__,
               __LINE__,
               "SQL [%s]",
               sql);

    switch (sql_insert (mysql_info, sql))
    {
      case MYSQL_REQUEST_SKIPED:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] SKIPED.",
                         sql);
              return MYSQL_REQUEST_SKIPED;
           };

      case MYSQL_CONNECTION_LOST:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Connection lost.",
                         sql);
              return MYSQL_CONNECTION_LOST;
           };

      case MYSQL_RECONNECTION_FAILED:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Could not reconnect.",
                         sql);
              return MYSQL_RECONNECTION_FAILED;
           };

      case MYSQL_SQL_PROBLEM:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Some SQL syntax error.",
                         sql);
              return MYSQL_SQL_PROBLEM;
           };

      case MYSQL_UNEXPECTED_ERROR:
           {
              my_syslog (
                         LEVEL_WARNING,
                         HIGH_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] Unexpected error.",
                         sql);
              return MYSQL_UNEXPECTED_ERROR;
           };

      default:
           {
              my_syslog (
                         LEVEL_VERBOSE,
                         TERMINAL_LEVEL,
                         __FILE__,
                         __LINE__,
                         "Request [%s] OK.",
                         sql);
           };
    }
  }

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Ticket successfully sent to MyDns database.",
             sql);

  return 0;
}



/*! \brief Load the content of table 'LOGISTIC'.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>logistic.LOGIN_MODEM
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
            </UL>
    \remark The result is copied into the entry 'table_logistic_radius' of the structure
            pointed by 'mysql_tables'. Fields are:
            <ul>
               <li>RADIUS_LOGIN
               <li>FLAG_CHECK_RADIUS
            </ul>
 */

int load_logistic (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE], integer1[32];
  int                n, e;
  MYSQL_ROW          row;
  unsigned long int  *length;


  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling load_logistic().");

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "SELECT RADIUS_LOGIN, FLAG_CHECK_RADIUS FROM LOGISTIC_RADIUS WHERE LOGIN_MODEM='%s'",
            mysql_tables->logistic.LOGIN_MODEM);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect to server.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_INFO,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Can not find LOGIN_MODEM (%s) in database.",
                    sql,
                    mysql_tables->logistic.LOGIN_MODEM);
         mysql_free_result(mysql_info->result);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n != 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record with LOGIN_MODEM (%s). This should not happen, please investigate!",
               sql,
               mysql_tables->logistic.LOGIN_MODEM);

    mysql_free_result(mysql_info->result);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  /* ----------------------------------------------------- */
  /* Copy the result                                       */
  /* ----------------------------------------------------- */

  row    = mysql_fetch_row (mysql_info->result);
  length = mysql_fetch_lengths (mysql_info->result);

  memset ((void*)mysql_tables->logistic.RADIUS_LOGIN, 0, LOGISTIC_RADIUS_LOGIN_SIZE);
  memset ((void*)integer1,                            0, 32);

  memcpy ((void*)mysql_tables->logistic.RADIUS_LOGIN,
          (void*)row[0],
          (length[0] < LOGISTIC_RADIUS_LOGIN_SIZE) ? length[0] : LOGISTIC_RADIUS_LOGIN_SIZE-1);

  memcpy ((void*)integer1, (void*)row[1],
          (length[1] < 32) ? length[1] : 31);

  mysql_tables->logistic.FLAG_CHECK_RADIUS = string2unsigned_int (integer1, &e);

  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Result is:\n\tRADIUS_LOGIN=%s\n\tFLAG_CHECK_RADIUS=%d",
             mysql_tables->logistic.RADIUS_LOGIN,
             mysql_tables->logistic.FLAG_CHECK_RADIUS);

  mysql_free_result(mysql_info->result);

  return 0;
}

/*! \brief Set the flag FLAG_CHECK_RADIUS to the value 1.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>logistic.LOGIN_MODEM
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
            </UL>
 */

int set_flag_check_radius (struct smysql *mysql_info,
                           struct mysql_tables *mysql_tables,
                           struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE];
  int                n;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling set_flag_check_radius().");

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "UPDATE LOGISTIC_RADIUS SET FLAG_CHECK_RADIUS='1' WHERE LOGIN_MODEM='%s'",
            mysql_tables->logistic.LOGIN_MODEM);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_update (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Reconnection failed.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_ERROR,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Found no record with LOGIN_MODEM='%s'.",
                    sql,
                    mysql_tables->logistic.LOGIN_MODEM);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n > 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record with LOGIN_MODEM='%s'. This should not happen, please investigate.",
               sql,
               mysql_tables->logistic.LOGIN_MODEM);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  return 0;
}

/*! \brief Insert a couple (login_modem,mac_address) into the LOGISTIC_RADIUS table.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>logistic.LOGIN_MODEM
               <li>logistic.MAC_ADDRESS
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
            </UL>
 */

int signal_unknown_mac_address (struct smysql *mysql_info,
                                struct mysql_tables *mysql_tables,
                                struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE];
  int                n;

  my_syslog (
             LEVEL_WARNING,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "Calling signal_unknown_mac_address().");


  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "INSERT INTO LOGISTIC_RADIUS SET LOGIN_MODEM='%s', MAC_ADDRESS='%s', CODE_ACTION='DHCP', FLAG_CHECK_MODEM='0', FLAG_CHECK_RADIUS='0'",
            mysql_tables->logistic.LOGIN_MODEM,
            mysql_tables->logistic.MAC_ADDRESS);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_insert (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;
  }

  return 0;
}

/*! \brief Update the value of the field 'nack_flag' of the table 'abonnes'.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>abonnes.id
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \param new_value New value for the field 'nack_flag'.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
            </UL>
 */

int nack_flag_abonne (struct smysql          *mysql_info,
                      struct mysql_tables    *mysql_tables,
                      struct global_config   *config,
                      unsigned long int      new_value)
{
  static char        sql[SQL_REQUEST_SIZE];
  int                n;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling nack_flag_abonne().");

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "UPDATE abonnes SET nack_flag='%lu' where id='%lu'",
            new_value,
            mysql_tables->abonnes.id);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_update (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_ERROR,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Found no record with id='%lu' in table 'abonnes'. This should not happen (unless somebody just deleted the record). Please investigate!",
                    sql,
                    mysql_tables->abonnes.id);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n > 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record with id='%lu'? This should _NEVER_ happen since the id is a primary key. Please investigate, this is an emergency!",
               sql,
               mysql_tables->abonnes.id);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  return 0;
}

/*! \brief Set a client's profile to "autoconfblackhole".
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>abonnes.id
               <li>abonnes.autoconf_blackhole_profile
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
               <li>MYSQL_INTERFACE_NOT_FOUND
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
            </UL>
    \remark You should have loaded the table "abonnes" before you call this function
            (So the structure should be already filled).
 */

int blackhole_abonne (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE];
  int                n;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling blackhole_abonne().");


  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "UPDATE abonnes SET profile='%s', nack_flag='1' WHERE id='%lu'",
            mysql_tables->abonnes.autoconf_blackhole_profile,
            mysql_tables->abonnes.id);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_update (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_ERROR,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Found no record with id='%lu'. This should not happen (unless somebody just deleted the record). Please investigate, this is an emergency.",
                    mysql_tables->abonnes.id,
                    sql);
         return MYSQL_INTERFACE_NOT_FOUND;
  }

  if (n > 1)
  {
     my_syslog (
                LEVEL_ERROR,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Request [%s] Found more than one record with id='%lu'. This should _NEVER_ happen since is id is a primary key! Please investigate, this is an emergency!",
                sql,
                mysql_tables->abonnes.id);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  return 0;
}

/*! \brief Set a client's profile to "STANDARD".
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'smysql' data structure that contains the MySql configuration.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that represents the databases model.
           The following information must be set :
           <ul>
               <li>abonnes.id
               <li>abonnes.standard_profile
               <li>abonnes.autoconf_blackhole_profile
           </ul>
    \param config Pointer to a 'global_config' data structure that contains the main server's configuration.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function may return one of the following values:
            <ul>
               <li>MYSQL_INTERFACE_REQUEST_SKIPED
               <li>MYSQL_INTERFACE_CONNECTION_LOST
               <li>MYSQL_INTERFACE_RECONNECTION_FAILED
               <li>MYSQL_INTERFACE_SQL_PROBLEM
               <li>MYSQL_INTERFACE_UNEXPECTED_ERROR
               <li>MYSQL_INTERFACE_MORE_THAN_ONE
            </UL>
 */

int remove_autoconf_bh (struct smysql *mysql_info, struct mysql_tables *mysql_tables, struct global_config *config)
{
  static char        sql[SQL_REQUEST_SIZE];
  int                n;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling remove_autoconf_bh()."); 

  /* ----------------------------------------------------- */
  /* Format SQL request                                    */
  /* ----------------------------------------------------- */

  memset ((void*)sql, 0, SQL_REQUEST_SIZE);

  snprintf (sql,
            SQL_REQUEST_SIZE,
            "UPDATE abonnes SET profile='%s', nack_flag='1' WHERE id='%lu' AND profile='%s'",
            mysql_tables->abonnes.standard_profile,
            mysql_tables->abonnes.id,
            mysql_tables->abonnes.autoconf_blackhole_profile);

  my_syslog (
             LEVEL_DEBUG,
             HIGH_LEVEL,
             __FILE__,
             __LINE__,
             "SQL [%s]",
             sql);

  /* ----------------------------------------------------- */
  /* Send it to MySql server                               */
  /* ----------------------------------------------------- */

  n = sql_update (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] SKIPED.",
                    sql);
         return MYSQL_INTERFACE_REQUEST_SKIPED;

    case MYSQL_CONNECTION_LOST:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Connection lost.",
                    sql);
         return MYSQL_INTERFACE_CONNECTION_LOST;

    case MYSQL_RECONNECTION_FAILED:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Could not reconnect.",
                    sql);
         return MYSQL_INTERFACE_RECONNECTION_FAILED;

    case MYSQL_SQL_PROBLEM:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Some SQL syntax error.",
                    sql);
         return MYSQL_INTERFACE_SQL_PROBLEM;

    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (
                    LEVEL_WARNING,
                    HIGH_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Unexpected error.",
                    sql);
         return MYSQL_INTERFACE_UNEXPECTED_ERROR;

    case 0:
         my_syslog (
                    LEVEL_INFO,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Request [%s] Found no record with id='%lu' and profile='%s'. This is normal, don't worry to much.",
                    sql,
                    mysql_tables->abonnes.id,
                    mysql_tables->abonnes.autoconf_blackhole_profile);
         break;
  }

  if (n > 1)
  {
    my_syslog (
               LEVEL_ERROR,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Request [%s] Found more than one record with id='%lu' and profile='%s'. This should _NEVER_ happen since is id is a primary key! Please investigate, this is an emergency!",
               sql,
               mysql_tables->abonnes.id,
               mysql_tables->abonnes.autoconf_blackhole_profile);
    return MYSQL_INTERFACE_MORE_THAN_ONE;
  }

  return 0;
}

packets.c

/*! \file packets.c
          This file contains the low level DHCP packet manipulation tools.
 */

#include "flock.h"    /* EXT */
#include "dstring.h"  /* EXT */
#include "packets.h"  /* INT */
#include "modem.h"    /* INT */
#include "logging.h"  /* INT */
#include <unistd.h>
#include <time.h>


static char* dater();
static void get_remote_address (struct sockaddr_in *sender, char *ip, int *port);

/*! \brief Order used to print standard options (other than option 82).
 */

static int order[256] = {1, 3, 15, 6, 0, 2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255}; 

/*! \brief This file descriptor is defined in the main server source (dhcp.c).
           It is used to synchronize access to the dump file.
 */

extern int dump_sync_fd; 










/*! \brief Buffer used to store the client hardware address (with ':' as separator between bytes).
 */

static char chaddr[DHCP_P_STR_HADDR_SIZE];

/*! \brief Buffer used to store the client hardware address (without separator between bytes).
 */

static char chaddr_exact[DHCP_P_STR_HADDR_SIZE_EXACT];

/*! \brief Buffer used to store the server names.
 */

static char sname[DHCP_P_STR_SNAME_SIZE];

/*! \brief Buffer used to store the boot file.
 */

static char file[DHCP_P_STR_FILE_SIZE];

/*! \brief Buffer used to store the host name.
 */

static char myhostname[256];

/*! \brief Initialize the dump service for DHCP packets.
    \remark The function MUSR be called before any call to packet_dump().
 */

void packet_init_dump_service ()
{
  memset ((void*)myhostname, 0, 256);
  gethostname (myhostname, 255);
}

/*! \brief This array contains the human readable description for all options.
 */

static char* descriptions[256] =
{
  /*   0 */   "Pad",
  /*   1 */   "Subnet Mask",
  /*   2 */   "Time Offset",
  /*   3 */   "Router",
  /*   4 */   "Time Server",
  /*   5 */   "Name Server",
  /*   6 */   "Domain Name Server",
  /*   7 */   "Log Server",
  /*   8 */   "Cookie Server",
  /*   9 */   "LPR Server",
  /*  10 */   "Impress Server",
  /*  11 */   "Resource Location Server",
  /*  12 */   "Host Name",
  /*  13 */   "Boot File Size",
  /*  14 */   "Merit Dump File",
  /*  15 */   "Domain Name",
  /*  16 */   "Swap Server",
  /*  17 */   "Root Path",
  /*  18 */   "Extensions Path",
  /*  19 */   "IP Forwarding Enable/Disable",
  /*  20 */   "Non-Local Source Routing Enable/Disable",
  /*  21 */   "Policy Filter",
  /*  22 */   "Maximum Datagram Reassembly Size",
  /*  23 */   "Default IP Time-to-live",
  /*  24 */   "Path MTU Aging Timeout",
  /*  25 */   "Path MTU Plateau Table",
  /*  26 */   "Interface MTU",
  /*  27 */   "All Subnets are Local",
  /*  28 */   "Broadcast Address",
  /*  29 */   "Perform Mask Discovery",
  /*  30 */   "Mask Supplier",
  /*  31 */   "Perform Router Discovery",
  /*  32 */   "Router Solicitation Address",
  /*  33 */   "Static Route",
  /*  34 */   "Trailer Encapsulation",
  /*  35 */   "ARP Cache Timeout",
  /*  36 */   "Ethernet Encapsulation",
  /*  37 */   "TCP Default TTL",
  /*  38 */   "TCP Keepalive Interval",
  /*  39 */   "TCP Keepalive Garbage",
  /*  40 */   "Network Information Service Domain",
  /*  41 */   "Network Information Servers",
  /*  42 */   "Network Time Protocol Servers",
  /*  43 */   "Vendor Specific Information",
  /*  44 */   "NetBIOS over TCP/IP Name Server",
  /*  45 */   "NetBIOS over TCP/IP Datagram Distribution Server",
  /*  46 */   "NetBIOS over TCP/IP Node Type",
  /*  47 */   "NetBIOS over TCP/IP Scope",
  /*  48 */   "X Window System Font Server",
  /*  49 */   "X Window System Display Manager",
  /*  50 */   "Requested IP Address",
  /*  51 */   "IP Address Lease Time",
  /*  52 */   "Option Overload",
  /*  53 */   "DHCP Message Type",
  /*  54 */   "Server Identifier",
  /*  55 */   "Parameter Request List",
  /*  56 */   "Message",
  /*  57 */   "Maximum DHCP Message Size",
  /*  58 */   "Renewal (T1) Time Value",
  /*  59 */   "Rebinding (T2) Time Value",
  /*  60 */   "Vendor class identifier",
  /*  61 */   "Client-identifier",
  /*  62 */   "TAG_NDS_IPDOMAIN",
  /*  63 */   "TAG_NDS_IPINFO",
  /*  64 */   "Network Information Service+ Domain",
  /*  65 */   "Network Information Service+ Servers",
  /*  66 */   "TFTP server name",
  /*  67 */   "Bootfile name",
  /*  68 */   "Mobile IP Home Agent",
  /*  69 */   "Simple Mail Transport Protocol (SMTP) Server",
  /*  70 */   "Post Office Protocol (POP3) Server",
  /*  71 */   "Network News Transport Protocol (NNTP) Server",
  /*  72 */   "Default World Wide Web (WWW) Server",
  /*  73 */   "Default Finger Server",
  /*  74 */   "Default Internet Relay Chat (IRC) Server",
  /*  75 */   "StreetTalk Server",
  /*  76 */   "StreetTalk Directory Assistance (STDA) Server",
  /*  77 */   "TAG_USER_CLASS",
  /*  78 */   "TAG_SLP_DA",
  /*  79 */   "TAG_SLP_SCOPE",
  /*  80 */   "TAG_SLP_NAMING_AUTH",
  /*  81 */   "TAG_CLIENT_FQDN",
  /*  82 */   "Agent Circuit ID",
  /*  83 */   "TAG_AGENT_REMOTE",
  /*  84 */   "TAG_AGENT_MASK",
  /*  85 */   "TAG_NDS_SERVERS",
  /*  86 */   "TAG_NDS_TREE_NAME",
  /*  87 */   "TAG_NDS_CONTEXT",
  /*  88 */   "TAG_TZ_STRING",
  /*  89 */   "TAG_FQDN_OPTION",
  /*  90 */   "TAG_AUTH",
  /*  91 */   "TAG_VINES_SERVERS",
  /*  92 */   "TAG_SERVER_RANK",
  /*  93 */   "TAG_CLIENT_ARCH",
  /*  94 */   "TAG_CLIENT_NDI",
  /*  95 */   "TAG_LDAP_URL",
  /*  96 */   "TAG_6OVER4",
  /*  97 */   "TAG_CLIENT_GUID",
  /*  98 */   "TAG_OPEN_GROUP_UAP",
  /*  99 */   "Unknown option",
  /* 100 */   "Printer Name",
  /* 101 */   "TAG_MDHCP_SERVER",
  /* 102 */   "Unknown option",
  /* 103 */   "Unknown option",
  /* 104 */   "Unknown option",
  /* 105 */   "Unknown option",
  /* 106 */   "Unknown option",
  /* 107 */   "Unknown option",
  /* 108 */   "Unknown option",
  /* 109 */   "Unknown option",
  /* 110 */   "TAG_IPX_COMPAT",
  /* 111 */   "Unknown option",
  /* 112 */   "TAG_NETINFO_PARENT",
  /* 113 */   "TAG_NETINFO_PARENT_TAG",
  /* 114 */   "TAG_URL",
  /* 115 */   "TAG_FAILOVER",
  /* 116 */   "TAG_DISABLE_AUTOCONF",
  /* 117 */   "TAG_NS_SEARCH",
  /* 118 */   "TAG_IP",
  /* 119 */   "Unknown option",
  /* 120 */   "Unknown option",
  /* 121 */   "Unknown option",
  /* 122 */   "Unknown option",
  /* 123 */   "Unknown option",
  /* 124 */   "Unknown option",
  /* 125 */   "Unknown option",
  /* 126 */   "TAG_EXTENDED_REQUEST",
  /* 127 */   "TAG_EXTENDED_OPTION",
  /* 128 */   "Unknown option",
  /* 129 */   "Unknown option",
  /* 130 */   "Unknown option",
  /* 131 */   "Unknown option",
  /* 132 */   "Unknown option",
  /* 133 */   "Unknown option",
  /* 134 */   "Unknown option",
  /* 135 */   "Unknown option",
  /* 136 */   "Unknown option",
  /* 137 */   "Unknown option",
  /* 138 */   "Unknown option",
  /* 139 */   "Unknown option",
  /* 140 */   "Unknown option",
  /* 141 */   "Unknown option",
  /* 142 */   "Unknown option",
  /* 143 */   "Unknown option",
  /* 144 */   "Unknown option",
  /* 145 */   "Unknown option",
  /* 146 */   "Unknown option",
  /* 147 */   "Unknown option",
  /* 148 */   "Unknown option",
  /* 149 */   "Unknown option",
  /* 150 */   "Unknown option",
  /* 151 */   "Unknown option",
  /* 152 */   "Unknown option",
  /* 153 */   "Unknown option",
  /* 154 */   "Unknown option",
  /* 155 */   "Unknown option",
  /* 156 */   "Unknown option",
  /* 157 */   "Unknown option",
  /* 158 */   "Unknown option",
  /* 159 */   "Unknown option",
  /* 160 */   "Unknown option",
  /* 161 */   "Unknown option",
  /* 162 */   "Unknown option",
  /* 163 */   "Unknown option",
  /* 164 */   "Unknown option",
  /* 165 */   "Unknown option",
  /* 166 */   "Unknown option",
  /* 167 */   "Unknown option",
  /* 168 */   "Unknown option",
  /* 169 */   "Unknown option",
  /* 170 */   "Unknown option",
  /* 171 */   "Unknown option",
  /* 172 */   "Unknown option",
  /* 173 */   "Unknown option",
  /* 174 */   "Unknown option",
  /* 175 */   "Unknown option",
  /* 176 */   "Unknown option",
  /* 177 */   "Unknown option",
  /* 178 */   "Unknown option",
  /* 179 */   "Unknown option",
  /* 180 */   "Unknown option",
  /* 181 */   "Unknown option",
  /* 182 */   "Unknown option",
  /* 183 */   "Unknown option",
  /* 184 */   "Unknown option",
  /* 185 */   "Unknown option",
  /* 186 */   "Unknown option",
  /* 187 */   "Unknown option",
  /* 188 */   "Unknown option",
  /* 189 */   "Unknown option",
  /* 190 */   "Unknown option",
  /* 191 */   "Unknown option",
  /* 192 */   "Unknown option",
  /* 193 */   "Unknown option",
  /* 194 */   "Unknown option",
  /* 195 */   "Unknown option",
  /* 196 */   "Unknown option",
  /* 197 */   "Unknown option",
  /* 198 */   "Unknown option",
  /* 199 */   "Unknown option",
  /* 200 */   "Unknown option",
  /* 201 */   "Unknown option",
  /* 202 */   "Unknown option",
  /* 203 */   "Unknown option",
  /* 204 */   "Unknown option",
  /* 205 */   "Unknown option",
  /* 206 */   "Unknown option",
  /* 207 */   "Unknown option",
  /* 208 */   "Unknown option",
  /* 209 */   "Unknown option",
  /* 210 */   "Unknown option",
  /* 211 */   "Unknown option",
  /* 212 */   "Unknown option",
  /* 213 */   "Unknown option",
  /* 214 */   "Unknown option",
  /* 215 */   "Unknown option",
  /* 216 */   "Unknown option",
  /* 217 */   "Unknown option",
  /* 218 */   "Unknown option",
  /* 219 */   "Unknown option",
  /* 220 */   "Unknown option",
  /* 221 */   "Unknown option",
  /* 222 */   "Unknown option",
  /* 223 */   "Unknown option",
  /* 224 */   "Unknown option",
  /* 225 */   "Unknown option",
  /* 226 */   "Unknown option",
  /* 227 */   "Unknown option",
  /* 228 */   "Unknown option",
  /* 229 */   "Unknown option",
  /* 230 */   "Unknown option",
  /* 231 */   "Unknown option",
  /* 232 */   "Unknown option",
  /* 233 */   "Unknown option",
  /* 234 */   "Unknown option",
  /* 235 */   "Unknown option",
  /* 236 */   "Unknown option",
  /* 237 */   "Unknown option",
  /* 238 */   "Unknown option",
  /* 239 */   "Unknown option",
  /* 240 */   "Unknown option",
  /* 241 */   "Unknown option",
  /* 242 */   "Unknown option",
  /* 243 */   "Unknown option",
  /* 244 */   "Unknown option",
  /* 245 */   "Unknown option",
  /* 246 */   "Unknown option",
  /* 247 */   "Unknown option",
  /* 248 */   "Unknown option",
  /* 249 */   "Unknown option",
  /* 250 */   "Unknown option",
  /* 251 */   "Unknown option",
  /* 252 */   "Unknown option",
  /* 253 */   "Unknown option",
  /* 254 */   "Unknown option",
  /* 255 */   "End",
};


/***** BEGIN CODE *****/


/* -------------------------------------------------------------- */
/* Packet's initialisation                                        */
/* -------------------------------------------------------------- */


/*! \brief Returns a string that describes the type of DHCP packet.
    \author Denis BEURIVE
    \param type Value of the option 53 (DHCP Message Type).
    \return The function returns a pointer to a zero terminated string that represents the type of the packet.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrit. Do not try to free it!
 */

char* packets_type_to_char (int type)
{
  static char DHCPDISCOVER_S[] = "DHCPDISCOVER";
  static char DHCPOFFER_S[]    = "DHCPOFFER"; 
  static char DHCPREQUEST_S[]  = "DHCPREQUEST";
  static char DHCPDECLINE_S[]  = "DHCPDECLINE";
  static char DHCPACK_S[]      = "DHCPACK";
  static char DHCPNAK_S[]      = "DHCPNAK";
  static char DHCPRELEASE_S[]  = "DHCPRELEASE";
  static char DHCPINFORM_S[]   = "DHCPINFORM";
  static char DEFAULT_S[]      = "Unknown type";

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_type_to_char(%d).",
             type);

  switch (type)
  {
    case DHCPDISCOVER: return DHCPDISCOVER_S;  
    case DHCPOFFER:    return DHCPOFFER_S; 
    case DHCPREQUEST:  return DHCPREQUEST_S;
    case DHCPDECLINE:  return DHCPDECLINE_S;
    case DHCPACK:      return DHCPACK_S;
    case DHCPNAK:      return DHCPNAK_S;
    case DHCPRELEASE:  return DHCPRELEASE_S;
    case DHCPINFORM:   return DHCPINFORM_S;
    default:           return DEFAULT_S;
  }

  return DEFAULT_S;
}

/*! \brief Initialize the packet's data before writing options.
    \author Denis BEURIVE
    \param p Pointer to the packet to initialize.
    \warning You must always call this function before calling packets_set_option().
             Once you have set all the options you want to set, then you must call packets_close_option().
             The shema is:
             <UL>
                <LI>Call packets_init_option_writer(). Note that packets_clear() calls packets_init_option_writer(). 
                <LI>Call packets_set_option() for all options you want to set.
                <LI>Call packets_close_option().
             </UL>
 */

void packets_init_option_writer (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_init_option_writer().");

  (p->ctrl).opt_pointer = p->options;

  *((p->ctrl).opt_pointer) = 99;    (p->ctrl).opt_pointer += 1;
  *((p->ctrl).opt_pointer) = 130;   (p->ctrl).opt_pointer += 1;
  *((p->ctrl).opt_pointer) = 83;    (p->ctrl).opt_pointer += 1;
  *((p->ctrl).opt_pointer) = 99;    (p->ctrl).opt_pointer += 1;

  /* 236 fixed bytes + the magic number */

  (p->ctrl).taille = 236+4;
}

/*! \brief Initialize the packet's data before reading options.
    \author Denis BEURIVE
    \param p Pointer to the packet to initialize.
    \warning You must always call this function before calling packets_parse_options(). Note that packets_clear() calls
             packets_init_option_reader().
 */

void packets_init_option_reader (struct dhcp_packet *p)
{
  int i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_init_option_reader().");

  /* We skip the 4 bytes reserved for the magic number */

  (p->ctrl).opt_pointer_reader = p->options + 4;

  for (i=0; i<256; i++)
  {
    ((p->ctrl).list[i]).code = 0;
    ((p->ctrl).list[i]).len  = 0;
    memset ((void*)((p->ctrl).list[i]).value, 0, VALUE_MAX_SIZE);
  }

  memset ((void*)(&((p->ctrl).dslam_data)), 0, sizeof(struct dhcp82));
}

/*! \brief Clear the content of a packet and intialize it for read/write option.
    \author Denis BEURIVE
    \param p Pointer to the packet to clear.
 */

void packets_clear (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_clear().");

  memset ((void*)p, 0, PACKET_SIZE);
  packets_init_option_writer (p);     /* Set the minimum size of the packet (and do other things)        */
  packets_init_option_reader (p);     /* Set access pointer to begining of options (and do other things) */
}

/*! \brief Clear the option's part of a given packet.
    \author Denis BEURIVE
    \param p Pointer to the packet that you want to clear the option's part.
 */

void packets_options_clear (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_options_clear().");

  memset ((void*)(p->options), 0, OPTION_SIZE);
}




/* -------------------------------------------------------------- */
/* Setter and getter methods                                      */
/* -------------------------------------------------------------- */


/*! \brief Set the packet's opcode.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param op Value of the opcode (should be 1 or 2).
 */

void packets_set_op (struct dhcp_packet *p, int op)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_op(%d).",
             op);

  p->op = ((unsigned char)op) & 0x000000FF;
}

/*! \brief Get the packet's opcode.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the packet's opcode.
 */

unsigned char packets_get_op (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_op().");

  return p->op;
}

/*! \brief Set the type of hardware address (field 'htype').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param htype Value that represents the type of hardware address.
 */

void packets_set_htype (struct dhcp_packet *p, int htype) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_htype().");

  p->htype = ((unsigned char)htype) & 0x000000FF;
}



/*! \brief Get the type of hardware address (field 'htype').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the type of hardware address (field 'htype').
 */

unsigned char packets_get_htype (struct dhcp_packet *p) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_htype().");

  return p->htype;
}

/*! \brief Set the length of the binary representation of the hardware address (field 'hlen').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param hlen Lenght, in bytes, of the binary representation of the hardware address.
 */

void packets_set_hlen (struct dhcp_packet *p, int hlen) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_hlen().");

  p->hlen = ((unsigned char)hlen) & 0x000000FF;
}

/*! \brief Get the length of the binary representation of the hardware address (field 'hlen').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the length of the binary representation of the hardware address (field 'hlen').
 */

unsigned char packets_get_hlen (struct dhcp_packet *p) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_hlen().");

  return p->hlen;
}

/*! \brief Set the number of hops (field 'hops').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param hops Number of hops.
 */

void packets_set_hops (struct dhcp_packet *p, int hops)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_hops().");

  p->hops = ((unsigned char)hops) & 0x000000FF;
}

/*! \brief Get the number of hops (field 'hops').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the number of hops (field 'hops').
 */

unsigned char packets_get_hops (struct dhcp_packet *p) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_hops().");

  return p->hops;
}

/*! \brief Set the transaction ID (field 'xid').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param xid Transaction ID.
 */

void packets_set_xid (struct dhcp_packet *p, unsigned long int xid) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_xid().");

  p->xid = htonl(xid);
} 

/*! \brief Get the transaction ID (field 'xid'.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the transaction ID (field 'xid').
 */

unsigned long int packets_get_xid (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_xid().");

  return ntohl(p->xid);
}

/*! \brief Set the number of seconds (field 'secs').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param secs Number of seconds.
 */ 

void packets_set_secs (struct dhcp_packet *p, unsigned short int secs) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_secs().");

  p->secs =  htons(secs);
}

/*! \brief Get the number of seconds (field 'secs').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the number of seconds (field 'secs').
 */

unsigned short int packets_get_secs (struct dhcp_packet *p) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_secs().");

  return ntohs (p->secs);
}

/*! \brief Set the packet's flags (field (flags').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param flags Flags.
 */

void packets_set_flags (struct dhcp_packet *p, unsigned short int flags)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_flags().");

  p->flags = htons(flags);
}

/*! \brief Get the packet's flags (field (flags').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the packet's flags (field (flags').
 */

unsigned short int packets_get_flags (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_flags().");

  return htons(p->flags);
}


/*! \brief Set the client's IP address (field 'ciaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param ciaddr Pointer to a zero terminated string of characters that represents the IP address of the client in
                  standard numbers-and-dots notation.
    \return If the IP address is valid, the function returns the value 0. Otherwize, the function returns the value 1.
 */

int packets_set_ciaddr (struct dhcp_packet *p, char *ciaddr) 
{
  struct in_addr inp;
  int    rc;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_ciaddr(%s).",
             ciaddr);

  rc = inet_aton (ciaddr, &inp);
  if (rc == 0) { return 1; }
  p->ciaddr = inp.s_addr;
  return 0;
}

/*! \brief Set the client's IP address (field 'ciaddr'). The field 'ciaddr' is given as an unsigned long integer in network byte order.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param ciaddr IP address of the client in RAW format (4 bytes in network byte order).
 */

void packets_set_bin_ciaddr (struct dhcp_packet *p, unsigned long int ciaddr)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_bin_ciaddr().");

  p->ciaddr = ciaddr;
}

/*! \brief Get the client's IP address (field 'ciaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function return a pointer to a zero terminated string of characters that represents the IP address of the client
            in standard numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_ciaddr (struct dhcp_packet *p)
{
  struct in_addr   inp;
  static char      ip[16];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_ciaddr().");
  
  inp.s_addr = p->ciaddr;
  memset ((void*)ip, 0, 16);
  strncpy (ip, inet_ntoa(inp), 15);
  return ip;
}

/*! \brief Get the client's IP address (field 'ciaddr') as a 4 bytes integer in network byte order.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a 4 bytes long integer in network byte order that represents thet IP address (field 'ciaddr').
 */

unsigned long int packets_get_bin_ciaddr (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_bin_ciaddr().");

  return p->ciaddr;
}

/*! \brief Set the field 'Your IP address' (field 'yiaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param yiaddr Pointer to a zero terminated string of characters that represents the IP address in
                  standard numbers-and-dots notation.
    \return If the IP address is valid, the function returns the value 0. Otherwize, the function returns the value 1.
 */

int packets_set_yiaddr (struct dhcp_packet *p, char *yiaddr)
{
  struct in_addr inp;
  int    rc;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_yiaddr(%s).",
             yiaddr);

  rc = inet_aton (yiaddr, &inp);
  if (rc == 0) { return 1; }
  p->yiaddr = inp.s_addr;
  return 0;
}

/*! \brief Get the field 'yiaddr' ("Your IP address").
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a pointer to a zero terminated string of characters that represents the IP address
            in standard numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_yiaddr (struct dhcp_packet *p)
{
  struct in_addr inp;
  static char    ip[16];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_yiaddr().");

  inp.s_addr = p->yiaddr;
  memset ((void*)ip, 0, 16);
  strncpy (ip, inet_ntoa(inp), 15);
  return ip;
}

/*! \brief Set the server IP address (field 'siaddr).
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param siaddr Pointer to a zero terminated string of characters that represents the IP address in standard numbers-and-dots notation.
    \return If the IP address is valid, the function returns the value 0. Otherwize, the function returns the value 1.
 */

int packets_set_siaddr (struct dhcp_packet *p, char *siaddr)
{
  struct in_addr inp;
  int    rc;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_siaddr(%s).",
             siaddr);

  rc = inet_aton (siaddr, &inp);
  if (rc == 0) { return 1; }
  p->siaddr = inp.s_addr;
  return 0;
}

/*! \brief Get the server IP address (field 'siaddr).
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a pointer to a zero terminated string of characters that represents the IP address
            in standard numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_siaddr (struct dhcp_packet *p)
{
  struct in_addr inp;
  static char    ip[16];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_siaddr().");

  inp.s_addr = p->siaddr;
  memset ((void*)ip, 0, 16);
  strncpy (ip, inet_ntoa(inp), 15);
  return ip;
}

/*! \brief Set the gateway IP address (field 'giaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param giaddr Pointer to a zero terminated string of characters that represents the IP address in standard numbers-and-dots notation.
    \return If the IP address is valid, the function returns the value 0. Otherwize, the function returns the value 1.
 */

int packets_set_giaddr (struct dhcp_packet *p, char *giaddr)
{
  struct in_addr inp;
  int    rc;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_giaddr(%s).",
             giaddr);

  rc = inet_aton (giaddr, &inp);
  if (rc == 0) { return 1; }
  p->giaddr = inp.s_addr;
  return 0;
}

/*! \brief Set the gateway IP address (field 'giaddr'). The IP address is given as 4 bytes entity in network byte order.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param giaddr 4 bytes in network byte order that represents an IP address. 
 */

void packets_set_bin_giaddr (struct dhcp_packet *p, unsigned long int giaddr)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_bin_giaddr(%X).",
             giaddr);

  p->giaddr = giaddr;
}

/*! \brief Get the gateway IP address (field 'giaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a pointer to a zero terminated string of characters that represents the
            IP address in standard numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_giaddr (struct dhcp_packet *p)
{
  struct in_addr inp;
  static char    ip[16];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_giaddr().");

  inp.s_addr = p->giaddr;
  memset ((void*)ip, 0, 16);
  strncpy (ip, inet_ntoa(inp), 15);
  return ip;
}

/*! \brief Get the gateway IP address (field 'giaddr'). IP address is returned as a 4 bytes integer in network byte order.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the IP address that represents the field 'giaddr'.
 */ 

unsigned long int packets_get_bin_giaddr (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_bin_giaddr().");

  return p->giaddr;
} 

/*! \brief Set the client hardware address (field 'chaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param chaddr Pointer to 16 bytes long buffer that represents the binary representation of the client's hardware address.
    \warning If the client hardware address is only 6 bytes long, the 10 last bytes must be set to 0.
 */

void packets_set_chaddr (struct dhcp_packet *p, char *chaddr) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_chaddr().");

  memcpy ((void*)p->chaddr, (void*)chaddr, 16);
}

/*! \brief Get the client hardware address (field 'chaddr').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a zero terminated string of characters that represents the hardware address of
            the client in standard ':' notation.
    \warning The string is returned in a statically allocated buffer,
             which subsequent calls will overwrite. Do not try to free it!
 */ 

char* packets_get_chaddr (struct dhcp_packet *p)
{
  int  len, i, pp;
  char *c;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_chaddr().");

  len = ((int)packets_get_hlen(p)) & 0x000000FF;
  c   = p->chaddr;
  pp  = 0;

  if (len > 16) { len = 16; }

  memset ((void*)chaddr, 0, DHCP_P_STR_HADDR_SIZE);

  for (i=0; i<len; i++)
  {
    chaddr[pp++] = int_to_char (((*c) & 0xF0) >> 4);
    chaddr[pp++] = int_to_char ((*c) & 0x0F);
    c += 1;
    if (i < len-1) { chaddr[pp++] = ':'; }
  }

  return chaddr;
}

/*! \brief Return a literal representation of the client hardware address. 
           This function is identical to the function packets_get_chaddr(), except that the returned string
           does not contain ':'.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a zero terminated string of characters that represents the hardware address of
            the client.
    \warning The string is returned in a statically allocated buffer,                                                         which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_chaddr_no_separator (struct dhcp_packet *p)
{
  int  len, i, pp;
  char *c;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_chaddr_no_separator().");

  len = ((int)packets_get_hlen(p)) & 0x000000FF;
  c   = p->chaddr;
  pp  = 0;

  if (len > 16) { len = 16; }

  memset ((void*)chaddr_exact, 0, DHCP_P_STR_HADDR_SIZE_EXACT);

  for (i=0; i<len; i++)
  {
    chaddr_exact[pp++] = int_to_char (((*c) & 0xF0) >> 4);
    chaddr_exact[pp++] = int_to_char ((*c) & 0x0F);
    c += 1;
  }

  return chaddr_exact;
} 

/*! \brief Get the client hardware address (field 'chaddr'). The hardware address is returned as RAW buffer.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \warning The RAW buffer is returned in a statically allocated buffer that points to the
             packet's data pointed by 'p'! Do <B>NOT</B> modify it!.
 */

char* packets_get_bin_chaddr (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_bin_chaddr().");

  return p->chaddr;
}

/*! \brief Set the server name (field 'sname').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param sname Pointer to a sero terminated string that represents the name of the server.
 */

void packets_set_sname (struct dhcp_packet *p, char *sname) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_sname(%s).",
             sname);

  strncpy (p->sname, sname, DHCP_P_STR_SNAME_SIZE-1);
}

/*! \brief Get the server name (field 'sname').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a zero terminated string of characters that represents name of the server.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_sname (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_sname(%s).",
             sname);

  memset ((void*)sname, 0, DHCP_P_STR_SNAME_SIZE);
  strncpy (sname, p->sname, DHCP_P_STR_SNAME_SIZE-1);
  return sname;
}

/*! \brief Set the boot file (field 'file').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param file Pointer to a zero terminated string that represents the path to the boot file.
 */

void packets_set_file (struct dhcp_packet *p, char *file) 
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_file(%s).",
             file);

  strncpy (p->file, file, DHCP_P_STR_FILE_SIZE-1); 
}

/*! \brief Get the path to the boot file (field 'file').
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns a zero terminated string of characters that represents the pat to the boot file.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite. Do not try to free it!
 */

char* packets_get_file (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_file(%s).",
             file);

  memset ((void*)file, 0, DHCP_P_STR_FILE_SIZE);
  strncpy (file, p->file, DHCP_P_STR_FILE_SIZE-1);
  return file;
}

/*! \brief Set a given DHCP option.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param option Option's code (from 1 to 254 included).
    \param value Pointer to a buffer that contains tha binary representation of the option's value.
    \param len Number of bytes for the buffer pointed by 'value'.
    \return Upon successful completion, the function returns the value 0. Otherwize, it returns the value 1.
    \warning You must call packets_init_option_writer() before! The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_writer().
               <LI>Call packets_set_option() for all options you wan to set.
               <LI>Call packets_close_option().
             </UL>
 */

int packets_set_option (struct dhcp_packet *p, unsigned char option, char *value, int len)
{
  int i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_set_option().");

  if (len > VALUE_MAX_SIZE) { return 1; }

  *((p->ctrl).opt_pointer) = option;                     (p->ctrl).opt_pointer += 1;
  *((p->ctrl).opt_pointer) = ((char)len) & 0x000000FF;   (p->ctrl).opt_pointer += 1;
  (p->ctrl).taille += 2;

  for (i=0; i<len; i++)
  {
    *((p->ctrl).opt_pointer) = *(value + i);
    (p->ctrl).opt_pointer += 1;
    (p->ctrl).taille      += 1;
  }

  return 0;
}

/*! \brief Terminate the option's part cleanly.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \warning You MUST call this function when you don't need to write any more option.
             The proper way to operate is:
    \warning You must call packets_init_option_writer() before! The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_writer().
               <LI>Call packets_set_option() for all options you wan to set.
               <LI>Call packets_close_option().
             </UL>
 */

void packets_close_option (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_close_option().");

   *((p->ctrl).opt_pointer)  = 0xFF;
   (p->ctrl).taille         += 1;
}

/*! \brief Read options from a given packet.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
    \warning You MUST call packets_init_option_reader() first!
 */

int packets_parse_options (struct dhcp_packet *p)
{
  int           inopt = 0;
  int           len, i, total;
  int           dslam_vendor;
  unsigned char code;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_parse_options().");

  packets_init_option_reader (p);
  dslam_vendor = DSLAM_UNKNOWN;

  /* ------------------------------------------------------------ */
  /* If (p->ctrl).taille has been set, then use the value         */
  /* ((p->ctrl).taille - 236). Otherwize, use the maximum size    */
  /* defined for an option, that is: OPTION_SIZE.                 */
  /*                                                              */
  /* We skip the 4 bytes at the beginning of the option's part.   */
  /*                                                              */
  /* In all cases, total MUST be less than OPTION_SIZE - 4.       */
  /* ------------------------------------------------------------ */

  total = (((p->ctrl).taille > (236 + 4)) ? ((p->ctrl).taille - 236) : OPTION_SIZE) - 4;

  if (total > OPTION_SIZE - 4) { return 1; }
 

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Size of the option's part total = %d",
             total);

  while (1)
  {
    my_syslog (
               LEVEL_FULL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "total = %d",
               total);

    if (inopt == 0)
    {
      if (*((p->ctrl).opt_pointer_reader) == 0x00)
      {
        (p->ctrl).opt_pointer_reader += 1; if (--total < 1) { return 1; }
        continue;
      }

      if (*((p->ctrl).opt_pointer_reader) == 0xFF)  { break; }

      code = *((p->ctrl).opt_pointer_reader);
      (p->ctrl).opt_pointer_reader += 1; if (--total < 1) { return 1; }
      inopt = 1;
      continue;
    }

    len = (int)(*((p->ctrl).opt_pointer_reader)) & 0x000000FF;

    ((p->ctrl).list[code]).code = code;
    ((p->ctrl).list[code]).len  = len;
    (p->ctrl).opt_pointer_reader += 1; if (--total < 1) { return 1; }

    if (len > VALUE_MAX_SIZE) { return 1; }
    for (i=0; i<len; i++)
    {
      (((p->ctrl).list[code]).value)[i] = *((p->ctrl).opt_pointer_reader);
      (p->ctrl).opt_pointer_reader += 1; if (--total < 1) { return 1; }

      my_syslog (
                 LEVEL_FULL_VERBOSE,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Size of the option's part total = %d",
                 total);
    }

    inopt = 0;
  }

  /* ------------------------------------------------------------ */
  /* If option 82 is set, then parse it                           */
  /* Please note that the format of the option 82 depends on the  */
  /* DSLAM's vendor.                                              */
  /*  - Utstarcom: size is exactly 28 bytes                       */
  /*               and vendor ID is 0X79D.                        */
  /*  - Alcatel                                                   */
  /* ------------------------------------------------------------ */

  if (((p->ctrl).list[82]).code != 0) /* Begin OPTION 82 processing block */
  {
    if (((p->ctrl).list[82]).len ==  28)  /* Begin UTSTARCOM's processing block */ 
    {
      struct m_dhcp82    *mask;
      unsigned long int  vid, nasip;
      unsigned short int vlanid, node, vci;
  
      mask = (struct m_dhcp82*)((p->ctrl).list[82]).value;
  
      /* ---------------------------------------------------------- */
      /* Skip alignement problems                                   */ 
      /* ---------------------------------------------------------- */
  
      vid = 0;
      vid = (mask->vendor_id[0] << 24) |
            (mask->vendor_id[1] << 16) |
            (mask->vendor_id[2] << 8)  |
            mask->vendor_id[3];
  
      vlanid = 0;
      vlanid = (mask->vlan_id[0] << 8) |
               mask->vlan_id[1];
  
      nasip = 0;
      nasip = (mask->nas_ip[0] << 24) |
              (mask->nas_ip[1] << 16) |
              (mask->nas_ip[2] << 8)  |
              mask->nas_ip[3];
  
      node = (mask->node_id[0] << 8) |
             mask->node_id[1];
  
      vci = (mask->vci[0] << 8) |
            mask->vci[1]; 

      /* ---------------------------------------------------------- */
      /* If vendor is Utstarcom, then proceed.                      */
      /* ---------------------------------------------------------- */

      if (vid == 0x0000079D) 
      {

        my_syslog (
                   LEVEL_FULL_VERBOSE,
                   TERMINAL_LEVEL,
                   __FILE__,
                   __LINE__,
                   "Vendor ID for UTSTARCOM found.");

        /* -------------------------------------------------------- */
        /* Sanity checks                                            */ 
        /* -------------------------------------------------------- */
    
        if (mask->sub_option != 2)
        {
          my_syslog (
                     LEVEL_WARNING,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "Invalid value for option 82 sub-option (%d instead of 2)",
                     (int)mask->sub_option);
          return 1; 
        }
    
        if (mask->length != 26)
        {
          my_syslog (
                     LEVEL_WARNING,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "Invalid value for option 82 length (%d instead of 26)",
                     (int)mask->length);
          return 1; 
        }
    
        (p->ctrl).dslam_data.sub_option = mask->sub_option;
        (p->ctrl).dslam_data.length     = mask->length;
        (p->ctrl).dslam_data.vendor_id  = vid;
        (p->ctrl).dslam_data.port_type  = mask->port_type;
        (p->ctrl).dslam_data.version    = mask->version;
        (p->ctrl).dslam_data.vlan_id    = vlanid;
    
        memcpy ((void*)(p->ctrl).dslam_data.nas_mac, mask->nas_mac, 6);
        memset ((void*)((p->ctrl).dslam_data.node_id), 0, NODE_BUFFER_SIZE);
        snprintf ((p->ctrl).dslam_data.node_id, NODE_BUFFER_SIZE-1, "%u", node);
    
        (p->ctrl).dslam_data.nas_ip      = nasip;
        (p->ctrl).dslam_data.shelf       = mask->shelf       + 1;  /* Add 1 ??? Why */
        (p->ctrl).dslam_data.numero_slot = mask->numero_slot + 1;  /* Add 1 ??? Why */
        (p->ctrl).dslam_data.numero_port = mask->numero_port + 1;  /* Add 1 ??? Why */
        (p->ctrl).dslam_data.vpi         = mask->vpi;
        (p->ctrl).dslam_data.vci         = vci;

        dslam_vendor = DSLAM_UTSTARCOM;
      }
    }  /* End UTSTARCOM processing block */


    /* ------------------------------------------------------------ */
    /* If this is not an Utstarcom, then we assume that it is an    */
    /* Alcatel.                                                     */ 
    /* First byte should be "01" (sub-option).                      */
    /* Second byte should be the length of sub-option).             */
    /*                                                              */
    /*                        Minimum  Maximum                      */
    /* Sub-option code:       1        1                            */
    /* Sub-option length:     1        1                            */
    /* Node:                  0        20                           */
    /* String "atm":          3        3                            */
    /* One character "space": 1        1                            */
    /* Rack:                  1        1                            */
    /* One character "/":     1        1                            */
    /* Shelf:                 1        1                            */
    /* One character "/":     1        1                            */
    /* Slot:                  2        2                            */
    /* One character "/":     1        1                            */ 
    /* Port:                  2        2                            */
    /* One character ":":     1        1                            */
    /* VPI:                   1        3                            */
    /* One character ".":     1        1                            */
    /* VCI:                   1        3                            */
    /* One character "STX":   1        1                            */
    /* Other characters:      0        11                           */
    /*                        -------- --------                     */
    /*                        20       55                           */
    /*                                                              */
    /* The character "STX" has the ASCII code 2.                    */
    /* It should be followed by a character "New line" (ASCII code  */
    /* 10, in decimal).                                             */
    /* The other characters should be the phone number.             */
    /* ------------------------------------------------------------ */

    if (dslam_vendor == DSLAM_UNKNOWN) /* Begin ALCATEL procesing block */
                                       /* The loop "while" is used beacause we need the "break" */ 
    {
      while (
              (((p->ctrl).list[82]).len >= 20)
              &&
              (((p->ctrl).list[82]).len < VALUE_MAX_SIZE)
            )
      {
        char          *c, *v82, value82[VALUE_MAX_SIZE], node[NODE_BUFFER_SIZE], rack[2], shelf[2], slot[3], port[3];
        char          vpi[4], vci[4], vlanid[7];
        unsigned char subopt, subopt_length;


        my_syslog (
                   LEVEL_FULL_VERBOSE,
                   TERMINAL_LEVEL,
                   __FILE__,
                   __LINE__,
                   "Is it an ALCATEL DSLAM ?");

        memset ((void*)value82, 0,    VALUE_MAX_SIZE);
        memset ((void*)node,    0,    NODE_BUFFER_SIZE);
        memset ((void*)rack,    0,    2);
        memset ((void*)shelf,   0,    2);
        memset ((void*)slot,    0,    3);
        memset ((void*)port,    0,    3);
        memset ((void*)vpi,     0,    4);
        memset ((void*)vci,     0,    4);
        memset ((void*)vlanid,  0,    7);

        /* -------------------------------------------------------- */
        /* Note that the string pointed by 'value82' should be      */
        /* zero-terminated, because:                                */
        /* (((p->ctrl).list[82]).len < VALUE_MAX_SIZE)              */
        /* -------------------------------------------------------- */

        memcpy ((void*)value82, (void*)((p->ctrl).list[82]).value, ((p->ctrl).list[82]).len);
        v82 = value82;

        /* -------------------------------------------------------- */
        /* Extract the sub-option's data.                           */
        /* -------------------------------------------------------- */

        subopt        = value82[0];   /* Should be "01" for ALCATEL              */
        subopt_length = value82[1];   /* Should be between 17 and 40 for ALCATEL */

        my_syslog (
                    LEVEL_FULL_VERBOSE,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "OPT82 = [%s]",
                    value82);

        my_syslog (
                    LEVEL_FULL_VERBOSE,
                    TERMINAL_LEVEL,
                    __FILE__,
                    __LINE__,
                    "Sub-Option=%u and Sub-Option length=%u",
                    subopt,
                    subopt_length);

        /* -------------------------------------------------------- */
        /* Look for the string " atm ".                             */
        /* Extract the node.                                        */
        /* Skip the string " atm ".                                 */
        /* -------------------------------------------------------- */

        v82 = value82 + 2;
        c   = strstr (v82, " atm ");
        if (c == NULL)
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Can not find the string \"atm\" ! (wrong packet ?)");
          return 1;
        }

        if (c != v82) { 
                        int length;
                        length = (int)(c - v82);
                        if (length >= NODE_BUFFER_SIZE) { break; }
                        memcpy ((void*)node, (void*)v82, length);
                        v82 = c;
                      }

        v82 += 5;

        /* -------------------------------------------------------- */
        /* Extract the Rack                                         */
        /* Skip the character "/".                                  */
        /* -------------------------------------------------------- */

        if ((*v82 < 48) || (*v82 > 57))
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Rack is not numeric! (wrong packet ?)");
          return 1;
        }

        if (*(v82+1) != '/')
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character '/' after Rack! (wrong packet ?)");
          return 1;
        }

        rack[0] = *v82;
        v82 += 2;

        /* -------------------------------------------------------- */
        /* Extract the shelf.                                       */
        /* Skip the character "/".                                  */
        /* -------------------------------------------------------- */

        if ((*v82 < 48) || (*v82 > 57)) 
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Shelf is not numeric! (wrong packet ?)");
          return 1;
        }

        if (*(v82+1) != '/')
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character '/' after Shelf! (wrong packet ?)");
          return 1;
        }

        shelf[0] = *v82;
        v82 += 2;

        /* -------------------------------------------------------- */
        /* Extract the slot.                                        */
        /* Skip the character "/".                                  */
        /* -------------------------------------------------------- */

        if ((*v82 < 48) || (*v82 > 57))
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Slot is not numeric! (wrong packet ?)");
          return 1;
        }
 
        if ((*(v82+1) < 48) || (*(v82+1) > 57))
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Slot is not numeric! (wrong packet ?)");
          return 1;
        }

        if (*(v82+2) != '/')
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character '/' after Slot! (wrong packet ?)");
          return 1;
        }

        slot[0] = *v82;
        slot[1] = *(v82 + 1);
        v82 += 3;

        /* -------------------------------------------------------- */
        /* Extract the port.                                        */
        /* Skip the character ":".                                  */
        /* -------------------------------------------------------- */

        if ((*v82 < 48) || (*v82 > 57))
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Port is not numeric! (wrong packet ?)");
          return 1;
        }

        if ((*(v82+1) < 48) || (*(v82+1) > 57))
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Port is not numeric! (wrong packet ?)");
          return 1;
        }

        if (*(v82+2) != ':')
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character ':' after Port!");
          return 1;
        }

        port[0] = *v82;
        port[1] = *(v82+1);
        v82 += 3;

        /* -------------------------------------------------------- */
        /* Extract the VPI.                                         */
        /* Skip the character ".".                                  */
        /* -------------------------------------------------------- */

        c = strstr (v82, ".");
        if (c == NULL)
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character '.' after VPI!");
          return 1;
        }

        if (c == v82)
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Empty VPI!");
          return 1;
        }
        else {
               int length;
               length = (int)(c - v82);
               if (length > 3)
               {
                 my_syslog (
                            LEVEL_WARNING,
                            TERMINAL_LEVEL,
                            __FILE__,
                            __LINE__,
                            "VPI size is %d  (too long, max is 3)!",
                            length);
                 return 1;
               }
               memcpy ((void*)vpi, (void*)v82, length);
             }
        v82 = c + 1;

        /* -------------------------------------------------------- */
        /* Extract the VCI.                                         */
        /* -------------------------------------------------------- */

        c = strstr (v82, "\2");   /* look for character "STX = Start of text" */
        if (c == NULL)
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "No character '.' after VCI!");
          return 1;
        }

        if (c == v82)
        {
          my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "Empty VCI!");
          return 1;
        }
        else {
               int length;
               length = (int)(c - v82);
               if (length > 3)
               {
                 my_syslog (
                            LEVEL_WARNING,
                            TERMINAL_LEVEL,
                            __FILE__,
                            __LINE__,
                            "VCI size is %d  (too long, max is 3)!",
                            length);
                 return 1;
               }
               memcpy ((void*)vci, (void*)v82, length);
             }

        /* Note that the string pointed by 'value82' should be      */
        /* zero-terminated (see earlier comment).                   */

        v82 = c + 1;  /* This may point to character '0' */

        /* -------------------------------------------------------- */
        /* Now assign values to data structure.                     */
        /* -------------------------------------------------------- */

        (p->ctrl).dslam_data.sub_option = (unsigned char)subopt;
        (p->ctrl).dslam_data.length     = (unsigned char)subopt_length;
        (p->ctrl).dslam_data.vendor_id  = 0;
        (p->ctrl).dslam_data.port_type  = 0;
        (p->ctrl).dslam_data.version    = 0;
        
        memset ((void*)(p->ctrl).dslam_data.nas_mac,   0, 6);
        memset ((void*)((p->ctrl).dslam_data.node_id), 0, NODE_BUFFER_SIZE);
        strncpy ((p->ctrl).dslam_data.node_id, node, NODE_BUFFER_SIZE-1);

        (p->ctrl).dslam_data.nas_ip      = 0;
        (p->ctrl).dslam_data.shelf       = (unsigned char)(atoi(shelf));
        (p->ctrl).dslam_data.numero_slot = (unsigned char)(atoi(slot));
        (p->ctrl).dslam_data.numero_port = (unsigned char)(atoi(port));
        (p->ctrl).dslam_data.vpi         = (unsigned short int)(atoi(vpi));  /* 999 < 65535 => that's OK */
        (p->ctrl).dslam_data.vci         = (unsigned short int)(atoi(vci));  /* 999 < 65535 => that's OK */

        /* -------------------------------------------------------- */
        /* The Vlan ID is compose [VPI+VCI]                         */ 
        /* The maximum size for VPI is 3 characters.                */
        /* The maximum size for VCI is 3 characters.                */
        /* -------------------------------------------------------- */

        strncpy  (vlanid, vpi, 3);
        strncat  (vlanid, vci, 3);

        (p->ctrl).dslam_data.vlan_id = (unsigned int)(atoi(vlanid)); /* Maximum is 999999 => that's OK */

        dslam_vendor = DSLAM_ALCATEL;
        break;
      }
    } /* End ALCATEL procesing block */

    /* ------------------------------------------------------------ */
    /* If we could not find the vendor, then we don't know how to  */
    /* parse the option's string.                                  */
    /* ------------------------------------------------------------ */

    (p->ctrl).dslam_data.constructor = dslam_vendor;

    if (dslam_vendor == DSLAM_UNKNOWN)
    {

      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Could not find the DSLAM's vendor!.");
      return 1;
    }
  } /* End OPTION 82 processing block */

  return 0;
}

/*! \brief Get a specific option.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param option Option's code (value between 1 and 254 included).
    \param len Pointer to an integer used to store the size of the option's value.
    \param value Pointer to a pointer that will point to the option's value.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract.
             </UL>
 */

int packets_get_option (struct dhcp_packet *p, int option, int *len, unsigned char **value)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_option(%d).",
             option);

  if (((p->ctrl).list[option]).code == 0) { return 1; }

  *len   = ((p->ctrl).list[option]).len;
  *value = ((p->ctrl).list[option]).value;

  return 0;
}

/*! \brief Get the type of packet (value of option 53 (DHCP Message Type).
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return Upon successful completion, the function returns the numerical representation of the message type.
            This could be:
            <UL>
              <LI>DHCPDISCOVER (1)
              <LI>DHCPOFFER (2)
              <LI>DHCPREQUEST (3)
              <LI>DHCPDECLINE (4)
              <LI>DHCPACK (5)
              <LI>DHCPNAK (6)
              <LI>DHCPRELEASE (7)
              <LI>DHCPINFORM (8)
            </UL>
            If an error occured, the function returns the value -1.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type(). 
             </UL>
 */

int packets_get_message_type (struct dhcp_packet *p)
{
  int            rc, len;
  unsigned char  *value;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_message_type().");

  rc = packets_get_option (p, 53, &len, &value);
  if (rc == 1) { return -1; }

  return ((int)*value) & 0x000000FF;
}

/*! \brief Get the subnet mask associated with a given packet.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return Upon successful completion, the function returns a non NULL pointer to a zero terminated string of
            characters that represents the network mask. Otherwise the function returns the value NULL.
    \warning The returned string can only be used until the next call to packets_get_subnet_mask().
             The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
             Do not try to free it!
 */

char* packets_get_subnet_mask (struct dhcp_packet *p)
{
  int            rc, len;
  unsigned char  *value;
  static char    subvalue[OPTIONS_OPTION_VALUE_SIZE];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_subnet_mask().");

  memset ((void*)subvalue, 0, OPTIONS_OPTION_VALUE_SIZE);

  rc = packets_get_option (p, 1, &len, &value);
  if (rc == 1) { return NULL; }

  memcpy ((void*)subvalue, (void*)value, (len < OPTIONS_OPTION_VALUE_SIZE) ? len : OPTIONS_OPTION_VALUE_SIZE-1);

  return subvalue;
}

/*! \brief Return a zero terminated string of characters the represents the DSLAM's node ID from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's node ID.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type(). 
               <LI>Call packets_get_node_id().
             </UL>
 */

char* packets_get_node_id (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_node_id().");

  return (p->ctrl).dslam_data.node_id; 
}

/*! \brief Return the DSLAM's shelf from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's shelf.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type(). 
               <LI>Call packets_get_shelf().
             </UL>
 */

unsigned char packets_get_shelf (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_shelf().");

  return (p->ctrl).dslam_data.shelf;
}

/*! \brief Return the DSLAM's slot number from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's slot number.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type(). 
               <LI>Call packets_get_numero_slot().
             </UL>
 */

unsigned char packets_get_numero_slot (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_numero_slot().");

  return (p->ctrl).dslam_data.numero_slot;
} 

/*! \brief Return the DSLAM's VCI from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's VCI.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type().
               <LI>Call packets_get_vci().
             </UL>
 */

unsigned short int packets_get_vci (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_vci().");

  return (p->ctrl).dslam_data.vci;
}

/*! \brief Return the DSLAM's port number from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's port number.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type(). 
               <LI>Call packets_get_numero_port().
             </UL>
 */

unsigned char packets_get_numero_port (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_numero_port().");

  return (p->ctrl).dslam_data.numero_port;
}

/*! \brief Return the DSLAM's VLAN ID from the option 82.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \return The function returns the DSLAM's VLAN ID.
    \warning You must call packets_parse_options() first. The proper way to operate is:
             <UL>
               <LI>Call packets_init_option_reader().
               <LI>Call packets_parse_options().
               <LI>Call packets_get_option() for all options you want to extract (you may skip this step).
               <LI>Call packets_get_message_type().
               <LI>Call packets_get_vlan_id().
             </UL>
 */

unsigned short int packets_get_vlan_id (struct dhcp_packet *p)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_get_vlan_id().");

  return (p->ctrl).dslam_data.vlan_id;
}

/*! \brief Size of the buffer used to write data in function packet_dump().
    \remark the value 4096 should be more than enough, since it is much bigger than the maximum DHCP packet size.
 */

#define BUFFER_SIZE 4096

/*! \brief Dump the DHCP packet in a file (in human readable format).
    \author Denis BEURIVE
    \param p Pointer to the packet to dump.
    \param pin Pointer to the incoming packet (used for the modem's manufacturor).
    \param mysql_tables Pointer to a 'mysql_tables' data structure that contains the loaded context.
    \param file Path to the output file.
    \param csv Path to the CSV file.
    \param from Internet address of the sender. If NULL, then a character '-' is printed.
    \param to Internet address of the addressee. If NULL, then a character '-' is printed.
    \return Upon successful completion, the function returns the value 0. Otherwise, it returns the value 1.
    \warning If the function could not allocate memory, it calls the function "exit()" with status value 1.
             You must call packet_init_dump_service() before you can use this function.
 */

int packet_dump (struct dhcp_packet *p, struct dhcp_packet *pin, struct mysql_tables *mysql_tables, char *file, char *csv, struct sockaddr_in *from, struct sockaddr_in *to)
{
  FILE                *out, *csvfd;
  int                 iout, icsvfd;
  int                 i, j, k, len, port_from, port_to, type, modem_manufacturor, size, o;
  unsigned char       *c, *value;
  char                addresse_from[16], addresse_to[16], buffer[BUFFER_SIZE], buff82[BUFFER_SIZE], *s, *sopt;
  static unsigned int mark = 0;
  dstring             ds, dsoptions;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packet_dump().");

  memset ((void*)buff82, 0, BUFFER_SIZE);

  iout = open (file, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
  if (iout == -1)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Could not open file '%s' - open() failed - %s",
                file,
                strerror(errno));
    return 1;
  }

  out = fdopen (iout, "a");
  if (out == NULL)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Could not \"fdopen()\" file '%s' - %s",
                file,
                strerror(errno));
    return 1;
  }

  /* ------------------------------------------------------------ */
  /* Get the modem's manufacturor.                                */
  /* ------------------------------------------------------------ */

  modem_manufacturor = get_modem_manufacturor(pin);

  /* ------------------------------------------------------------ */
  /* Parse options                                                */
  /* ------------------------------------------------------------ */

  if (packets_parse_options(p) == 1)
  {
    my_syslog (
                LEVEL_WARNING,
                HIGH_LEVEL,
                __FILE__,
                __LINE__,
                "Error while parsing packet (p), drop packet");
    fclose (out);
    return 1;
  }

  if (packets_parse_options(pin) == 1)
  {
    my_syslog (
                LEVEL_WARNING,
                HIGH_LEVEL,
                __FILE__,
                __LINE__,
                "Error while parsing packet (pin), drop packet");
    fclose (out);
    return 1;
  }

  /* ------------------------------------------------------------ */
  /* Allocate dynamic strings.                                    */
  /* ------------------------------------------------------------ */

  if (dstring_init (&ds, 2048) == 1)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "packet_dump(): Can not allocate memory for dynamic string (ds)!");
    fclose (out);
    exit (1);
  }

  if (dstring_init (&dsoptions, 2048) == 1)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "packet_dump(): Can not allocate memory for dynamic string (dsoptions)!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Get "from" and "to" address.                                 */
  /* ------------------------------------------------------------ */

  if (from != NULL)
  { memset ((void*)addresse_from, 0, 16); get_remote_address (from, addresse_from, &port_from); }

  if (to   != NULL)
  { memset ((void*)addresse_to,   0, 16); get_remote_address (to,   addresse_to,   &port_to);   }

  /* ------------------------------------------------------------ */
  /* Lock dump file (using synchronization file)                  */
  /* ------------------------------------------------------------ */

  if (dump_sync_fd != -1)
  {
    if (lock_file (dump_sync_fd) == 1)
    {
      my_syslog (
                  LEVEL_WARNING,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "packet_dump(): Could not lock dump file! Continue processing anyway...");
    }
  }

  /* ------------------------------------------------------------ */
  /* Print date and mark (auto increment)                         */
  /* ------------------------------------------------------------ */

  fprintf (out, "%s (%u)\n\n", dater(), mark);

  memset ((void*)buffer, 0, BUFFER_SIZE);
  snprintf  (buffer, BUFFER_SIZE, "%s;%u;%s;", dater(), mark, myhostname);
  mark++;
  if (dstring_add (&ds, buffer, strlen(buffer)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Print sender's TCP data (IP and port)                        */
  /* ------------------------------------------------------------ */

  memset ((void*)buffer, 0, BUFFER_SIZE);

  if (from != NULL)
  {
    fprintf (out, "%s (%d) => ", addresse_from, port_from);
    snprintf (buffer, BUFFER_SIZE, "IN;%s;%d;", addresse_from, port_from);
  }
  else
  {
    fprintf (out, "- => ");
    snprintf (buffer, BUFFER_SIZE, "OUT;-;-;"); 
  }

  if (dstring_add (&ds, buffer, strlen(buffer)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Print receiver's TCP data (IP and port)                      */
  /* ------------------------------------------------------------ */

  memset ((void*)buffer, 0, BUFFER_SIZE);

  if (to != NULL)
  {
    fprintf (out, "%s (%d)", addresse_to, port_to);
    snprintf (buffer, BUFFER_SIZE, "%s;%d;", addresse_to, port_to);
  }
  else
  {
    fprintf (out, "-");
    snprintf (buffer, BUFFER_SIZE, "-;-;");
  }

  if (dstring_add (&ds, buffer, strlen(buffer)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Print the message type                                       */
  /* ------------------------------------------------------------ */

  type = packets_get_message_type(p);
  fprintf (out, " %s", packets_type_to_char(type));
  fprintf (out, "\n\n");

  memset ((void*)buffer, 0, BUFFER_SIZE);
  snprintf (buffer, BUFFER_SIZE, "%s;", packets_type_to_char(type));
  if (dstring_add (&ds, buffer, strlen(buffer)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Dump fixed fields                                            */
  /* ------------------------------------------------------------ */

  fprintf (out, "Number of bytes                : %u\n",  (unsigned int)((p->ctrl).taille));
  fprintf (out, "Opcode                         : %u\n",  ((unsigned int)packets_get_op(p)) & 0x000000FF);
  fprintf (out, "Hardware type                  : %u\n",  ((unsigned int)packets_get_htype(p)) & 0x000000FF);
  fprintf (out, "Hardware address length        : %u\n",  ((unsigned int)packets_get_hlen(p)) & 0x000000FF);
  fprintf (out, "Hop count                      : %u\n",  ((unsigned int)packets_get_hops(p)) & 0x000000FF);
  fprintf (out, "Transaction ID                 : %lu\n",     packets_get_xid(p));
  fprintf (out, "Ellapsed time                  : %hu\n",     packets_get_secs(p));
  fprintf (out, "Flags                          : %hu\n",     packets_get_flags(p));
  fprintf (out, "Client IP address              : %s\n",      packets_get_ciaddr(p));
  fprintf (out, "Your IP address                : %s\n",      packets_get_yiaddr(p));
  fprintf (out, "Server IP address              : %s\n",      packets_get_siaddr(p));
  fprintf (out, "Gateway IP address             : %s\n",      packets_get_giaddr(p));
  fprintf (out, "Client hardware address        : %s (%s)\n", packets_get_chaddr(p),
		                                              id_manufacturor_to_string(modem_manufacturor));
  fprintf (out, "Server host name               : %s\n",      packets_get_sname(p));
  fprintf (out, "Boot file name                 : %s\n",      packets_get_file(p));
  fprintf (out, "\n");

  memset ((void*)buffer, 0, BUFFER_SIZE);
  snprintf (buffer, BUFFER_SIZE, "%u;%u;%u;%u;%u;%lu;%hu;%hu;%s;%s;%s;%s;%s;%s;%s;%s;",
            (unsigned int)((p->ctrl).taille),
            ((unsigned int)packets_get_op(p))    & 0x000000FF,
            ((unsigned int)packets_get_htype(p)) & 0x000000FF,
            ((unsigned int)packets_get_hlen(p))  & 0x000000FF,
            ((unsigned int)packets_get_hops(p))  & 0x000000FF,
            packets_get_xid(p),
            packets_get_secs(p),
            packets_get_flags(p),
            packets_get_ciaddr(p),
            packets_get_yiaddr(p),
            packets_get_siaddr(p),
            packets_get_giaddr(p),
            packets_get_chaddr(p),
            packets_get_sname(p),
            packets_get_file(p),
            id_manufacturor_to_string(modem_manufacturor));

  if (dstring_add (&ds, buffer, strlen(buffer)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Print The options                                            */
  /* ------------------------------------------------------------ */


  my_syslog (
             LEVEL_DEBUG,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "packet_dump(): Start dumping options now.");


  fprintf (out, "Options:\n\n");

  for (o=0; o<256; o++)
  {
    /* ---------------------------------------------------------- */
    /* Print options in the correct order                         */
    /* (that is: 1, 3, 15, 6,...)                                 */ 
    /* ---------------------------------------------------------- */

    i = order[o];   

    /* ---------------------------------------------------------- */
    /* Special options                                            */
    /* ---------------------------------------------------------- */

    if ((i==1 || i==3 || i==15 || i==6) && (((p->ctrl).list[i]).code == 0))
    {
      char aux[]=";";
      if (dstring_add (&dsoptions, aux, strlen(aux)) == 1)
      {
         my_syslog (
                     LEVEL_WARNING,
                     TERMINAL_LEVEL,
                     __FILE__,
                     __LINE__,
                     "packet_dump(): Can not allocate memory!");
         fclose (out);
         exit (1);
      } 
      continue;
    }

    /* ---------------------------------------------------------- */
    /* Standard options                                           */
    /*                                                            */
    /* NOTE: Specific test is done later in the code for i=82     */
    /* ---------------------------------------------------------- */

    if (
         (i != 82)
         &&
         (((p->ctrl).list[i]).code == 0)
       )
    { continue; }

    my_syslog (
                LEVEL_DEBUG,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "packet_dump(): Dump option %d", i);


    len   = ((p->ctrl).list[i]).len;
    value = ((p->ctrl).list[i]).value;

    fprintf (out, "\t%3d (%s) ", i, descriptions[i]);

    /* --- CSV */

    if (i != 82)
    {
       if (! (i==1 || i==3 || i==15 || i==6))
       {
         memset ((void*)buffer, 0, BUFFER_SIZE);
         snprintf (buffer, BUFFER_SIZE, "%3d|%s|", i, descriptions[i]);
         if (dstring_add (&dsoptions, buffer, strlen(buffer)) == 1)
         {
           my_syslog (
                      LEVEL_WARNING,
                      TERMINAL_LEVEL,
                      __FILE__,
                      __LINE__,
                      "packet_dump(): Can not allocate memory!");
           fclose (out);
           exit (1);
         }
       }
    }

    /* --- */

    memset ((void*)buffer, 0, BUFFER_SIZE);
    c = value;

    for (j=0; j<len; j++)
    {
      fprintf (out, "%c%c ",
                     int_to_char (((*c) & 0xF0) >> 4),  
                     int_to_char ((*c) & 0x0F));

      /* --- CSV */

         if (i != 82)
         {
            snprintf (buffer, BUFFER_SIZE, "%c%c",
                      int_to_char (((*c) & 0xF0) >> 4),
                      int_to_char ((*c) & 0x0F));
            if (dstring_add (&dsoptions, buffer, strlen(buffer)) == 1)
            {
              my_syslog (
                         LEVEL_WARNING,
                         TERMINAL_LEVEL,
                         __FILE__,
                         __LINE__,
                         "packet_dump(): Can not allocate memory!");
              fclose (out);
              exit (1);
            }
         }

      /* --- */

      c++;
    }

    /* --- CSV */

       if (i != 82)
       {
          if (dstring_add (&dsoptions, ";", 1) == 1)
          {
            my_syslog (
                       LEVEL_WARNING,
                       TERMINAL_LEVEL,
                       __FILE__,
                       __LINE__,
                       "packet_dump(): Can not allocate memory!");
            fclose (out);
            exit (1);
          }
       }

    /* --- */

    fprintf (out, "\n");

    /* ---------------------------------------------------------- */
    /* Options 82 - From the incoming packet                      */
    /* ---------------------------------------------------------- */

    if ((i==82) && (((pin->ctrl).list[i]).code != 0))
    {
      my_syslog (
                  LEVEL_DEBUG,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "packet_dump(): dump option 82");

      fprintf (out, "\t\tsub option:  %u\n",    (pin->ctrl).dslam_data.sub_option);
      fprintf (out, "\t\tlength:      %u\n",    (pin->ctrl).dslam_data.length);
      fprintf (out, "\t\tvendor ID:   %#lX\n",  (pin->ctrl).dslam_data.vendor_id);
      fprintf (out, "\t\tport type:   %u\n",    (pin->ctrl).dslam_data.port_type);
      fprintf (out, "\t\tversion:     %u\n",    (pin->ctrl).dslam_data.version);
      fprintf (out, "\t\tvlan ID:     %hu\n",   (pin->ctrl).dslam_data.vlan_id);

      /* --- CSV */

         snprintf (buff82, BUFFER_SIZE, "82;%#lX;%u;%u;%hu;",
                   (pin->ctrl).dslam_data.vendor_id,
                   (pin->ctrl).dslam_data.port_type,
                   (pin->ctrl).dslam_data.version,
                   (pin->ctrl).dslam_data.vlan_id);

      /* --- */

      fprintf (out, "\t\tnas mac:     ");
      for (k=0; k<6; k++)
      {
        char          dd[3];
        unsigned char c  = (pin->ctrl).dslam_data.nas_mac[k];
        char          c1 = int_to_char ((c & 0xF0) >> 4);
	char          c2 = int_to_char (c & 0x0F);

	fprintf (out, "%c%c", c1, c2); 
        snprintf (dd, 3, "%c%c", c1, c2);
        strcat (buff82, dd);

	if (k<5) { fprintf (out, ":"); strcat (buff82, ":"); }
      }
      strcat (buff82, ";");
      fprintf (out, "\n"); 

      fprintf (out, "\t\tnas ip:      %s\n",  get_doted_ip((pin->ctrl).dslam_data.nas_ip));
      fprintf (out, "\t\tnode:        %s\n",  (pin->ctrl).dslam_data.node_id);
      fprintf (out, "\t\tshelf:       %u\n",  (pin->ctrl).dslam_data.shelf);
      fprintf (out, "\t\tslot:        %u\n",  (pin->ctrl).dslam_data.numero_slot);
      fprintf (out, "\t\tport:        %u\n",  (pin->ctrl).dslam_data.numero_port);
      fprintf (out, "\t\tvpi:         %u\n",  (pin->ctrl).dslam_data.vpi);
      fprintf (out, "\t\tvci:         %hu\n", (pin->ctrl).dslam_data.vci);
      fprintf (out, "\t\tvendor:      ");

      /* --- CSV */

         memset ((void*)buffer, 0, BUFFER_SIZE);
         snprintf (buffer, BUFFER_SIZE, "%s;%s;%u;%u;%u;%u;%hu;",
                   get_doted_ip((pin->ctrl).dslam_data.nas_ip),
                   (pin->ctrl).dslam_data.node_id,
                   (pin->ctrl).dslam_data.shelf,
                   (pin->ctrl).dslam_data.numero_slot,
                   (pin->ctrl).dslam_data.numero_port,
                   (pin->ctrl).dslam_data.vpi,
                   (pin->ctrl).dslam_data.vci);

         strcat (buff82, buffer);

      /* --- */

      switch ((pin->ctrl).dslam_data.constructor)
      {
        case DSLAM_ALCATEL:    { fprintf (out, "ALCATEL\n");
                                 strcat (buff82, "ALCATEL;"); }
                               break;
        case DSLAM_UTSTARCOM:  { fprintf (out, "UTSTARCOM\n");
                                 strcat (buff82, "UTSTARCOM;"); }
                               break;
        default:               { fprintf (out, "Unknown (%d) - This should not happen!\n", (pin->ctrl).dslam_data.constructor);
                                 strcat (buff82, "UNKNOWN;"); }
      }
    }
    else {
           if (i == 82)
           {
              my_syslog (
                           LEVEL_DEBUG,
                           TERMINAL_LEVEL,
                           __FILE__,
                           __LINE__,
                           "packet_dump(): Do NOT dump option 82");
                        }
          }

  } /* End of options' section */ 

  /* ------------------------------------------------------------ */
  /* Add option 82 to the end of the fixed part.                  */
  /* ------------------------------------------------------------ */

  if (buff82[0] != 0)
  {
    if (dstring_add (&ds, buff82, strlen(buff82)) == 1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "packet_dump(): Can not allocate memory!");
      fclose (out);
      exit (1);
    }
  }
  else
  {
    char aux[]=";;;;;;;;;;;;;;";

    if (dstring_add (&ds, aux, strlen(aux)) == 1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "packet_dump(): Can not allocate memory!");
      fclose (out);
      exit (1);
    }
  }

  fprintf (out, "\n\n\n");

  /* ------------------------------------------------------------ */
  /* Add options to the end of the CSV.                           */
  /* ------------------------------------------------------------ */

  sopt = dstring_get_data (&dsoptions, &size);
  if (sopt == NULL)
  {
     my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "packet_dump(): Can not allocate memory!");
     fclose (out);
     exit (1);
  }

  if (dstring_add (&ds, sopt, strlen(sopt)) == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  /* ------------------------------------------------------------ */
  /* Print the CSV                                                */
  /* ------------------------------------------------------------ */

  s = dstring_get_data (&ds, &size);
  if (s == NULL)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Can not allocate memory!");
    fclose (out);
    exit (1);
  }

  icsvfd = open (csv, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
  if (icsvfd == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Could not open file '%s' open() failed - %s",
               csv,
               strerror(errno));
    fclose (out);
    return 1;
  }


  csvfd = fdopen (icsvfd, "a");
  if (csvfd == NULL)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packet_dump(): Could not \"fdopen\" file '%s' - %s",
               csv,
               strerror(errno));
    fclose (out);
    return 1;
  }

  fprintf (csvfd, "%s\n", s);
  fclose (csvfd);

  /* ------------------------------------------------------------ */
  /* Unlock dump file                                             */
  /* ------------------------------------------------------------ */

  if (dump_sync_fd != -1)
  {
    if (unlock_file (dump_sync_fd) == 1)
    {
      my_syslog (
                 LEVEL_WARNING,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "packet_dump(): Could not unlock dump file! Continue processing ...");
    }
  }

  fclose (out);

  /* ------------------------------------------------------------ */
  /* Free all allocated memory                                    */
  /* ------------------------------------------------------------ */

  dstring_free (&ds);
  dstring_free (&dsoptions);
  free (s);
  free (sopt);

  return 0;
}

/*! \brief Check the size of a packet. 
    \author Denis BEURIVE
    \param size Size of the packet.
    \return If the size of the packet is valid, the function returns 1. Otherwize, it returns 0.
 */

int check_packet_size (int size)
{
  /* ------------------------------------------------------------ */
  /* Minimum size is: fixed size (mandatory fields): 236 bytes    */
  /*                  Magic number (for options):      4 bytes    */
  /*                  The message ty (option 53)       3 bytes    */
  /*                  End padding (FF):                1 byte     */
  /*                                               -------------  */
  /*                                                 244 bytes    */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling check_packet_size().");

  return (size >= 244);
}

/*! \brief Set the total size of a packet.
    \author Denis BEURIVE
    \param p Pointer to the packet.
    \param taille Total size of the packet.
    \warning You MUST call this function just after you receive the packet from the network
             (after the call to recvfrom().
 */

void packet_set_taille (struct dhcp_packet *p, int taille)
{
  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packet_set_taille().");

  (p->ctrl).taille = taille;
}

/*! \brief Return the current date as Apache's standard.
    \author Denis BEURIVE
    \return The function returns a pointer to a string of characters that contains the current date.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
 */

static char* dater()
{
  static char  strtime[128];
  time_t       tt;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling dater().");

  tt = time(NULL);
  strftime (strtime, 128, "%Y-%m-%d %k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Return the IP address and the port number of a remote end point.
    \author Denis BEURIVE
    \param sender Pointer to the address of the destant end point.
    \param ip Pointer to a string of character used to store the IP address.
           This string should be, at least 16 characters long.
    \param port Pointer to an integer used to store the port number.
 */

static void get_remote_address (struct sockaddr_in *sender, char *ip, int *port)
{
  int  i;
  char *a;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_remote_address().");

  a = inet_ntoa(sender->sin_addr);
  for (i=0; i<15; i++) { ip[i] = *(a+i); };
  ip[15] = 0;
  *port = ntohs (sender->sin_port);
}

packets_operations.c

/*! \file packets_operations.c
          This file implements output packet mechanism (OFFER, ACK or INFORM).
 */

#include "server_config.h" 
#include "packets_operations.h"
#include "dhcp.h"




static void clear_profile (struct opt *options);
static int add_option_to_profile (struct opt *mprofile, int option, char *type, char *value, int len);
static int remove_option_from_profile (struct opt *mprofile, int option);
static void context2profile (struct opt *profile, struct mysql_tables *mysql_tables);
static char* dater();




/*! \brief Global DHCP configuration handler.
 */

extern struct global_config configuration_globale;

/*! \brief Reset option profile to "all zeros".
    \author Denis BEURIVE
    \param options Pointer to a destination 'opt' data structure to reset.
    \warning The pointer 'options' should point to an array which contains at least MAX_PROFILE_OPTIONS
             (which should be greater than 256) elements.
 */

static void clear_profile (struct opt *options)
{
  int i;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling clear_profile().");

  for (i=0; i<MAX_PROFILE_OPTIONS; i++)
  {
    options[i].code = 0;
    options[i].len  = 0;
    memset ((void*)(options[i]).value, 0, VALUE_MAX_SIZE);
  }
}

/*! \brief Add an option to the loaded profile.
    \author Denis BEURIVE
    \param mprofile Pointer to an array of 'opt' data structures that represents the profile to manipulate.
    \param option Option's code (between 1 and 254 included).
    \param type Pointer to a zero terminated string of characters the represents the type of value.
           Type could be:
                <UL>
                    <LI>"UINT32" (values are separated by ':')
                    <LI>"UINT16" (values are separated by ':')
                    <LI>"IP" (values are separated by ':')
                    <LI>"HEXA-BYTE"
                    <LI>"ASCII-BYTE"
                </UL>
    \param value Pointer to the value. The format of the value depends on its type.
    \param len Number of bytes of the value.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

static int add_option_to_profile (struct opt *mprofile, int option, char *type, char *value, int len)
{
    int         converted;

    my_syslog (
               LEVEL_FULL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Calling add_option_to_profile(%d).",
               option);

    /* ------------------------------------------------- */
    /* Sanity check                                      */
    /* ------------------------------------------------- */

    if ((option > 254) || (option < 1))
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "add_option_to_profile: Invalid option's value (%d) (this should not happen).",
                 option);
       return 1;
    }

    converted = 0;

    if (strcmp(type, "UINT32") == 0)
    {
      int rc = uint32_to_network_byte_order (value, (mprofile[option]).value, VALUE_MAX_SIZE);
      if (rc == -1) { return 1; }
      (mprofile[option]).len = rc * 4;
      (mprofile[option]).code = option;
      converted = 1;
    }

    if (strcmp(type, "UINT16") == 0)
    {
      int rc = uint16_to_network_byte_order (value, (mprofile[option]).value, VALUE_MAX_SIZE);
      if (rc == -1) { return 1; }
      (mprofile[option]).len = rc * 2;
      (mprofile[option]).code = option;
      converted = 1;
    }

    if (strcmp(type, "HEXA-BYTE") == 0)
    {
      int rc = hexa_to_binary (value, (mprofile[option]).value, VALUE_MAX_SIZE);
      if (rc == -1) { return 1; }
      (mprofile[option]).len = rc;
      (mprofile[option]).code = option;
      converted = 1;
    }

    if (strcmp(type, "ASCII-BYTE") == 0)
    {
      int rc = ascii_to_binary (value, (mprofile[option]).value, len, VALUE_MAX_SIZE);
      if (rc == -1) { return 1; }
      (mprofile[option]).len = rc;
      (mprofile[option]).code = option;
      converted = 1;
    }

    if (strcmp(type, "IP") == 0)
    {
      int rc = ip_to_network_byte_order (value, (mprofile[option]).value, VALUE_MAX_SIZE);
      if (rc == -1) { return 1; }
      (mprofile[option]).len = rc * 4;
      (mprofile[option]).code = option;
      converted = 1;
    }

    if (converted == 0)
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "Invalid option type (%s) for option (this should not happen).",
                 type);
      return 1;
    }

    return 0;
}

/*! \brief Remove an option from the loaded profile.
    \author Denis BEURIVE
    \param mprofile Pointer to an array of 'opt' data structures that represents the profile to manipulate.
    \param option Option's code (between 1 and 254 included).
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

static int remove_option_from_profile (struct opt *mprofile, int option)
{
    my_syslog (
               LEVEL_FULL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Calling remove_option_from_profile(%d).",
               option);

    if ((option > 254) || (option < 1))
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "remove_option_from_profile: Invalid option's value (%d) (this should not happen).",
                 option);
       return 1;
    }

    (mprofile[option]).code = 0;
    (mprofile[option]).len  = 0;

    memset ((void*)(mprofile[option]).value, 0, VALUE_MAX_SIZE);

    return 0;
}

/*! \brief Copy the options' profile extracted from the client's context into a 'opt' data structure (used
           to assemble the output DHCP packet).
    \author Denis BEURIVE
    \param profile Pointer to a destination 'opt' data structure.
    \param mysql_tables Pointer to a 'mysql_tables' data structure that contains the client's context (loaded
           form the database).
    \remark Types of options' values can be:
            <UL>
                <LI>"UINT32" (one or more values, separated by ':')
                <LI>"UINT16" (one or more values, separated by ':')
                <LI>"IP" (one or more values, separated by ':')
                <LI>"HEXA-BYTE"
                <LI>"ASCII-BYTE"
            </UL>
    \warning The pointer 'options' should point to an array which contains at least MAX_PROFILE_OPTIONS
             (which should be greater than 256) elements.
 */

static void context2profile (struct opt *profile, struct mysql_tables *mysql_tables)
{
  int  i, code, converted;
  char *type;
  char *value;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling context2profile().");

  clear_profile (profile);

  /* --------------------------------------------------- */
  /* Convert all values to the correct internal format   */
  /* --------------------------------------------------- */

  for (i=0; i<mysql_tables->option_number; i++)
  {
    code = (int)(((mysql_tables->options)[i]).option_code);

    /* ------------------------------------------------- */
    /* Sanity check                                      */
    /* ------------------------------------------------- */

    if ((code > 254) || (code < 1))
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "context2profile: Invalid option code (%u) for profile_optionnel=[%s] (this should not happen).",
                 code,
                 ((mysql_tables->options)[i]).profile_optionnel);
      continue;
    }

    /* ------------------------------------------------- */
    /* 'option_value' needs to be interpreted depending  */
    /* on the value of 'option_type'.                    */
    /* The following code set the following values :     */
    /*      + (profile[code]).code                       */ 
    /*      + (profile[code]).len                        */
    /*      + (profile[code]).value.                     */
    /* ------------------------------------------------- */

    type  = ((mysql_tables->options)[i]).option_type;
    value = ((mysql_tables->options)[i]).option_value;

    converted = 0;

    if (strcmp(type, "UINT32") == 0)
    {
      int rc = uint32_to_network_byte_order (value, (profile[code]).value, VALUE_MAX_SIZE);
      if (rc == -1) { continue; }
      (profile[code]).len = rc * 4;
      (profile[code]).code = code;
      converted = 1;
    }

    if (strcmp(type, "UINT16") == 0)
    {
      int rc = uint16_to_network_byte_order (value, (profile[code]).value, VALUE_MAX_SIZE);
      if (rc == -1) { continue; }
      (profile[code]).len = rc * 2;
      (profile[code]).code = code;
      converted = 1;
    }

    if (strcmp(type, "HEXA-BYTE") == 0)
    {
      int rc = hexa_to_binary (value, (profile[code]).value, VALUE_MAX_SIZE);
      if (rc == -1) { continue; }
      (profile[code]).len = rc;
      (profile[code]).code = code;
      converted = 1;
    }

    if (strcmp(type, "ASCII-BYTE") == 0)
    {
      int rc = ascii_to_binary (value, (profile[code]).value, strlen(value), VALUE_MAX_SIZE);
      if (rc == -1) { continue; }
      (profile[code]).len = rc;
      (profile[code]).code = code;
      converted = 1;
    }

    if (strcmp(type, "IP") == 0)
    {
      int rc = ip_to_network_byte_order (value, (profile[code]).value, VALUE_MAX_SIZE);
      if (rc == -1) { continue; }
      (profile[code]).len = rc * 4;
      (profile[code]).code = code;
      converted = 1;
    }

    if (converted == 0)
    {
      my_syslog (
                 LEVEL_ERROR,
                 TERMINAL_LEVEL,
                 __FILE__,
                 __LINE__,
                 "context2profile: Invalid option type (%s) for profile [%s] (this should not happen).",
                 type,
                 ((mysql_tables->options)[i]).profile_optionnel);
      continue;
    }
  }
}

/*! \brief Send a DHCPOFFER and log the output packet.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP DISCOVER).
    \param mysql_tables Pointer to a 'mysql_tables' data structure that contains the loaded client's context.
    \param ip Pointer to a zero terminated string of characters that represents the IP address of the user.
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order)
           of the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order)
           of the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address
           of the incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always send broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int packets_send_offer (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address)
{
  struct dhcp_packet     packet_out;
  struct sockaddr_in     addr_target;
  int                    adress_size, rc, i;
  char                   *serverip;
  struct opt             options[MAX_PROFILE_OPTIONS];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_send_offer().");

  packets_clear (&packet_out);
  serverip = configuration_globale.server_ip_seen_by_client;

  /* ------------------------------------------------------------ */
  /* Transfert options from loaded profile (from database) into   */
  /* internal profile representation.                             */
  /* ------------------------------------------------------------ */

  context2profile (options, mysql_tables);

  /* ------------------------------------------------------------ */
  /* Format the OFFER                                             */
  /* Notes:                                                       */
  /* - We don't set 'ciaddr' -> This field will be all zero.      */
  /* - We don't set, 'sname' and 'file' are all zero.             */
  /* ------------------------------------------------------------ */

  packets_set_op           (&packet_out, BOOTREPLY);
  packets_set_htype        (&packet_out, packets_get_htype(p));
  packets_set_hlen         (&packet_out, packets_get_hlen(p));
  packets_set_hops         (&packet_out, 0);
  packets_set_xid          (&packet_out, packets_get_xid(p));
  packets_set_secs         (&packet_out, packets_get_secs(p));
  packets_set_flags        (&packet_out, packets_get_flags(p));
  packets_set_yiaddr       (&packet_out, ip);
  packets_set_siaddr       (&packet_out, configuration_globale.server_ip_seen_by_client);
  packets_set_bin_giaddr   (&packet_out, packets_get_bin_giaddr(p));
  packets_set_chaddr       (&packet_out, packets_get_bin_chaddr(p));

  /* ------------------------------------------------------------ */
  /* Set the correct options' profile                             */
  /*    - lease (already in loaded profile)                       */
  /*    - routers (already in loaded profile)                     */
  /*    - domain name (already in loaded profile)                 */
  /*    - domain name server (already in loaded profile)          */
  /*    - subnet mask (already in loaded profile)                 */
  /*    - message type (added)                                    */
  /*    - server identifier (added)                               */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add options to DHCP packets.");

  /* Message type */
  add_option_to_profile (options, 53, "HEXA-BYTE", DHCPOFFER_HEXA,     strlen(DHCPOFFER_HEXA)); 

  /* Server identifier */
  add_option_to_profile (options, 54, "IP",        serverip,           strlen(serverip)); 

  /* ------------------------------------------------------------ */
  /* Add the gateway and subnet                                   */ 
  /* ------------------------------------------------------------ */

  add_option_to_profile (options, 3, "IP", mysql_tables->abonnes.gateway, 
                         strlen(mysql_tables->abonnes.gateway)); 
  add_option_to_profile (options, 1, "IP", mysql_tables->abonnes.network,
                         strlen(mysql_tables->abonnes.network));

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add gateway %s and subnet %s to options.",
             mysql_tables->abonnes.gateway,
             mysql_tables->abonnes.network);

  /* ------------------------------------------------------------ */
  /* Write packet's options                                       */
  /* ------------------------------------------------------------ */

  for (i=1; i<255; i++)
  {
    if ((options[i]).code != 0)
    {
       packets_set_option (&packet_out, i, (options[i]).value, (options[i]).len);

       my_syslog (
                  LEVEL_VERBOSE,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Adding option %d.",
                  i);
    }
  }

  packets_close_option (&packet_out);

  /* ------------------------------------------------------------ */
  /* Send it                                                      */
  /* ------------------------------------------------------------ */

  adress_size = sizeof (struct sockaddr);
  memset ((void*)&addr_target, 0, sizeof(struct sockaddr_in));

  if (configuration_globale.broadcast_mode == 1)
  {
    addr_target.sin_family        = AF_INET;
    addr_target.sin_port          = htons(TARGET_PORT);
    (addr_target.sin_addr).s_addr = broadcast;
  }
  else
  { memcpy ((void*)&addr_target, (void*)client_address, sizeof(struct sockaddr_in)); }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Sending DHCP OFFER for xid %u.",
             packets_get_xid(p));

  if (configuration_globale.dumper_mode > 0)
  { packet_dump (&packet_out, p, mysql_tables, configuration_globale.debug_file, configuration_globale.csv_file, NULL, &addr_target); }


  rc = sendto (
                socket_desc,
                (void*)&packet_out,
                packet_out.ctrl.taille,
                0,
                (struct sockaddr*)&addr_target,
                adress_size
              );
  
  if (rc == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packets_send_offer: Could not send OFFER for xid %u - %s.",
               packets_get_xid(p),
               strerror(errno));
    return 1;
  }

  return 0;
}

/*! \brief Send a DHCPACK in response to a REQUEST and log the output packet.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP REQUEST).
    \param mysql_tables pointer to a 'mysql_tables' data structure that contains the loaded client's
           context.
    \param ip Pointer to a zero terminated string of characters that represents the client's IP address. 
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order) of
           the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order) of
           the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address of the
           incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always sends broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int packets_send_ack (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address)
{
  struct dhcp_packet     packet_out;
  struct sockaddr_in     addr_target;
  int                    adress_size, rc, i;
  char                   *serverip;
  struct opt             options[MAX_PROFILE_OPTIONS];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_send_ack().");

  packets_clear (&packet_out);
  serverip = configuration_globale.server_ip_seen_by_client;

  /* ------------------------------------------------------------ */
  /* Transfert options from loaded profile (from database) into   */
  /* internal profile representation.                             */
  /* ------------------------------------------------------------ */

  context2profile (options, mysql_tables);

  /* ------------------------------------------------------------ */
  /* Format the ACK                                               */
  /* Notes:                                                       */
  /* - We don't set, 'sname' and 'file' are all zero.             */
  /* ------------------------------------------------------------ */

  packets_set_op           (&packet_out, BOOTREPLY);
  packets_set_htype        (&packet_out, packets_get_htype(p));
  packets_set_hlen         (&packet_out, packets_get_hlen(p));
  packets_set_hops         (&packet_out, 0);
  packets_set_xid          (&packet_out, packets_get_xid(p));
  packets_set_secs         (&packet_out, packets_get_secs(p));
  packets_set_flags        (&packet_out, packets_get_flags(p));
  packets_set_yiaddr       (&packet_out, ip);
  packets_set_siaddr       (&packet_out, configuration_globale.server_ip_seen_by_client);
  packets_set_bin_giaddr   (&packet_out, packets_get_bin_giaddr(p));
  packets_set_bin_ciaddr   (&packet_out, packets_get_bin_ciaddr(p));
  packets_set_chaddr       (&packet_out, packets_get_bin_chaddr(p));

  /* ------------------------------------------------------------ */
  /* Set the correct options' profile                             */
  /*                                                              */
  /* from loaded profile:                                         */
  /*    - lease (already in loaded profile)                       */
  /*    - domain name (already in loaded profile)                 */
  /*    - domain name server (already in loaded profile)          */
  /* From other sources:                                          */
  /*    - routers (added, from mysql_tables->abonnes.gateway)     */
  /*    - subnet mask (added, from mysql_tables->abonnes.network) */
  /*    - message type (added, constant)                          */
  /*    - server identifier (added, from argument serverip)       */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 53 (message type). Option's value is 3.");

  /* Message type */ 
  add_option_to_profile (options, 53, "HEXA-BYTE", DHCPACK_HEXA, strlen(DHCPACK_HEXA)); 

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 54 (server ID). Option's value is \"%s\".",
             serverip);

  /* Server Identifier */
  add_option_to_profile (options, 54, "IP", serverip, strlen(serverip)); 

  /* ------------------------------------------------------------ */
  /* Add the gateway and the network                              */
  /* ------------------------------------------------------------ */

  add_option_to_profile (options, 3, "IP", mysql_tables->abonnes.gateway,
                         strlen(mysql_tables->abonnes.gateway));
  add_option_to_profile (options, 1, "IP", mysql_tables->abonnes.network,
                         strlen(mysql_tables->abonnes.network));

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add gateway %s and subnet %s.",
             mysql_tables->abonnes.gateway,
             mysql_tables->abonnes.network);

  /* ------------------------------------------------------------ */
  /* Write packet's options                                       */
  /* ------------------------------------------------------------ */

  for (i=1; i<255; i++)
  {
    if ((options[i]).code != 0)
    {
       my_syslog (
                  LEVEL_VERBOSE,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Adding option %d.",
                  i);

       packets_set_option (&packet_out, i, (options[i]).value, (options[i]).len);
    }
  }

  packets_close_option (&packet_out);

  /* ------------------------------------------------------------ */
  /* Send it                                                      */
  /* ------------------------------------------------------------ */

  memset ((void*)&addr_target, 0, sizeof(struct sockaddr_in));
  adress_size = sizeof (struct sockaddr);

  if (configuration_globale.broadcast_mode == 1)
  {
     addr_target.sin_family        = AF_INET;
     addr_target.sin_port          = htons(TARGET_PORT);
     (addr_target.sin_addr).s_addr = broadcast;
  }
  else
  { memcpy ((void*)&addr_target, (void*)client_address, sizeof(struct sockaddr_in)); }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Sending DHCP ACK for xid %u.",
             packets_get_xid(p));

  if (configuration_globale.dumper_mode > 0)
  { packet_dump (&packet_out, p, mysql_tables, configuration_globale.debug_file, configuration_globale.csv_file, NULL, &addr_target); }

  rc = sendto (
                socket_desc,
                (void*)&packet_out,
                packet_out.ctrl.taille,
                0,
                (struct sockaddr*)&addr_target,
                adress_size
              );

  if (rc == -1)
  {

    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packets_send_ack: Could not send ACK for xid %u - %s.",
               packets_get_xid(p),
               strerror(errno));
    return 1;
  }

  return 0;
}

/*! \brief Log a packet's profile (list of options) in a human readables format.
    \author Denis BEURIVE
    \param file Pointer to a zero terminated string of characters that represents the path to the log file.
    \param mes Pointer to a zero terminated string of characters that represents a text that will be printed
           before the profile.
    \param profile pointer to a opt data structure that contains the profile to print.
    \return Upon successful completion, the function returns the value 0. Othrwise, the function returns the
            value 1.
 */

int log_profile (const char *file, const char *mes, const struct opt *profile)
{
   int             i, l;
   FILE            *fd;
   unsigned char   *c;

   fd = fopen (file, "a");
   if (fd == NULL) { return 1; }

   fprintf (fd, "%s %s ", dater(), mes);

   for (i=0; i<256; i++)
   {
     if ((profile[i]).code != 0)
     {
       fprintf (fd, "(%d) %d [", (profile[i]).code, (profile[i]).len);
       c = (unsigned char*)(profile[i]).value;
       for (l=0; l<(profile[i]).len; l++)
       {
         fprintf (fd, "%c%c", int_to_char (((*c) & 0xF0) >> 4), int_to_char ((*c) & 0x0F));
         if (l < (profile[i]).len - 1) { fprintf (fd, "."); }
         c += 1;
       }
       fprintf (fd, "]  ");
     }
   }
   fprintf (fd, "\n");

   fclose (fd);
   return 0;
}


/*! \brief Send a DHCPACK as response to an INFORM.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP INFORM).
    \param mysql_tables pointer to a 'mysql_tables' data structure that contains the loaded client's context.
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order)
           of the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order)
           of the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address of
           the incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always send broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int reply_to_inform (
                      struct dhcp_packet    *p,
                      struct mysql_tables   *mysql_tables,
                      unsigned long int     broadcast,
                      unsigned long int     server_ip,
                      int                   socket_desc,
                      struct sockaddr_in    *client_address)
{
  struct dhcp_packet     packet_out;
  struct sockaddr_in     addr_target;
  int                    adress_size, rc, i;
  char                   *serverip;
  struct opt             options[MAX_PROFILE_OPTIONS];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling reply_to_inform().");

  packets_clear (&packet_out);
  serverip = configuration_globale.server_ip_seen_by_client;

  /* ------------------------------------------------------------ */
  /* Transfert options from loaded profile (from database) into   */
  /* internal profile representation.                             */
  /* ------------------------------------------------------------ */

  context2profile (options, mysql_tables);

  /* ------------------------------------------------------------ */
  /* Format the ACK                                               */
  /* Notes:                                                       */
  /* - We don't set  'yiaddr' -> This field will be all zero.     */
  /* - We don't set, 'sname' and 'file' are all zero.             */
  /* ------------------------------------------------------------ */

  packets_set_op           (&packet_out, BOOTREPLY);
  packets_set_htype        (&packet_out, packets_get_htype(p));
  packets_set_hlen         (&packet_out, packets_get_hlen(p));
  packets_set_hops         (&packet_out, 0);
  packets_set_xid          (&packet_out, packets_get_xid(p));
  packets_set_secs         (&packet_out, packets_get_secs(p));
  packets_set_flags        (&packet_out, packets_get_flags(p));
  packets_set_siaddr       (&packet_out, configuration_globale.server_ip_seen_by_client);
  packets_set_bin_giaddr   (&packet_out, packets_get_bin_giaddr(p));
  packets_set_bin_ciaddr   (&packet_out, packets_get_bin_ciaddr(p));
  packets_set_chaddr       (&packet_out, packets_get_bin_chaddr(p));

  /* ------------------------------------------------------------ */
  /* Set the correct options' profile                             */
  /*    - routers (already in loaded profile)                     */
  /*    - domain name (already in loaded profile)                 */
  /*    - domain name server (already in loaded profile)          */
  /*    - subnet mask (already in loaded profile)                 */
  /*    - message type (added)                                    */
  /*    - server identifier (added)                               */
  /*                                                              */
  /* Note: remove lease from option's profile.                    */
  /* ------------------------------------------------------------ */

  add_option_to_profile (options, 53, "HEXA-BYTE", DHCPACK_HEXA, strlen(DHCPACK_HEXA)); /* Message type       */
  add_option_to_profile (options, 54, "IP",        serverip,     strlen(serverip));     /* Server Identifier  */
  
  remove_option_from_profile (options, 51);

  /* ------------------------------------------------------------ */
  /* Write packet's options                                       */
  /* ------------------------------------------------------------ */

  for (i=1; i<255; i++)
  {
    if ((options[i]).code != 0)
    {
       packets_set_option (&packet_out, i, (options[i]).value, (options[i]).len);

       my_syslog (
                  LEVEL_VERBOSE,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Adding option %d.",
                  i);
    }
  }

  packets_close_option (&packet_out);

  /* ------------------------------------------------------------ */
  /* Send it                                                      */
  /* ------------------------------------------------------------ */

  adress_size = sizeof (struct sockaddr);
  memset ((void*)&addr_target, 0, sizeof(struct sockaddr_in));

  if (configuration_globale.broadcast_mode == 1)
  {
    addr_target.sin_family        = AF_INET;
    addr_target.sin_port          = htons(TARGET_PORT);
    (addr_target.sin_addr).s_addr = broadcast;
  }
  else
  { memcpy ((void*)&addr_target, (void*)client_address, sizeof(struct sockaddr_in)); }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Sending DHCP OFFER for xid %u.",
             packets_get_xid(p));

  if (configuration_globale.dumper_mode > 0)
  { packet_dump (&packet_out, p, mysql_tables, configuration_globale.debug_file, configuration_globale.csv_file, NULL, &addr_target); }

  rc = sendto (
                socket_desc,
                (void*)&packet_out,
                packet_out.ctrl.taille,
                0,
                (struct sockaddr*)&addr_target,
                adress_size
              );

  if (rc == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "reply_to_inform: Could not send OFFER for xid %u - %s.",
               packets_get_xid(p),
               strerror(errno));
    return 1;
  }

  return 0;
}

/*! \brief Send a DHCPNAK in response to a REQUEST and log the output packet.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP REQUEST).
    \param mysql_tables pointer to a 'mysql_tables' data structure that contains the loaded client's
           context.
    \param ip Pointer to a zero terminated string of characters that represents the client's IP address.
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order) of
           the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order) of
           the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address of the
           incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always sends broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int packets_send_nack (
                         struct dhcp_packet    *p,
                         struct mysql_tables   *mysql_tables,
                         char                  *ip,
                         unsigned long int     broadcast,
                         unsigned long int     server_ip,
                         int                   socket_desc,
                         struct sockaddr_in    *client_address)
{
  struct dhcp_packet     packet_out;
  struct sockaddr_in     addr_target;
  int                    adress_size, rc, i;
  char                   *serverip;
  struct opt             options[MAX_PROFILE_OPTIONS];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_send_nack().");

  packets_clear (&packet_out);
  serverip = configuration_globale.server_ip_seen_by_client;

  /* ------------------------------------------------------------ */
  /* Initialize the list of options                               */
  /* ------------------------------------------------------------ */

  clear_profile(options);

  /* ------------------------------------------------------------ */
  /* Format the NAK                                               */
  /* ------------------------------------------------------------ */

  packets_set_op           (&packet_out, BOOTREPLY);
  packets_set_htype        (&packet_out, packets_get_htype(p));
  packets_set_hlen         (&packet_out, packets_get_hlen(p));
  packets_set_hops         (&packet_out, 0);
  packets_set_xid          (&packet_out, packets_get_xid(p));
  packets_set_secs         (&packet_out, packets_get_secs(p));
  packets_set_flags        (&packet_out, packets_get_flags(p));
  packets_set_yiaddr       (&packet_out, ip);
  packets_set_siaddr       (&packet_out, configuration_globale.server_ip_seen_by_client);
  packets_set_bin_giaddr   (&packet_out, packets_get_bin_giaddr(p));
  packets_set_bin_ciaddr   (&packet_out, packets_get_bin_ciaddr(p));
  packets_set_chaddr       (&packet_out, packets_get_bin_chaddr(p));

  /* ------------------------------------------------------------ */
  /* Set the type of the response (in this case, a DHCPNAK)       */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 53 (message type). Option's value is 6.");

  add_option_to_profile (options, 53, "HEXA-BYTE", DHCPNAK_HEXA, strlen(DHCPNAK_HEXA)); 

  /* ------------------------------------------------------------ */
  /* Set the IP address of the DHCP server (for futur requests)   */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 54 (server ID). Option's value is \"%s\".",
             serverip);

  add_option_to_profile (options, 54, "IP", serverip, strlen(serverip)); 

  /* ------------------------------------------------------------ */
  /* Write packet's options                                       */
  /* ------------------------------------------------------------ */

  for (i=1; i<255; i++)
  {
    if ((options[i]).code != 0)
    {
       my_syslog (
                  LEVEL_VERBOSE,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Adding option %d.",
                  i);

       packets_set_option (&packet_out, i, (options[i]).value, (options[i]).len);
    }
  }

  /* ------------------------------------------------------------ */
  /* Send it                                                      */
  /* ------------------------------------------------------------ */

  packets_close_option (&packet_out);

  memset ((void*)&addr_target, 0, sizeof(struct sockaddr_in));
  adress_size = sizeof (struct sockaddr);

  if (configuration_globale.broadcast_mode == 1)
  {
     addr_target.sin_family        = AF_INET;
     addr_target.sin_port          = htons(TARGET_PORT);
     (addr_target.sin_addr).s_addr = broadcast;
  }
  else
  { memcpy ((void*)&addr_target, (void*)client_address, sizeof(struct sockaddr_in)); }

  my_syslog (
              LEVEL_VERBOSE,
              TERMINAL_LEVEL,
              __FILE__,
              __LINE__,
              "Sending DHCP NACK for xid %u.",
              packets_get_xid(p));

  if (configuration_globale.dumper_mode > 0)
  { packet_dump (&packet_out, p, mysql_tables, configuration_globale.debug_file, configuration_globale.csv_file, NULL, &addr_target); }

  rc = sendto (
                socket_desc,
                (void*)&packet_out,
                packet_out.ctrl.taille,
                0,
                (struct sockaddr*)&addr_target,
                adress_size
              );
  
  if (rc == -1)
  {
    my_syslog (
                LEVEL_WARNING,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Could not send NAK for xid %u - %s.",
                packets_get_xid(p),
                strerror(errno));
    return 1;
  }

  return 0;
}

/*! \brief Send a dummy DHCPNAK and log the output packet.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP REQUEST).
    \param mysql_tables pointer to a 'mysql_tables' data structure that contains the loaded client's
           context.
    \param ip Pointer to a zero terminated string of characters that represents the client's IP address.
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order) of
           the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order) of
           the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address of the
           incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always sends broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int packets_send_dummy_nak (
                             struct dhcp_packet    *p,
                             struct mysql_tables   *mysql_tables,
                             char                  *ip,
                             unsigned long int     broadcast,
                             unsigned long int     server_ip,
                             int                   socket_desc,
                             struct sockaddr_in    *client_address)
{
  int cr;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_send_dummy_nak().");

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Sending DUMMY NAK.");

  cr = packets_send_nack ( p,
                           mysql_tables,
                           ip,
                           broadcast,
                           server_ip,
                           socket_desc,
                           client_address);

  if (cr == 1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packets_send_dummy_nak: Could not send the DUMMY DHCPNAK - %s.",
               strerror(errno));
    return 1;
  }

  return 0;
}

/*! \brief Return the current date as Apache's standard.
    \author Denis BEURIVE
    \return The function returns a pointer to a string of characters that contains the current date.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
 */

static char* dater()
{
  static char  strtime[128];
  time_t       tt;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling dater().");

  tt = time(NULL);
  strftime (strtime, 128, "%Y-%m-%d %k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Send a dummy DHCPACK and log the output packet.
    \author Denis BEURIVE
    \param p Pointer to the incoming packet (should be a DHCP REQUEST).
    \param mysql_tables pointer to a 'mysql_tables' data structure that contains the loaded client's
           context.
    \param dummy_ip Pointer to a zero terminated string of characters that represents the dummy IP address to send.
    \param broadcast 4 bytes long integer that contains the binary representation (in network byte order) of
           the broadcast IP address.
    \param server_ip 4 bytes long integer that contains the binary representation (in network byte order) of
           the server IP address.
    \param socket_desc Socket descriptor of the DHCP server.
    \param client_address Pointer to a 'sockaddr_in' data structure that contains the internet address of the
           incoming packet's sender.
           If the configuration tag 'enable-broadcast-responses' is set to "yes", then the parameter
           'client_address' is never used (since the server always sends broadcasts).
    \return Upon successful completion, the function returns the value 0.
            Otherwise, the function returns the value 1.
 */

int packets_send_dummy_ack (
                             struct dhcp_packet    *p,
                             struct mysql_tables   *mysql_tables,
                             char                  *dummy_ip,
                             unsigned long int     broadcast,
                             unsigned long int     server_ip,
                             int                   socket_desc,
                             struct sockaddr_in    *client_address)
{
  struct dhcp_packet     packet_out;
  struct sockaddr_in     addr_target;
  int                    adress_size, rc, i;
  char                   *serverip, lease[256];
  struct opt             options[MAX_PROFILE_OPTIONS];

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling packets_send_ack().");

  clear_profile(options);
  packets_clear (&packet_out);
  serverip = configuration_globale.server_ip_seen_by_client;

  /* ------------------------------------------------------------ */
  /* Format the ACK                                               */
  /* Notes:                                                       */
  /* - We don't set, 'sname' and 'file' are all zero.             */
  /* - All IP address are the one pointed by 'dummy_ip'.          */
  /* ------------------------------------------------------------ */

  packets_set_op           (&packet_out, BOOTREPLY);
  packets_set_htype        (&packet_out, packets_get_htype(p));
  packets_set_hlen         (&packet_out, packets_get_hlen(p));
  packets_set_hops         (&packet_out, 0);
  packets_set_xid          (&packet_out, packets_get_xid(p));
  packets_set_secs         (&packet_out, packets_get_secs(p));
  packets_set_flags        (&packet_out, packets_get_flags(p));
  packets_set_yiaddr       (&packet_out, dummy_ip);
  packets_set_siaddr       (&packet_out, configuration_globale.server_ip_seen_by_client);
  packets_set_bin_giaddr   (&packet_out, packets_get_bin_giaddr(p));
  packets_set_ciaddr       (&packet_out, dummy_ip);
  packets_set_chaddr       (&packet_out, packets_get_bin_chaddr(p));

  /* ------------------------------------------------------------ */
  /* Set the correct options' profile                             */
  /*                                                              */
  /*    - lease                Yes                                */
  /*    - message type         Yes                                */
  /*    - server identifier    Yes                                */
  /*    - domain name          No                                 */
  /*    - domain name server   No                                 */
  /*    - routers              No                                 */
  /*    - subnet mask          No                                 */
  /* ------------------------------------------------------------ */

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 53 (message type). Option's value is 3.");

  add_option_to_profile (options, 53, "HEXA-BYTE", DHCPACK_HEXA, strlen(DHCPACK_HEXA)); 

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 54 (server ID). Option's value is \"%s\".",
             serverip);

  add_option_to_profile (options, 54, "IP", serverip, strlen(serverip)); 

  memset ((void*)lease, 0, 256);
  strcpy (lease, "3600");

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Add option 51 (lease). Option's value is \"%s\".",
             lease);

  add_option_to_profile (options, 51, "UINT32", lease, strlen(lease));

  /* ------------------------------------------------------------ */
  /* Write packet's options                                       */
  /* ------------------------------------------------------------ */

  for (i=1; i<255; i++)
  {
    if ((options[i]).code != 0)
    {
       my_syslog (
                  LEVEL_VERBOSE,
                  TERMINAL_LEVEL,
                  __FILE__,
                  __LINE__,
                  "Adding option %d.",
                  i);

       packets_set_option (&packet_out, i, (options[i]).value, (options[i]).len);
    }
  }

  packets_close_option (&packet_out);

  /* ------------------------------------------------------------ */
  /* Send it                                                      */
  /* ------------------------------------------------------------ */

  memset ((void*)&addr_target, 0, sizeof(struct sockaddr_in));
  adress_size = sizeof (struct sockaddr);

  if (configuration_globale.broadcast_mode == 1)
  {
     addr_target.sin_family        = AF_INET;
     addr_target.sin_port          = htons(TARGET_PORT);
     (addr_target.sin_addr).s_addr = broadcast;
  }
  else
  { memcpy ((void*)&addr_target, (void*)client_address, sizeof(struct sockaddr_in)); }

  my_syslog (
             LEVEL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Sending DHCP ACK for xid %u.",
             packets_get_xid(p));

  if (configuration_globale.dumper_mode > 0)
  { packet_dump (&packet_out, p, mysql_tables, configuration_globale.debug_file, configuration_globale.csv_file, NULL, &addr_target); }

  rc = sendto (
                socket_desc,
                (void*)&packet_out,
                packet_out.ctrl.taille,
                0,
                (struct sockaddr*)&addr_target,
                adress_size
              );

  if (rc == -1)
  {
    my_syslog (
               LEVEL_WARNING,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "packets_send_ack: Could not send ACK for xid %u - %s.",
               packets_get_xid(p),
               strerror(errno));
    return 1;
  }

  return 0;
}

read_conf.c

#include <stdio.h>
#include <string.h>
#include "config.h"

int main (int argc, char *argv[])
{
  int     e, res, rc;
  char    *value;

  if (argc != 3)
  {
    fprintf (stdout, "FATAL: Wrong arguments (Usage: read_conf <path to configuration file> <tag>)");
    return 1;
  }

  rc = parse_configuration_file (argv[1], &e);
  if (rc != PARSE_CONFIGURATION_OK)
  {

    switch (rc)
    {
      case PARSE_CONFIGURATION_NO_MEM:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - Could not allocate memory!",
                       argv[1]);
           }; break;
      case PARSE_CONFIGURATION_FILE_NOT_FOUND:
           {
              fprintf (stderr,
                       "FATAL :Could not load the configuration file <%s> - %s",
                       argv[1], strerror(e));
           }; break;
      case PARSE_CONFIGURATION_SYNTAX_ERROR:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - Found syntax error.",
                       argv[1]);
           }; break;
      case PARSE_CONFIGURATION_DUPLICATED_TAG:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - Duplicated tag found.",
                       argv[1]);
           }; break;
      case PARSE_CONFIGURATION_DLL_OPEN_ERROR:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - Could not open DLL. %s.",
                       argv[1], conf_get_last_error());
           }; break;
      case PARSE_CONFIGURATION_DLL_INVALID:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - DLL is not valid. %s.",
                       argv[1], conf_get_last_error());
           }; break;
      case PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - Modem's configuration is not valid.",
                       argv[1]);
           }; break;
      case PARSE_CONFIGURATION_VCI_CONF_NOT_VALID:
           {
              fprintf (stderr,
                       "FATAL: Could not load the configuration file <%s> - VCI's configuration is not valid.",
                       argv[1]);
           }; break;
    }

    return 1;
  }

  res = get_value(argv[2], &value);

  if (res == 0)
  {
    fprintf (stdout, "FATAL: Tag <%s> not found in configuration file <%s>", argv[2], argv[1]);
    return  1;
  }

  if (res == -1)
  {
    fprintf (stdout, "FATAL: Unexpected error while parsing configuration file <%s> for tag <%s>",
             argv[1], argv[2]);
    return 1;
  }


  if (strcmp(argv[2], "debug-level") == 0)
  {
    unsigned char cint[4];
    unsigned int  vint;

    cint[0] = (unsigned char)*value;
    cint[1] = (unsigned char)*(value+1);
    cint[2] = (unsigned char)*(value+2);
    cint[3] = (unsigned char)*(value+3);

    vint = (cint[0] << 24) | (cint[1] << 16) | (cint[2] << 8) | cint[3];

    fprintf (stdout, "%X", vint);
  }
  else { fprintf (stdout, "%s", value); }

  return 0;
}

sockets.c

/*! \file sockets.c
    This file implements low level network functionalities.
 */

#include "sockets.h"

static char *get_doted_ip (unsigned long int ip);

/*! \brief Maximum number of characters for the error message.
 */

#define SOCKET_ERROR_SIZE  4096

/*! \brief Maximum number of network interfaces fot the host.
 */

#define MAX_INTERFACE      16

/*! \brief Buffer that will contain the last error message.
 */

static char last_error[SOCKET_ERROR_SIZE];

/*! \brief Returns a pointer to the last error message.
    \author Denis BEURIVE
    \return The function returns a pointer to a zero terminated string of characters that represents
            the last error message.
 */

char *get_last_socket_error() { return last_error; }

/*! \brief Create a UDP socket and bind it to a given port and a given network interface.
           Note that this socket is allowed to send broadcast messages.
    \author Denis BEURIVE
    \param port Port number: the socket is binded to this port.
    \param add Pointer to a sockaddr_in data structure that will be used to store the internet address
           of the created socket.
    \param host Pointer to a zero terminated string of characters that represents the host name
           (or IP address) of the network interface to bind with the socket.
    \param interface Pointer to a buffer used to store the name of the network interface.
           This buffer MUST be at least IFNAMSIZ bytes long.
    \param len Size, in bytes, of the buffer 'buff'.
    \param broadcast Pointer to a 4 bytes long integer used to store the binary representation of the IP
           address associated with broadcasts (in network byte order) - for the interface.
    \param netmask Pointer to a 4 bytes long integer used to store the binary representation of the netmask
           (in network byte order) - for the interface.
    \param myip  Pointer to a 4 bytes long integer used to store the binary representation of the IP address
           associated with the interace.
    \return Upon successful completion, the function returns the newly created socket descriptor.
            Otherwise, the function returns the value -1.
 */

int create_socket (
                     int port,
                     struct sockaddr_in *add,
                     char *host,
                     char *interface,
                     int len,
                     unsigned long int *broadcast,
                     unsigned long int *netmask,
                     unsigned long int *myip
                  )
{
  int                desc, longueur, on, i, number_of_interfaces, length;
  struct ifreq       *ifr, if_req;
  struct hostent     *h;
  struct ifconf      if_conf;
  unsigned long int  ip, fip;
  char               *buffer, interfaces_names[MAX_INTERFACE][IFNAMSIZ];


  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling create_socket().");

  memset ((void*)last_error, 0, SOCKET_ERROR_SIZE);
  for (i=0; i<MAX_INTERFACE; i++) { memset ((void*)&(interfaces_names[i][0]), 0, IFNAMSIZ); }
  *myip = 0;

  /* ------------------------------------------------------- */
  /* Sanity check                                            */
  /* ------------------------------------------------------- */

  if (len < IFNAMSIZ)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "Invalid lenght for interface's buffer (segmentation fault avoided!)");
    return -1;
  }

  memset ((void*)interface, 0, len);

  /* ------------------------------------------------------- */
  /* Get the IP address of the host 'host'                   */
  /* ------------------------------------------------------- */

  h = gethostbyname(host);

  if (h == NULL)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call gethostbyname(%s) failed - %s)",
              host,
              strerror(errno));
    return -1;
  }

  if (h->h_length != 4)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "The size of the Internet address returned by gethostbyname(%s) - %d - is not valid",
              host,
              h->h_length);
    return -1;
  }

  memcpy ((void*)&ip, h->h_addr_list[0], h->h_length);

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "IP address of host %s is %s.",
             host,
             get_doted_ip(ip));

  *myip = ip;

  /* ------------------------------------------------------- */
  /* Create the UDP socket                                   */
  /* ------------------------------------------------------- */

  if ((desc = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "System call socket(INET, SOCK_DGRAM, IPPROTO_UDP) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Get the list of all interfaces available                */
  /* ------------------------------------------------------- */

  memset ((void*)&if_conf, 0, sizeof(struct ifconf));

  buffer = (char*)malloc(MAX_INTERFACE * sizeof(struct ifreq));
  if (buffer == NULL)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "Could not allocate memory (this should never happen)");
    return -1;
  }

  if_conf.ifc_len = MAX_INTERFACE * sizeof(struct ifreq);
  if_conf.ifc_buf = buffer;

  if (ioctl(desc, SIOCGIFCONF, &if_conf) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call ioctl(SIOCGIFCONF) failed - %s", strerror(errno));
    free (buffer);
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Get the list of all interfaces names                    */
  /* ------------------------------------------------------- */

  number_of_interfaces = 0;
  for (i=0; i<(if_conf.ifc_len)/sizeof(struct ifreq); i++)
  {  
    ifr = ((struct ifreq*)buffer) + i;  

    /* ----------------------------------------------------- */
    /* Skip interfaces that are not connected to the network */
    /* ----------------------------------------------------- */

    if (ifr->ifr_addr.sa_family != AF_INET) { continue; }

    /* ----------------------------------------------------- */
    /* Get the name                                          */
    /* ----------------------------------------------------- */

    memcpy (interfaces_names[number_of_interfaces++], ifr->ifr_name, IFNAMSIZ);
  }

  free (buffer);

  /* ------------------------------------------------------- */
  /* Find the interface with the wanted IP address           */
  /* ------------------------------------------------------- */

  for (i=0; i<number_of_interfaces; i++)
  {
     /* ---------------------------------------------------- */
     /* Get the IP address of the specified interface        */
     /* Note: See file /usr/include/if.h for details about   */
     /*       the 'ifreq' structure.                         */
     /*       See 'man ioctl_list' for the list of all       */
     /*       posible interface's actions.                   */
     /* ----------------------------------------------------- */
   
     memset ((void*)&if_req, 0, sizeof(struct ifreq));
     strcpy (if_req.ifr_name, interfaces_names[i]);
   
     if (ioctl(desc, SIOCGIFADDR, &if_req) == -1)
     {
       snprintf (last_error, SOCKET_ERROR_SIZE - 1,
                 "System call ioctl(SIOCGIFADDR) failed - %s", strerror(errno));
       return -1;
     }
   
     fip = ((struct sockaddr_in*)(&(if_req.ifr_addr)))->sin_addr.s_addr;

     if (fip == ip) { strcpy (interface, interfaces_names[i]); }
  
     my_syslog (
                LEVEL_INFO,
                TERMINAL_LEVEL,
                __FILE__,
                __LINE__,
                "Found interface %s (%s).",
                interfaces_names[i],
                get_doted_ip(fip)); 
  } 

  /* ------------------------------------------------------- */
  /* Make sure that we found the interface                   */
  /* ------------------------------------------------------- */
 
  if (interface[0] == 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "No interface found for alias %s (%s)", host, get_doted_ip(ip));
    return -1;
  } 
 
  /* ------------------------------------------------------- */
  /* Get the network mask (for information)                  */
  /* ------------------------------------------------------- */

  memset ((void*)&if_req, 0, sizeof(struct ifreq));
  strcpy (if_req.ifr_name, interface);

  if (ioctl(desc, SIOCGIFNETMASK, &if_req) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call ioctl(SIOCGIFNETMASK) failed - %s", strerror(errno));
    return -1;
  }

  *netmask = ((struct sockaddr_in*)(&(if_req.ifr_netmask)))->sin_addr.s_addr;

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Netmask assigned to %s is: %s.",
             interface,
             get_doted_ip(*netmask));

  /* ------------------------------------------------------- */
  /* Get broadcast address (for information)                 */
  /* ------------------------------------------------------- */

  memset ((void*)&if_req, 0, sizeof(struct ifreq));
  strcpy (if_req.ifr_name, interface);

  if (ioctl(desc, SIOCGIFBRDADDR, &if_req) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call ioctl(SIOCGIFNETMASK) failed - %s", strerror(errno));
    return -1;
  }

  *broadcast = ((struct sockaddr_in*)(&(if_req.ifr_broadaddr)))->sin_addr.s_addr;

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Broadcast address assigned to %s is: %s.",
             interface,
             get_doted_ip(*broadcast));

  /* ------------------------------------------------------- */
  /* make the socket quickly reusable                        */
  /* ------------------------------------------------------- */

  on = 1;
  if (setsockopt(desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call setsockopt(SO_REUSEADDR) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Bind the socket to the given port                       */
  /*                                                         */
  /* Important note: Don't try to bind the socket to any     */
  /* specific IP address. You must bind it to 'INADDR_ANY'.  */
  /* The value 'INADDR_ANY' means "any IP address associated */
  /* with the host". This includes:                          */
  /* (1) All IP addresses of all network interfaces.         */
  /* (2) The broadcast address.                              */
  /* (3) Any assigned multicast address.                     */
  /*                                                         */
  /* If you bind the socket to a specific IP address (for    */
  /* example 10.33.33.2), then the socket can receive pac-   */
  /* -kets which destination IP address is 10.33.33.2. All   */
  /* other destination IP address are ignored (the broadcast */
  /* IP address included!). This means that you can not re-  */
  /* -ceive broadcasts.                                      */
  /*                                                         */
  /* In order to associate a specific network interface to   */
  /* the socket, we use the socket's option SO_BINDTODEVICE. */
  /* The combination (INADDR_ANY, SO_BINDTODEVICE/eth0)      */
  /* means "any UP address associated to the interface eth0, */
  /* and only eth0. This includes the broadcast address and  */
  /* any multicast addresses.                                */
  /* ------------------------------------------------------- */

  longueur = (int)sizeof (struct sockaddr_in);

  memset ((void*)add, 0, longueur);
  add->sin_family      = AF_INET; 
  add->sin_port        = htons((unsigned short)port); 
  add->sin_addr.s_addr = INADDR_ANY;

  if (bind(desc, (struct sockaddr*)add, longueur) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call bind() failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* "Link" the socket to a given interface                  */
  /* ------------------------------------------------------- */

  if (setsockopt(desc, SOL_SOCKET, SO_BINDTODEVICE, interface, strlen(interface)+1) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call setsockopt(SO_BINDTODEVICE, %s) failed - %s",
              interface,
              strerror(errno));
    return -1;
  }

  my_syslog (
             LEVEL_INFO,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Binding server to IP address %s - (%s) on port %d - %s (%s).",
             get_doted_ip(add->sin_addr.s_addr),
             interface,
             port,
             host,
             get_doted_ip(ip));

  /* ------------------------------------------------------- */
  /* Allow socket to receive / send broadcast messages       */
  /* ------------------------------------------------------- */

  on = 1;
  if (setsockopt(desc, SOL_SOCKET, SO_BROADCAST, &on, sizeof(int)) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call setsockopt(SO_BROADCAST) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Make sure that we can handle broadcasts                 */
  /* ------------------------------------------------------- */
 
  on = 0;
  length = sizeof(int);
  if (getsockopt(desc, SOL_SOCKET, SO_BROADCAST, &on, &length) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call getsockopt(SO_BROADCAST) failed - %s", strerror(errno));
    return -1;
  }

  if (on == 1)
  {
    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Broadcast is activated.");
  }
  else
  {
    my_syslog (
               LEVEL_VERBOSE,
               TERMINAL_LEVEL,
               __FILE__,
               __LINE__,
               "Broadcast is __NOT__ activated.");
  }

  return (desc);
};

/*! \brief Return the IP address and the port number of a remote end point.
    \author Denis BEURIVE
    \param sender Pointer to the address of the destant end point.
    \param ip Pointer to a string of character used to store the IP address.
           This string should be, at least MAX_IP_ADDRESS_STR_SIZE characters long.
    \param port Pointer to an integer used to store the port number.
 */

void get_remote_address (struct sockaddr_in *sender, char *ip, int *port)
{
  int  i;
  char *a;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_remote_address().");

  a = inet_ntoa(sender->sin_addr);
  for (i=0; i<MAX_IP_ADDRESS_STR_SIZE-1; i++) { ip[i] = *(a+i); };
  ip[MAX_IP_ADDRESS_STR_SIZE-1] = 0;
  *port = ntohs (sender->sin_port);
}

/*! \brief Convert IP address in binary representation (4 bytes in network byte order)
           into standard numbers-and-dots notation.
    \author Denis BEURIVE
    \param ip Binary representation of the IP address to convert (4 bytes in network byte order).
    \return The function returns a zero terminated string that represents the IP address in standard
            numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
             Do not try to free it!
 */

static char *get_doted_ip (unsigned long int ip)
{
  struct in_addr     add;

  my_syslog (
             LEVEL_FULL_VERBOSE,
             TERMINAL_LEVEL,
             __FILE__,
             __LINE__,
             "Calling get_doted_ip().");

  add.s_addr = ip;

  return inet_ntoa(add);
}

vci_surf.c

vci_tv.c

Configuration Doxygen

# Doxyfile 1.2.9.1

# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project
#
# All text after a hash (#) is considered a comment and will be ignored
# The format is:
#       TAG = value [value, ...]
# For lists items can also be appended using:
#       TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ")

#---------------------------------------------------------------------------
# General configuration options
#---------------------------------------------------------------------------

# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
# by quotes) that should identify the project.

PROJECT_NAME           = MyDhcp_V2

# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
# This could be handy for archiving the generated documentation or 
# if some version control system is used.

PROJECT_NUMBER         = 1

# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
# base path where the generated documentation will be put. 
# If a relative path is entered, it will be relative to the location 
# where doxygen was started. If left blank the current directory will be used.

OUTPUT_DIRECTORY       = ./doc

# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
# documentation generated by doxygen is written. Doxygen will use this 
# information to generate all constant output in the proper language. 
# The default language is English, other supported languages are: 
# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, 
# German, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, 
# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish.

OUTPUT_LANGUAGE        = English

# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
# documentation are documented, even if no documentation was available. 
# Private class members and static file members will be hidden unless 
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES

EXTRACT_ALL            = NO

# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
# will be included in the documentation.

EXTRACT_PRIVATE        = YES

# If the EXTRACT_STATIC tag is set to YES all static members of a file 
# will be included in the documentation.

EXTRACT_STATIC         = YES

# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
# undocumented members of documented classes, files or namespaces. 
# If set to NO (the default) these members will be included in the 
# various overviews, but no documentation section is generated. 
# This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_MEMBERS     = NO

# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
# undocumented classes that are normally visible in the class hierarchy. 
# If set to NO (the default) these class will be included in the various 
# overviews. This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_CLASSES     = NO

# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
# include brief member descriptions after the members that are listed in 
# the file and class documentation (similar to JavaDoc). 
# Set to NO to disable this.

BRIEF_MEMBER_DESC      = YES

# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
# the brief description of a member or function before the detailed description. 
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
# brief descriptions will be completely suppressed.

REPEAT_BRIEF           = YES

# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
# Doxygen will generate a detailed section even if there is only a brief 
# description.

ALWAYS_DETAILED_SEC    = NO

# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
# path before files name in the file list and in the header files. If set 
# to NO the shortest path that makes the file name unique will be used.

FULL_PATH_NAMES        = NO

# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
# can be used to strip a user defined part of the path. Stripping is 
# only done if one of the specified strings matches the left-hand part of 
# the path. It is allowed to use relative paths in the argument list.

STRIP_FROM_PATH        = 

# The INTERNAL_DOCS tag determines if documentation 
# that is typed after a \internal command is included. If the tag is set 
# to NO (the default) then the documentation will be excluded. 
# Set it to YES to include the internal documentation.

INTERNAL_DOCS          = NO

# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
# generate a class diagram (in Html and LaTeX) for classes with base or 
# super classes. Setting the tag to NO turns the diagrams off.

CLASS_DIAGRAMS         = YES

# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
# be generated. Documented entities will be cross-referenced with these sources.

SOURCE_BROWSER         = YES

# Setting the INLINE_SOURCES tag to YES will include the body 
# of functions and classes directly in the documentation.

INLINE_SOURCES         = NO

# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
# doxygen to hide any special comment blocks from generated source code 
# fragments. Normal C and C++ comments will always remain visible.

STRIP_CODE_COMMENTS    = NO

# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
# file names in lower case letters. If set to YES upper case letters are also 
# allowed. This is useful if you have classes or files whose names only differ 
# in case and if your file system supports case sensitive file names. Windows 
# users are adviced to set this option to NO.

CASE_SENSE_NAMES       = YES

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
# (but less readable) file names. This can be useful is your file systems 
# doesn't support long names like on DOS, Mac, or CD-ROM.

SHORT_NAMES            = YES

# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
# will show members with their full class and namespace scopes in the 
# documentation. If set to YES the scope will be hidden.

HIDE_SCOPE_NAMES       = NO

# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
# will generate a verbatim copy of the header file for each class for 
# which an include is specified. Set to NO to disable this.

VERBATIM_HEADERS       = YES

# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
# will put list of the files that are included by a file in the documentation 
# of that file.

SHOW_INCLUDE_FILES     = YES

# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
# will interpret the first line (until the first dot) of a JavaDoc-style 
# comment as the brief description. If set to NO, the JavaDoc 
# comments  will behave just like the Qt-style comments (thus requiring an 
# explict @brief command for a brief description.

JAVADOC_AUTOBRIEF      = NO

# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
# member inherits the documentation from any documented member that it 
# reimplements.

INHERIT_DOCS           = YES

# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
# is inserted in the documentation for inline members.

INLINE_INFO            = YES

# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
# will sort the (detailed) documentation of file and class members 
# alphabetically by member name. If set to NO the members will appear in 
# declaration order.

SORT_MEMBER_DOCS       = YES

# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
# tag is set to YES, then doxygen will reuse the documentation of the first 
# member in the group (if any) for the other members of the group. By default 
# all members of a group must be documented explicitly.

DISTRIBUTE_GROUP_DOC   = NO

# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
# Doxygen uses this value to replace tabs by spaces in code fragments.

TAB_SIZE               = 8

# The ENABLED_SECTIONS tag can be used to enable conditional 
# documentation sections, marked by \if sectionname ... \endif.

ENABLED_SECTIONS       = 

# The GENERATE_TODOLIST tag can be used to enable (YES) or 
# disable (NO) the todo list. This list is created by putting \todo 
# commands in the documentation.

GENERATE_TODOLIST      = YES

# The GENERATE_TESTLIST tag can be used to enable (YES) or 
# disable (NO) the test list. This list is created by putting \test 
# commands in the documentation.

GENERATE_TESTLIST      = YES

# The GENERATE_BUGLIST tag can be used to enable (YES) or 
# disable (NO) the bug list. This list is created by putting \bug 
# commands in the documentation.

GENERATE_BUGLIST       = YES

# This tag can be used to specify a number of aliases that acts 
# as commands in the documentation. An alias has the form "name=value". 
# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
# put the command \sideeffect (or @sideeffect) in the documentation, which 
# will result in a user defined paragraph with heading "Side Effects:". 
# You can put \n's in the value part of an alias to insert newlines.

ALIASES                = 

# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
# the initial value of a variable or define consist of for it to appear in 
# the documentation. If the initializer consists of more lines than specified 
# here it will be hidden. Use a value of 0 to hide initializers completely. 
# The appearance of the initializer of individual variables and defines in the 
# documentation can be controlled using \showinitializer or \hideinitializer 
# command in the documentation regardless of this setting.

MAX_INITIALIZER_LINES  = 30

# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources 
# only. Doxygen will then generate output that is more tailored for C. 
# For instance some of the names that are used will be different. The list 
# of all members will be omitted, etc.

OPTIMIZE_OUTPUT_FOR_C  = YES

# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
# at the bottom of the documentation of classes and structs. If set to YES the 
# list will mention the files that were used to generate the documentation.

SHOW_USED_FILES        = YES

#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------

# The QUIET tag can be used to turn on/off the messages that are generated 
# by doxygen. Possible values are YES and NO. If left blank NO is used.

QUIET                  = NO

# The WARNINGS tag can be used to turn on/off the warning messages that are 
# generated by doxygen. Possible values are YES and NO. If left blank 
# NO is used.

WARNINGS               = YES

# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
# automatically be disabled.

WARN_IF_UNDOCUMENTED   = YES

# The WARN_FORMAT tag determines the format of the warning messages that 
# doxygen can produce. The string should contain the $file, $line, and $text 
# tags, which will be replaced by the file and line number from which the 
# warning originated and the warning text.

WARN_FORMAT            = 

# The WARN_LOGFILE tag can be used to specify a file to which warning 
# and error messages should be written. If left blank the output is written 
# to stderr.

WARN_LOGFILE           = doxygen.war

#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------

# The INPUT tag can be used to specify the files and/or directories that contain 
# documented source files. You may enter file names like "myfile.cpp" or 
# directories like "/usr/src/myproject". Separate the files or directories 
# with spaces.

INPUT = \
./src/config.c \
./src/configuration.c \
./src/conversion.c \
./src/create_database_read.c \
./src/create_database_read_write.c \
./src/dhcp.c \
./src/find_ip_and_reply.c \
./src/flock.c \
./src/hitachi.c \
./src/logging.c \
./src/logistic.c \
./src/modem.c \
./src/mysql.c \
./src/mysql_interface.c \
./src/packets.c \
./src/packets_operations.c \
./src/read_conf.c \
./src/sockets.c \
./include/config.h \
./include/conversion.h \
./include/dhcp.h \
./include/find_ip_and_reply.h \
./include/flock.h \
./include/hitachi.h \
./include/logging.h \
./include/logistic.h \
./include/modem.h \
./include/mysql_header.h \
./include/mysql_interface.h \
./include/packets_data.h \
./include/packets.h \
./include/packets_operations.h \
./include/server_config.h \
./include/sockets.h \
./include/tables.h

 
# If the value of the INPUT tag contains directories, you can use the 
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
# and *.h) to filter out the source-files in the directories. If left 
# blank all files are included.

FILE_PATTERNS          = 

# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
# should be searched for input files as well. Possible values are YES and NO. 
# If left blank NO is used.

RECURSIVE              = NO

# The EXCLUDE tag can be used to specify files and/or directories that should 
# excluded from the INPUT source files. This way you can easily exclude a 
# subdirectory from a directory tree whose root is specified with the INPUT tag.

EXCLUDE                = 

# If the value of the INPUT tag contains directories, you can use the 
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
# certain files from those directories.

EXCLUDE_PATTERNS       = 

# The EXAMPLE_PATH tag can be used to specify one or more files or 
# directories that contain example code fragments that are included (see 
# the \include command).

EXAMPLE_PATH           = 

# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
# and *.h) to filter out the source-files in the directories. If left 
# blank all files are included.

EXAMPLE_PATTERNS       = 

# The IMAGE_PATH tag can be used to specify one or more files or 
# directories that contain image that are included in the documentation (see 
# the \image command).

IMAGE_PATH             = 

# The INPUT_FILTER tag can be used to specify a program that doxygen should 
# invoke to filter for each input file. Doxygen will invoke the filter program 
# by executing (via popen()) the command <filter> <input-file>, where <filter> 
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
# input file. Doxygen will then use the output that the filter program writes 
# to standard output.

INPUT_FILTER           = 

# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
# INPUT_FILTER) will be used to filter the input files when producing source 
# files to browse.

FILTER_SOURCE_FILES    = NO

#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------

# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
# of all compounds will be generated. Enable this if the project 
# contains a lot of classes, structs, unions or interfaces.

ALPHABETICAL_INDEX     = YES

# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
# in which this list will be split (can be a number in the range [1..20])

COLS_IN_ALPHA_INDEX    = 5

# In case all classes in a project start with a common prefix, all 
# classes will be put under the same header in the alphabetical index. 
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
# should be ignored while generating the index headers.

IGNORE_PREFIX          = 

#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------

# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
# generate HTML output.

GENERATE_HTML          = YES

# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
# put in front of it. If left blank `html' will be used as the default path.

HTML_OUTPUT            = 

# The HTML_HEADER tag can be used to specify a personal HTML header for 
# each generated HTML page. If it is left blank doxygen will generate a 
# standard header.

HTML_HEADER            = 

# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
# each generated HTML page. If it is left blank doxygen will generate a 
# standard footer.

HTML_FOOTER            = 

# The HTML_STYLESHEET tag can be used to specify a user defined cascading 
# style sheet that is used by each HTML page. It can be used to 
# fine-tune the look of the HTML output. If the tag is left blank doxygen 
# will generate a default style sheet

HTML_STYLESHEET        = 

# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
# files or namespaces will be aligned in HTML using tables. If set to 
# NO a bullet list will be used.

HTML_ALIGN_MEMBERS     = YES

# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
# will be generated that can be used as input for tools like the 
# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
# of the generated HTML documentation.

GENERATE_HTMLHELP      = NO

# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
# controls if a separate .chi index file is generated (YES) or that 
# it should be included in the master .chm file (NO).

GENERATE_CHI           = NO

# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
# controls whether a binary table of contents is generated (YES) or a 
# normal table of contents (NO) in the .chm file.

BINARY_TOC             = NO

# The TOC_EXPAND flag can be set to YES to add extra items for group members 
# to the contents of the Html help documentation and to the tree view.

TOC_EXPAND             = NO

# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
# top of each HTML page. The value NO (the default) enables the index and 
# the value YES disables it.

DISABLE_INDEX          = NO

# This tag can be used to set the number of enum values (range [1..20]) 
# that doxygen will group on one line in the generated HTML documentation.

ENUM_VALUES_PER_LINE   = 4

# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
# generated containing a tree-like index structure (just like the one that 
# is generated for HTML Help). For this to work a browser that supports 
# JavaScript and frames is required (for instance Netscape 4.0+ 
# or Internet explorer 4.0+).

GENERATE_TREEVIEW      = NO

# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
# used to set the initial width (in pixels) of the frame in which the tree 
# is shown.

TREEVIEW_WIDTH         = 250

#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------

# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
# generate Latex output.

GENERATE_LATEX         = NO

# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
# put in front of it. If left blank `latex' will be used as the default path.

LATEX_OUTPUT           = 

# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
# LaTeX documents. This may be useful for small projects and may help to 
# save some trees in general.

COMPACT_LATEX          = NO

# The PAPER_TYPE tag can be used to set the paper type that is used 
# by the printer. Possible values are: a4, a4wide, letter, legal and 
# executive. If left blank a4wide will be used.

PAPER_TYPE             = a4wide

# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
# packages that should be included in the LaTeX output.

EXTRA_PACKAGES         = 

# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
# the generated latex document. The header should contain everything until 
# the first chapter. If it is left blank doxygen will generate a 
# standard header. Notice: only use this tag if you know what you are doing!

LATEX_HEADER           = 

# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
# contain links (just like the HTML output) instead of page references 
# This makes the output suitable for online browsing using a pdf viewer.

PDF_HYPERLINKS         = NO

# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
# plain latex in the generated Makefile. Set this option to YES to get a 
# higher quality PDF documentation.

USE_PDFLATEX           = NO

# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
# command to the generated LaTeX files. This will instruct LaTeX to keep 
# running if errors occur, instead of asking the user for help. 
# This option is also used when generating formulas in HTML.

LATEX_BATCHMODE        = NO

#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------

# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
# The RTF output is optimised for Word 97 and may not look very pretty with 
# other RTF readers or editors.

GENERATE_RTF           = NO

# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
# put in front of it. If left blank `rtf' will be used as the default path.

RTF_OUTPUT             = 

# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
# RTF documents. This may be useful for small projects and may help to 
# save some trees in general.

COMPACT_RTF            = NO

# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
# will contain hyperlink fields. The RTF file will 
# contain links (just like the HTML output) instead of page references. 
# This makes the output suitable for online browsing using WORD or other 
# programs which support those fields. 
# Note: wordpad (write) and others do not support links.

RTF_HYPERLINKS         = NO

# Load stylesheet definitions from file. Syntax is similar to doxygen's 
# config file, i.e. a series of assigments. You only have to provide 
# replacements, missing definitions are set to their default value.

RTF_STYLESHEET_FILE    = 

# Set optional variables used in the generation of an rtf document. 
# Syntax is similar to doxygen's config file.

RTF_EXTENSIONS_FILE    = 

#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------

# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
# generate man pages

GENERATE_MAN           = NO

# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
# put in front of it. If left blank `man' will be used as the default path.

MAN_OUTPUT             = 

# The MAN_EXTENSION tag determines the extension that is added to 
# the generated man pages (default is the subroutine's section .3)

MAN_EXTENSION          = 

# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.

MAN_LINKS              = NO

#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------

# If the GENERATE_XML tag is set to YES Doxygen will 
# generate an XML file that captures the structure of 
# the code including all documentation. Note that this 
# feature is still experimental and incomplete at the 
# moment.

GENERATE_XML           = NO

#---------------------------------------------------------------------------
# Configuration options related to the preprocessor   
#---------------------------------------------------------------------------

# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
# evaluate all C-preprocessor directives found in the sources and include 
# files.

ENABLE_PREPROCESSING   = YES

# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
# names in the source code. If set to NO (the default) only conditional 
# compilation will be performed. Macro expansion can be done in a controlled 
# way by setting EXPAND_ONLY_PREDEF to YES.

MACRO_EXPANSION        = NO

# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
# then the macro expansion is limited to the macros specified with the 
# PREDEFINED and EXPAND_AS_PREDEFINED tags.

EXPAND_ONLY_PREDEF     = NO

# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
# in the INCLUDE_PATH (see below) will be search if a #include is found.

SEARCH_INCLUDES        = YES

# The INCLUDE_PATH tag can be used to specify one or more directories that 
# contain include files that are not input files but should be processed by 
# the preprocessor.

INCLUDE_PATH           = 

# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
# patterns (like *.h and *.hpp) to filter out the header-files in the 
# directories. If left blank, the patterns specified with FILE_PATTERNS will 
# be used.

INCLUDE_FILE_PATTERNS  = 

# The PREDEFINED tag can be used to specify one or more macro names that 
# are defined before the preprocessor is started (similar to the -D option of 
# gcc). The argument of the tag is a list of macros of the form: name 
# or name=definition (no spaces). If the definition and the = are 
# omitted =1 is assumed.

PREDEFINED             = 

# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then 
# this tag can be used to specify a list of macro names that should be expanded. 
# The macro definition that is found in the sources will be used. 
# Use the PREDEFINED tag if you want to use a different macro definition.

EXPAND_AS_DEFINED      = 

#---------------------------------------------------------------------------
# Configuration::addtions related to external references   
#---------------------------------------------------------------------------

# The TAGFILES tag can be used to specify one or more tagfiles.

TAGFILES               = 

# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
# a tag file that is based on the input files it reads.

GENERATE_TAGFILE       = 

# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
# in the class index. If set to NO only the inherited external classes 
# will be listed.

ALLEXTERNALS           = NO

# The PERL_PATH should be the absolute path and name of the perl script 
# interpreter (i.e. the result of `which perl').

PERL_PATH              = 

#---------------------------------------------------------------------------
# Configuration options related to the dot tool   
#---------------------------------------------------------------------------

# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
# available from the path. This tool is part of Graphviz, a graph visualization 
# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
# have no effect if this option is set to NO (the default)

HAVE_DOT               = NO

# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
# will generate a graph for each documented class showing the direct and 
# indirect inheritance relations. Setting this tag to YES will force the 
# the CLASS_DIAGRAMS tag to NO.

CLASS_GRAPH            = YES

# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
# will generate a graph for each documented class showing the direct and 
# indirect implementation dependencies (inheritance, containment, and 
# class references variables) of the class with other documented classes.

COLLABORATION_GRAPH    = YES

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
# tags are set to YES then doxygen will generate a graph for each documented 
# file showing the direct and indirect include dependencies of the file with 
# other documented files.

INCLUDE_GRAPH          = YES

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
# documented header file showing the documented files that directly or 
# indirectly include this file.

INCLUDED_BY_GRAPH      = YES

# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
# will graphical hierarchy of all classes instead of a textual one.

GRAPHICAL_HIERARCHY    = YES

# The tag DOT_PATH can be used to specify the path where the dot tool can be 
# found. If left blank, it is assumed the dot tool can be found on the path.

DOT_PATH               = 

# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
# this value, doxygen will try to truncate the graph, so that it fits within 
# the specified constraint. Beware that most browsers cannot cope with very 
# large images.

MAX_DOT_GRAPH_WIDTH    = 1024

# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
# this value, doxygen will try to truncate the graph, so that it fits within 
# the specified constraint. Beware that most browsers cannot cope with very 
# large images.

MAX_DOT_GRAPH_HEIGHT   = 1024

# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
# generate a legend page explaining the meaning of the various boxes and 
# arrows in the dot generated graphs.

GENERATE_LEGEND        = YES

# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
# remove the intermedate dot files that are used to generate 
# the various graphs.

DOT_CLEANUP            = YES

#---------------------------------------------------------------------------
# Configuration::addtions related to the search engine   
#---------------------------------------------------------------------------

# The SEARCHENGINE tag specifies whether or not a search engine should be 
# used. If set to NO the values of all tags below this one will be ignored.

SEARCHENGINE           = NO

# The CGI_NAME tag should be the name of the CGI script that 
# starts the search engine (doxysearch) with the correct parameters. 
# A script with this name will be generated by doxygen.

CGI_NAME               = 

# The CGI_URL tag should be the absolute URL to the directory where the 
# cgi binaries are located. See the documentation of your http daemon for 
# details.

CGI_URL                = 

# The DOC_URL tag should be the absolute URL to the directory where the 
# documentation is located. If left blank the absolute path to the 
# documentation, with file:// prepended to it, will be used.

DOC_URL                = 

# The DOC_ABSPATH tag should be the absolute path to the directory where the 
# documentation is located. If left blank the directory on the local machine 
# will be used.

DOC_ABSPATH            = 

# The BIN_ABSPATH tag must point to the directory where the doxysearch binary 
# is installed.

BIN_ABSPATH            = 

# The EXT_DOC_PATHS tag can be used to specify one or more paths to 
# documentation generated for other projects. This allows doxysearch to search 
# the documentation for these projects as well.

EXT_DOC_PATHS          =

Documentation du code

Cliquez sur ce lien pour accéder à la documentation du serveur DHCP. Cette documentation a été générée avec Doxygen.

Makefile

### Makefile for the DHCP server
### Author: Denis BEURIVE
###
### External modules : common_c_libs (author: Denis BEURIVE)


# --------------------------------------------
# Directory configuration.
# --------------------------------------------

BIN_DIR     = ./bin
INCLUDE_DIR = ./include
SRC_DIR     = ./src
OBJ_DIR     = ./objs
TMP_DIR     = ./tmp
LIB_DIR     = ./lib
TEST_DIR    = ./tests
CONF_DIR    = ./conf
PLUGIN_DIR  = ./plugins

# --------------------------------------------
# Tools pathes
# --------------------------------------------

CC          = gcc
DOXY        = doxygen
SED         = sed
FLEX        = flex
AR          = ar
FLEX_FLAGS  =
ARFLAGS     = rcs

# --------------------------------------------
# Build tags
# --------------------------------------------

DATE := $(shell date)
HOST := $(shell uname -a)

# --------------------------------------------
# Path to the project top level directory
# --------------------------------------------

TOP_LEVEL = /root/backup_dhcp/dhcp_adsl_v3

# --------------------------------------------
# Path to the 'common_c_libs'
# --------------------------------------------

COMMON_C_LIBS_HEADERS = /home/common_c_libs/includes
COMMON_C_LIBS_LIBS    = /home/common_c_libs/libs

# --------------------------------------------
# Path to the MySql headers and libraries
# --------------------------------------------

MYSQL_HEADERS = /usr/include/mysql
MYSQL_LIBS    = /usr/lib

# MYSQL_HEADERS = /export/dhcp_adsl_v2/tests/mysql/include/mysql
# MYSQL_LIBS    = /export/dhcp_adsl_v2/tests/mysql/lib/mysql

# --------------------------------------------
# Compiler options
# --------------------------------------------

CCFLAGS = -Wall -ggdb -I${INCLUDE_DIR} \
          -I${COMMON_C_LIBS_HEADERS} \
          -I${MYSQL_HEADERS} \
          -L${COMMON_C_LIBS_LIBS} \
          -L${MYSQL_LIBS} \
          -L${LIB_DIR} \
          -D_GNU_SOURCE \
          -static \
          -o $@

# --------------------------------------------
# Lexical parsers
# --------------------------------------------

lexical_parsers: ${OBJ_DIR}/config.lex.o

${SRC_DIR}/config.lex.c: ${SRC_DIR}/config.lex
	${FLEX} ${FLEX_FLAGS} -Pconfig -o${SRC_DIR}/config.lex.c ${SRC_DIR}/config.lex

${OBJ_DIR}/config.lex.o: ${SRC_DIR}/config.lex.c \
                         ${INCLUDE_DIR}/config.h
	${CC} -c ${CCFLAGS} -w ${SRC_DIR}/config.lex.c

# --------------------------------------------
# Build all standalone objects
# --------------------------------------------

standalones: ${OBJ_DIR}/logging.o \
             ${OBJ_DIR}/config.o \
             ${OBJ_DIR}/libip.o \
             ${OBJ_DIR}/configuration.o \
             ${OBJ_DIR}/flock.o

${OBJ_DIR}/logging.o: ${SRC_DIR}/logging.c \
                      ${INCLUDE_DIR}/logging.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/logging.c

${OBJ_DIR}/config.o: ${SRC_DIR}/config.c \
                     ${INCLUDE_DIR}/config.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/config.c

${OBJ_DIR}/configuration.o: ${SRC_DIR}/configuration.c \
                            ${INCLUDE_DIR}/server_config.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/configuration.c

${OBJ_DIR}/flock.o: ${SRC_DIR}/flock.c \
                    ${INCLUDE_DIR}/flock.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/flock.c

# --------------------------------------------
# Libraries
# --------------------------------------------

libs: ${LIB_DIR}/libip.a

${OBJ_DIR}/libip.o: ${SRC_DIR}/libip.c \
                    ${INCLUDE_DIR}/libip.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/libip.c

${LIB_DIR}/libip.a: ${OBJ_DIR}/libip.o
	${AR} ${ARFLAGS} ${LIB_DIR}/libip.a ${OBJ_DIR}/libip.o

# --------------------------------------------
# Other objects
# --------------------------------------------

other_objects: ${OBJ_DIR}/mysql.o \
               ${OBJ_DIR}/conversion.o \
               ${OBJ_DIR}/packets.o \
               ${OBJ_DIR}/modem.o \
               ${OBJ_DIR}/sockets.o \
               ${OBJ_DIR}/packets_operations.o \
               ${OBJ_DIR}/mysql_interface.o \
               ${OBJ_DIR}/find_ip_and_reply.o \
               ${OBJ_DIR}/logistic.o 

${OBJ_DIR}/mysql.o: ${SRC_DIR}/mysql.c \
                    ${INCLUDE_DIR}/mysql_header.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/mysql.c

${OBJ_DIR}/conversion.o: ${SRC_DIR}/conversion.c \
                         ${INCLUDE_DIR}/conversion.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/conversion.c

${OBJ_DIR}/packets.o: ${SRC_DIR}/packets.c \
                      ${INCLUDE_DIR}/packets.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/packets.c

${OBJ_DIR}/modem.o: ${SRC_DIR}/modem.c \
                    ${INCLUDE_DIR}/modem.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/modem.c

${OBJ_DIR}/sockets.o: ${SRC_DIR}/sockets.c \
                      ${INCLUDE_DIR}/sockets.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/sockets.c

${OBJ_DIR}/packets_operations.o: ${SRC_DIR}/packets_operations.c \
                                 ${INCLUDE_DIR}/packets_operations.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/packets_operations.c

${OBJ_DIR}/mysql_interface.o: ${SRC_DIR}/mysql_interface.c
	${CC} -c ${CCFLAGS} ${SRC_DIR}/mysql_interface.c

${OBJ_DIR}/find_ip_and_reply.o: ${SRC_DIR}/find_ip_and_reply.c \
                                ${INCLUDE_DIR}/find_ip_and_reply.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/find_ip_and_reply.c

${OBJ_DIR}/logistic.o: ${SRC_DIR}/logistic.c \
                       ${INCLUDE_DIR}/logistic.h
	${CC} -c ${CCFLAGS} ${SRC_DIR}/logistic.c

# --------------------------------------------
# Plugins
# --------------------------------------------

plugins: ${PLUGIN_DIR}/libhitachi.so \
         ${PLUGIN_DIR}/libvci_tv.so \
         ${PLUGIN_DIR}/libvci_surf.so

## -- Hitachi

${OBJ_DIR}/hitachi_dyn.o: ${SRC_DIR}/hitachi.c 
	${CC} -I${INCLUDE_DIR} -fPIC -g -c ${SRC_DIR}/hitachi.c -o ${OBJ_DIR}/hitachi_dyn.o

${PLUGIN_DIR}/libhitachi.so: ${OBJ_DIR}/hitachi_dyn.o
	${CC} -shared -Wl,-soname,libhitachi.so -o ${PLUGIN_DIR}/libhitachi.so ${OBJ_DIR}/hitachi_dyn.o

## -- VCI TV

${OBJ_DIR}/vci_tv.o: ${SRC_DIR}/vci_tv.c
	${CC} -I${INCLUDE_DIR} -fPIC -g -c ${SRC_DIR}/vci_tv.c -o ${OBJ_DIR}/vci_tv.o

${PLUGIN_DIR}/libvci_tv.so: ${OBJ_DIR}/vci_tv.o
	${CC} -L${LIB_DIR} -shared -Wl,-soname,libvci_tv.so -o ${PLUGIN_DIR}/libvci_tv.so ${OBJ_DIR}/vci_tv.o -lip

## -- VCI SURF

${OBJ_DIR}/vci_surf.o: ${SRC_DIR}/vci_surf.c
	${CC} -I${INCLUDE_DIR} -fPIC -g -c ${SRC_DIR}/vci_surf.c -o ${OBJ_DIR}/vci_surf.o

${PLUGIN_DIR}/libvci_surf.so: ${OBJ_DIR}/vci_surf.o
	${CC} -L${LIB_DIR} -shared -Wl,-soname,libvci_surf.so -o ${PLUGIN_DIR}/libvci_surf.so ${OBJ_DIR}/vci_surf.o -lip

# --------------------------------------------
# Build test suite
# --------------------------------------------

tests: ${BIN_DIR}/mysql.test \
       ${BIN_DIR}/libip.test \
       ${BIN_DIR}/plugins.test 

${BIN_DIR}/mysql.test: ${TEST_DIR}/test_mysql.c \
                       ${OBJ_DIR}/logging.o \
                       ${OBJ_DIR}/config.o \
                       ${OBJ_DIR}/configuration.o \
                       ${OBJ_DIR}/mysql.o \
                       ${OBJ_DIR}/config.lex.o
	${CC}  ${CCFLAGS} ${TEST_DIR}/test_mysql.c \
                          ${OBJ_DIR}/logging.o \
                          ${OBJ_DIR}/config.o \
                          ${OBJ_DIR}/mysql.o \
                          ${OBJ_DIR}/configuration.o \
                          ${OBJ_DIR}/config.lex.o \
                          -lmy_config -lmy_hash_table -lmy_list -lmy_strings -lmysqlclient -lz -lmy_dstring -ldl

${BIN_DIR}/libip.test: ${TEST_DIR}/test_libip.c \
                       ${LIB_DIR}/libip.a 
	${CC}  ${CCFLAGS} ${TEST_DIR}/test_libip.c -lip

${BIN_DIR}/plugins.test: ${TEST_DIR}/test_plugins.c \
                         ${OBJ_DIR}/configuration.o \
                         ${OBJ_DIR}/config.lex.o \
                         ${OBJ_DIR}/config.o
	${CC} ${CCFLAGS} ${TEST_DIR}/test_plugins.c \
                         ${OBJ_DIR}/configuration.o \
                         ${OBJ_DIR}/config.lex.o \
                         ${OBJ_DIR}/config.o \
                         -rdynamic -lmy_hash_table -lmy_list -lmy_strings -lfl -ldl

# --------------------------------------------
# Build the server
# --------------------------------------------

${TMP_DIR}/dhcp.c: ${SRC_DIR}/dhcp.c
	${SED} -e "s/__DATE__/${DATE}/g; s/__HOST__/${HOST}/g; s/__CVSTAGS__/${VCVS}/g;" ${SRC_DIR}/dhcp.c > ${TMP_DIR}/dhcp.c

${BIN_DIR}/mydhcp: standalones other_objects libs \
                   ${TMP_DIR}/dhcp.c
	${CC} ${CCFLAGS} ${TMP_DIR}/dhcp.c \
                         ${OBJ_DIR}/mysql.o \
                         ${OBJ_DIR}/flock.o \
                         ${OBJ_DIR}/modem.o \
                         ${OBJ_DIR}/config.o \
                         ${OBJ_DIR}/sockets.o \
                         ${OBJ_DIR}/logging.o \
                         ${OBJ_DIR}/packets.o \
                         ${OBJ_DIR}/logistic.o \
                         ${OBJ_DIR}/conversion.o \
                         ${OBJ_DIR}/config.lex.o \
                         ${OBJ_DIR}/configuration.o \
                         ${OBJ_DIR}/mysql_interface.o \
                         ${OBJ_DIR}/find_ip_and_reply.o \
                         ${OBJ_DIR}/packets_operations.o \
                         -lmy_hash_table -lmy_list -lmy_strings -lmysqlclient -lz -lmy_deamon -lmy_dstring ${PLUGINS_LIB} -ldl

# --------------------------------------------
# Build tools
# --------------------------------------------

configuration: ${BIN_DIR}/read_conf

${BIN_DIR}/read_conf: ${SRC_DIR}/read_conf.c \
                      ${OBJ_DIR}/configuration.o \
                      ${OBJ_DIR}/config.o \
                      ${OBJ_DIR}/config.lex.o
	${CC} ${CCFLAGS} ${SRC_DIR}/read_conf.c ${OBJ_DIR}/configuration.o ${OBJ_DIR}/config.o ${OBJ_DIR}/config.lex.o -lmy_hash_table -lmy_list -lmy_strings -ldl

# --------------------------------------------
# Standard rules
# --------------------------------------------

clean:
	rm -f ${OBJ_DIR}/*.o
	rm -f ${BIN_DIR}/*
	rm -f ${TMP_DIR}/*
	rm -f ${SRC_DIR}/config.lex.c
	rm -f ${LIB_DIR}/*

all: tests plugins configuration ${BIN_DIR}/mydhcp

Développement système sous UNIX

Les codes ci-après sont extraits d’une petite librairie que j’ai développée au fil du temps. Veuillez cliquer sur ce lien pour télécharger l’archive de la librairie.

Les entêtes

array.h

/*! \file array.h
    Header file for array.c
 */

#include <stdlib.h>

/*! \brief Data structure that defines an array handler.
 */

struct s_array {
                 /*! \brief Pointer to the first element of the array. */
                 void *first_element;

                 /*! \brief Size of the array (maximum number of elements). */
                 int  array_size;

                 /*! \brief Current number of elements in the array. */
                 int  number_of_elements;

                 /*! \brief User defined function used to copy data from/to the array.
                     \param src Pointer to the data to copy.
                     \param dest Pointer to the destination.
                     \return Upon successful completion the function returns 0, otherwise it returns 1.
                     \warning <UL>
                                 <li><i>data</i> is copied from <i>src</i> to <i>dest</i>.
                                 <li>The function <i>copy_data()</i> <FONT COLOR="#FF0000"><B>MUST take care of memory management</B></FONT>
                                     (if required).
                              </UL>
                  */
                 int  (*copy_data)(void *src, void *dest);

                 /*! \brief User defined function used to remove an element from the array (it may be necessary to free memory for example).
                     \param target Pointer to the element to remove.
                     \return Upon successful completion the function returns 0, otherwise it returns 1.
                  */
                 int  (*remove_data)(void *target);

                 /*! \brief User defined function used to compare two elements of the array.
                     \param d1 Pointer to the first element.
                     \param d2 Pointer to the second element.
                     \return The function must return:
                             <UL>
                               <li>-1 if <i>d1 < d2</i>
                               <li>0  if <i>d1 = d2</i>
                               <li>+1 if <i>d1 > d2</i>
                               <li>-2 if an error occured.
                             </UL>
                  */
                 int  (*compare)(void *d1, void *d2);

                 /*! \brief User defined function that returns a pointer to the element which index is <i>idx</i>.
                     \param start Pointer to the first element of the array.
                     \param idx Index of the element.
                     \return The function returns a pointer to the element which index is <i>idx</i>.
                     \warning The gap between two elements of the array depends on the type of data stored.
                  */
                 void* (*index)(void *start, int idx);

                 /*! \brief User defined function used to initialize data (may be a NULL pointer if no initialization is required).
                     \param data Pointer to the data to initialize.
                     \return Upon successful completion the function returns 0, otherwise it returns 1
                  */
                 int (*init_data)(void *data);

                 /*! \brief Number of elements scheduled for removing.
                  */
                 int element_to_remove;

                 /*! \brief Pointer to an array of integers that will receive the index to remove from the array.
                            This array is allocated during the initialization of the array. You must free the memory using 
                            the function array_free().
                  */
                 int *to_remove;
               };

/*! \brief C data type for the <i>array</i> handler.
 */

typedef struct s_array Array;

/*! \Brief This macro returns the size of the array (that is, the maximum number of elements that can be stored in the array).
 */ 

#define array_size(array) (array.array_size)

/*! \Brief This macro returns the current number of element in the array.
 */ 

#define array_number_of_elements(array) (array.number_of_elements)

/*! \Brief This macro return a pointer on the first element in the array.
 */

#define array_first_elem(array) (array.first_element)

/*! \Brief This macro returns the number of element to remove.
 */

#define array_to_remove(array) (array.element_to_remove)


int array_init (
                 Array *array,
                 void  *first_element,
                 int   size,
                 int   (*copy_data)(void *src, void *dest),
                 int   (*remove_data)(void *target),
                 int   (*compare)(void *d1, void *d2),
                 void* (*index)(void *start, int idx),
                 int   (*init_data)(void *data)
               );

void array_free (Array *array);

int array_init_element (Array *array);

int array_add (
                Array *array,
                void  *element
              );

int array_rem (
                Array *array,
                int   idx
              );

int array_insert (
                   Array *array,
                   int   idx,
                   void  *data
                 );

int array_schedule_for_rem (Array *array, int idx);

int array_rem_all (Array *array);

int array_find (
                   Array *array,
                   void  *data
               );

bitmanip.h

buffers.h

cgi.h

chtbl.h

/*! \file chtbl.h
    Header file for chtbl.c
 */


#ifdef __cplusplus
extern "C" {
#endif


#ifndef CHTBL_H
#define CHTBL_H

#include <stdlib.h>
#include "list.h"


/* ---------------------------------------------------------------- */
/* Structure used to walk through a hash                            */
/* ---------------------------------------------------------------- */

/*! \brief This value is used by the function chtbl_next(). It tells the function to set the hash pointer to the
           first element of the hash.
 */

#define REWIND_HASH    0

/*! \brief This value is used by the function chtbl_next(). It tells the function to set the hash pointer to the
           current element of the hash.
 */

#define CURRENT_HASH   1

/*! \brief Data structure that defines one element within a hash table. This structure is used by the function
           chtbl_next().
 */

typedef struct CHTbl_handle_
{
  /*! \brief Index of the current linked list. */
  int        current_list;

  /*! \brief Pointer to the current element within the current linked list. */
  ListElmt   *current_element;

} CHTbl_handle;

/* ---------------------------------------------------------------- */
/* Data structures for the hash tables                              */
/* ---------------------------------------------------------------- */

/*! \brief Data structure that defines a linked hash table.
 */

typedef struct CHTbl_
{
  /*! \brief Number of linked list hold by the hash table. */
  int  conteneurs;

  /*! \brief Pointer to the function used to hash the input key. */
  int  (*h)(const void *cle);

  /*! \brief Pointer to the function used to compare the data pointed by two elements of the hash table. */
  int  (*corresp)(const void *cle1, const void *cle2);

  /*! \brief Pointer to the function used to free the memory allocated for the data pointed by one element of the hash table. */
  void (*detruire)(void *donnee);

  /*! \brief Number of element in the hash table. */
  int  taille;

  /*! \brief Pointer to a linked list. */
  List *table;

  /*! \brief This parameter represents the position of one element within the linked list. It is used bu the
             function chtbl_next(). */
  CHTbl_handle pointer;

} CHTbl;

/* ---------------------------------------------------------------- */
/* Hash table's API                                                 */
/* ---------------------------------------------------------------- */


int chtbl_init(CHTbl *htab, int conteneurs, 
              int (*h)(const void *cle), 
              int (*corresp)(const void *cle1, const void *cle2), 
              void (*detruire)(void *donnee));

void chtbl_destroy(CHTbl *htab);

int chtbl_insert(CHTbl *htab, const void *donnee);

int chtbl_remove(CHTbl *htab, void **donnee);

int chtbl_lookup(const CHTbl *htab, void **donnee);

int chtbl_find (const CHTbl *htab, void **donnee);

void* chtbl_next (CHTbl *htab, int rewind);

#define chtbl_size(htab) ((htab)->taille)

#endif

#ifdef __cplusplus
}
#endif

config.h

/*! \file config.h
    Header file for config.c.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONFIG_HD

  #ifdef PRIVATE_CODE_ONLY

     /*! \brief Thei FLEX configuration file is not valid.
      */

     #define CONF_PARSER_SYNTAX_ERROR   -1

     /*! \brief The FLEX configuration parser could not allocate memory.
      */

     #define CONF_PARSER_NO_MEM         -2

     /*! \brief The FLEX configuration parser found a duplicated tag in the configuration file.
      */

     #define CONF_PARSER_DUPLICATED_TAG -3

     /*! \brief The configuration file has been successfully parsed.
      */

     #define CONF_PARSER_OK             0

     /*! \brief Data structure used to store the couples (tag, value).
      */

     struct user_data {
                         char *tag;
                         char *value;
                      };

  #endif

  /*! \brief configuration parser could not open the configuration file.
   */

  #define PARSE_CONFIGURATION_FILE_NOT_FOUND    -1

  /*! \brief configuration parser could not allocate memory.
   */

  #define PARSE_CONFIGURATION_NO_MEM            -2

  /*! \brief configuration parser found an invalid line.
   */

  #define PARSE_CONFIGURATION_SYNTAX_ERROR      -3

  /*! \brief configuration parser found a duplicated tag.
   */

  #define PARSE_CONFIGURATION_DUPLICATED_TAG    -4

  /*! \brief configuration parser terminated successfully.
   */

  #define PARSE_CONFIGURATION_OK                0


  int parse_configuration_file (char *path, int *err);
  void free_all_configuration_data();
  int get_value (char *tag, char **value);


  #define CONFIG_HD

#endif

#ifdef __cplusplus
}
#endif

cyclic_buffer.h

/*! \file cyclic_buffer.h
    Header file for cyclic_buffer.c
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef CYCLIC_BUFFER_HD


#include <stdlib.h>
#include <string.h>


  /* ========================================================== */
  /* Data structure                                             */
  /* ========================================================== */

  /*! \brief Basic structure that defines the cyclic buffer. 
   */
  struct s_cyclic_buffer {
                           /*! \brief Array of pointers to (void*), each element points to an item of the buffer. */
                           void           **buffer;

                           /*! \brief Maximum number of elements in the buffer. */
                           unsigned long  size;

                           /*! \brief Index to the first item in the cyclic buffer. */
                           unsigned long  start;

                           /*! \brief Index to the last item in the cyclic buffer. */
                           unsigned long  stop;

                           /*! \brief Pointer to the current index. */
                           unsigned long  current;

                           /*! \brief Current number of element in the buffer (from 0 to 'size'). */ 
                           unsigned long  current_size;

                           /*! \brief Current number of element extracted (this is used by get_element()). */
                           unsigned long  n;

                         };

  typedef struct s_cyclic_buffer* cyclic_buffer;


  /* ========================================================== */
  /* Buffer functions                                           */
  /* ========================================================== */

  cyclic_buffer create_cyclic_buffer (unsigned long size);
  void destroy_cyclic_buffer (cyclic_buffer buffer);
  void* cyclic_buffer_add_element (cyclic_buffer buffer, void* element, unsigned element_size);
  void rewind_cyclic_buffer (cyclic_buffer buffer);
  void* cyclic_buffer_get_element(cyclic_buffer buffer);
  unsigned long cyclic_buffer_get_start(cyclic_buffer buffer);
  unsigned long cyclic_buffer_get_stop(cyclic_buffer buffer);
  unsigned long cyclic_buffer_get_current_size(cyclic_buffer buffer);

  #define CYCLIC_BUFFER_HD
#endif


#ifdef __cplusplus
}
#endif

date.h

/*! \file date.h
    Header file for all date's utilities.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef DATE_HPP

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include "strings_utils.h"

/*! \brief Maximum number of bytes for the environment variable "TZ" (ex: "TZ=GMT +0").
 */

#define TZSET_MAX_SIZE  256

/*! \brief Maximum number of bytes for the tag that defines the time zone (MET, CEST, ...).
 */

#define TIMEZONE_SIZE   50

/*! \brief Maximum number of bytes for the tag that defines the time daylight saving mode (DST, ...).
 */

#define DAYLIGHT_SIZE   50

/*! \brief This defines the maximum number of bytes for a TSM formated date (ex: Thu Aug 30 01:00:48 MET DST
           2001).
 */

#define MAX_TSM_DATE_SIZE  256

/*! \brief This defines the maximum number of lines in the time zones configuration file. One line is a set of 3 vales:
           (time zone, daylight saving mode, time shift) - for example (MET DST -3600).
 */

#define MAX_TZ_DEF        300

/*! \brief Return value for the function load_timezones(). Too many time zones definitions in the time zones configuration
           file. This maximum number is represented by the constant MAX_TZ_DEF.
 */

#define TIME_ZONES_DEF_OVERFLOW        -1

/*! \brief Return value for the function load_timezones(). This means that the program is running out of memory.
 */

#define TIME_ZONES_NO_MEM              -2

/*! \brief Return value for the function load_timezones() (or via the time zone configuration parser). This means that
           the time zone configuration file is not valid. One time zone tag is too long (too many characters).
 */

#define TIME_ZONES_TIMEZONE_OVERFLOW   -3

/*! \brief Return value for the function load_timezones() (or via the time zone configuration parser). This means that
           the time zone configuration file is not valid. One daylight saving tag is too long.
 */

#define TIME_ZONES_DAYLIGHT_OVERFLOW   -4

/*! \brief Return value for the function load_timezones() (or via the time zone configuration parser). This means that
           the time zone configuration file is not valid. The parser found a syntax error.
 */

#define TIME_ZONES_PARSE_ERROR         -5

/*! \brief Return value for the function load_timezones(). No time zones configuration file specified. Please read the 
           documentation for the function load_timezones().
 */

#define TIME_ZONES_NO_FILE             -6

/*! \brief Return value for the function load_timezones(). This means that the time zones configuration file is empty
           (no configuration found).
 */

#define TIME_ZONES_NO_DEF_FOUND        -7

/*! \brief Return value for the function load_timezones(). Can not open the time zones configuration file.
 */

#define TIME_ZONES_CAN_NOT_OPEN_FILE   -8

/*! \brief Return value for the function load_timezones(). This means that the function loaded the time zones configuration
           file successfully.
 */

#define TIME_ZONES_LOAD_OK             -9


/*! \brief If the last argument of the function date2timestamp() is set to AUTOMATIC_TIME_SHIFT_COMPUTATION, then
           the function date2timestamp() will use the external timezone configuration file to find out the correct
           time shift. please note that AUTOMATIC_TIME_SHIFT_COMPUTATION = 24*3600 (one day shift).
 */

#define AUTOMATIC_TIME_SHIFT_COMPUTATION 86400

/*! \brief Data structure that defines a time zone (for example "MET DST -3600").
 */

struct timezones {

                   /*! \brief Tag that defines the time zone (ex: MET). */

                   char   timezone[TIMEZONE_SIZE];    /* ex: MET    */

                   /*! \brief Tag that defines the daylight saving mode (ex: DST). */

                   char   daylight[DAYLIGHT_SIZE];    /* ex: DST    */

                   /*! \brief Time shift (ex: -3600). */

                   int    shift;                      /* ex: -3600  */
                 };

/*! \brief Data structure that contains all the time zone configuration extracted from the time zones configuration file.
           This structure is set up by the function load_timezones() (calling the time zones configuration file parser).
 */

struct tz_tab {

                /*! \brief Array of data structures that define time zones. */

                struct timezones tz[MAX_TZ_DEF];

                /*! \brief Number of elements in the array 'tz'. */

                int              entry_number;
              };



/*! \brief Maximum size for a reference date (load the timestamps reference parser).
 */
#define TTREF_MAX_DATE_SIZE        1020

/*! \brief Maximum size for a reference timestamp (load the timestamps reference parser).
 */
#define TTREF_MAX_TIMESTAMP_SIZE   100

/*! \brief Maximum number of entries in the reference timestamp configuration file.
 */
#define MAX_TTREF_ENTRIES          300

/*! \brief The data structure defines a couple (date, timestamp) used  as reference.
 */
struct tstamp_ref {
                    /*! \brief Date used as reference. */

                    char   date[TTREF_MAX_DATE_SIZE];

                    /*! \brief Timestalo used as reference. */

                    char   timestamp[TTREF_MAX_TIMESTAMP_SIZE];
                  }; 


/*! \brief The data structure defines the list of couples (date, timestamp) loaded from the timestamps reference file).
 */ 
struct ttref_tab  {
                    /*! \brief List of all couples (date, timestamp) used  as reference. */

                    struct tstamp_ref ttref[MAX_TTREF_ENTRIES];

                    /*! \brief Number of couples (date, timestamp), in the array 'tstamp_ref'. */

                    int               entry_number;
                  };

/*! \brief Return value for the timestamps reference parser. 
 */
#define TTREF_TOO_MANY_REF  -1

/*! \brief Return value for the timestamps reference parser.
 */
#define TTREF_NO_MEM        -2

/*! \brief Return value for the timestamps reference parser.
 */
#define TTREF_SYNTAX_ERROR  -3

/*! \brief Return value for the timestamps reference parser.
 */
#define TTREF_DATE_TOO_LONG -4

/*! \brief Return value for the timestamps reference parser.
 */
#define TTREF_REF_TOO_LONG  -5

/*! \brief Return value for the function test_tz_conf(). This means that this function could not open the configuration
           file.
 */
#define TTREF_CAN_NOT_OPEN_CONF_FILE -6

/*! \brief Return value for the function test_tz_conf(). This means that one of the input date was invalid (the input
           date comes from the timestamps reference configuration file.
 */
#define TTREF_INVALID_DATE  -7

/*! \brief Return value for the function test_tz_conf(). This means that the timestamps' computation was correct.
 */
#define TTREF_OK            0 

/*! \brief Return value for the function test_tz_conf(). This means that the timestamps' computation was not correct.
 */
#define TTREF_KO            1

/*********************************************************/

/*! \brief Configuration value for the function test_tz_conf(). This means that we request the time zone auto configuration
           mode.
 */
#define TZ_AUTOCONF_ON    0

/*! \brief Configuration value for the function test_tz_conf(). This means that we do NOT request the time zone auto
           configuration mode.
 */
#define TZ_AUTOCONF_OFF   1

/*********************************************************/

/*! \brief This defines fields' indexes. The day of the week is the field number 0 (the first one) in the TSM's date.
 */

#define DAY_OF_THE_WEEK    0

/*! \brief This defines fields' indexes. The month is the field numbre 1 (the second one) in the TSM's date.
 */

#define MONTH              1

/*! \brief This defines fields' indexes. The day of the month is the field number 2 (the third one) in the TSM's date.
 */

#define DAY_OF_THE_MONTH   2

/*! \brief This defines fields' indexes. The clock time is the field number 3 (the fourth one) in the TSM's date.
 */

#define CLOCK              3

/*! \brief This defines fields' indexes. The hour is the field number 0 (the first one) in the TSM's clock time.
 */

#define HOUR               0

/*! \brief This defines fields' indexes. The minute is the field number 1 (the second one) in the TSM's clock time.
 */

#define MINUTES            1

/*! \brief This defines fields' indexes. The second is the field number 2 (the third one) in the TSM's clock time.
 */

#define SECONDS            2

/*! \brief This defines fields' indexes. The tag "MET" should be the field number 4 (the fifth one) in the TSM's date.
 */

#define TAG1               4

/*! \brief This defines fields' indexes. The tag "DST" should be the field number 5 (the sixth one) in the TSM's date.
 */

#define TAG2               5 

/*! \brief This defines fields' indexes. The year should be the field number 6 (the seventh one) in the TSM's date.
 */

#define YEAR               6

/*! \brief The maximum number of bytes used to save the current date.
 */

#define MAX_TIMER_SIZE     256

int set_local_TZ_to_GMT();
char* print_tz_conf();
int test_tz_conf (char* config_file, int auto_conf);
int load_timezones (char *filename);
int tzfound (struct timezones *tzz);
int tzcmp (struct timezones *tz1, struct timezones *tz2);
int get_day (char *day);
int get_month (char *month);
char* date2timestamp (char* date, char* timestamp, int nbcar, int shift);
char* dater();
time_t get_utc_timestamp();
char *get_tsm_date (time_t timestamp, int debug);

#define DATE_HPP
#endif


#ifdef __cplusplus
}
#endif

deamon.h

dmalloc.h

double_list.h

dstring.h

/*! \file dstring.h
    Header file for dstring.c
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef DSTRING_HEADER

  #include <sys/types.h>

  /*! \brief Data structure that defines a dynamic string.
   */

  struct s_dstring {
                     /*! \brief Pointer to the start of the data. */
                     char        *data;

                     /*! \brief Total number of bytes allocated for the data. */
                     size_t      size;

                     /*! \brief Number of characters in the string. */
                     size_t      nb_car;
                   };

  /*! \brief Data type for dynamic string.
   */

  typedef struct s_dstring dstring;

  int dstring_init (dstring *s, size_t init_size);
  void dstring_free (dstring *s);
  int dstring_add (dstring *s, char *buff, size_t nb_elem);
  char* dstring_get_data (dstring *s, size_t *size);

#define DSTRING_HEADER
#endif

#ifdef __cplusplus
}
#endif

files.h

/*! \file files.h
    Header file for file.c.
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef FILES_HD

#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>


#include "flock.h"

int wait_for_file (char* file_name, int period, char* stop_file);
char* wait_for_multiple_file (char **file_names, int period, char* stop_file);
int read_file (char *file_name, char **buff);
int set_timeout_file (char *filename);
int test_timeout_file (char *filename, int timeout);
void basename (char *src, char *dst);

/*! \brief This value is used by various functions that need to allocate buffers. This represents the initial size of the
           buffer (in bytes).
 */
#define FILES_UTIL_INIT_BUFF_SIZE   2048

/*! \brief Return value for the function read_file(). The function can not allocate memory.
 */
#define FILES_UTIL_MALLOC_ERR       -1

/*! \brief Return value for the function read_file(). An error occured while reading the input file.
 */
#define FILES_UTIL_READ_ERR         -2

/*! \brief Return value for the function read_file(). Can not open the input file.
 */
#define FILES_UTIL_OPEN_ERR         -3

/*! \brief Return value for the function set_timeout_file(). Can not open target file.
 */
#define SET_TIMEOUT_FILE_OPEN_ERROR   -4

/*! \brief Return value for the function set_timeout_file(). An error occured while writing into the target file.
 */
#define SET_TIMEOUT_FILE_WRITE_ERROR  -5 

/*! \brief Return value for the function set_timeout_file(). Timeout file set correctly.
 */
#define SET_TIMEOUT_FILE_OK           -6

/*! \brief Return value for the function test_timeout_file(). The timeout is passed.
 */ 
#define TEST_TIMEOUT_FILE_TIMEOUT_ELLAPSED  -7

/*! \brief Return value for the function test_timeout_file(). An error occured while reading the timeout file.
 */
#define TEST_TIMEOUT_FILE_READ_ERROR  -8

/*! \brief Return value for the function test_timeout_file(). The timeout is not passed (you may have to wait).
 */
#define TEST_TIMEOUT_FILE_TIMEOUT_NOT_ELLAPSED  -9

/*! \brief Return value for the function test_timeout_file(). The function could not delete the timeout file.
 */
#define TEST_TIMEOUT_FILE_UNLINK_FAILED -10

#define FILES_HD
#endif 

#ifdef __cplusplus
}
#endif

flock.h

/*! \file flock.h
    Header file for flock.c.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef FLOCK_HD

  #include <stdio.h>
  #include <unistd.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <string.h>
  #include <stdarg.h>

  #ifdef LINUX
  #include <sys/file.h>
  #endif

  #ifdef SUN

/*************************************************************************/
/* Note 1:                                                               */
/*                                                                       */
/* In the SunOS header file "sys/varargs.h" you can read that:           */
/*                                                                       */
/* Many compilation systems depend upon the use of special functions     */
/* built into the the compilation system to handle variable argument     */
/* lists and stack allocations.  The method to obtain this in SunOS      */
/* is to define the feature test macro "__BUILTIN_VA_ARG_INCR" which     */
/* enables the following special built-in functions:                     */
/*      __builtin_alloca                                                 */
/*      __builtin_va_alist                                               */
/*      __builtin_va_arg_incr                                            */
/* It is intended that the compilation system define this feature test   */
/* macro, not the user of the system.                                    */
/*                                                                       */
/* ...                                                                   */
/* Do not follow these rules ... I've tried and it does not work.        */
/*                                                                       */
/* Note 2:                                                               */
/*                                                                       */
/* In the SunOS' man page for "va_start()", they tell you to include the */
/* header file "sys/varargs.h". Don't do that because it is wrong. You   */
/* must include "stdarg.h" instead.                                      */
/*************************************************************************/

  #include <fcntl.h>

  #endif


  /*! \brief Size, in bytes, of the buffer used by copy_file_with_lock() for I/O operations.
   */

  #define COPY_IOBUFF_SIZE   4096

  /*! \brief Return value for the function my_logger(). This means that the argument 'buffer' is too small.
   */

  #define LOG_BUFFER_OVERFLOW  -1

  /*! \brief Return value for the function my_logger(). The function can not write to the file (which name is specified
             as first argument).
   */

  #define LOG_WRITE_ERROR      -2

  /*! \brief Return value for the function my_logger(). The function can not open the file (which name is specified
             as first argument).
   */

  #define LOG_OPEN_ERROR       -3

  /*! \brief Return value for the function my_logger(). The function can not close the file (which name is specified
             as first argument).
   */

  #define LOG_CLOSE_ERROR      -4

  /*! \brief Return value for the function my_logger(). The function can not lock the file (which name is specified
             as first argument).
   */

  #define LOG_LOCK_ERROR       -5

  /*! \brief Return value for the function my_logger(). The function succed. Everything is fine.
   */

  #define LOG_OK               -6

  /*! \brief Return value for the function copy_file_with_lock(). Can not open the source file.
   */

  #define COPY_SRC_OPEN_ERROR  -1

  /*! \brief Return value for the function copy_file_with_lock(). Can not open the destination file.
   */

  #define COPY_DST_OPEN_ERROR  -2

  /*! \brief Return value for the function copy_file_with_lock(). Lock on the destination file failed.
   */

  #define COPY_LOCK_ERROR      -3

  /*! \brief Return value for the function copy_file_with_lock(). Can not stat() the srouce file.
   */

  #define COPY_STAT_ERROR      -4

  /*! \brief Return value for the function copy_file_with_lock(). Error while reading the source file.
   */

  #define COPY_READ_ERROR      -5

  /*! \brief Return value for the function copy_file_with_lock(). Error while writing to the destination file.
   */

  #define COPY_WRITE_ERROR     -6

  /*! \brief Return value for the function copy_file_with_lock(). Error while unlocking the destinatination file.
   */

  #define COPY_UNLOCK_ERROR    -7

  /*! \brief Return value for the function copy_file_with_lock(). Error while closing the source file.
   */

  #define COPY_SRC_CLOSE_ERROR -8

  /*! \brief Return value for the function copy_file_with_lock(). Error while closing the destination file.
   */

  #define COPY_DST_CLOSE_ERROR -9

  /*! \brief Return value for the function copy_file_with_lock(). File successfully copied.
   */

  #define COPY_OK               0


  int lock_file(int fd);
  int unlock_file(int fd);
  int my_logger(char *file_name, char *buffer, int buffsize, char *format, ...);
  int append_file_with_lock (char *src, char *dst);

#define FLOCK_HD
#endif


#ifdef __cplusplus
}
#endif

hashfunc.h

list.h

/*! \file list.h
    Header file for list.c
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

  /* ----------------------------------------------------------------------- */
  /* Data structures                                                         */
  /* ----------------------------------------------------------------------- */

  /*! \brief This structure defines one element of the linked list.
   */

  typedef struct ListElmt_
  {
    /*! \brief Pointer to the element's data. */
    void  *donnee;

    /*! \brief Pointer to the next element in the linked list. */
    struct ListElmt_   *suivant;

    #ifdef DOUBLE_LINK

      /*! \brief Pointer to the previous element in the linked list. */ 
      struct ListElmt_   *precedent;

    #endif

  } ListElmt;

  /*! \brief This structure defines a linked list.
   */

  typedef struct List_
  {
    /*! \brief Number of elements in the linked list. */
    int    taille;
  
    /*! \brief Pointer to the user defined function used to compare two elements. */
    int    (*corresp)(const void *val1, const void *val2);

    /*! \brief Pointer on to the user defined function used to free the element's data memory. */
    void   (*detruire)(void *donnee);

    /*! \brief Pointer to the beginning of the linked list. */
    ListElmt   *tete;

    /*! \brief Pointer to the end of the linked list. */
    ListElmt   *queue;
  } List;

  /* ----------------------------------------------------------------------- */
  /* library's API                                                           */
  /* ----------------------------------------------------------------------- */

  void list_init(List *liste, void (*detruire)(void *donnee), int (*corresp)(const void *val1, const void *val2));

  void list_destroy(List *liste);

  int list_ins_next(List *liste, ListElmt *element, const void *donnee);

  int list_rem_next(List *liste, ListElmt *element, void **donnee);

  ListElmt* list_find (List *liste, ListElmt* from, void* data, ListElmt **prec);

  /* ----------------------------------------------------------------------- */
  /* Library's macros                                                        */
  /* ----------------------------------------------------------------------- */

  /*! \brief Return the number of elements in a linked list.
      \param liste Pointer to the list structure.
   */

  #define list_size(liste) ((liste)->taille)

  /*! \brief Return a pointer to the first element of the linked list.
      \param liste Pointer to the list structure.
   */

  #define list_head(liste) ((liste)->tete)

  /*! \brief Return a pointer to the last element of the linked list.
      \param liste Pointer to the list structure.
   */

  #define list_tail(liste) ((liste)->queue)

  /*! \brief Test if a given element is the first element of a linked list.
      \param liste Pointer to the list structure.
      \param element Pointer to the linked list element.
      \return This macro returns 1 if <i>element</i> point to the beginning of <i>liste</i>. Otherwise it returns 0.
   */

  #define list_is_head(liste, element)((element) == (liste)->tete ? 1 : 0)

  /*! \brief Test if a given element is the last element of a linked list.
      \param liste Pointer to the list structure.
      \param element Pointer to the linked list element.
      \return This macro returns 1 if <i>element</i> point to the end of <i>liste</i>. Otherwise it returns 0.
   */

  #define list_is_tail(element)((element)->suivant == NULL ? 1 : 0)

  /*! \brief Return a pointer to the data hold by an element.
      \param element Pointer to the linked list element.
      \return This macro returns a pointer to the data associted with <i>element</i>.
   */

  #define list_data(element) ((element)->donnee)

  /*! \brief Return a pointer to the next element in the linked list.
      \param element Pointer to the linked list element.
      \return This macro returns a pointer to the element next to <i>element</i>.
   */
 
  #define list_next(element) ((element)->suivant)

  #ifdef DOUBLE_LINK

    /*! \brief Return a pointer to the previous element in the linked list.
        \param element Pointer to the linked list element.
        \return This macro returns a pointer to the element previous to <i>element</i>.
     */

    #define list_prev(element) ((element)->precedent)
  #endif

#endif



#ifdef __cplusplus
}
#endif

my_dir.h

/*! \file my_dir.h
    Header file for dir.c.
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef DIR_HD

#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h>
#include <sys/stat.h>

#ifdef LINUX
#include <string.h>
#endif

#ifdef SUN
#include <strings.h>
#endif

  /*! \brief Maximum number of characters for a file name.
   */

  #define FILE_NUMBER 10

  /*! \brief Data structure used to store directory's entries.
   */

  struct file_list {
                     /*! \brief Array of zero terminated strings of characters. It contains all the directory's entries. */
                     char **list;

                     /*! \brief Total number of allocated strings in the array 'list'. */
                     int  total_alloc;

                     /*! \brief Number of entries in the directory (less ot equal to 'total_alloc') */
                     int  num;
                   }; 

  /*! \brief Return code for base_dir_name(): the function did not find the base name.
   */
  #define BASE_DIR_NOT_FOUND  0

  /*! \brief Return code for base_dir_name(): can not allocate memory.
   */
  #define BASE_DIR_NO_MEM     1

  /*! \brief Return code for base_dir_name(): the function found the base name.
   */
  #define BASE_DIR_FOUND      2


  int read_directory (char *dir_name, struct file_list *flist);
  int read_directory_only (char *dir_name, struct file_list *flist_out);
  void free_file_list(struct file_list *flist);
  int base_dir_name (char *dirname, char **res);

  #define DIR_HD
#endif

#ifdef __cplusplus
}
#endif

my_endian.h

my_math.h

my_sem.h

/*! \file my_sem.h
    Header file for sem.c.
 */


#ifdef __cplusplus
extern "C" {
#endif

#ifndef SEMAPHORES_HD

  #include <sys/types.h>
  #include <sys/ipc.h>
  #include <sys/sem.h>

  /* =========================================================================== */
  /* WARNING                                                                     */
  /*                                                                             */
  /* Under new version of Linux, the union 'semun' is NOT defined by default.    */
  /* See the file '/usr/include/bits/sem.h' for details: if the macro            */
  /* _SEM_SEMUN_UNDEFINED is defined, that you must define 'semun' yourself.     */
  /*                                                                             */
  /* Under Solaris, you must define the union 'semun'. Please look at the man    */
  /* page for semctl().                                                          */
  /* =========================================================================== */

  #ifdef LINUX
    #ifdef _SEM_SEMUN_UNDEFINED
      union semun
      {
        int val;                          
        struct semid_ds *buf;             
        unsigned short int *array;     
        struct seminfo *__buf;    
      };
    #endif
  #endif

  #ifdef SUN
    union semun
    {
      int             val;
      struct semid_ds *buf;
      ushort_t        *array;
    };
  #endif 


  /*! \brief This macro represents the default semaphore's premission (applied at creation time). This means that we grant
             all access rights (Read/Write/Execute) to the process' user. In binary, 0x1C0, is 111 000 000.
   */
  #define SEM_PERMISSION 0x000001C0

  /* ========================================================= */
  /* Return value for create_semaphore_set()                   */
  /* ========================================================= */

  /*! \brief Return value for the function create_semaphore_set(). The function was successful. */
  #define CREATE_SEMAPHORE_OK              0

  /*! \brief Return value for the function create_semaphore_set(). An error occured while creating the set of semaphores. */
  #define CREATE_SEMAPHORE_CREATE_ERROR   -1

  /*! \brief Return value for the function create_semaphore_set().  An error occured while setting the semaphores' values. */
  #define CREATE_SEMAPHORE_SET_VAL_ERROR  -2

  /* ========================================================= */
  /* return value for get_semaphore_set()                      */
  /* ========================================================= */

  /*! \brief Return value for the function get_semaphore_set(). The function was successful. */
  #define GET_SEM_OK                      0

  /*! \brief Return value for the function get_semaphore_set(). The process already got the set of semaphores. */
  #define GET_SEM_ALREADY_GET             -1

  /*! \brief Return value for the function get_semaphore_set(). An error occured while getting the set of semaphores. */
  #define GET_SEM_ERROR                   -2                   

  /* ========================================================= */
  /* Return value for set_semaphore_values()                   */
  /* ========================================================= */

  /*! \brief Return value for the function set_semaphore_values(). The function was successful. */
  #define SET_SEM_VALUES_OK                0

  /*! \brief Return value for the function set_semaphore_values(). The semaphore set was not created (or get). */
  #define SET_SEM_VALUES_SEM_NOT_CREATED  -1

  /*! \brief Return value for the function set_semaphore_values(). An error occured while setting the semaphores' values. */
  #define SET_SEM_VALUES_SET_ERROR        -2

  /* ========================================================= */
  /* API's description                                         */
  /* ========================================================= */

  void change_sem_access_permission(int new_permission);
  int create_semaphore_set (key_t ipc_key, int number_of_sem);
  int set_semaphore_values (int *values);
  int set_semaphore_value (int value, int sem_number);
  int take_sem (int sem_idx);
  int release_sem (int sem_idx);
  int destroy_semaphore_set();
  int get_semaphore_set();

#endif

#ifdef __cplusplus
}
#endif

my_shm.h

/*! \file my_shm.h
    Header file for shm.c.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef SHM_HD

  #include <sys/types.h>
  #include <sys/ipc.h>
  #include <sys/shm.h>


  #ifdef SUN
  #define SHM_addr    void*
  #endif

  #ifdef LINUX
  #define SHM_addr    char*
  #endif

  #ifndef SHM_addr
  #error "ERROR: You must specify a build target (LINUX or SUN)."
  #endif

  /*! \brief Define default permissions for all newly created SHM. It should ne read just like file permissions:
             0x1C0 = 111000000 in binary, that is 111 000 000. This gives all rights for the user and nothing for other 
             users.
   */

  #define SHM_PERMISSION 0x000001C0

  /* ============================================================= */
  /* Return value for the function create_shared_memory_segment()  */
  /* ============================================================= */

  /*! \brief Return value for the function create_shared_memory_segment(). This means that the SHM has been successfully 
             created.
   */
  #define CREATE_SHM_OK               -1

  /*! \brief Return value for the function create_shared_memory_segment(). This means that the SHM has already been created.
   */
  #define CREATE_SHM_ALREADY_CREATED  -2

  /*! \brief Return value for the function create_shared_memory_segment(). This means that an error occured while creating
             the shared memory segment.
   */
  #define CREATE_SHM_ERROR            -3

  /* ============================================================= */
  /* Return value for the function get_shared_memory_segment_id()  */
  /* ============================================================= */

  /*! \brief Return value for the function get_shared_memory_segment_sys_id(). This means that the SHM system identifier
             has been looked up successfully.
   */
  #define GET_SHM_OK                  -1

  /*! \brief Return value for the function get_shared_memory_segment_sys_id(). This means that the SHM system identifier
             jas already been looked up.
   */
  #define GET_SHM_ALREADY_GET         -2

  /*! \brief Return value for the function get_shared_memory_segment_sys_id(). This means that an error occured while
             getting the system's identifier.
   */
  #define GET_SHM_ERROR               -3 

  /* ============================================================= */
  /* Module's API                                                  */
  /* ============================================================= */

  void change_shm_access_permission (int new_permission);
  int create_shared_memory_segment (key_t ipc_key, int size);
  int get_shared_memory_segment_sys_id (key_t ipc_key, int size);
  int get_shared_memory_segment_id();
  SHM_addr attache_shared_memory_segment ();
  SHM_addr get_shm_address();
  int set_shm_auto_destroy();
  struct shmid_ds* get_shm_info();
  int detache_shm();

  #define SHM_HD

#endif

#ifdef __cplusplus
}
#endif

my_smtp.h

/*! \file my_smtp.h
    Header file for the smtp.c
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef MY_SMTP_HEADER

  #include "my_sockets.h"

  /* ------------------------------------------------- */
  /* Configuration values and data structures          */
  /* ------------------------------------------------- */

  /*! \brief Maximum number of characters for the client identification (HELO command).
   */

  #define SMTP_ID_SIZE        1034

  /*! \brief Maximum number of characters for an e-mail address.
   */

  #define SMTP_EMAIL_SIZE_MAX 1024

  /*! \brief Maximum number of recipients for a given mail.
   */

  #define SMTP_RCPT_MAX       128

  /*! \brief This structure defines the information used by the SMTP client to send an e-mail.
   */

  struct smtp_mail {
                      /*! \brief The e-mail address of the sender. */
                      char from[SMTP_EMAIL_SIZE_MAX];

                      /*! \brief The e-mail addresses of the recipients. */
                      char rcpt[SMTP_RCPT_MAX][SMTP_EMAIL_SIZE_MAX];

                      /*! \brief The number of recipients. */
                      int  rcpt_number;

                      /*! \brief Mail body to be sent. This must point to a zero terminated string of
                                 characters. */
                      char *data;
                   };

  /*! \brief Maximum number of characters for a host name.
   */

  #define SMTP_HOSTNAME_SIZE   512

  /*! \brief This structure defines the information used by the SMTP client to connect to the server.
   */

  struct smtp_connexion_config {
                                 /*! \brief The client identification (HELO command). */
                                 char id[SMTP_ID_SIZE];

                                 /*! \brief TCP port used to the server (default is 25). */
                                 int port;

                                 /*! \brief Host name of the server that runs the SMTP server. */
                                 char host[SMTP_HOSTNAME_SIZE];

                                 /*! \brief Connexion timeout in seconds. */
                                 long  connect_timeout_sec;

                                 /*! \brief Connexion timeout in micro seconds. */
                                 long connect_timeout_micro;

                                 /*! \brief Read timeout in seconds. */
                                 long  read_timeout_sec;

                                 /*! \brief Read timeout in micro seconds. */
                                 long  read_timeout_micro;
                               };

  /* ------------------------------------------------- */
  /* Data structure used to store the status of an     */
  /* operation.                                        */
  /* ------------------------------------------------- */

  /*! \brief This structure defines the information returned by all client SMTP functions.
   */

  struct smtp_res {
                    /*! \brief Error code. */
                    int  error_code;

                    /*! \brief Ellapsed time in milli-seconds. */
                    long ellapsed;
                  };

  /* ------------------------------------------------- */
  /* Data structure used to store information about    */
  /* the answer of a SMTP server.                      */
  /* ------------------------------------------------- */

  /*! \brief This structure contains the information included in the answer from a SMTP server.
   */

  struct smtp_response {
                         /* Not used yet, but defined for future improvement */
                       };

  /* ------------------------------------------------- */
  /* Library API                                       */
  /* ------------------------------------------------- */

  int client_smtp_connect (
                            struct smtp_connexion_config *conf,
                            struct smtp_res *result
                          );

  void smtp_disconnect();

  int smtp_send_email (
                        struct smtp_connexion_config  *conf,
                        struct smtp_mail              *email,
                        struct smtp_res               *result
                      );

  /* ------------------------------------------------- */
  /* Error codes                                       */
  /*                                                   */
  /*                  ### WARNING ###                  */
  /*                                                   */
  /* This library uses the library 'libmy_sockets.a'.  */
  /* The returned error codes for the SMTP library     */
  /* must be negative and lower that the lowest return */
  /* value for the library 'libmy_sockets.a' (see file */
  /* "my_sockets.h").                                  */
  /* ------------------------------------------------- */

  /*! \brief Return balues for all the SMTP API. This means that the system call write() failed.
   */

  #define SMTP_WRITE_ERROR         -100

  /*! \brief Return balues for all the SMTP API. This means that the response from the SMTP server was
             not valid.
   */

  #define SMTP_BAD_ANSWER          -101

  /*! \brief Return balues for the function smtp_send_email(). This means that one of the input arguments
             "from" or "rcpt" is too long.
   */

  #define   SMTP_BUFFER_OVERFLOW   -102

  /* ------------------------------------------------- */
  /* Internal buffer size used to receive/send data    */
  /* from/to the SMTP server.                          */
  /* ------------------------------------------------- */

  /*! \brief Size of the buffer used to receive/send data from/to the SMTP server.
   */

  #define SMTP_BUFFER_SIZE   1024

  /* ------------------------------------------------- */
  /* SMTP status returned by the SMTP server           */
  /* ------------------------------------------------- */

  /*! \brief Return value for the function response_parser(). The SMTP server returned "220 ...". */

  #define SMTP_SERVER_IDENTIFICATION_OK    220

  /*! \brief Return value for the function response_parser(). The SMTP server returned "250 ...". */

  #define SMTP_CLIENT_IDENTIFICATION_OK    250

  /*! \brief Return value for the function response_parser(). The SMTP server returned "250 ...". */

  #define SMTP_FROM_OK                     250

  /*! \brief Return value for the function response_parser(). The SMTP server returned "250 ...". */

  #define SMTP_RCPT_OK                     250

  /*! \brief Return value for the function response_parser(). The SMTP server returned "354 ...". */

  #define SMTP_DATA_OK                     354

  /*! \brief Return value for the function response_parser(). The SMTP server returned "250 ...". */

  #define SMTP_END_OF_DATA_OK              250

  /*! \brief Return value for the function response_parser(). The SMTP server an invalid response. */

  #define SMTP_INVALID_ANSWER              -1

  /* ------------------------------------------------- */
  /* Constants used to format output to the SMTP       */
  /* server.                                           */
  /* ------------------------------------------------- */

  #define SMTP_FROM_TAG_START    "MAIL FROM:<"
  #define SMTP_FROM_TAG_STOP     ">\r\n"

  #define SMTP_RCPT_TAG_START    "RCPT TO:<"
  #define SMTP_RCPT_TAG_STOP     ">\r\n"

  #define MY_SMTP_HEADER
#endif

#ifdef __cplusplus
}
#endif

my_sockets.h

/*! \file my_sockets.h
    Header file for sockets.c.
 */

#ifdef __cplusplus
extern "C" {
#endif 


#ifndef SOCKETS_H

  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netdb.h>
  #include <netinet/in.h>
  #include <sys/param.h>
  #include <arpa/inet.h>


  int open_tcp_connexion (struct sockaddr_in*, char*, int, long, long, unsigned long int*);
  void Get_Sock_Adress (char *Machine_serveur, int port_serveur, struct sockaddr_in *TCP_address);
  int read_from_socket (int sockfd, char *buffer, size_t buffer_size, size_t* extracted, long tt_sec, long tt_micro, unsigned long int* ellapsed_time);
  int read_all_socket (int sockfd, char** buffer, long tt_sec, long tt_micro, unsigned long int* ellapsed_time, unsigned long int* size);
  void get_ip_addr(struct sockaddr_in *Address_Sender, char *IP_Address, int *Port);

  /* ----------------------------------------------------------- */
  /* Buffer sizes                                                */
  /* ----------------------------------------------------------- */

  /*! \brief Initial number of bytes for the buffer used to read data from a socket.
   */
  #define SCK_BUFFER_INIT_SIZE           1024

  /*! \brief Number of characters for an IP address.
   */

  #define SCK_ADDR_LEN                   16 

  /* ----------------------------------------------------------- */
  /* Error codes for open_tcp_connexion()                        */
  /* ----------------------------------------------------------- */

  /*! \brief Return value for the function open_tcp_connexion(). This means that the process can not create a new socket
             (in other words, the system call socket() failed).
   */
  #define SCK_CREATE_ERROR		-1

  /*! \brief Return value for the function open_tcp_connexion(). This means that the process can not connect to the remote
             server. In other words, the function connect() failed.
   */
  #define SCK_CONNECT_ERROR		-2

  /*! \brief Return value for the function open_tcp_connexion(). This means that the process can not get the IP address of
      the host running the remote server. In other words, the function gethostbyname() failed.
   */
  #define SCK_GET_IP_ERROR		-3

  /*! \brief Return value for the function open_tcp_connexion(). This means that the system call connect() has been
      interrupted by a signal (it should be SIGALRM.
   */  
  #define SCK_TIMEOUT_CONNECT		-4

  /*! \brief Return value for the function open_tcp_connexion(). This means that there was a problem with the high precision timer (that
             raises the signal SIGALRM). This error should not happen.
   */
  #define SCK_TIMER_ERROR               -5

  /*! \brief Return value for the function open_tcp_connexion(). This means that there was a problem with the high precision chronometer
   */
  #define SCK_CHRONO_ERROR              -6

  /* ----------------------------------------------------------- */
  /* Error codes fro read_all_socket() and read_from_socket()    */
  /* ----------------------------------------------------------- */

  /*! \brief Return value for the function read_all_socket() and read_from_socket(). This means that the function was successful.
   */
  #define SCK_READ_OK                   -7

  /*! \brief Return value for the function read_all_socket(). This means that the function can not allocate memory to store the data read
             from the socket.
   */
  #define SCK_READ_NO_MEM               -8

  /*! \brief Return value for the function read_all_socket() and read_from_socket(). This means that the function failed on the read()
             system call.
   */
  #define SCK_READ_READ_ERROR           -9

  /*! \brief Return value for the function read_all_socket() and read_from_socket(). Read timeout!
   */
  #define SCK_READ_TIMEOUT              -10

  /*! \brief Return value for the function read_all_socket() and read_from_socket(). This means that there was a problem with the high
             precision chronometer.
   */
  #define SCK_READ_CHRONO_ERROR         -11

  /*! \brief Return value for the function read_all_socket() and read_from_socket(). This means that there was a problem with the high
             precision timer.
   */
  #define SCK_READ_TIMER_ERROR          -12

  #define SOCKETS_H


#endif /* SOCKETS_H */


#ifdef __cplusplus
}
#endif

option.h

/*! \file option.h
    This file defines data structures for the option reader.
 */


#ifdef __cplusplus
extern "C" {
#endif


#ifndef OPTION_H
#define OPTION_H
#endif

/*! \brief This data structure contains the definition for one option.
 */

typedef struct Option_
        {
          /*! \brief Pointer to a zero terminated string of characters that represents the option flag.
                     Please note that an option's flag should verify the following rules:
                     <UL>
                         <LI>At least 2 characters.
                         <LI>Begin with a '-'.
                         <LI>No spaces.
                         <LI>Not all '-'.
                     </UL>
          */
          char   *flag;

          /*! \brief This flag defines the number of argument required by the option. The option may require
                     zero (ex: --help) or one argument.
                     <UL>
                         <LI>If you set this argument to the value 0, it means that the option does not
                             require any arguemnt (ex: --help).
                         <LI>Any other value means that the option requires one (and only one) argument.
                     </UL>
          */
          int    arg;

          /*! \brief The tag defines the maximum number of characters for the option's argument.
          */
          int    max_size;

          /*! \brief Pointer to a zero terminated string of characters that represents the regular expression
                     that matches the option's argument.
          */
          char   *reg_exp;

          /*! \brief Address to a pointer that will receive the address of the sero terminated string of 
                     characters that represents en option's argument.
          */ 
          char   **pointer;

          /*! \brief Pointer to a zero terminated string of characters that contains a literal description of
                     the option.
          */
          char   *desc;
        } Option;

/*! \brief This data structure is used to store all option definitions for the process.
 */
typedef struct Option_set_
        {
          /*! \brief Pointer to an array of <I>Option</I> data structures that define all the process' options.
          */
          Option *opt;

          /*! \brief Number of elements in the array pointed by <I>opt</I>.
          */
          int    count;

          /*! \brief This integer represents the index (in the array of strings that represents the command
                     line) of the last item (option or argument) parsed. Following arguments start at index
                     <I>last_index</I> + 1.
          */
          int    last_index; 
        } Option_set;

int init_options (Option_set *opt);
int parse_command_line (char *argv[], int argc, Option_set *opt, char **err, char **flag, char **arg);
int get_argument (Option_set *opt, char *flag, char **arg);
int is_argument_required (Option_set *opt, char *flag);

/*! \brief Return the index (in the array of strings that represents the command ine) of the last item 
           (option or argument) parsed.
 */

#define last_argv_index(options)        (options.last_index)

#ifdef __cplusplus
}
#endif

replacer.h

sha.h

/*! \file sha.h
    Header file for sha.c.
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef SHA_H

/* SHA.H */
/* 
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is SHA 180-1 Header File
 * 
 * The Initial Developer of the Original Code is Paul Kocher of
 * Cryptography Research.  Portions created by Paul Kocher are 
 * Copyright (C) 1995-9 by Cryptography Research, Inc.  All
 * Rights Reserved.
 * 
 * Contributor(s):
 *
 *     Paul Kocher
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL"), in which case the provisions of the GPL are applicable 
 * instead of those above.  If you wish to allow use of your 
 * version of this file only under the terms of the GPL and not to
 * allow others to use your version of this file under the MPL,
 * indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by
 * the GPL.  If you do not delete the provisions above, a recipient
 * may use your version of this file under either the MPL or the
 * GPL.
 */

typedef struct {
  unsigned long H[5];
  unsigned long W[80];
  int lenW;
  unsigned long sizeHi,sizeLo;
} SHA_CTX;


void shaInit(SHA_CTX *ctx);
void shaUpdate(SHA_CTX *ctx, unsigned char *dataIn, int len);
void shaFinal(SHA_CTX *ctx, unsigned char hashout[20]);
void shaBlock(unsigned char *dataIn, int len, unsigned char hashout[20]);
void shahash_r(const char*, char [41]);


#define SHA_H
#endif

#ifdef __cplusplus
}
#endif

signals.h

sort.h

/*! \file sort.h
    Header file for qksort.c
 */

#ifndef SORT_HEADER

#ifdef __cplusplus
extern "C" {
#endif

int issort (
              void *donnee,
              int  nb_elts,
              int  taille_elt,
              int  (*compare)(const void *cle1, const void *cle2)
           );

int extended_issort (
                      void  *donnee,
                      int   nb_elts,
                      int   taille_elt,
                      int   (*compare)(const void *cle1, const void *cle2),
                      int   (*copy_data)(void *src, void *dest),
                      int   (*init_elem)(void *elm)
                    );

int qksort (
             void *donnee,
             int  nb_elts,
             int  taille_elt,
             int  i,
             int  k,
             int  (*compare)(const void *cle1, const void *cle2)
           );

int extended_qksort (
                      void  *donnee,
                      int   nb_elts,
                      int   taille_elt,
                      int   i,
                      int   k,
                      int   (*compare)(const void *cle1, const void *cle2),
                      int   (*copy_data)(void *src, void *dest),
                      int   (*init_elem)(void *elm)
                    );



#ifdef __cplusplus
}
#endif

#define SORT_HEADER
#endif

stack.h

/*! \file stack.h
    Header file for stack.c
 */

#ifndef STACK_H
#define STACK_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdlib.h>
#include "list.h"

/*! \brief A stack is implemented as a linked list.
 */

typedef List Stack;

/* ---------------------------------------------------------- */
/* Public API                                                 */
/* ---------------------------------------------------------- */

int stack_push(Stack *pile, const void *donnee);
int stack_pop(Stack *pile, void **donnee);

/*! \brief Initialize the stack. The prototype for this function is the same than for list_init().
           Please consult the documentation for the linked list API.
 */

#define stack_init list_init

/*! \brief Free all memory allocated for the stack. The prototype for this function is the same than for list_destroy().
           Please consult the documentation for the linked list API.
 */

#define stack_destroy list_destroy

/*! \brief Return a pointer to the element at the top of the list (the element is <B>NOT</B> extracted from the list).
    \param Pointer to a stack data structure.
 */

#define stack_peek(pile)\
        ((pile)->tete == NULL ? NULL : (pile)->tete->donnee)

/*! \brief Return the numder of element in the stack. This macro is identical to the macro <i>list_size</i> used for linked list.
           Please consult the documentation for the linked list API.
 */

#define stack_size list_size

#endif

#ifdef __cplusplus
}
#endif

strings_utils.h

/*! \file strings_utils.h
    Header file for strings_utils.c
 */

#ifdef __cplusplus
extern "C" {
#endif



#ifndef STRINGS_UTILS_HPP

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

/*! \brief This defines the minimum number of fields to allocate. 10 should ne enough.
 */

#define INITIAL_NUMBER_OF_FIELD 10

/*! \brief When a string is cut into fields, the fields are saved into a 'fields' structure.
 */

struct fields {
                /*! \brief Number of field extracted from the string. */
                int  number_of_fields;
                /*! \brief Number of allocated string. Please note that you can have 10 allocated fields, but only 7 are
                           actually used to put fields */
                int  size;
                /*! The field tabs points to an array of strings. Each string contains one field. */
                char **tabs;
              };

char *make_one_line (char *st);
int s_split(char *st, char* delimitor, struct fields *f);
int s_split_exact(char *st, char* delimitor, struct fields *f);
void free_fields (struct fields *fd);
char* get_end_of_string (char *src, char *dst, int nbcar);
char* IP2hex (char *src, char *dst, int nbcar);
char* post_chop(char *src);
char* pre_chop(char *src);
char* chop(char *src);
char* add_comment (char *src, char **dst);
char* get_config_value (char *buffer, char *delim);
char* replace_tag_by_integer (char* src, char *tag, int value);
unsigned int string2unsigned_int (char *st, int *error);
int string2int (char *st, int *error);
time_t string2time_t (char *st, int *error);
int is_integer (char *st);
int is_hexa (char *st);
int is_ip_address (char *st);
int ip_address_to_num (char *st, unsigned char *num);
int bin2hex (char *src, char *dst, int dst_size);
int bin2hex_binary (unsigned char *src, unsigned char *dst, int src_size, int dst_size);

#define STRINGS_UTILS_HPP
#endif


#ifdef __cplusplus
}
#endif

timing.h

/*! \file timing.h
    Header file for timing.c
 */

#ifdef __cplusplus
extern "C" {
#endif

#ifndef TIMING_HD

#include <sys/time.h>

  int start_chrono();
  int stop_chrono();
  unsigned long int get_ms(); 
  int set_one_shot_timer(long sec, long micro_second);
  int cancel_one_shot_timer();
  int pause_one_shot_timer();
  int restart_one_shot_timer();


/*! \brief Return value for the function set_one_shot_timer(). An error occured while setting the one shot timer.
 */
#define SET_ONE_SHOT_TIMER_ERROR        -1

/*! \brief Return value for the function set_one_shot_timer(). The one shot timer was successfully created.
 */
#define SET_ONE_SHOT_TIMER_OK           -2

/*! \brief Return value for the function cancel_one_shot_timer(). An error occured while canceling the one shot timer.
 */
#define CANCEL_ONE_SHOT_TIMER_ERROR     -3

/*! \brief Return value for the function cancel_one_shot_timer().  The one shot timer was successfully canceled.
 */
#define CANCEL_ONE_SHOT_TIMER_OK        -4

/*! \brief Return value for the function pause_one_shot_timer(). An error occured with the high precision timer.
 */
#define PAUSE_ONE_SHOT_TIMER_ERROR      -5

/*! \brief Return value for the function pause_one_shot_timer(). The one shot timer was successfully paused.
 */
#define PAUSE_ONE_SHOT_TIMER_OK         -6

/*! \brief Return value for the function restart_one_shot_timer(). An error occured with the high precision timer.
 */
#define RESTART_ONE_SHOT_TIMER_ERROR    -7

/*! \brief Return value for the function restart_one_shot_timer(). The one shot timer was successfully restarted.
 */
#define RESTART_ONE_SHOT_TIMER_OK       -8


#define TIMING_HD
#endif

#ifdef __cplusplus
}
#endif

Les sources

array.c

/*! \file array.c
    This file implements basic array manipulation tools.
 */


#include "array.h"
#include "sort.h"

/*! \brief Initialize an array handler.
    \param array Pointer to the array handler to initialize.
    \param first_element pointer to the first element of the array.
    \param size Size of the array (that is: the maximum number of elements in the array).
    \param copy_data User defined function used to copy data from/to the array.
                     Upon successful completion the function returns 0, otherwise it returns 1.
                     See the description of <i>struct s_array</i> for a complete description.
                     <FONT COLOR="#FF0000"><B>WARNING:</B></FONT> The function copy_data <B>MUST</B> take care off memory 
                     allocation/desallocation (if required).
    \param remove_data User defined function used to remove an element from the array.
                       Upon successful completion the function returns 0, otherwise it returns 1.
                       See the description of <i>struct s_array</i> for a complete description.
                       <i>remove_data</i> can be a NULL pointer if no special operation is required to remove an element.
    \param compare User defined function used to compare two elements of the array.
                   The function must return:
                   <UL>
                     <li>-1 if <i>d1 < d2</i>
                     <li>0  if <i>d1 = d2</i>
                     <li>+1 if <i>d1 > d2</i>
                     <li>-2 if an error occured.
                   </UL>
                   See the description of <i>struct s_array</i> for a complete description.
    \param index User defined function that returns a pointer to the element which index is <i>idx</i>.
                 See the description of <i>struct s_array</i> for a complete description.
    \param init_data User defined function used to initialize data. You can specify a NULL pointer if initialization is not required.
                     See the description of <i>struct s_array</i> for a complete description.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_init (
                  Array *array,
                  void  *first_element,
                  int   size,
                  int   (*copy_data)(void *src, void *dest),
                  int   (*remove_data)(void *target),
                  int   (*compare)(void *d1, void *d2),
                  void* (*index)(void *start, int idx),
                  int   (*init_data)(void *data)
               )
{
  array->first_element      = first_element;
  array->array_size         = size;
  array->number_of_elements = 0;
  array->copy_data          = copy_data;
  array->remove_data        = remove_data;
  array->compare            = compare;
  array->index              = index;
  array->init_data          = init_data;
  array->element_to_remove  = 0;
  array->to_remove          = (int*)malloc(array->array_size * sizeof(int));

  if (array->to_remove == NULL) { return -1; }

  return 0;
}

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Free all memory allocated for the array structure.
    \warning This function <B>DOES NOT</B> free memory allocated for the user's data (this is the responsability of the user).
 */

void array_free (Array *array) { free(array->to_remove); return; }

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Schedule an element of the array for removing.
    \param array Pointer to an array data structure.
    \param idx Index of the element to remove.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_schedule_for_rem (Array *array, int idx)
{
  int i;

  /* ------------------------------------------------- */
  /* First make sure that this index is not already    */
  /* scheduled.                                        */
  /* ------------------------------------------------- */

  for (i=0; i<array->element_to_remove; i++)
  { if (array->to_remove[i] == idx) { return 0; } }

  /* ------------------------------------------------- */
  /* Then, make sure that we can add an element to     */
  /* the list of elements to remove.                   */
  /* ------------------------------------------------- */

  if (array->element_to_remove >= array->array_size) { return -1; }

  /* ------------------------------------------------- */
  /* Add the index to the list of index to remove      */
  /* ------------------------------------------------- */

  array->to_remove[array->element_to_remove] = idx;

  /* ------------------------------------------------- */
  /* Increment the number of index to remove and exit  */
  /* ------------------------------------------------- */

  array->element_to_remove += 1;

  return 0;
}

/*! \example test_array.c
    This program shows how to use the array API
 */


/* ------------------------------------------------------------ */
/* Compare two integers -- Not part of public API               */
/* ------------------------------------------------------------ */

static int compare_int(const void *int1, const void *int2)
{
  if (*(const int *)int1 > *(const int *)int2) { return 1; }
  if (*(const int *)int1 < *(const int *)int2) { return -1; }
  return 0;
}

/*! \brief Remove a list of previouly scheduled element.
    \param array Pointer to an array data structure.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_rem_all (Array *array)
{
  int i;

  /* ------------------------------------------------- */
  /* Is there something to remove ?                    */
  /* ------------------------------------------------- */

  if (array->element_to_remove == 0) { return 0; }

  /* ------------------------------------------------- */
  /* Sort the idexes of the elements to remove         */
  /* ------------------------------------------------- */

  issort((void*)array->to_remove, array->element_to_remove, sizeof(int), compare_int);

  /* ------------------------------------------------- */
  /* Modify indexes, so we take care of the left shift */
  /* ------------------------------------------------- */

  for (i=0; i<array->element_to_remove; i++) { array->to_remove[i] -= i; }

  /* ------------------------------------------------- */
  /* Now remove the elements                           */
  /* ------------------------------------------------- */
  
  for (i=0; i<array->element_to_remove; i++)
  { if (array_rem(array, array->to_remove[i]) == -1) { return -1; } }

  /* ------------------------------------------------- */
  /* Reset the number of element to remove             */
  /* ------------------------------------------------- */

  array->element_to_remove = 0;

  return 0;
}

/*! \brief Initialize all elements of an array.
    \param array Pointer to an array data structure.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
    \warning Depending on what you put in the function <i>init_data()</i>, you may call this function one or more times.
 */

int array_init_element (Array *array)
{
  void *location;
  int  i;

  for (i=0; i<array->array_size; i++)
  {
    location = array->index(array->first_element, i);
    if (array->init_data(location) == 1) { return -1; }
  }

  return 0;
}

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Add an element to the array (the element id added after the last element).
    \param array Pointer to the array handler to initialize.
    \param element Pointer to the element to add to the array.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_add (
                Array *array,
                void  *element
              )
{
  void *location;

  /* ------------------------------------------------- */
  /* First, make sure that we can add an element       */
  /* ------------------------------------------------- */

  if (array->number_of_elements >= array->array_size) { return -1; }

  /* ------------------------------------------------- */
  /* Get a pointer to the first available location     */
  /* (That is, the end of the array)                   */
  /* Indexes start at 0. The index of the Nth element  */
  /* is N-1.                                           */
  /* ------------------------------------------------- */

  location = array->index(array->first_element, array->number_of_elements);

  /* ------------------------------------------------- */
  /* Copy the element to the available location        */
  /* ------------------------------------------------- */

  if (array->copy_data (element, location) == 1) { return -1; }
  
  /* ------------------------------------------------- */
  /* Increment the number of elements and exit         */ 
  /* ------------------------------------------------- */

  array->number_of_elements += 1;

  return 0;

}

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Remove an element from an array. The elements next to the one removed are shifted to the left (so there is no gaps, and the
           elements' order does not change).
    \param array Pointer to the array handler to initialize.
    \param idx Index of the element to remove.
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_rem (
                Array *array,
                int   idx
              )
{
  void *location, *src, *dst;
  int  i;

  /* ------------------------------------------------- */
  /* First, make sure that 'idx' is not out of the     */
  /* array. Indexes start at 0. The index of the Nth   */
  /* element is N-1                                    */
  /* ------------------------------------------------- */

  if (idx > array->number_of_elements-1) { return -1; }

  /* ------------------------------------------------- */
  /* Get a pointer to the location pointed by 'idx'    */
  /* ------------------------------------------------- */

  location = array->index(array->first_element, idx);

  /* ------------------------------------------------- */
  /* Remove the element and shift the next elements    */
  /* ------------------------------------------------- */

  if (array->remove_data != NULL)
  { if (array->remove_data(location) == 1) { return -1; } }

  /* ------------------------------------------------- */
  /* Now, the difficult part: shift all the elements   */
  /* ------------------------------------------------- */

  for (i=idx; i<array->number_of_elements-1; i++)
  {
    dst = array->index(array->first_element, i);
    src = array->index(array->first_element, i+1);

    if (array->copy_data (src, dst) == 1) { return -1; }
  }

  /* ------------------------------------------------- */
  /* Remove the last element. Keep in mind that the    */
  /* function 'copy_data' doest not remove the source  */
  /* ------------------------------------------------- */

  if (array->remove_data != NULL)
  {
    location = array->index(array->first_element, array->number_of_elements-1);
    if (array->remove_data(location) == 1) { return -1; }
  }

  /* ------------------------------------------------- */
  /* Decrement the number of element in the array and  */
  /* exit                                              */
  /* ------------------------------------------------- */

  array->number_of_elements -= 1;

  return 0;
}

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Insert an element in an array.
    \param array Pointer to an array data structure.
    \param idx Index in the array where to insert the new elememt.
    \param data Pointer to a user defined data (that represents the content of the new element).
    \return Upon successful completion the function returns 0, otherwise it returns -1.
 */

int array_insert (
                   Array *array,
                   int   idx,
                   void  *data
                 )
{

  void *src, *dst, *location;
  int  i;

  /* ------------------------------------------------- */
  /* First, make sure that we can add an element       */
  /* ------------------------------------------------- */

  if (array->number_of_elements >= array->array_size) { return -1; }

  /* ------------------------------------------------- */
  /* The make shure that 'idx' is a valid position     */
  /* Note: the index of the last element is            */
  /*       (array->number_of_elements - 1)             */
  /* ------------------------------------------------- */

  if (idx >= array->number_of_elements) { return -1; } 

  /* ------------------------------------------------- */
  /* Shift all elements which index is greater that    */
  /* 'idx' to the right.                               */
  /* ------------------------------------------------- */

  for (i=array->number_of_elements; i>idx; i--)
  {
    src = array->index(array->first_element, i-1);
    dst = array->index(array->first_element, i);

    if (array->copy_data (src, dst) == 1) { return -1; }
  }

  /* ------------------------------------------------- */
  /* Now copy 'data' at index 'idx'.                   */
  /* ------------------------------------------------- */

  location = array->index(array->first_element, idx);
  if (array->copy_data (data, location) == 1) { return -1; }

  /* ------------------------------------------------- */
  /* Increment the number of elements and exit         */
  /* ------------------------------------------------- */

  array->number_of_elements += 1;

  return 0;
}

/*! \example test_array.c
    This program shows how to use the array API
 */

/*! \brief Find an given element in the array.
    \param array Pointer to the array data structure.
    \param data Pointer to the user defined element to find.
    \return If the element is found, then the function returns the index of the element. Otherwise the function
            returns -1.
 */

int array_find (
                   Array *array,
                   void  *data
               )
{
  int  idx;
  void *location;

  for (idx=0; idx<array->number_of_elements; idx++)
  {
    location = array->index(array->first_element, idx);
    if (array->compare(location, data) == 0) { return idx; }
  }

  return -1;
}

/*! \example test_array.c
    This program shows how to use the array API
 */

cgi.c

/*! \file cgi.c
    This file contains utilities for CGIs.
 */


#include <stdlib.h>
#include <stdio.h>
#include <strings.h>


/*! \brief Extract the login and the domain from a given email address (login@domain).
    \param address Pointer to a zero terminated string of characters that represents the email address.
    \param login Pointer to a memory location that will be used to store a zero terminated string of characters
                 that is the login.
    \param domain Pointer to a memory location that will be used to store a zero terminated string of characters
                  that is the domain.
    \return Upon successful completion, the function returns the value 0. Otherwise the function returns 1, this
            means that the given address does not contain any character '@'.
    \warning No test is done regarding the size of the memory chuncks pointed by login and domain. It is your
             responsability to allocate enough memory.
 */

int get_domain (char *address, char *login, char *domain)
{
  char *pt, c;

  pt = strstr(address, "@");
  if (pt == NULL) { return 1; }

  c = *pt;

  strcpy (domain, pt+1);

  *pt = 0;

  strcpy (login, address);

  *pt = c;

  return 0;
}

/*! \brief URL encode a string of characters.
    \param string Pointer to a zero terminated string that contains the string to encode.
    \return The function returns a pointer to the URL encoded string. If an error occured, then the function
            returns NULL.
    \warning Note that the returned string has been allocated by the function. Therefore you must free the memory.
 */ 

char* url_escape(char *string)
{
   int            alloc;
   char           *ns;
   unsigned char  in;
   int            newlen;
   int            index;



   newlen = alloc = strlen(string)+1;
   ns = (char*) malloc((size_t)alloc);
   if (ns == NULL) { return NULL; }
   index = 0;

   while((*string) != 0)
   {
      in = *string;
      if(' ' == in) { ns[index++] = '+'; }
      else if(!(in >= 'a' && in <= 'z') &&
              !(in >= 'A' && in <= 'Z') &&
              !(in >= '0' && in <= '9'))
           {
             /****************************************************/
             /* encode it:                                       */
             /* the size grows with two, since this'll become a  */
             /* %XX.                                             */
             /****************************************************/
	         
	         newlen += 2;
	         
	         if(newlen > alloc)
	         {
	           alloc *= 2;
	           ns = realloc(ns, alloc);
	           if (ns == NULL) { return NULL; }
	         }
	         
	         sprintf(&ns[index], "%%%02X", in);
	         index+=3;
           }
           else
           { ns[index++]=in; }

           string++;
   }
 
   ns[index]=0;
   return ns;
}

/*! \example test_url_encoding.c
    This file shows how to use the function url_escape().
 */

/*! \brief URL decode a string of characters.
    \param string Pointer to a zero terminated string that contains the string to decode.
    \param length number of character to decode (should be the size of the string).
    \return The function returns a pointer to the URL decoded string. If an error occured, then the function
            returns NULL.
    \warning Note that the returned string has been allocated by the function. Therefore you must free the memory.             */

char* url_unescape(char *string, int length)
{
   int alloc; 
   char *ns;
   unsigned char in;
   int index;
   int hex;
   char querypart;       /* everything to the right of a '?' letter is
                            the "query part" where '+' should become ' '.
                            RFC 2316, section 3.10 */

   alloc = (length?length:strlen(string))+1;
   ns = malloc(alloc);
   if (ns == NULL) { return NULL; }
   index = 0;
   querypart = 0;
  
   while(--alloc > 0)
   {
      in = *string;
      if ((querypart == 1) && ('+' == in)) { in = ' '; }
      else if ((querypart == 0) && ('?' == in))
      {
        /* we have "walked in" to the query part */
        querypart = 1;
      }
      else if('%' == in)
           {
             /* encoded part */
             if(sscanf(string+1, "%02X", &hex))
             {
               in = hex;
               string+=2;
               alloc-=2;
             }
           }

      ns[index++] = in;
      string++;
   }
   
   ns[index]=0; /* terminate it */
   return ns;
}  

/*! \example test_url_encoding.c
    This file shows how to use the function url_unescape().
 */

char2hex.c

int char2hex[256] = {
                      -1, /* 0 (-) */
                      -1, /* 1 (-) */
                      -1, /* 2 (-) */
                      -1, /* 3 (-) */
                      -1, /* 4 (-) */
                      -1, /* 5 (-) */
                      -1, /* 6 (-) */
                      -1, /* 7 (-) */
                      -1, /* 8 (-) */
                      -1, /* 9 (-) */
                      -1, /* 10 (-) */
                      -1, /* 11 (-) */
                      -1, /* 12 (-) */
                      -1, /* 13 (-) */
                      -1, /* 14 (-) */
                      -1, /* 15 (-) */
                      -1, /* 16 (-) */
                      -1, /* 17 (-) */
                      -1, /* 18 (-) */
                      -1, /* 19 (-) */
                      -1, /* 20 (-) */
                      -1, /* 21 (-) */
                      -1, /* 22 (-) */
                      -1, /* 23 (-) */
                      -1, /* 24 (-) */
                      -1, /* 25 (-) */
                      -1, /* 26 (-) */
                      -1, /* 27 (-) */
                      -1, /* 28 (-) */
                      -1, /* 29 (-) */
                      -1, /* 30 (-) */
                      -1, /* 31 (-) */
                      -1, /* 32 (-) */
                      -1, /* 33 (-) */
                      -1, /* 34 (-) */
                      -1, /* 35 (-) */
                      -1, /* 36 (-) */
                      -1, /* 37 (-) */
                      -1, /* 38 (-) */
                      -1, /* 39 (-) */
                      -1, /* 40 (-) */
                      -1, /* 41 (-) */
                      -1, /* 42 (-) */
                      -1, /* 43 (-) */
                      -1, /* 44 (-) */
                      -1, /* 45 (-) */
                      -1, /* 46 (-) */
                      -1, /* 47 (-) */
                      0, /* 48 (0) */
                      1, /* 49 (1) */
                      2, /* 50 (2) */
                      3, /* 51 (3) */
                      4, /* 52 (4) */
                      5, /* 53 (5) */
                      6, /* 54 (6) */
                      7, /* 55 (7) */
                      8, /* 56 (8) */
                      9, /* 57 (9) */
                      -1, /* 58 (-) */
                      -1, /* 59 (-) */
                      -1, /* 60 (-) */
                      -1, /* 61 (-) */
                      -1, /* 62 (-) */
                      -1, /* 63 (-) */
                      -1, /* 64 (-) */
                      10, /* 65 (A) */
                      11, /* 66 (B) */
                      12, /* 67 (C) */
                      13, /* 68 (D) */
                      14, /* 69 (E) */
                      15, /* 70 (F) */
                      -1, /* 71 (-) */
                      -1, /* 72 (-) */
                      -1, /* 73 (-) */
                      -1, /* 74 (-) */
                      -1, /* 75 (-) */
                      -1, /* 76 (-) */
                      -1, /* 77 (-) */
                      -1, /* 78 (-) */
                      -1, /* 79 (-) */
                      -1, /* 80 (-) */
                      -1, /* 81 (-) */
                      -1, /* 82 (-) */
                      -1, /* 83 (-) */
                      -1, /* 84 (-) */
                      -1, /* 85 (-) */
                      -1, /* 86 (-) */
                      -1, /* 87 (-) */
                      -1, /* 88 (-) */
                      -1, /* 89 (-) */
                      -1, /* 90 (-) */
                      -1, /* 91 (-) */
                      -1, /* 92 (-) */
                      -1, /* 93 (-) */
                      -1, /* 94 (-) */
                      -1, /* 95 (-) */
                      -1, /* 96 (-) */
                      10, /* 97 (a) */
                      11, /* 98 (b) */
                      12, /* 99 (c) */
                      13, /* 100 (d) */
                      14, /* 101 (e) */
                      15, /* 102 (f) */
                      -1, /* 103 (-) */
                      -1, /* 104 (-) */
                      -1, /* 105 (-) */
                      -1, /* 106 (-) */
                      -1, /* 107 (-) */
                      -1, /* 108 (-) */
                      -1, /* 109 (-) */
                      -1, /* 110 (-) */
                      -1, /* 111 (-) */
                      -1, /* 112 (-) */
                      -1, /* 113 (-) */
                      -1, /* 114 (-) */
                      -1, /* 115 (-) */
                      -1, /* 116 (-) */
                      -1, /* 117 (-) */
                      -1, /* 118 (-) */
                      -1, /* 119 (-) */
                      -1, /* 120 (-) */
                      -1, /* 121 (-) */
                      -1, /* 122 (-) */
                      -1, /* 123 (-) */
                      -1, /* 124 (-) */
                      -1, /* 125 (-) */
                      -1, /* 126 (-) */
                      -1, /* 127 (-) */
                      -1, /* 128 (-) */
                      -1, /* 129 (-) */
                      -1, /* 130 (-) */
                      -1, /* 131 (-) */
                      -1, /* 132 (-) */
                      -1, /* 133 (-) */
                      -1, /* 134 (-) */
                      -1, /* 135 (-) */
                      -1, /* 136 (-) */
                      -1, /* 137 (-) */
                      -1, /* 138 (-) */
                      -1, /* 139 (-) */
                      -1, /* 140 (-) */
                      -1, /* 141 (-) */
                      -1, /* 142 (-) */
                      -1, /* 143 (-) */
                      -1, /* 144 (-) */
                      -1, /* 145 (-) */
                      -1, /* 146 (-) */
                      -1, /* 147 (-) */
                      -1, /* 148 (-) */
                      -1, /* 149 (-) */
                      -1, /* 150 (-) */
                      -1, /* 151 (-) */
                      -1, /* 152 (-) */
                      -1, /* 153 (-) */
                      -1, /* 154 (-) */
                      -1, /* 155 (-) */
                      -1, /* 156 (-) */
                      -1, /* 157 (-) */
                      -1, /* 158 (-) */
                      -1, /* 159 (-) */
                      -1, /* 160 (-) */
                      -1, /* 161 (-) */
                      -1, /* 162 (-) */
                      -1, /* 163 (-) */
                      -1, /* 164 (-) */
                      -1, /* 165 (-) */
                      -1, /* 166 (-) */
                      -1, /* 167 (-) */
                      -1, /* 168 (-) */
                      -1, /* 169 (-) */
                      -1, /* 170 (-) */
                      -1, /* 171 (-) */
                      -1, /* 172 (-) */
                      -1, /* 173 (-) */
                      -1, /* 174 (-) */
                      -1, /* 175 (-) */
                      -1, /* 176 (-) */
                      -1, /* 177 (-) */
                      -1, /* 178 (-) */
                      -1, /* 179 (-) */
                      -1, /* 180 (-) */
                      -1, /* 181 (-) */
                      -1, /* 182 (-) */
                      -1, /* 183 (-) */
                      -1, /* 184 (-) */
                      -1, /* 185 (-) */
                      -1, /* 186 (-) */
                      -1, /* 187 (-) */
                      -1, /* 188 (-) */
                      -1, /* 189 (-) */
                      -1, /* 190 (-) */
                      -1, /* 191 (-) */
                      -1, /* 192 (-) */
                      -1, /* 193 (-) */
                      -1, /* 194 (-) */
                      -1, /* 195 (-) */
                      -1, /* 196 (-) */
                      -1, /* 197 (-) */
                      -1, /* 198 (-) */
                      -1, /* 199 (-) */
                      -1, /* 200 (-) */
                      -1, /* 201 (-) */
                      -1, /* 202 (-) */
                      -1, /* 203 (-) */
                      -1, /* 204 (-) */
                      -1, /* 205 (-) */
                      -1, /* 206 (-) */
                      -1, /* 207 (-) */
                      -1, /* 208 (-) */
                      -1, /* 209 (-) */
                      -1, /* 210 (-) */
                      -1, /* 211 (-) */
                      -1, /* 212 (-) */
                      -1, /* 213 (-) */
                      -1, /* 214 (-) */
                      -1, /* 215 (-) */
                      -1, /* 216 (-) */
                      -1, /* 217 (-) */
                      -1, /* 218 (-) */
                      -1, /* 219 (-) */
                      -1, /* 220 (-) */
                      -1, /* 221 (-) */
                      -1, /* 222 (-) */
                      -1, /* 223 (-) */
                      -1, /* 224 (-) */
                      -1, /* 225 (-) */
                      -1, /* 226 (-) */
                      -1, /* 227 (-) */
                      -1, /* 228 (-) */
                      -1, /* 229 (-) */
                      -1, /* 230 (-) */
                      -1, /* 231 (-) */
                      -1, /* 232 (-) */
                      -1, /* 233 (-) */
                      -1, /* 234 (-) */
                      -1, /* 235 (-) */
                      -1, /* 236 (-) */
                      -1, /* 237 (-) */
                      -1, /* 238 (-) */
                      -1, /* 239 (-) */
                      -1, /* 240 (-) */
                      -1, /* 241 (-) */
                      -1, /* 242 (-) */
                      -1, /* 243 (-) */
                      -1, /* 244 (-) */
                      -1, /* 245 (-) */
                      -1, /* 246 (-) */
                      -1, /* 247 (-) */
                      -1, /* 248 (-) */
                      -1, /* 249 (-) */
                      -1, /* 250 (-) */
                      -1, /* 251 (-) */
                      -1, /* 252 (-) */
                      -1, /* 253 (-) */
                      -1, /* 254 (-) */
                      -1  /* 255 (-) */
                    };

chtbl.c

/*! \file chtbl.c
    Hash table implementation
 */

#include <stdlib.h>
#include <string.h>
#include "list.h"
#include "chtbl.h"



/*! \brief Initialize the hash table. This function must be called first.
    \param htab Pointer to a hash table data structure.
    \param conteneurs Number of linked list in the hash table.
    \param h Pointer to the function used to hash the input key.
    \param corresp Pointer to the function used to compare user's defined data. This function is specific to the type of data stored into
                   the hash table. This function must return if the user defined data are identical, 0 otherwise.
    \param detruire Pointer to the function used to free all allocated memory for the user's defined data. This function is specific to the
                    type of data stored into the hash table.
    \return Upon successful completion the function returns 0, otherwise the function returns 1.
 */

int chtbl_init(
                CHTbl *htab,
                int   conteneurs, 
                int   (*h)(const void *cle), 
                int   (*corresp)(const void *cle1, const void *cle2), 
                void  (*detruire)(void *donnee)
              )
{
  int  i;

  /* ------------------------------------------------------------------------- */
  /* Allocate linked lists for hash table                                      */
  /* ------------------------------------------------------------------------- */

  if ((htab->table = (List *)malloc(conteneurs * sizeof(List))) == NULL) { return -1; }

  /* ------------------------------------------------------------------------- */
  /* Initialize the linked lists                                               */
  /* ------------------------------------------------------------------------- */

  htab->conteneurs = conteneurs;
  for (i = 0; i < htab->conteneurs; i++) { list_init(&htab->table[i], detruire, corresp); }

  /* ------------------------------------------------------------------------- */
  /* Initialize the hash table                                                 */
  /* ------------------------------------------------------------------------- */

  htab->h = h;
  htab->corresp = corresp;
  htab->detruire = detruire;
  htab->taille = 0;

  return 0;
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Free all memory allocated for the hash table.
    \param htab Pointer to the hash table data structure to destroy.
 */

void chtbl_destroy(CHTbl *htab)
{
  int                i;
 
  /* ------------------------------------------------------------------------- */
  /* Delete all linked list                                                    */
  /* ------------------------------------------------------------------------- */

  for (i = 0; i < htab->conteneurs; i++) { list_destroy(&htab->table[i]); }

  /* ------------------------------------------------------------------------- */
  /* Free all memory used by the hash table data structure                     */
  /* ------------------------------------------------------------------------- */

  free(htab->table);

  /* ------------------------------------------------------------------------- */
  /* Clean up the structure (just to look better)                              */
  /* ------------------------------------------------------------------------- */

  memset(htab, 0, sizeof(CHTbl));

  return;
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Insert data into the hash table.
    \param htab Pointer to the hash table data structure.
    \param donnee Pointer to the user defined data to insert.
    \return The function may return one of the following value:
            <UL>
              <li>0: The data was not in the hash table and it has been successfuly inserted.
              <li>1: The data already was in the hash table (this is not an error).
              <li>-1: An error occured (this means that the program is running out of memory).
            </UL>
    \warning Data are <B>NOT</B> copied into the hash table. The hash table only contains pointers to user's data. Therefore you should
             not free the memory allocated fot the data yourself.
 */

int chtbl_insert(CHTbl *htab, const void *donnee)
{
  void *temp;
  int   conteneur, retval;

  /* ------------------------------------------------------------------------- */
  /* Make sure that the data is not already into the hash table                */
  /* ------------------------------------------------------------------------- */

  temp = (void *)donnee;
  if (chtbl_lookup(htab, &temp) == 0) { return 1; }

  /* ------------------------------------------------------------------------- */
  /* Hash the input key                                                        */
  /* ------------------------------------------------------------------------- */

  conteneur = htab->h(donnee) % htab->conteneurs;

  /* ------------------------------------------------------------------------- */
  /* Insert data into the hash table                                           */
  /* ------------------------------------------------------------------------- */

  if ((retval = list_ins_next(&htab->table[conteneur], NULL, donnee)) == 0)
  { htab->taille++; }

  return retval;
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Remove a record from the hash table.
    \param htab Pointer to a hash table data structure.
    \param donnee Pointer to a data structure pointer that will point to the data of the element that have been removed. Keep in mind that
                  the user data is <B>NOT</B> freed by the function chtbl_remove(). You must free it yourself.
    \return Upon successful completion the function returns 0, otherwise the function returns -1. Please note that the return value -1
            is not really an error. It really means that the data was not found in the hash table.
    \warning You must keep in mind that the data section of the removed element is <B>NOT</B> freed by the function. A pointer to the
             data section is returned (via <i>donnee</i>). This allows you to free it yourself.
 */

int chtbl_remove(CHTbl *htab, void **donnee)
{
  ListElmt           *element, *prec;
  int                conteneur;

  /* ------------------------------------------------------------------------- */
  /* Hash the input key                                                        */
  /* ------------------------------------------------------------------------- */

  conteneur = htab->h(*donnee) % htab->conteneurs;

  /* ------------------------------------------------------------------------- */
  /* Search the linked list for the data                                       */
  /* ------------------------------------------------------------------------- */

  element = list_find (&htab->table[conteneur], NULL, *donnee, &prec); 
  if (element != NULL)
  {
    /* ----------------------------------------------------------------------- */
    /* Data found, remove it                                                   */
    /* Note that 'prec' could be NULL, but that's OK.                          */
    /* ----------------------------------------------------------------------- */

    if (list_rem_next(&htab->table[conteneur], prec, donnee) == 0)
    {
      htab->taille--;
      return 0;
    }
  }

  /* ------------------------------------------------------------------------- */
  /* The data was not found                                                    */
  /* ------------------------------------------------------------------------- */

  return -1;

}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Searh the hash table for a given data.
    \param htab Pointer to a hash table structure.
    \param donnee Pointer to a user defined data. This pointer will be used:
                  <UL>
                     <li>To specify the data to search for.
                     <li>To point to the element's data (that has been found).
                  </UL>
    \return If the element was in the hash table, that the function returns 0 and <i>donnee</i> points to the element's data. Otherwise, 
            the function return -1.
 */

int chtbl_lookup(const CHTbl *htab, void **donnee)
{
  ListElmt           *element;
  int                conteneur;
 
  /* ------------------------------------------------------------------------- */
  /* Hash the input key                                                        */
  /* ------------------------------------------------------------------------- */

  conteneur = htab->h(*donnee) % htab->conteneurs;

  /* ------------------------------------------------------------------------- */
  /* Search for the jey in the linked list                                     */
  /* ------------------------------------------------------------------------- */

  for (element = list_head(&htab->table[conteneur]); element != NULL; element = list_next(element))
  {
    if (htab->corresp(*donnee, list_data(element)))
    {
      /* --------------------------------------------------------------------- */
      /* The record has been found                                             */
      /* Assign 'donnee' to the element's data.                                */
      /* --------------------------------------------------------------------- */

      *donnee = list_data(element);
      return 0;
    }
  }

  /* ------------------------------------------------------------------------- */
  /* The data was not found                                                    */
  /* ------------------------------------------------------------------------- */

  return -1;
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Cover the entire hash table in search for an given element.
    \param htab Pointer to a hash table structure.
    \param donnee Pointer to a user defined data. This pointer will be used:
                  <UL>
                     <li>To specify the data to search for.
                     <li>To point to the element's data (that has been found).
                  </UL>
    \return If the element was in the hash table, that the function returns 0 and <i>donnee</i> points to the element's data. Otherwise, the function return -1.
    \warning This function lookup compare each element in the hash table with a given element (<i>donnee</i>).
             It may take long ... do not use it if you don't have to!
 */

int chtbl_find (const CHTbl *htab, void **donnee)
{
  int       ht;
  List      *linked_list;
  ListElmt  *element;

  /* ------------------------------------------------------------------------- */
  /* For each linked list, look for the data                                   */
  /* ------------------------------------------------------------------------- */

  for (ht=0; ht<htab->conteneurs; ht++)
  {
    linked_list = &(htab->table[ht]);
    element     = list_head (linked_list);

    while (element != NULL)
    {
      if (htab->corresp(list_data(element), *donnee))
      {
        *donnee = list_data(element);
        return 0;
      }
      element = list_next(element);
    }
  }

  return -1;
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

/*! \brief Returns the next element of a given linked list.
    \param htab Pointer to a hash table structure.
    \param rewind Flag used to set the hash pointer to the first element of the hash. The value of this
                  parameter can be:
                  <UL>
                     <LI>REWIND_HASH: Set the hash pointer to the first element of the hash. 
                     <LI>CURRENT_HASH: Set the hash pointer to the current element in the hash. 
                  </UL>
    \return The function returns a pointer to the current element in the hash, or NULL if the current element
            is the last one.
    \warning Each time you call the function, it returns the next element in the hash (until the last one where
             the function returns NULL).
             <UL>
                <LI>When you <B>start walking</B> through a hash table, you <B>must</B> set the parameter
                    <I>rewind</I> to the value REWIND_HASH !. If you don't do that, the baheviour of the function
                    is unpredictable. You may generate a segmentation fault.
                <LI>Do <B>NOT</B> modify (add or remove elements) the hash while you are walking
                    through it! If you don't do that, the baheviour of the function is unpredictable.
                    You may generate a segmentation fault.
             </UL>
 */

void* chtbl_next (CHTbl *htab, int rewind)
{
  List      *linked_list;
  ListElmt  *element;

  /* ------------------------------------------------------------------------- */
  /* Set the hash pointer to the first element if necessary                    */
  /* ------------------------------------------------------------------------- */

  if (rewind == REWIND_HASH)
  {
    linked_list = &(htab->table[0]);
    (htab->pointer).current_list    = 0;
    (htab->pointer).current_element = list_head(linked_list);
  }
  else
  {
    linked_list = &(htab->table[(htab->pointer).current_list]);
  } 

  /* ------------------------------------------------------------------------- */
  /* Find the next element                                                     */
  /* ------------------------------------------------------------------------- */

  while ((htab->pointer).current_element == NULL)
  {
    /* ----------------------------------------------------------------------- */
    /* Go to the next linked list                                              */
    /* ----------------------------------------------------------------------- */

    (htab->pointer).current_list += 1;
    if ((htab->pointer).current_list >= htab->conteneurs) { return NULL; }

    linked_list = &(htab->table[(htab->pointer).current_list]);
    (htab->pointer).current_element = list_head(linked_list);
  }

  element = (htab->pointer).current_element;

  (htab->pointer).current_element = list_next(element);

  return list_data(element);
}

/*! \example test_hash_table.c
    This test program shows how to use the hash table's API.
 */

config.c

/*! \file config.c
          Configuration parser interface.
 */

#include <stdio.h>
#include <errno.h>
#include "chtbl.h"

#define PRIVATE_CODE_ONLY
#include "config.h"
#undef PRIVATE_CODE_ONLY


/*! \brief This flag indicates wether the memory allocated for the hash table is freed or not.
 */

static int allochtab = 0;

/*! \brief Hash function used by the hash table module.
    \remark See example for the hash table module.
 */

int config_hash_function (const void *key)
{
  struct user_data *data;
  int              index, i;

  data = (struct user_data*)key;
  index = 0;

  for (i=0; i<strlen(data->tag); i++) { index *= (int)(data->tag[i]); }

  if (index < 0) { index *= - 1; }

  return index;
}

/*! \brief Function used to free allocated memory in the hash table.
    \remark See example for the hash table module.
 */

void config_free_user_data (void *d)
{
  struct user_data *data;

  data = (struct user_data*)d;
  free (data->tag);
  free (data->value);
  free (data);

  return;
}

/*! \brief Function used to compare 2 elements in the hash table.
    \remark See example for the hash table module.
 */

int config_compare_user_data (const void *d1, const void *d2)
{
  struct user_data *data1, *data2;

  data1 = (struct user_data*)d1;
  data2 = (struct user_data*)d2;

  return !strcmp(data1->tag, data2->tag);
}

/*! \brief Handler to the hash table.
 */

CHTbl htab;

/*! \brief Flex generated parser.
 */

extern int configlex();

/*! \brief Flex input file descriptor.
 */

extern FILE *configin;

/*! \brief Load a given configuration file.
    \param path Path to the configuration file to load.
    \param err Pointer to an integer that will be used to store the value of 'errno' if an error occured.
    \return Upon successful completion, the function returns tha value PARSE_CONFIGURATION_OK.
            Otherwise the function may return one of the following values:
            <UL>
               <LI>PARSE_CONFIGURATION_NO_MEM: Could not allocate memory.
               <LI>PARSE_CONFIGURATION_FILE_NOT_FOUND: Could not open configuration file.
               <LI>PARSE_CONFIGURATION_SYNTAX_ERROR: Syntax error in configuration file.
               <LI>PARSE_CONFIGURATION_DUPLICATED_TAG: Configuration contains a duplicated tag.
               <LI>PARSE_CONFIGURATION_OK: Success.
            </UL>
    \warning <UL>
               <LI>If the returned value is PARSE_CONFIGURATION_NO_MEM, the module does not free
                   allocated memory. You should abort the program.
               <LI>If the returned value is PARSE_CONFIGURATION_FILE_NOT_FOUND, PARSE_CONFIGURATION_SYNTAX_ERROR
                   or PARSE_CONFIGURATION_DUPLICATED_TAG, the module free all allocated memory.
             </UL>
 */

int parse_configuration_file (char *path, int *err)
{
  int rc, retval;

  *err   = 0;
  retval = PARSE_CONFIGURATION_OK;

  /* ------------------------------------------------ */
  /* Initialize the hash table                        */
  /* ------------------------------------------------ */

  if (
       chtbl_init (
                    &htab,
                    10,
                    config_hash_function,
                    config_compare_user_data,
                    config_free_user_data
                  ) == -1
     )
  { return PARSE_CONFIGURATION_NO_MEM; }

  allochtab = 1;
 
  /* ------------------------------------------------ */
  /* Parse configuration file                         */
  /* ------------------------------------------------ */

  configin = fopen (path, "r");
  if (configin == NULL) { *err = errno; return PARSE_CONFIGURATION_FILE_NOT_FOUND; }

  rc = configlex();
  switch (rc)
  {
    case CONF_PARSER_SYNTAX_ERROR:   retval = PARSE_CONFIGURATION_SYNTAX_ERROR;
                                     free_all_configuration_data();
                                     break;
    case CONF_PARSER_DUPLICATED_TAG: retval = PARSE_CONFIGURATION_DUPLICATED_TAG;
                                     free_all_configuration_data();
                                     break;
    case CONF_PARSER_NO_MEM:         retval = PARSE_CONFIGURATION_NO_MEM; 
                                     break;
  }

  fclose (configin);

  return retval;
}

/*! \brief Free all data allocated for the hash table.
 */

void free_all_configuration_data() { if (allochtab == 1) { chtbl_destroy (&htab); allochtab = 0; } }

/*! \brief Return the value associated with a given tag.
    \param tag Pointer to a zero terminated string of characters that represents the tag to look for.
    \param value Pointer that will point to the corresponding value (if the tag was found).
    \return <UL>
              <LI>If the tag could not be find, the function returns the value 0. 'value' is NULL.
              <LI>If the tag has been found, the function returns the value 1.
              <LI>If the function ran out of memory, the function returns the value -1. 'value' is NULL.
            </UL> 
 */

int get_value (char *tag, char **value)
{
  struct user_data *ud, sud;
  int              cr, retval;

  /* ------------------------------------------------ */
  /* Initialise values                                */
  /* ------------------------------------------------ */

  *value  = NULL;
  retval  = 0;
 
  /* ------------------------------------------------ */
  /* Prepare user data for lookup                     */
  /* ------------------------------------------------ */

  sud.tag   = tag;
  sud.value = NULL;

  ud = &sud;

  /* ------------------------------------------------ */
  /* Lookup hash table                                */
  /* ------------------------------------------------ */

  cr = chtbl_lookup (&htab, (void**)&ud);

  if (cr == 0) { retval = 1; *value = ud->value; }

  return retval;
}

config.lex

%{

#include <stdio.h>
#include <string.h>
#include "strings_utils.h"
#include "chtbl.h"

#define PRIVATE_CODE_ONLY
#include "config.h"
#undef PRIVATE_CODE_ONLY



int configwrap() { return 1; }



static struct fields    fd;
static int              n;
static struct user_data *ud;
extern CHTbl htab;

%}

SPACE         \x20
TABUL         \t
BLANK         [\x20\t]
NUMBER        [0-9]
INTEGER       {NUMBER}+
BLANK_LINE    ^{BLANK}+\n
COMMENT       ^{BLANK}*#.+\n
EMPTY_LINE    ^\n

TAG           [0-9a-zA-Z\-_]+
CONF          ^{TAG}{BLANK}*=.+$



%%

{CONF}       {
               /* ---------------------------------------------- */
               /* Split couple (tag = value)                     */
               /* ---------------------------------------------- */

               n = s_split_exact (yytext, "=", &fd); 
               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (fd.number_of_fields != 2) { return CONF_PARSER_SYNTAX_ERROR; }

               /* ---------------------------------------------- */
               /* Remove spaces                                  */
               /* ---------------------------------------------- */

               if (chop(fd.tabs[0]) == NULL) { return CONF_PARSER_NO_MEM; }
               if (chop(fd.tabs[1]) == NULL) { return CONF_PARSER_NO_MEM; }

               /* ---------------------------------------------- */
               /* Allocate hash table element                    */
               /* ---------------------------------------------- */

               ud = malloc(sizeof(struct user_data));
               if (ud == NULL) { return CONF_PARSER_NO_MEM; }

               ud->tag = malloc(strlen(fd.tabs[0])+1);
               if (ud->tag == NULL) { return CONF_PARSER_NO_MEM; }

               ud->value = malloc(strlen(fd.tabs[1])+1);
               if (ud->value == NULL) { return CONF_PARSER_NO_MEM; }

               /* ---------------------------------------------- */
               /* Set hash table element                         */
               /* ---------------------------------------------- */

               strcpy (ud->tag,   fd.tabs[0]);
               strcpy (ud->value, fd.tabs[1]);

               free_fields(&fd);

               /* ---------------------------------------------- */
               /* Add element to the hash                        */
               /* ---------------------------------------------- */

               n = chtbl_insert (&htab, (void*)ud);

               if (n == -1) { return CONF_PARSER_NO_MEM; }

               if (n ==  1) { return CONF_PARSER_DUPLICATED_TAG; } 
             }


{BLANK_LINE} {  }
{EMPTY_LINE} {  }
{COMMENT}    {  }
\n           {  }
.*           { return CONF_PARSER_SYNTAX_ERROR; }

%%

cyclic_buffer.c

/*! \file cyclic_buffer.c
    This file contains a basic implementation of cyclic buffer.
 */

#include "cyclic_buffer.h"


/*! \brief Create a new cyclic buffer. 
    \param size Maximum number of elements of the buffer.
    \return The function return a handle on the newly vreated cyclic buffer, or NULL if an error occured (out of memory).
    \warning The function create_cyclic_buffer() allocates memory (using malloc()). Therefore, when you don't need the
             buffer anymore, you should destry it using destroy_cyclic_buffer().
 */

cyclic_buffer create_cyclic_buffer (unsigned long size)
{
   cyclic_buffer buffer;
   unsigned long i;

   /* ======================================================= */
   /* Allocate new data structure                             */
   /* ======================================================= */

   buffer = (cyclic_buffer)malloc(sizeof(struct s_cyclic_buffer));
   if (buffer == NULL) { return NULL; }

   buffer->buffer = (void**)malloc(size*sizeof(void*));
   if (buffer->buffer == NULL)
   {
     free (buffer);
     return NULL;
   }

   /* ======================================================= */
   /* Initialize data structure                               */
   /* ======================================================= */

   for (i=0; i<size; i++) { (buffer->buffer)[i] = NULL; }
   buffer->size         = size;
   buffer->start        = 0;
   buffer->stop         = 0;
   buffer->current      = 0;
   buffer->current_size = 0;
   buffer->n            = 0;

   return buffer;
}

/*! \example test_cyclic_buffer.c
    This file shows how to use the function create_cyclic_buffer().
 */

/*! \brief Destroy a cyclic buffer (free all allocated memory).
    \param buffer Handle to the cyclic buffer to destroy.
 */

void destroy_cyclic_buffer (cyclic_buffer buffer)
{
   unsigned long i;

   /* ======================================================= */
   /* Free all alocated memory                                */
   /* ======================================================= */

   for (i=0; i<buffer->size; i++) 
   {
     if ((buffer->buffer)[i] != NULL) { free ((buffer->buffer)[i]); }
   }

   free (buffer->buffer);
   free (buffer);
}

/*! \example test_cyclic_buffer.c
    This file shows how to use the function destroy_cyclic_buffer().
 */

/*! \brief Add a new element to the cyclic buffer.
    \param buffer Handle to the cyclic buffer that will be used to receive the new element.
    \param element Pointer to the element to add to the cyclic buffer.
    \param element_size Size (in bytes) of the element to add.
    \return If succees, the function returns a pointer to the element in the cyclic buffer. Otherwise, if an error occured,
            the function returns NULL.
    \warning Please note that the element is <B>copied</B> into the cyclic buffer. This implies that memory is allocated.
 */

void* cyclic_buffer_add_element (cyclic_buffer buffer, void* element, unsigned element_size)
{
  void *elem;

  /* ======================================================== */
  /* Delete element if necessary                              */ 
  /* ======================================================== */

  if ((buffer->buffer)[buffer->stop] != NULL)
  {
    free ((buffer->buffer)[buffer->stop]);
    (buffer->buffer)[buffer->stop] = NULL;
  }

  /* ======================================================== */
  /* Allocate new element                                     */
  /* ======================================================== */

  (buffer->buffer)[buffer->stop] = (void*)malloc(element_size);
  if ((buffer->buffer)[buffer->stop] == NULL) { return NULL; }

  /* ======================================================== */
  /* Copy element                                             */
  /* ======================================================== */

  memcpy ((buffer->buffer)[buffer->stop], element, element_size);
  elem = (buffer->buffer)[buffer->stop];

  /* ======================================================== */
  /* update indexes                                           */
  /* ======================================================== */

  buffer->stop = (buffer->stop + 1) % buffer->size; 
  if (buffer->stop == buffer->start) { buffer->start = (buffer->stop + 1) % buffer->size; }

  /* ======================================================== */
  /* One more element                                         */
  /* ======================================================== */

  if (buffer->current_size < buffer->size) { buffer->current_size += 1; }

  return elem;
}

/*! \example test_cyclic_buffer.c
    This file shows how to use the function add_element().
 */


/*! \brief Reset the current buffer's pointer (used to extract element from the buffer).
    \param buffer Handle to the cyclic buffer.
 */

void rewind_cyclic_buffer (cyclic_buffer buffer)
{
  buffer->current = buffer->start;
  buffer->n       = 0;
}

/*! \example test_cyclic_buffer.c
    This file shows how to use the function rewind_cyclic_buffer().
 */

/*! \brief Returns the current element of the cyclic buffer.
    \param buffer Handle to the cyclic buffer.
    \return The function returns a pointer to the current buffer's element, or NULL if the buffer's pointer reached the end
            of the buffer.
    \warning Before calling get_element(), you should call rewind_cyclic_buffer() first.
 */

void* cyclic_buffer_get_element(cyclic_buffer buffer)
{
  void    *elem; 

  if (buffer->n >= buffer->current_size) { buffer->n = 0;  return NULL; }

  elem = (buffer->buffer)[buffer->current];
  buffer->current = (buffer->current + 1) % buffer->size;
  (buffer->n)++;

  return elem;
}

/*! \example test_cyclic_buffer.c
    This file shows how to use the function get_element().
 */

/*! \brief Return the index of the first element in the buffer.
    \param buffer Handle to the cyclic buffer.
    \return The function returns the index of the first element in the buffer.
 */

unsigned long cyclic_buffer_get_start(cyclic_buffer buffer) { return buffer->start; }

/*! \example test_cyclic_buffer.c
    This file shows how to use the function get_start().
 */

/*! \brief Return the index of the last element in the buffer.
    \param buffer Handle to the cyclic buffer.
    \return The function returns the index of the last element in the buffer.
 */

unsigned long cyclic_buffer_get_stop(cyclic_buffer buffer) { return buffer->stop; }

/*! \example test_cyclic_buffer.c
    This file shows how to use the function get_stop().
 */

/*! \brief Return the number of elements in the cyclic buffer.
    \param buffer Handle to the cyclic buffer.
    \return The function returns the number of elements in the cyclic buffer.
 */ 

unsigned long cyclic_buffer_get_current_size(cyclic_buffer buffer) { return buffer->current_size; }

/*! \example test_cyclic_buffer.c
    This file shows how to use the function get_current_size().
 */

date.c

/*! \file date.c
    This file contains various functions used to manupulate dates.
 */

#include "date.h"


/*! \brief Current line in the time zones definitions file.
 */

int             date_line_num;

/*! \brief This structure contains the date 'timezone', 'daylight', 'time shift'.
 */

struct tz_tab   tzs;

/*! \brief Parser's entry point (created by flex).
 */

int             dateyylex();

/*! \brief Parser's input stream (used by dateyylex()).
 */

extern FILE     *dateyyin;


/*! \brief This array should contain "MET" and "MET DST" for TZ=MET.
 */

extern char *tzname[2];

/*! \brief The external time_t variable altzone  contains  the  difference, in seconds, between Coordinated Universal
           Time and the alternate time zone.
 */
extern time_t timezone;

/*! \brief The external variable daylight indicates whether time should  reflect  daylight  savings  time.  Both timezone and
           altzone default to 0 (UTC). The external  variable  daylight is  non-zero if an alternate time zone exists.
 */
extern int daylight;

/*! \brief The function date2timestamp() lookups the structure 'tzs' to find the correct timezone configuration for the 
           current date actually processed. This variable points to the current time zone configuration that aplies to
           the currently scaned date.
 */
struct timezones *current_tz;

/*! \brief Set the local time zone to GTM (which is equivalent to UTC).
    \return The function returns 0 if success, 1 otherwise.
 */

int set_local_TZ_to_GMT()
{
  static char current_tz[TZSET_MAX_SIZE];


  strcpy (current_tz, "TZ=GMT +0");

  if (putenv(current_tz) != 0) { return 1; }
  tzset();
  return 0;
}

/*! \brief Load time zones definitions.
    \param filename Pointer to a NULL terminated string of characters that contains the name on the file that contains the
           time zones definitions. If 'filename' is NULL, then the function looks for the environmanr variable 
           "TIMEZONES_DEFINITION".
    \return If the operation succed, the function returns TIME_ZONES_LOAD_OK. Otherwise, the function may return:
<UL>
  <li>TIME_ZONES_NO_FILE: No file name specified (ie; 'filename' is NULL, and TIMEZONES_DEFINITION is not set).
  <li>TIME_ZONES_CAN_NOT_OPEN_FILE: Can not open definition file.
  <li>TIME_ZONES_NO_DEF_FOUND: Definition file is empty.
  <li>TIME_ZONES_DEF_OVERFLOW: Too many timezones definitions.
  <li>TIME_ZONES_NO_MEM: Running out of memory.
  <li>TIME_ZONES_TIMEZONE_OVERFLOW: the timezone flag is too long.
  <li>TIME_ZONES_DAYLIGHT_OVERFLOW: the daylight flag is too long.
  <li>TIME_ZONES_PARSE_ERROR: parser error - check config file.
</UL>

 */

int load_timezones (char *filename)
{
  char *fname;
  int  parser_status;


  if (filename == NULL)
  {
    fname = getenv("TIMEZONES_DEFINITION");
    if (fname == NULL) { return TIME_ZONES_NO_FILE; }
  }
  else (fname = filename);

  dateyyin = fopen (fname, "r");
  if (dateyyin == NULL) { return TIME_ZONES_CAN_NOT_OPEN_FILE; }
  
  parser_status = dateyylex();

  if (parser_status != 0) { return parser_status; }

  if (tzs.entry_number == 0) { return TIME_ZONES_NO_DEF_FOUND; }

  return TIME_ZONES_LOAD_OK;
}

/*! \example test_load_tz.c
    This file shows how to use the function load_timezones().
 */


/*! \brief Compare 2 timezone structures.
    \param tz1 Pointer to the first timezone to compare.
    \param tz2 Pointer to the second timezone to compare.
    \return The function returns 1 if the two structure are identical, otherwise the function returns 0.
 */

int tzcmp (struct timezones *tz1, struct timezones *tz2)
{
  if (strcmp (tz1->timezone, tz2->timezone) != 0) { return 0; }
  if (strcmp (tz1->daylight, tz2->daylight) != 0) { return 0; }

  return 1;
}

/*! \brief Find a time zone data structure in the time zone configuration file.
    \param tzz Pointer to a time zone data structure. This structure must have the fields 'timezone' and 'daylight'
           correctly initialized (NULL terminated string of characters).
    \return If the function found a configuration that matches the time zone defined by 'tzz', it returns 1. Otherwise,
            the function returns 0. Please note that the structure 'tzz' will contain the correct value for the field
            'shift'.
 */

int tzfound (struct timezones *tzz)
{
  int i;

  current_tz = NULL;
  for (i=0; i<tzs.entry_number; i++)
  {
    if (tzcmp (&((tzs.tz)[i]), tzz) == 1)
    {
      current_tz = &((tzs.tz)[i]);
      tzz->shift = (tzs.tz)[i].shift;
      return 1;
    }
  }

  return 0;
}

/*! \example test_load_tz.c
    This file shows how to use the function tzfound().
 */

/*! \brief Contains the names of the 7 days of the week.
 */

extern char *days[7];

/*! \brief Contains the names of the 12 months of the year.
 */

extern char *months[12];

/*! \brief Returns the index of the day (starting at 0, so the returned value is between 0 and 6). The first day (index 0)
           is 'Sunday'.
    \param day Pointer to a string of characters that contains the day of the week.
    \return The function returns the index of the day (starting at 0, so the returned value is between 0 and 6). If an
            error occurs, the function returns -1.
 */

int get_day (char *day)
{
  int  i;

  for (i=0; i<7; i++)
  { if (strcmp(day, days[i]) == 0) { return i; } }

  return -1;
}

/*! \brief Returns the index of the month (starting at 0, so the returned value is between 0 and 11). The first month
           (index 0) is 'january'.
    \param month Pointer to a string of characters that contains the month of the year.
    \returns The function returns the index of the month (starting at 0, so the returned value is between 0 and 11).
             If an error occurs, the function returns -1.
 */ 

int get_month (char *month)
{
  int  i;

  for (i=0; i<12; i++)
  { if (strcmp(month, months[i]) == 0) { return i; } }

  return -1;
}

/*! \brief Returns a zero terminated string of characters that represents the time zones configuration.
    \return If the function succed, it returns a non NULL pointer. Otherwise, it returns NULL.
    \warning The returned pointer has been allocated within the function, make sure to free it (using free()).
 */

char* print_tz_conf()
{
  int    n, size, i;
  char   *res;

  n = tzs.entry_number;

  size = n * (TIMEZONE_SIZE + DAYLIGHT_SIZE + TTREF_MAX_TIMESTAMP_SIZE + 50);
  res  = (char*)malloc((size+1)*sizeof(char));
  if (res == NULL) { return NULL; }

  *res = 0;

  for (i=0; i<n-1; i++)
  {
    strcat (res, "(");
    strcat (res, (tzs.tz)[i].timezone);
    strcat (res, ", ");
    strcat (res, (tzs.tz)[i].daylight);
    strcat (res, ", ");
    sprintf (res+strlen(res), "%d) - ", (tzs.tz)[i].shift);
  } 

  strcat (res, "(");
  strcat (res, (tzs.tz)[i].timezone);
  strcat (res, ", ");
  strcat (res, (tzs.tz)[i].daylight);
  strcat (res, ", ");
  sprintf (res+strlen(res), "%d)", (tzs.tz)[i].shift);

  return res;
}



/*! \brief Calculate the timestamp of a ticket (The number of seconds since the first of January 1970).
    \param date Pointer to a string of characters that contains the date as it is read from the TSM's log. the date looks
           something like ' Tue Aug 28 01:02:24 MET DST 2001'.
    \param timestamp Pointer to a string that will receive the timestamp.
    \param nbcar Size of the memory location pointed by 'timestamp'.
    \param shift This value represents the number of seconds between the current date and the UTC date. If the value of
           shift is AUTOMATIC_TIME_SHIFT_COMPUTATION, then the function will use the time zones configuration file
           to find out the correct time shift.
    \return The function returns a pointer to 'timestamp'. If an error occurs, the function returns NULL. This can mean that
            the program is running out of memory, or that the date is not well formated (not "MET" "DST" ...).
    \warning <UL>
               <li>The first thing to do when using all this function of this library is to call set_local_TZ_to_GMT().
                   Otherwise, timestamps will depend on the system's local time zone configuration.
               <li>You MUST call the function load_timezones() before using this function !!!! If you do not do that you may
                   produce a segmentation fault. 
               <li>The input date 'date' will be modified. If you need to used it after, then make a copy!.
             </UL>

 */

char* date2timestamp (char* date, char* timestamp, int nbcar, int shift)
{
  struct fields    f;
  struct fields    t;
  int              nb_fields;
  struct tm        tt;
  int              seconds;            /* 0    -  59   */
  int              minutes;            /* 0    -  59   */
  int              hours;              /* 0    -  23   */
  int              day_of_the_month;   /* 1    -  31   */ 
  int              month;              /* 0    -  11   */
  int              year;               /* year - 1900  */
  int              day_of_the_week;    /* 0    -  6    */
  int              day_of_the_year;    /* 0    -  365  */
  int              decalage;           /* any number - see doc */ 
  int              year_tag;           /* the position of the year depends on the number of field */
  char             tstamp[200];
  char*            timep;
  time_t           v;
  struct timezones tzz;

  #ifdef DEBUG
  int i;
  #endif

  if (nbcar <= 0) { return NULL; }

  /***********************************************************/
  /* Split the date                                          */
  /* You can have 6 or 7 fields exactly.                     */
  /***********************************************************/


  nb_fields = s_split(date, " ", &f);

  #ifdef DEBUG
  fprintf (stdout, "\n\ndate2timestamp() nb_fields = %d\n", nb_fields); fflush(stdout);
  #endif

  if ((nb_fields != 7) && (nb_fields != 6))
  {
    free_fields (&f);
    timestamp[0] = 0;
    return NULL;
  }

  /***********************************************************/
  /* Find the correct timezone and daylight                  */
  /* So you get the time shift.                              */
  /***********************************************************/

  year_tag = YEAR;

  if (nb_fields == 7)
  {
    if (strlen(f.tabs[TAG1]) >= TIMEZONE_SIZE)
    {
      free_fields (&f);
      timestamp[0] = 0;
      return NULL;
    }

    if (strlen(f.tabs[TAG2]) >= DAYLIGHT_SIZE)
    {
      free_fields (&f);
      timestamp[0] = 0;
      return NULL;
    }

    strcpy (tzz.timezone, f.tabs[TAG1]);
    strcpy (tzz.daylight, f.tabs[TAG2]);
  }

  if (nb_fields == 6)
  {
    if (strlen(f.tabs[TAG1]) >= TIMEZONE_SIZE)
    {
      free_fields (&f);
      timestamp[0] = 0;
      return NULL;
    }

    strcpy (tzz.timezone, f.tabs[TAG1]);
    (tzz.daylight)[0] = 0;

    /* One field missing => the year tag is one tag before !!!!!! */

    year_tag = YEAR - 1;
  }

  #ifdef DEBUG
  fprintf (stdout, "\n\ndate2timestamp(): tzz done\n"); fflush(stdout);
  #endif

  /***********************************************************/
  /* lookup timezone configuration                           */
  /***********************************************************/

  current_tz = NULL;

  if (tzfound(&tzz) == 0)
  {
    free_fields (&f);
    timestamp[0] = 0;
    return NULL;
  }

  #ifdef DEBUG
  fprintf (stdout, "\n\ndate2timestamp(): tzfound() passed\n"); fflush(stdout);
  #endif

  /***********************************************************/
  /* Time zone configuration found - set global variable     */
  /* current_tz                                              */
  /***********************************************************/

  /* set into tzfound() ... */

  /***********************************************************/
  /* Set time shift according to timezone configuration      */
  /***********************************************************/

  if (shift == AUTOMATIC_TIME_SHIFT_COMPUTATION) { shift = tzz.shift; }

  /***********************************************************/
  /* Split the clock time                                    */
  /***********************************************************/

  timep = (char*)malloc((strlen(f.tabs[CLOCK])+1)*sizeof(char));
  if (timep == NULL)
  {
    free_fields (&f);
    timestamp[0] = 0;
    return NULL;
  }

  strcpy (timep, f.tabs[CLOCK]);

  nb_fields = s_split(timep, ":", &t);
  if (nb_fields != 3)
  {
    free_fields (&t);
    free_fields (&f);
    free (timep);
    timestamp[0] = 0;
    return NULL;
  }

  free (timep);

  #ifdef DEBUG
  fprintf (stdout, "\nDate:");
  for (i=0; i<f.number_of_fields; i++)
  { fprintf (stdout, "\n -> %s", f.tabs[i]); }
  fprintf (stdout, "\n"); fflush(stdout);
  #endif
 
  #ifdef DEBUG
  fprintf (stdout, "\nHour:");
  for (i=0; i<t.number_of_fields; i++)
  { fprintf (stdout, "\n -> %s", t.tabs[i]); }
  fprintf (stdout, "\n"); fflush(stdout);
  #endif
 
  /***********************************************************/
  /* Compute UTC timestamp                                   */
  /***********************************************************/

  seconds            = atoi(t.tabs[SECONDS]);
  minutes            = atoi(t.tabs[MINUTES]);
  hours              = atoi(t.tabs[HOUR]);
  day_of_the_month   = atoi(f.tabs[DAY_OF_THE_MONTH]);
  month              = get_month(f.tabs[MONTH]);
  year               = atoi(f.tabs[year_tag]) - 1900;
  day_of_the_week    = get_day(f.tabs[DAY_OF_THE_WEEK]);
  day_of_the_year    = 0;

  decalage           = 0; 

  tt.tm_sec   = seconds;
  tt.tm_min   = minutes;
  tt.tm_hour  = hours;
  tt.tm_mday  = day_of_the_month;
  tt.tm_mon   = month;
  tt.tm_year  = year;
  tt.tm_wday  = day_of_the_week;
  tt.tm_yday  = day_of_the_year;  /* unused */
  tt.tm_isdst = decalage;

  #ifdef DEBUG
  fprintf (stdout, "\nsec:               %d", seconds);
  fprintf (stdout, "\nmin:               %d", minutes);
  fprintf (stdout, "\nhour:              %d", hours);
  fprintf (stdout, "\nday_of_the_month:  %d", day_of_the_month);
  fprintf (stdout, "\nmonth:             %d", month);
  fprintf (stdout, "\nyear:              %d", year);
  fprintf (stdout, "\nday_of_the_week:   %d", day_of_the_week);
  fprintf (stdout, "\nday_of_the_year:   %d", day_of_the_year);
  fprintf (stdout, "\n");
  #endif

  v = mktime(&tt);

  /***********************************************************/
  /* Add time shift                                          */
  /***********************************************************/

  sprintf (tstamp, "%lu", (unsigned long int)v + shift);

  /***********************************************************/
  /* Copy the result into output buffer and then clean all   */
  /***********************************************************/

  if (nbcar-1 < strlen(tstamp))
  { 
    free_fields (&t);
    free_fields (&f);
    timestamp[0] = 0;
    return NULL;
  }

  strcpy (timestamp, tstamp);

  free_fields (&f);
  free_fields (&t);
  return timestamp;
}

/*! \example test_date2timestamp.c
    This file shows how to use the function 'test_date2timestamp()'.
 */

/*! \brief Return the current date as Apache's standard.
    \return The function returns a pointer to a string of characters that contains the current date.
    \warning The returned pointer points to a static string of characters. Therefore you do NOT have to free it (do NOT free
             it!).
 */

char* dater()
{
  static char  strtime[MAX_TIMER_SIZE];
  time_t       tt;

  tt = time(NULL);
  strftime (strtime, 256, "%Y-%m-%d %k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \example test_date2timestamp.c
    This file shows how to use the date functions.
 */


/*! \brief Current line number being parsed by the time zones reference parsed.
 */
int                ttref_line_num = 0;

/*! \brief Data structure that contains all the couples (date, timestamp) used as reference.
 */ 
struct ttref_tab   ttrefs;

/*! \brief Lexical parser build by the flex utility (for parsing the timestamps references configuration file).
 */
extern int ttreflex();

/*! \brief Pointer to the stream descriptor used by the timestamps references parser.
 */
extern FILE* ttrefin;


/*! \brief Check the time zone configuration data against well known couple (date, timestamps).
    \param config_file Pointer to a zero terminated string of characters that represents the name of the timestamps
           reference configuration file. This file is a list of couple (date, timestamps).
    \param auto_conf Timezone autoconfiguration flag. This value can be:
           <UL>
              <li>TZ_AUTOCONF_ON: Auto configuration mode requested.
              <li>TZ_AUTOCONF_OFF: Auto configuration mode not requested.
           </UL>
    \return If the time zone configuration is OK, then the function returns TTREF_OK. Otherwise the function may return
            one of the following codes:
            <UL>
              <li>TTREF_TOO_MANY_REF; Too many references in the timestamps reference config file.
              <li>TTREF_NO_MEM: Not enough memory.
              <li>TTREF_SYNTAX_ERROR: Syntax error found in the timestamps reference config file.
              <li>TTREF_DATE_TOO_LONG: Date too long in the timestamps reference config file.
              <li>TTREF_REF_TOO_LONG: timestamp too long in the timestamps reference config file.
              <li>TTREF_CAN_NOT_OPEN_CONF_FILE Can not open the timestamps reference config file.
              <li>TTREF_INVALID_DATE: Invalid date format in the timestamps reference config file.
              <li>TTREF_KO: Invalid time zone configuration - check the time zone configuration file!
            </UL>
    \warning You must call load_timezones() before you can call this function!.
 */

int test_tz_conf (char* config_file, int auto_conf)
{
  int    cr;
  int    i;
  char   *pt;
  char   tt[TTREF_MAX_TIMESTAMP_SIZE];
  char   ref_date[TTREF_MAX_DATE_SIZE];

  time_t ref, conf;
  int    err, correction;

  /***********************************************************/
  /* Make sure we have not already loaded it !               */
  /***********************************************************/

  if (ttrefs.entry_number == 0)
  {

    /***********************************************************/
    /* Open the timestamps references parser's input file      */
    /***********************************************************/

    ttrefin = fopen(config_file, "r");
    if (ttrefin == NULL) { return TTREF_CAN_NOT_OPEN_CONF_FILE; }

    /***********************************************************/
    /* Load timestamps references                              */ 
    /***********************************************************/

    cr = ttreflex();
    if (cr != 0) { fclose (ttrefin); return cr; }

    fclose (ttrefin); 
  }

  /***********************************************************/
  /* Now compute known timestamps                            */
  /***********************************************************/

  for (i=0; i<ttrefs.entry_number; i++)
  {
    strcpy (ref_date, ((ttrefs.ttref)[i]).date);

    pt = date2timestamp(ref_date, tt, TTREF_MAX_TIMESTAMP_SIZE, AUTOMATIC_TIME_SHIFT_COMPUTATION);
    if (pt == NULL) { return TTREF_INVALID_DATE; }

    #ifdef DEBUG
    fprintf (stdout, "\n-> %s", current_tz->timezone);
    fprintf (stdout, "\n-> %s", current_tz->daylight);
    fprintf (stdout, "\n-> %d", current_tz->shift);
    fprintf (stdout, "\n");
    fflush (stdout);
    #endif

    if (strcmp(tt, ((ttrefs.ttref)[i]).timestamp) != 0)
    {
      if (auto_conf == TZ_AUTOCONF_OFF) { return TTREF_KO; }

      /*******************************************************/
      /* Time zone auto configuration mode activated ...     */
      /* Compute the correct time shift according to the     */
      /* couples (date, timestamp) considered as references. */
      /*******************************************************/

      ref         = string2time_t(((ttrefs.ttref)[i]).timestamp, &err);
      conf        = string2time_t(tt, &err);
      correction  = (int)((unsigned int)ref - (unsigned int)conf);

      current_tz->shift += correction;    
    }
  }

  return TTREF_OK; 
}

/*! \example test_load_ttref.c
    This file shows how to use test_tz_conf().
 */

/*! \brief Return the number of seconds since 00:00:00 UTC, January 1, 1970.
    \return The function returns the number of seconds since 00:00:00 UTC, January 1, 1970.
 */

time_t get_utc_timestamp ()
{
  time_t tt;

  /***********************************************************/
  /* Get the number of seconds since 00:00:00 UTC, January   */
  /* 1, 1970                                                 */
  /***********************************************************/

  tt = time(NULL);
  return tt;
}

/*! \example test_get_utc_timestamp.c
    This file shows how to use the function get_utc_timestamp ().
 */

/*! \brief Format a TSM date (ex: "Tue Sep 17 11:48:39 MET 2002") from a given timestamp.
    \param timestamp Number of seconds since 00:00:00 UTC, January 1, 1970 (as returned by the POSIX
           function time()).
    \param debug Debug flag (0: no debug, otherwize debug output).
    \return Upon successful completion, the function returns a pointer to a string of characters that
            represents the date associated with the given timestamp. This date respects the TSM's format.
            If an error occured, the function returns the value NULL.
    \warning The returned pointer points to a static memory area (declared whithin the function). Therefore
             you do not have to free it!
 */

char *get_tsm_date (time_t timestamp, int debug)
{
  static char  date[MAX_TSM_DATE_SIZE];
  static char  current_tz[TZSET_MAX_SIZE];
  static char  original_tz[TZSET_MAX_SIZE];
  char         buffer[TZSET_MAX_SIZE];
  char         *s;
  struct tm    *dd;

  

  if (debug)
  {
    s = getenv("TZ");

    fprintf (stdout, "\n------------------------");
    fprintf (stdout, "\nInitial timezone setting:\n");
    fflush (stdout);

    if (s != NULL) { fprintf (stdout, "\n       - TZ:         %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - TZ:         NULL pointer (getenv(\"TZ\"))"); fflush (stdout); }

    s = tzname[0];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[0]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[0]:  NULL pointer"); fflush (stdout); }

    s = tzname[1];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[1]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[1]:  NULL pointer"); fflush (stdout); }

    fprintf (stdout, "\n");
    fflush (stdout);
  }

  /* -------------------------------------------- */
  /* Save current timezone setting                */
  /* WARNING!! See "man putenv"                   */
  /* -------------------------------------------- */

  s = getenv("TZ");
  if (s == NULL) { return NULL; }
  strcpy (buffer, "TZ=");
  if (strlen(s) >= TZSET_MAX_SIZE-3) { return NULL; } 
  strcat (buffer, s);
  strcpy (original_tz, buffer);

  /* -------------------------------------------- */
  /* Now set current timezone to MET              */
  /* -------------------------------------------- */

  strcpy (current_tz, "TZ=MET");
  if (putenv(current_tz) != 0) { return NULL; }
  tzset();

  if (debug)
  {
    s = getenv("TZ");

    fprintf (stdout, "\nSetting process timezone to MET:\n");
    fflush (stdout);

    if (s != NULL) { fprintf (stdout, "\n       - TZ:         %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - TZ:         NULL pointer (getenv(\"TZ\"))"); fflush (stdout); }

    s = tzname[0];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[0]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[0]:  NULL pointer"); fflush (stdout); }

    s = tzname[1];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[1]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[1]:  NULL pointer"); fflush (stdout); }

    fprintf (stdout, "\n");
    fflush (stdout);
  }

  /* -------------------------------------------- */
  /* Format TSM's date                            */
  /* -------------------------------------------- */

  if (strcmp(tzname[0], "MET")     != 0) { return NULL; }
  if (strcmp(tzname[1], "MET DST") != 0) { return NULL; }

  dd = localtime(×tamp);

  sprintf (date, "%s %s %02d %02d:%02d:%02d %s %d",
                 days[dd->tm_wday],
                 months[dd->tm_mon],
                 dd->tm_mday,
                 dd->tm_hour,
                 dd->tm_min,
                 dd->tm_sec,
                 (dd->tm_isdst ? "MET": "MET DST"),
                 1900 + dd->tm_year);

  /* -------------------------------------------- */
  /* Restore original timezone setting            */
  /* -------------------------------------------- */

  if (putenv(original_tz) != 0) { return NULL; } 
  tzset();

  if (debug)
  {
    s = getenv("TZ");

    fprintf (stdout, "\nRestore initial process timezone:\n");
    fflush (stdout);

    if (s != NULL) { fprintf (stdout, "\n       - TZ:         %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - TZ:         NULL pointer (getenv(\"TZ\"))"); fflush (stdout); }

    s = tzname[0];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[0]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[0]:  NULL pointer"); fflush (stdout); }

    s = tzname[1];
    if (s != NULL) { fprintf (stdout, "\n       - tzname[1]:  %s", s); fflush (stdout);}
    else           { fprintf (stdout, "\n       - tzname[1]:  NULL pointer"); fflush (stdout); }

    fprintf (stdout, "\n");
    fflush (stdout);
  }


  return date;
}

/*! \example test_get_tsm_date.c
    This example shows how to use the function get_tsm_date().
 */

date.lex

%{

#include <stdio.h>
#include <string.h>
#include "date.h"
#include "strings_utils.h"

extern int             date_line_num;
extern struct tz_tab   tzs;


static int             tz_num = 0;
static int             n;
static struct fields   fd; 


int dateyywrap() { return 1; }


%}

ALPHA         ([A-Z]|[a-z])
NUMERIC       [0-9]
ALPHANUM      ({ALPHA}|{NUMERIC})
SPACE         \x20
TABUL         \t
BLANK         [\x20\t]
NUMBER        [0-9]
INTEGER       {NUMBER}+
BLANK_LINE    ^{BLANK}+\n
COMMENT       ^{BLANK}*#.+\n
EMPTY_LINE    ^\n

TIMEZONE      {ALPHA}+
DAYLIGHT      {ALPHA}+
SHIFT         (\+{INTEGER})|(\-{INTEGER})

TIMING1       ^{TIMEZONE}{SPACE}+{SHIFT}{SPACE}*$
TIMING2       ^{TIMEZONE}{SPACE}+{DAYLIGHT}{SPACE}+{SHIFT}{SPACE}*$


%%

{TIMING1}     {
                if (tz_num >= MAX_TZ_DEF) { return TIME_ZONES_DEF_OVERFLOW; }

                n = s_split(yytext, " ", &fd);
                if (n == -1) { return TIME_ZONES_NO_MEM; }

                if (strlen(fd.tabs[0]) >= TIMEZONE_SIZE) { return TIME_ZONES_TIMEZONE_OVERFLOW; }
                strcpy (((tzs.tz)[tz_num]).timezone, fd.tabs[0]);
                ((tzs.tz)[tz_num].daylight)[0] = 0;
                ((tzs.tz)[tz_num]).shift = atoi(fd.tabs[1]);

                tz_num += 1;
                tzs.entry_number = tz_num;
                free_fields(&fd);
              }



{TIMING2}     {
                if (tz_num >= MAX_TZ_DEF) { return TIME_ZONES_DEF_OVERFLOW; }

                n = s_split(yytext, " ", &fd);
                if (n == -1) { return TIME_ZONES_NO_MEM; }

                if (strlen(fd.tabs[0]) >= TIMEZONE_SIZE) { return TIME_ZONES_TIMEZONE_OVERFLOW; }
                if (strlen(fd.tabs[1]) >= TIMEZONE_SIZE) { return TIME_ZONES_DAYLIGHT_OVERFLOW; }
                strcpy (((tzs.tz)[tz_num]).timezone, fd.tabs[0]);
                strcpy (((tzs.tz)[tz_num]).daylight, fd.tabs[1]);
                ((tzs.tz)[tz_num]).shift = atoi(fd.tabs[2]);

                tz_num += 1;
                tzs.entry_number = tz_num;
                free_fields(&fd);
              }



{BLANK_LINE} { date_line_num++; }
{EMPTY_LINE} { date_line_num++; }
{COMMENT}    { date_line_num++; }
\n           { date_line_num++; }
.*           { return TIME_ZONES_PARSE_ERROR; }

%%

dates.c

deamon.c

/*! \file deamon.c
    Simple interface used to create a UNIX daemon.
 */

#include "deamon.h"

/*! \brief Turn the calling process into a deamon.
    \param pid Pointer to a PID descriptor that will receive the PID returned by the call to fork().
               <UL>
                  <LI>If pid < 0, then an error occured while calling fork().
                  <LI>If pid > 0, then we are in the 'father' process and PID represents the child's PID.
                  <LI>If PID == 0, then we are in the 'child' process.
               </UL>
    \param wd Pointer to a zero terminated string of characters that represents the deamon's working directory.
    \return Upon successful completion, the function returns the value 0. otherwize, the function returns
            the value 1. 
 */

int deamonizer(pid_t *pid, char *wd)
{
        pid_t sid;

        *pid = (pid_t)-1;

        /* ------------------------------------- */ 
        /* Fork off the parent process           */
        /*  - pid < 0: error                     */
        /*  - pid > 0: we are in the father      */
        /* ------------------------------------- */ 

        *pid = fork();
        if (*pid < 0) { return 1; }
        if (*pid > 0) { return 0; }
       
        /* ------------------------------------- */ 
        /* Change the file mode mask             */
        /* ------------------------------------- */ 

        umask(0);       
        
        /* ------------------------------------- */ 
        /* Create a new SID for the child        */
        /* process                               */ 
        /* ------------------------------------- */ 

        sid = setsid();
        if (sid < 0) { return 1; }
        
        /* ------------------------------------- */ 
        /* Change the current working directory  */
        /* ------------------------------------- */ 

        if ((chdir(wd)) < 0) { return 1; }
        
        /* ------------------------------------- */ 
        /* Close out the standard file           */
        /* Descriptors                           */
        /* ------------------------------------- */ 

        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);

        return 0;
}

dir.c

/*! \file dir.c
    This file contains various utilities to manipulate directory.
 */

#include <stdio.h>
#include "my_dir.h"


/*! \brief List the content of a directory (compatible SUN/LINUX).
    \param dir_name Pointer to a zero terminated string of characters that represents the name of the directory to list.
    \param flist Pointer to a 'file_list' structure that will be used to store directory's content.
    \return If the function succed, it returns a positive number that represents the number of entries in the directory.
            Oterwise, the function returns -1.
    \warning Some fields in the structure 'flist' has been allocated within the function. You must call free_file_list() 
             of 'flist' to free all the allocated memory.
 */

int read_directory (char *dir_name, struct file_list *flist)
{
  DIR           *dirp;
  struct dirent *dp;
  int           nb_file, total_file, fsize;

  flist->list        = NULL;
  flist->total_alloc = 0;
  flist->num         = 0;

  dirp = opendir(dir_name);
  if (dirp == NULL) { return -1; }

  total_file = FILE_NUMBER;
  flist->list = (char**)malloc(total_file*sizeof(char*));
  if (flist->list == NULL)
  {
    closedir(dirp);
    return -1;
  }
  flist->total_alloc = total_file;


  nb_file = 0;
  while ((dp = readdir(dirp)) != NULL)
  {
    if (nb_file >= total_file)
    {
      total_file *= 2;
      flist->list = (char**)realloc(flist->list, total_file*sizeof(char*));
      if (flist->list == NULL)
      {
        closedir(dirp);
        return -1;
      }
      flist->total_alloc = total_file;
    }
  
    fsize = strlen(dp->d_name) + 1 + strlen(dir_name); 
    (flist->list)[nb_file] = (char*)malloc((fsize+1)*sizeof(char));
    if ((flist->list)[nb_file] == NULL)
    {
      closedir(dirp);
      return -1;
    }

    sprintf ((flist->list)[nb_file], "%s/%s", dir_name, dp->d_name);
    nb_file++;
    flist->num = nb_file;
  }

  closedir(dirp);
  return nb_file; 
}

/*! \example test_dir.c
    this file shows how to use read_directory() and free_file_list().
 */

/*! \brief List the content of a directory, and keeps only the directories.
    \param dir_name Pointer to a zero terminated string of characters that represents the name of the directory
           to list.
    \param flist_out Pointer to a 'file_list' structure that will be used to store directory's content.
    \return If the function succed, it returns a positive number that represents the number of entries in the
            directory. Oterwise, the function returns -1.
    \warning Some fields in the structure 'flist' has been allocated within the function. You must call
             free_file_list() of 'flist' to free all the allocated memory.
 */

int read_directory_only (char *dir_name, struct file_list *flist_out)
{
  int              nb_files, i, fsize;
  struct file_list flist;
  struct stat      stat_buf;

  /* ------------------------------------------------------- */
  /* Read all the entries of the firectory                   */
  /* ------------------------------------------------------- */

  nb_files = read_directory (dir_name, &flist);
  if (nb_files == -1) { return -1; }

  /* ------------------------------------------------------- */
  /* Allocate memory for 'flist_out'. We know for sure that  */
  /* we have no more that 'nb_files' directories.            */
  /* ------------------------------------------------------- */

  flist_out->list = (char**)malloc(nb_files*sizeof(char*));
  if (flist_out->list == NULL)
  {
    free_file_list (&flist);
    return -1;
  }
  flist_out->total_alloc = nb_files;

  /* ------------------------------------------------------- */
  /* Now look at each entry to keep only the directories     */
  /* ------------------------------------------------------- */

  flist_out->num = 0;
  for (i=0; i<flist.num; i++)
  {
    if (stat ((flist.list)[i], &stat_buf) == -1)
    {
      free_file_list (&flist);
      return -1;
    }

    if (S_ISDIR(stat_buf.st_mode))
    {
      fsize = strlen((flist.list)[i]+1);
      
      (flist_out->list)[flist_out->num] = (char*)malloc((fsize)*sizeof(char));

      if ((flist_out->list)[flist_out->num] == NULL)
      {
        free_file_list (&flist);
        return -1;
      }

      strcpy ((flist_out->list)[flist_out->num], (flist.list)[i]); 

      flist_out->num += 1;
    }
  }

  /* ------------------------------------------------------- */
  /* Free all allocated memory                               */ 
  /* ------------------------------------------------------- */

  free_file_list (&flist);

  return flist_out->num;
}

/*! \example test_dir.c
    this file shows how to use read_directory() and free_file_list().
 */

/*! \brief Free all allocated memory after you called read_directory().
    \param flist Pointer to a structure 'file_list' that should have been filled by read_directory().
    \warning ALWAYS call this function after read_directory().
 */

void free_file_list(struct file_list *flist)
{
  int i;

  for (i=0; i<flist->num; i++)
  { free ((flist->list)[i]); }
  if (flist->total_alloc > 0) { free (flist->list); }
}

/*! \example test_dir.c
    this file shows how to use read_directory() and free_file_list().
 */


/*! \brief Extract the directory base name from a file name.
    \param dirname Pointer to a NULL terminated that represents the file name.
    \param res Pointer to a pointer that will receive the directory base name.
    \return If the function found the directory base name, then it returns BASE_DIR_FOUND and in this case 'res'
            contains the directory base name. If the function can not extract the directory base name it returns
            BASE_DIR_NOT_FOUND and in this case 'res' is a NULL pointer. If the function returns BASE_DIR_NO_MEM, it
            means that the function can not allocate memory (in this case 'res' is NULL).
    \warning 'res' has been allocated within the function. You must delete it yoursef (using free()). But before 
             you free it, make sure to check that 'res' is not NULL (if (res != NULL) { free (res); }).
 */

int base_dir_name (char *dirname, char **res)
{
  char   *c, save;
  int    size;

  *res = NULL;
  c = rindex (dirname, '/');
  if (c == NULL) { return BASE_DIR_NOT_FOUND; }

  save = *c;
  *c = 0;

  size = strlen(dirname);
  *res = (char*)malloc((size+1)*sizeof(char));
  if (*res == NULL)
  {
    *c = save;
    return BASE_DIR_NO_MEM;
  }

  strcpy (*res, dirname);
  *c = save;

  return BASE_DIR_FOUND;
}

/*! \example test_basename.c
    This file shows how to use the function base_dir_name().
 */

dmalloc.c

/*! \file dmalloc.c
    This file implements the debug tools for malloc.
 */


#include "dmalloc.h"

#define DMALLOC_ADDRESS_SIZE 100

/*! \brief Allocate memory (using malloc), and log a message into a log file.
    \param size Number of bytes to allocate.
    \param message Pointer to a zero terminated string of characters that contains the message to log.
    \param file Name of the log file.
    \return This function returns the pointer allocated (via malloc), or NULL if the system is running
            out of memory.
 */

void* dmalloc(size_t size, char *message, char *file)
{
  void *p;
  char *iobuff, address[DMALLOC_ADDRESS_SIZE];
  int  buff_size;

  p = malloc (size);
  if (p == NULL) { return NULL; }

  snprintf (address, DMALLOC_ADDRESS_SIZE-1, "\n%X", (unsigned int)p);

  buff_size = strlen(address)+strlen(": ")+strlen(message)+1;

  iobuff = (char*)malloc(buff_size);
  if (iobuff == NULL) { return NULL; }

  my_logger (
              file,
              iobuff,
              buff_size,
              "sss",
              address,
              ": ",
              message
            );

  free (iobuff);
  return p;
}

/*! \example test_dmalloc.c
    This file shows how to use the functions of the dmalloc library.
 */

/*! \brief Free allocated memory (using free), and log a message into a log file.
    \param p Pointer to the start of the memory location to free.
    \param message Pointer to a zero terminated string of characters that contains the message to log.
    \param file Name of the log file.
    \return The function returns 0 if success, otherwise the function returns 1 (this means that the system
            is running out of memory).
 */

int dfree(void* p, char *message, char *file)
{
  char *iobuff, address[DMALLOC_ADDRESS_SIZE];
  int  buff_size;

  snprintf (address, DMALLOC_ADDRESS_SIZE-1, "\n%X", (unsigned int)p);
  free (p);
  buff_size = strlen(address)+strlen(": ")+strlen(message)+1;

  iobuff = (char*)malloc(buff_size);
  if (iobuff == NULL) { return 1; }

  my_logger (
              file,
              iobuff,
              buff_size,
              "sss",
              address,
              ": ",
              message
            );

  free (iobuff);

  return 0;
}

/*! \example test_dmalloc.c
    This file shows how to use the functions of the dmalloc library.
 */

dstring.c

/*! \file dstring.c
    This file implements dynamic string manipulation functions.
 */

#include <stdlib.h>
#include <string.h>
#include "dstring.h"


#include <stdio.h>

/*! \brief Initialize a dynamic string.
    \param s Pointer to a given dynamic string.
    \param init_size Initial size of the dynamic string.
    \return Upon successful completion, the function returns 0. Otherwise the function returns 1 (this means
            that the process is running out of memory.
    \warning You <b>MUST</b> initialize a dynamic string (using dstring_init()), before you can do any
             operation on it.
 */

int dstring_init (dstring *s, size_t init_size)
{
  s->data   = (char*)malloc(init_size);
  if (s->data == NULL) { return 1; }
  memset ((void*)s->data, 0, init_size);
  s->size   = init_size;
  s->nb_car = 0;

  return 0;
}

/*! \example test_dstring.c
    This file shows how to use the entire API for dynamic string manipulation.
 */

/*! \brief Free all memory allocated for a dynamic string.
    \param s Pointer to a given dynamic string.
 */

void dstring_free (dstring *s)
{
  free (s->data);
  s->data   = NULL;
  s->size   = 0;
  s->nb_car = 0;
}

/*! \example test_dstring.c
    This file shows how to use the entire API for dynamic string manipulation.
 */

/*! \brief Add characters into a given dynamic string.
    \param s Pointer to a given dynamic string.
    \param buff Pointer to a buffer that contains the characters to add to the dynamic string.
    \param nb_elem Number of characters to add.
    \return Upon successful completion, the function returns 0. Otherwise the function returns 1 (this means
            that the process is running out of memory.
    \warning You <b>MUST</b> initialize a dynamic string (using dstring_init()), before you can add data into it.
 */

int dstring_add (dstring *s, char *buff, size_t nb_elem)
{

  /* --------------------------------------------- */
  /* We may need to allocate memory                */
  /* --------------------------------------------- */

  while ((s->nb_car + nb_elem) > s->size)
  {     
    s->size = 2 * s->size;
    s->data = (char*)realloc((void*)s->data, s->size);
    if (s->data == NULL) { return 1; }
  }

  memcpy ((void*)(s->data + s->nb_car), (void*)buff, nb_elem);

  s->nb_car = s->nb_car + nb_elem;

  return 0;
}

/*! \example test_dstring.c
    This file shows how to use the entire API for dynamic string manipulation.
 */

/*! \brief Return the content of a dynamic string.
    \param s Pointer to a given dynamic string.
    \param size pointer to a <i>size_t</i> value that will be used to store the number of bytes extracted
           from the dynamic string.
    \return Upon successful completion, the function returns a pointer to a dynamically allocated buffer
            that contains the dynamic string's data. The value pointed by <i>size</i> represents the number
            of bytes allocated for the returned string (including the final 0). If the function could not
            allocate memory, then it returns NULL.
    \warning The returned pointer points to a memory location that has been allocated within the function.
             Therefore you should free it (using free()) when you don't need it anymore.
 */

char* dstring_get_data (dstring *s, size_t *size)
{
  char *st;

  *size = s->nb_car + 1;

  st = (char*)malloc(*size);
  if (st == NULL) { return NULL; }

  memcpy ((void*)st, (void*)s->data, s->nb_car);

  /* --------------------------------------------- */
  /* Add a zero at the end ...                     */
  /* --------------------------------------------- */

  *(st + s->nb_car) = 0;

  return st;
}

/*! \example test_dstring.c
    This file shows how to use the entire API for dynamic string manipulation.
 */

endian.c

/*! \file endian.c
    This file implements various utilities to swap between little/big endian.
 */

#include "my_endian.h"


/*! \brief Swap a 2 byte signed integer.
    \param tni2 Pointer to the 2 byte signed integer to swap.
 */

void swap_short_2(short *tni2)
{
 *tni2=(((*tni2>>8)&0xff) | ((*tni2&0xff)<<8));  
}

/*! \brief Swap a 2 byte unsigned integer.
    \param tni2 Pointer to the 2 byte unsigned integer to swap.
 */

void swap_u_short_2(unsigned short *tni2) 
{
 *tni2=(((*tni2>>8)&0xff) | ((*tni2&0xff)<<8));  
}

/*! \brief Swap a 4 byte signed integer.
    \param tni4 Pointer to the 4 byte signed integer to swap.
 */

void swap_int_4(int *tni4) 
{
 *tni4=(((*tni4>>24)&0xff) | ((*tni4&0xff)<<24) |
	    ((*tni4>>8)&0xff00) | ((*tni4&0xff00)<<8));  
}

/*! \brief Swap a 4 byte unsigned integer.
    \param tni4 Pointer to the 4 byte unsigned integer to swap.
 */

void swap_u_int_4(unsigned int *tni4) 
{
 *tni4=(((*tni4>>24)&0xff) | ((*tni4&0xff)<<24) |
	    ((*tni4>>8)&0xff00) | ((*tni4&0xff00)<<8));  
}

/*! \brief Swap a 4 byte signed long integer.
    \param tni4 Pointer to the 4 byte signed long integer to swap.
 */

void swap_long_4(long *tni4)
{
 *tni4=(((*tni4>>24)&0xff) | ((*tni4&0xff)<<24) |
	    ((*tni4>>8)&0xff00) | ((*tni4&0xff00)<<8));  
}

/*! \brief Swap a 4 byte unsigned long integer.
    \param tni4 Pointer to the 4 byte unsigned long integer to swap.
 */

void swap_u_long_4(unsigned long *tni4) 
{
 *tni4=(((*tni4>>24)&0xff) | ((*tni4&0xff)<<24) |
	    ((*tni4>>8)&0xff00) | ((*tni4&0xff00)<<8));  
}

/*! \brief Swap a 4 byte floating point number.
    \param tnf4 Pointer to the 4 byte floating point number to swap.
 */

void swap_float_4(float *tnf4) 
{
 int *tni4=(int *)tnf4;
 *tni4=(((*tni4>>24)&0xff) | ((*tni4&0xff)<<24) |
	    ((*tni4>>8)&0xff00) | ((*tni4&0xff00)<<8));  
}

/*! \brief Swap a 8 byte double number.
        \param tndd8 Pointer to the 8 byte double number to swap.
 */

void swap_double_8(double *tndd8) 
{
  char *tnd8=(char *)tndd8;
  char tnc;

  tnc=*tnd8;
  *tnd8=*(tnd8+7);
  *(tnd8+7)=tnc;

  tnc=*(tnd8+1);
  *(tnd8+1)=*(tnd8+6);
  *(tnd8+6)=tnc;

  tnc=*(tnd8+2);
  *(tnd8+2)=*(tnd8+5);
  *(tnd8+5)=tnc;

  tnc=*(tnd8+3);
  *(tnd8+3)=*(tnd8+4);
  *(tnd8+4)=tnc;
}

files.c

/*! \file files.c
    This file contains all the file's related functions.
 */

#include "files.h"

/*! \brief Wait for a file to appear.
    \param file_name Name of the file.
    \param period The function test if the file exists periodically. If the file does not exist, then the process is put
           to sleep for a certain amount of time, and then the function tests the file existence again ... and so on. Between
           each test, the process is put to sleep for 'period' seconds.
    \param stop_file If the file that name is defined by 'stop_file' exists, then the function exists and returns 1.
    \return  If the file represented by 'file_name' exists, the function return 0. If the file represented by
             'stop_file' exists, the the function returns 1.
    \warning This function uses the system call access() to test the existence of a file. According to the documentation,
             this system call can be interrupted by a signal. But in this case the return value is -1, which is also the
             return value if the file does not exist. Therefore we do not have to perform any special action in case the
             system call is interrupted ... we just try again.
 */

int wait_for_file (char* file_name, int period, char* stop_file)
{
  while (access (file_name, F_OK) == -1)
  {
     if (stop_file != NULL)
     {
       if (access (stop_file, F_OK) == 0) { return 1; }
     }

     sleep (period);
  }
  return 0;
} 

/*! \example test_wait_for_file.c
    This file shows how to use the function wait_for_file().
 */


/*! \brief Wait for a file (within a list of files) to exist.
    \param file_names This variable represents the list of file names to test. It is an array of strings, each string 
           represents a file name. The last element of the list MUST be set to NULL.
    \param period The function test if the file exists periodically. If the file does not exist, then the process is put
           to sleep for a certain amount of time, and then the function tests the file existence again ... and so on. Between
           each test, the process is put to sleep for 'period' seconds.
    \param stop_file If the file that name is defined by 'stop_file' exists, then the function exists and returns 1.
    \return If one of the files specified in the list of files exists, the function returns a non NULL pointer that points
            a the name of the file. If the file represented by 'stop_file' exists, the the function returns NULL.
    \warning The last element of the list of file names MUST be set to NULL. If you want to wait on 3 files, then the
             variable 'file_names' must be an array of 4 elements: the 3 file names and the last NULL pointer.
 */

char* wait_for_multiple_file (char **file_names, int period, char* stop_file)
{
  char *name;
  int  pos;

  while (1==1)
  {
     pos  = 0;
     name = file_names[pos];

     while (name != NULL)
     {
       if (access (name, F_OK) == 0) { return name; }
       pos++;
       name = file_names[pos];
     }

     if (stop_file != NULL)
     { if (access (stop_file, F_OK) == 0) { break; } }

     sleep(period);
  }

  return NULL;
}

/*! \example test_wait_for_multiple_files.c
    This file shows how to use the function wait_for_multiple_file.
 */

/*! \brief Load the content of a file into an in-memory buffer.
    \param file_name Pointer to a zero terminated file that represents the name of the file to load..
    \param buff Pointer to a pointer that will be used to save the file's content.
    \return If the function succed, the function returns a positive interger that represents the number of bytes extracted
            from the file. If the function failes, then it returns a negative integer. This integer could be:
            <UL>
              <li>FILES_UTIL_MALLOC_ERR
              <li>FILES_UTIL_READ_ERR
            </UL>
    \warning The memory pointed by 'buff' has been allocated within the function, therefore you must free it yourself
             (using free()).
 */ 

int read_file (char *file_name, char **buff)
{
  int   c, lu, taille;
  FILE  *fd;
 
  fd = fopen (file_name, "r");
  if (fd == NULL) { return FILES_UTIL_OPEN_ERR; }

 
  taille = FILES_UTIL_INIT_BUFF_SIZE;
  *buff = (char*)malloc(taille);
  if (*buff == NULL)
  {
     fclose(fd);
     return FILES_UTIL_MALLOC_ERR;
  }

  lu=0;
  c = fgetc(fd);

  while (feof(fd) == 0)
  {
    if (c == EOF)
    {
       fclose(fd);
       return FILES_UTIL_READ_ERR;
    }
    lu++;
    
    while (lu > (taille-1))
    {
      taille *= 2;
      *buff = (char*)realloc((void*)(*buff), taille);
      if (*buff == NULL)
      { 
         fclose(fd);
         return FILES_UTIL_MALLOC_ERR;
      }
    }

    *((*buff) + (lu-1)) = (char)c;
    c = fgetc(fd);    
  }
  *((*buff) + lu) = '\0';

  fclose(fd);
  return lu;
}

/*! \example test_read_file.c
    This file shows how to use the function read_file().
 */

/*! \brief Set the timeout file that contains the current number of seconds since January 1970 00:00:00.
    \param filename Pointer to a zero terminated string of characters that represents the path to the file.
    \return The function returns one of the following values:
            <UL>
                <li>SET_TIMEOUT_FILE_OPEN_ERROR: Can not open the target file 'filename'.
                <li>SET_TIMEOUT_FILE_WRITE_ERROR: Error while writing in the target file.
                <li>SET_TIMEOUT_FILE_OK: The function succed.
            </UL>
 */

int set_timeout_file (char *filename)
{
  time_t  current_time;
  FILE    *fd;
  int     cr;

  fd = fopen(filename, "w");
  if (fd == NULL) { return SET_TIMEOUT_FILE_OPEN_ERROR; }

  current_time = time(NULL);

  cr = fwrite ((void*)¤t_time, sizeof(time_t), 1, fd);
  if (cr != 1)
  {
    fclose (fd);
    return SET_TIMEOUT_FILE_WRITE_ERROR;
  }

  fclose (fd);
  return SET_TIMEOUT_FILE_OK;
}

/*! \example test_timeout_file.c
    This file shows how to use the functions set_timeout_file() and test_timeout_file().
 */

/*! \brief Look at a <i>timeout file</i> to see if the calling process should wait or go ahead.
    \param filename Pointer to a zero terminated string of characters that represents the timeout file.
    \param timeout Integer value that represents the timeout in seconds.
    \return The function returns one of the following values:
            <UL>
                <li>TEST_TIMEOUT_FILE_TIMEOUT_ELLAPSED: The timeout is passed.
                <li>TEST_TIMEOUT_FILE_READ_ERROR: An error occured while reading the timeout file.
                <li>TEST_TIMEOUT_FILE_TIMEOUT_NOT_ELLAPSED: The timeout is not passed yet.
                <li>TEST_TIMEOUT_FILE_UNLINK_FAILED: An error occured while removing the timeout file.
            </UL>
    \warning The timeout file should have been set by using the function set_timeout_file(). 
 */

int test_timeout_file (char *filename, int timeout)
{
  time_t  current_time, file_time, delta;
  FILE    *fd;
  int     cr;

  /* ============================================= */
  /* Try to open the timeout file - If it does not */
  /* exist, it means that there was no timeout ... */
  /* ============================================= */

  fd = fopen(filename, "r");
  if (fd == NULL) { return TEST_TIMEOUT_FILE_TIMEOUT_ELLAPSED; }

  /* ============================================= */
  /* Read timestamp written into the file          */
  /* ============================================= */

  cr = fread ((void*)&file_time, sizeof(time_t), 1, fd);
  if (cr != 1)
  {
    fclose (fd);
    return TEST_TIMEOUT_FILE_READ_ERROR;
  }
  current_time = time(NULL);

  /* ============================================= */
  /* Calculate the ellapsed time                   */
  /* ============================================= */

  delta = current_time - file_time;
  if (delta < timeout)
  { 
    fclose (fd);
    return TEST_TIMEOUT_FILE_TIMEOUT_NOT_ELLAPSED;
  }
 
  fclose (fd);

  /* ============================================= */
  /* Delete timeout file if the timeout expired    */
  /* ============================================= */

  if (unlink (filename) != 0) { return TEST_TIMEOUT_FILE_UNLINK_FAILED; }

  return TEST_TIMEOUT_FILE_TIMEOUT_ELLAPSED;
}

/*! \example test_timeout_file.c
    This file shows how to use the functions set_timeout_file() and test_timeout_file().
 */



/*! \brief Extract the base name of a given file name.
    \param src Pointer to a zero terminated string of characters that represents the name of the file.
    \param dst Pointer to a memory location that will be sued to store a zero terminated string of
               characters that is the base name of the file.
    \warning No test is done regarding the size of the memory chunck pointed by dst. It is your responsability
             to allocate enough memory for the resulting string of characters!
 */

void basename (char *src, char *dst)
{
  char  *pt;

  pt = strrchr (src, '/');
  if (pt == NULL) { pt = src; }
  else { pt += 1; }

  strcpy (dst, pt);
}

flock.c

/*! \file flock.c
    This file contains funtions used to lock/unlock files.
 */

#include "flock.h"
#include <stdio.h>

#define DEBUG_TRACE(x) fprintf (stderr, x)

/*! \brief Lock a file.
    \param fd File descriptor that identifies the file to lock.
    \return If the lock succed, the function returns 0. Otherwise the function returns 1.
 */

int lock_file(int fd)
{
  int cr;

  #ifdef SUN
    struct flock lck;
  #endif

  #ifdef LINUX
    cr = flock (fd, LOCK_EX);
    if (cr == -1)
    {
      DEBUG_TRACE("\n\nflock failed\n\n");
      return 1;
    }
  #endif

  #ifdef SUN
    lck.l_start   = 0;        /* from the beginning of thr file ... */
    lck.l_len     = 0;        /* to the end if the file.            */
    lck.l_type    = F_WRLCK;  /* exclusive lock                     */
    lck.l_whence  = SEEK_SET; /* lock from the beginning            */
    cr = fcntl (fd, F_SETLKW, &lck);
    if (cr == -1)
    {
      DEBUG_TRACE("\n\nfcntl failed\n\n");
      return 1;
    }
  #endif

  return 0;
}

/*! \brief Unlock a file.
    \param fd File descriptor that identifies the file to unlock.
    \return If the operation succed, the function returns 0. Otherwise the function returns 1.
 */

int unlock_file(int fd)
{
  int cr;

  #ifdef SUN
    struct flock lck;
  #endif

  #ifdef LINUX
    cr = flock (fd, LOCK_UN);
    if (cr == -1)
    {
      DEBUG_TRACE("\n\nflock failed\n\n");
      return 1;
    }
  #endif

  #ifdef SUN
    lck.l_start   = 0;        /* from the beginning of thr file ... */
    lck.l_len     = 0;        /* to the end if the file.            */
    lck.l_type    = F_UNLCK;  /* exclusive lock                     */
    lck.l_whence  = SEEK_SET; /* lock from the beginning            */
    cr = fcntl (fd, F_SETLKW, &lck);
    if (cr == -1)
    {
      DEBUG_TRACE("\n\nfcntl failed\n\n");
      return 1;
    }
  #endif

  return 0;
}


/*! \brief Maximum number of characters for an integer.
 */

#define INT_MAX_CHAR    32

/*! \brief Write data into the log file.
    \param file_name Pointer to a NULL terminated string of characters that contains the name of the log file.
           Please note that if file_name[0] is equal to 0, then the function does nothing. This may be used to
           manage debug logging.
    \param buffer Pointer to a memory location used by the function to format the data to print.
    \param buffsize Size of the memory location 'buffer' in bytes.
    \param format Pointer to a NULL terminated string of characters that describes the format of the output. 's' means
           'char*', 'd' means 'interger' and 'u' means 'unsigned int'.
    \return The function return LOG_OK if the operation succed. Otherwise the function returns LOG_BUFFER_OVERFLOW,
            LOG_WRITE_ERROR, LOG_OPEN_ERROR, LOG_CLOSE_ERROR or LOG_LOCK_ERROR.
 */


int my_logger (char *file_name, char *buffer, int buffsize, char *format, ...)
{
   int          flock_fd;
   int          cr;
   int          done;
   char         buff[INT_MAX_CHAR];

   va_list      ap;
   char         *s;
   int          d;
   unsigned int u;
  

   /*****************************/
   /* If the name of the file   */
   /* empty, then do nothing.   */
   /*****************************/

   if (file_name[0] == 0) { return LOG_OK; }
 
   /*****************************/
   /* Open and lock the file    */
   /*****************************/

   flock_fd = open (file_name, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU);
   if (flock_fd == -1)
   {
     DEBUG_TRACE("\n\nopen failed\n\n");
     return LOG_OPEN_ERROR;
   }

   cr = lock_file (flock_fd);
   if (cr == 1)
   {
     DEBUG_TRACE("\n\nlock_file failed\n\n");
     close(flock_fd); return LOG_LOCK_ERROR;
   }

   /*****************************/
   /* Extract stuff to write    */
   /*****************************/

   va_start (ap, format);
   done      = 0;
   memset ((void*)buffer, 0, buffsize);

   while (*format)
   {
     switch  (*(format++))
     {
       case 's': {
            s = va_arg (ap, char *);
            if (s != NULL)
            {
              done += strlen(s);
              if (done > buffsize-1)
              {
                unlock_file (flock_fd);
                close (flock_fd);
                return LOG_BUFFER_OVERFLOW;
              }
              strcat (buffer, s);
            }
       }; break;

       case 'd': {
            d = va_arg (ap, int);
            sprintf (buff, "%d", d);
            done += strlen(buff);
            if (done > buffsize-1)
            {
              unlock_file (flock_fd);
              close (flock_fd);
              return LOG_BUFFER_OVERFLOW;
            }
            strcat (buffer, buff);
       }; break;

       case 'u': {
            u = va_arg (ap, unsigned int);
            sprintf (buff, "%u", u);
            done += strlen(buff);
            if (done > buffsize-1)
            {
              unlock_file (flock_fd);
              close (flock_fd);
              return LOG_BUFFER_OVERFLOW;
            }
            strcat (buffer, buff);
       }; break;
     }
   }

   /*****************************/
   /* Write data to log file    */
   /*****************************/

   cr = write (flock_fd, buffer, strlen(buffer));
   if (cr == -1)
   {
      unlock_file (flock_fd);
      close (flock_fd);
      return LOG_WRITE_ERROR;
   }

   /*****************************/
   /* Unlock and close the file */
   /*****************************/

   cr = unlock_file (flock_fd);
   if (cr == 1)
   {
     DEBUG_TRACE("\n\nunlock_file failed\n\n");
     close(flock_fd); return LOG_LOCK_ERROR;
   }

   cr = close (flock_fd);
   if (cr == -1)
   {
     DEBUG_TRACE("\n\nclose failed\n\n");
     return LOG_CLOSE_ERROR;
   }

   return LOG_OK;
}

/*! \example test_flock.c
    This file shows how to ise the function my_logger().
 */


/*! \brief Append a file to another - The destination file is locked.
    \param src Pointer to a zero terminated string of characters that represents the name of the source file.
    \param dst Pointer to a zero terminated string of characters that represents the name of the destination file.
    \return The function returns COPY_OK if the operation succed. Otherwise, the function may return:
            <UL>
              <li>COPY_SRC_OPEN_ERROR Can not open the source file.
              <li>COPY_DST_OPEN_ERROR Can not open the destination file.
              <li>COPY_LOCK_ERROR Lock on the destination file failed.
              <li>COPY_STAT_ERROR Can not stat() the srouce file.
              <li>COPY_READ_ERROR Error while reading the source file.
              <li>COPY_WRITE_ERROR Error while writing to the destination file.
              <li>COPY_UNLOCK_ERROR Error while unlocking the destinatination file.
              <li>COPY_SRC_CLOSE_ERROR Error while closing the source file.
              <li>COPY_DST_CLOSE_ERROR Error while closing the destination file.
            </UL>
 */

int append_file_with_lock (char *src, char *dst)
{
   int         src_fd, dst_fd;
   int         cr;
   off_t       fsize, i, nb_blcoks, reminder;
   char        iobuff[COPY_IOBUFF_SIZE];
   struct stat s_stat;
   size_t      rw;


   /**********************************/
   /* Open the source file           */
   /**********************************/
  
   src_fd = open (src, O_RDONLY, S_IRWXU);
   if (src_fd == -1)
   {
     return COPY_SRC_OPEN_ERROR;
   }

   /**********************************/
   /* Open the destination file and  */
   /* lock it.                       */
   /**********************************/

   dst_fd = open (dst, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU);
   if (dst_fd == -1)
   {
     close (src_fd);
     return COPY_DST_OPEN_ERROR;
   }

   cr = lock_file (dst_fd);
   if (cr == 1)
   {
     close(src_fd);
     close(dst_fd);
     return COPY_LOCK_ERROR;
   }

   /**********************************/
   /* Get file's size                */
   /**********************************/

   cr = stat (src, &s_stat);
   if (cr != 0)
   {
     close(src_fd);
     unlock_file (dst_fd);
     close(dst_fd);
     return COPY_STAT_ERROR;
   }

   /**********************************/
   /* Calculate number of full       */
   /* block.                         */
   /**********************************/

   fsize = s_stat.st_size;
   nb_blcoks = fsize / COPY_IOBUFF_SIZE;
   reminder = fsize - (nb_blcoks*COPY_IOBUFF_SIZE);

   /**********************************/
   /* Copy full blocks               */
   /**********************************/

   for (i=0; i<nb_blcoks; i++)
   {
     rw = read (src_fd, (void*)iobuff, COPY_IOBUFF_SIZE);
     if (rw != COPY_IOBUFF_SIZE)
     {
       close(src_fd);
       unlock_file (dst_fd);
       close(dst_fd);
       return COPY_READ_ERROR;
     }

     rw = write (dst_fd, (void*)iobuff, COPY_IOBUFF_SIZE);
     if (rw != COPY_IOBUFF_SIZE)
     {
       close(src_fd);
       unlock_file (dst_fd);
       close(dst_fd);
       return COPY_WRITE_ERROR;
     }
   }

   /**********************************/
   /* Copy reminder                  */
   /**********************************/

   rw = read (src_fd, (void*)iobuff, (size_t)reminder);
   if (rw != (size_t)reminder)
   {
     close(src_fd);
     unlock_file (dst_fd);
     close(dst_fd);
     return COPY_READ_ERROR;
   }

   rw = write (dst_fd, (void*)iobuff, (size_t)reminder);
   if (rw != (size_t)reminder)
   {
     close(src_fd);
     unlock_file (dst_fd);
     close(dst_fd);
     return COPY_WRITE_ERROR;
   }

   /**********************************/
   /* Unlock destination file        */
   /**********************************/

   cr = unlock_file (dst_fd);
   if (cr == 1)
   {
     close(src_fd); 
     close(dst_fd);
     return COPY_UNLOCK_ERROR;
   }

   /**********************************/
   /* Close all files                */
   /**********************************/

   cr = close(src_fd);
   if (cr == -1)
   {
     close(dst_fd);
     return COPY_SRC_CLOSE_ERROR;
   }

   cr = close(dst_fd);
   if (cr == -1)
   {
     return COPY_DST_CLOSE_ERROR;
   }

   return COPY_OK;
}

/*! \example test_copy_lock.c
    This file shows how to use the function append_file_with_lock().
 */

hashfunc.c

/*! \file hashfunc.c
    This file contains various hash functions.
 */

#include "hashfunc.h"


/*! \brief Calculate an index from a string of charecters.
    \param Key Pointer to a zero terminated string of characters.
    \param TableSize 'TableSize-1' represents the maximum value possible for the index. In other words, the value of 
           the returned index will be such as:  0 <= index <= (TableSize-1).
 */

Index Hash1( const char *Key, int TableSize )
{
  unsigned int HashVal = 0;

  while(*Key != '\0') { HashVal += *Key++; }
  HashVal += *Key++;

  return HashVal % TableSize;
}

/*! \example test_hash_func.c
    This file shows how to use the hashing functions.
 */

/*! \brief Calculate an index from a string of charecters.
    \param Key Pointer to a zero terminated string of characters.
    \param TableSize 'TableSize-1' represents the maximum value possible for the index. In other words, the value of
           the returned index will be such as:  0 <= index <= (TableSize-1).
 */

Index Hash2( const char *Key, int TableSize )
{ return ( Key[ 0 ] + 27 * Key[ 1 ] + 729 * Key[ 2 ] ) % TableSize; }

/*! \example test_hash_func.c
    This file shows how to use the hashing functions.
 */

/*! \brief Calculate an index from a string of charecters.
    \param Key Pointer to a zero terminated string of characters.
    \param TableSize 'TableSize-1' represents the maximum value possible for the index. In other words, the value of
           the returned index will be such as:  0 <= index <= (TableSize-1).
 */

Index Hash3( const char *Key, int TableSize )
{
  unsigned int HashVal = 0;

  while( *Key != '\0' ) { HashVal = ( HashVal << 5 ) + *Key++; }

  return HashVal % TableSize;
}

/*! \example test_hash_func.c
    This file shows how to use the hashing functions.
 */

issort.c

/*! \file issort.c
    This file implements sorting by insersion
 */


#include <stdlib.h>
#include <string.h>
#include "sort.h"




/*! \brief Sort data using the insertion method.
    \param donnee Pointer to the beginning of the array to sort.
    \param nb_elts Number of elements in the array.
    \param taille_elt Size in bytes of one element.
    \param compare User defined function used to compare two elements of the array.
           If you want to sort according to increasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 > cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 < cle2</i>
           </UL>
           If you want to sort according to decreasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 < cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 > cle2</i>
           </UL>
    \return Upon successful completion the function returns 0, otherwise it returns -1
    \warning This function is not suitable if you need to sort an inportant number of element.
 */

int issort (
              void *donnee,
              int  nb_elts,
              int  taille_elt, 
              int  (*compare)(const void *cle1, const void *cle2)
           )
{
  char  *tab = donnee;
  void  *cle;
  int   i, j;

  /* ------------------------------------------------------------ */
  /* Allocate memory                                              */
  /* ------------------------------------------------------------ */

  if ((cle = (char *)malloc(taille_elt)) == NULL) { return -1; }

  /* ------------------------------------------------------------ */
  /* Insert a key                                                 */
  /* ------------------------------------------------------------ */

  for (j = 1; j < nb_elts; j++)
  {
     memcpy(cle, &tab[j * taille_elt], taille_elt);
     i = j - 1;

    /* ---------------------------------------------------------- */
    /* Where to insert the key                                    */
    /* ---------------------------------------------------------- */

     while (i >= 0 && compare(&tab[i * taille_elt], cle) > 0)
     {
       memcpy(&tab[(i + 1) * taille_elt], &tab[i * taille_elt], taille_elt);
       i--;
     }

     memcpy(&tab[(i + 1) * taille_elt], cle, taille_elt);
  }

  /* ------------------------------------------------------------ */
  /* Free all allocated memory                                    */
  /* ------------------------------------------------------------ */

  free(cle);

  return 0;
}

/*! \example test_sort.c
    This file shows how to use the function issort().
 */

/*! \brief Extended version of the function <i>issort()</i>. This can be used to handle complex data.
    \param donnee Pointer to the beginning of the array to sort.
    \param nb_elts Number of elements in the array.
    \param compare User defined function used to compare two elements of the array.
           If you want to sort according to increasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 > cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 < cle2</i>
           </UL>
           If you want to sort according to decreasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 < cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 > cle2</i>
           </UL>
    \param copy_data User defined function used to copy data. <B>The function must take care of memory management.</B>
                     This function must return:
                     <UL>
                        <li>0 upon successful completion.
                        <li>1 if an error occured.
                     </UL>
    \param init_elem User defined function used to initialize an element. You can specify a NULL pointer if you do not need to initialize
                     elements. This function must return:
                     <UL>
                        <li>0 upon successful completion.
                        <li>1 if an error occured.
                     </UL>
                     This function is called whenever a new element is allocated.
    \return Upon successful completion the function returns 0, otherwise it returns -1
    \warning This function is not suitable if you need to sort an inportant number of element.
 */



int extended_issort (
                      void  *donnee,
                      int   nb_elts,
                      int   taille_elt,
                      int   (*compare)(const void *cle1, const void *cle2),
                      int   (*copy_data)(void *src, void *dest),
                      int   (*init_elem)(void *elm)
                    )
{
  char  *tab = donnee;
  void  *cle;
  int   i, j;

  /* ------------------------------------------------------------ */
  /* Allocate memory                                              */
  /* ------------------------------------------------------------ */

  if ((cle = (char *)malloc(taille_elt)) == NULL) { return -1; }
  if (init_elem != NULL) { if (init_elem(cle) == 1) { free(cle); return -1; } }

  /* ------------------------------------------------------------ */
  /* Insert a key                                                 */
  /* ------------------------------------------------------------ */

  for (j = 1; j < nb_elts; j++)
  {
     if (copy_data (&tab[j * taille_elt], cle) == 1) { free(cle); return -1; } 
     i = j - 1;

    /* ---------------------------------------------------------- */
    /* Where to insert the key                                    */
    /* ---------------------------------------------------------- */

     while (i >= 0 && compare(&tab[i * taille_elt], cle) > 0)
     {
       if (copy_data (&tab[i * taille_elt], &tab[(i + 1) * taille_elt]) == 1) { free(cle); return -1; }
       i--;
     }

     if (copy_data (cle, &tab[(i + 1) * taille_elt]) == 1) { free(cle); return -1; }
  }

  /* ------------------------------------------------------------ */
  /* Free all allocated memory                                    */
  /* ------------------------------------------------------------ */

  free(cle);

  return 0;
}

/*! \example test_ext_sort.c
    This file shows how to use the function extended_issort().
 */

list.c

/*! \file list.c
    This code implements linked lists.
 */


#include <stdlib.h>
#include <string.h>
#include "list.h"

/*! \brief Initialize the linked list. This function should be called first.
    \param liste Pointer to a linked list structure (that will be initialized).
    \param detruire Pointer to a function that will be called to free the memory used to store one link of the list. Please note that:
           <UL>
              <li>This function depends on the type of data stored into the linked list.
              <li><i>detruire</i> could be a NULL pointer (if user's data are not dtnamically allocated).
           </UL>
    \param corresp Pointer to a function that will be called to compare to elements. Please note that this function depends on the type
                   of data stored into the linked list. The function must returns 1 if the elements' datas are identical; 0 otherwise.
 */

void list_init(List *liste, void (*detruire)(void *donnee), int (*corresp)(const void *val1, const void *val2))
{
  liste->taille   = 0;
  liste->detruire = detruire;
  liste->corresp  = corresp;
  liste->tete     = NULL;
  liste->queue    = NULL;

  return;
}

/*! \example test_list.c
    This file shows how to use the function list_init().
 */

/*! \brief Destroy the linked list. This function free all allocated memory used by the list.
    \param liste Pointer to a linked list structure (that you need to destroy).
 */

void list_destroy(List *liste)
{
  void  *donnee;

  while (list_size(liste) > 0)
  {
    if ((list_rem_next(liste, NULL, (void **)&donnee) == 0) && (liste->detruire !=  NULL))
    { liste->detruire(donnee); }
  }

  memset(liste, 0, sizeof(List));

  return;
}

/*! \example test_list.c
    This file shows how to use the function list_destroy().
 */

/*! \brief Insert a new element into the linked list.
    \param liste Pointer to a linked list structure.
    \param element Pointer to an (existing) element of the linked list. The new element will be inserted <B>AFTER</B> the element pointed
                   by <i>element</i>.
    \param donnee Pointer to the data to insert. Please note that the data is <B>NOT</B> copied into the linked list.
    \return Upon successful completion the function return the value 0. Otherwise the function returns -1.
    \warning The inserted data is <B>NOT</B> copied into the linked list! Therefore you should not free it unless you know exactly what you
             are doing.
 */

int list_ins_next(List *liste, ListElmt *element, const void *donnee)
{
  ListElmt *nouv_element;

  /* --------------------------------------------------- */
  /* Allocate memory for the new element                 */
  /* --------------------------------------------------- */

  if ((nouv_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL) { return -1; }

  /* --------------------------------------------------- */
  /* Set new element's data                              */
  /* --------------------------------------------------- */

  nouv_element->donnee = (void *)donnee;

  if (element == NULL)
  {
    /* ------------------------------------------------- */
    /* Insert to the beginning of the list               */
    /*   - in this case there is no previous element.    */
    /*   - the new element becomes the head of the list  */
    /* ------------------------------------------------- */

     if (list_size(liste) == 0) { liste->queue = nouv_element; }

     nouv_element->suivant   = liste->tete;

     #ifdef DOUBLE_LINK
       nouv_element->precedent = NULL;
     #endif

     liste->tete = nouv_element;
  }
  else
  {
    /* ------------------------------------------------- */
    /* Somewhere into the list, but not the beginning    */
    /* ------------------------------------------------- */

     if (element->suivant == NULL) { liste->queue = nouv_element; }

     nouv_element->suivant = element->suivant;

     #ifdef DOUBLE_LINK
       nouv_element->precedent = element;
     #endif

     element->suivant = nouv_element;
  }

  /* --------------------------------------------------- */
  /* increment the number of elements of the list        */
  /* --------------------------------------------------- */

  liste->taille++;

  return 0;
}

/*! \example test_list.c
    This file shows how to use the function list_ins_next().
 */


/*! \brief Remove an element from the linked list.
    \param liste Pointer to a linked list structure.
    \param element Pointer to an (existing) element of the linked list. The element to delete is the element <B>AFTER</B> the element
                   pointed by <i>element</i>. If you want to remove the first element of the list, then you must specify NULL as second
                   argument for the function list_rem_next().
    \param donnee Pointer that vill point to the data stored by the removed element.
    \return Upon successful completion the function return the value 0. Otherwise the function returns -1.
    \warning This function does <B>NOT</B> free the element's data (it only frees the element's structure). Therefore you should use
             <i>donnee</i> to free the element's data yourself.
 */

int list_rem_next(List *liste, ListElmt *element, void **donnee)
{
  ListElmt  *ancien_element;

  /* --------------------------------------------------- */
  /* Make sure that the list is not empty                */
  /* --------------------------------------------------- */

  if (list_size(liste) == 0) { return -1; }

  /* --------------------------------------------------- */
  /* Removing the element                                */
  /* --------------------------------------------------- */

  if (element == NULL)
  {
    /* ------------------------------------------------- */
    /* Removing at the beginning of the list             */
    /*   - The second element becomes the first (which   */
    /*     has no previous element now).                 */
    /* ------------------------------------------------- */

    *donnee = liste->tete->donnee;
    ancien_element = liste->tete;
    liste->tete = liste->tete->suivant;

    if (list_size(liste) == 1) { liste->queue = NULL; }

    #ifdef DOUBLE_LINK
      else { liste->tete->precedent = NULL; }
    #endif
  }
  else
  {
    /* ------------------------------------------------- */
    /* Somewhere into the list, but not the beginning    */
    /* (And not at the end of the list of course).       */
    /* ------------------------------------------------- */

    if (element->suivant == NULL) { return -1; }

    *donnee = element->suivant->donnee;
    ancien_element = element->suivant;
    element->suivant = element->suivant->suivant;

    if (element->suivant == NULL) { liste->queue = element; }

    #ifdef DOUBLE_LINK
      else { element->suivant->precedent = element; }
    #endif
  }

  /* --------------------------------------------------- */
  /* Free the allocated memory (for the element)         */
  /* --------------------------------------------------- */

  free(ancien_element);

  /* --------------------------------------------------- */
  /* Decrement the number of element of the list         */
  /* --------------------------------------------------- */

  liste->taille--;

  return 0;
}

/*! \example test_list.c
    This file shows how to use the function list_rem_next().
 */


/*! \brief Search an element into the linked list.
    \param liste Pointer to the linked list structure.
    \param from Pointer to the linked list's element where the search begins. If 'point' in NULL, then the search begins at the beginning
                of the linked list.
    \param data Pointer to a data a user defined structure that contains the data to search for.
    \param prec Pointer to a pointer that will receive the address of the element before the found element.
    \return <UL>
              <li>If the function finds an element that matches <i>data</i>, then it returns a pointer to this element. In this case,
                  <i>prec</i> points to the previous element (unless the found element was the first element in the linked list ... in this
                  the value of <i>prec</i> is NULL).
              <li>If there is no element that matches <i>data</i>, then the function returns NULL.
            </UL>
 */

ListElmt* list_find (List *liste, ListElmt *from, void* data, ListElmt **prec)
{
  *prec = NULL; 

  /* --------------------------------------------------- */
  /* If 'from' is NULL pointer, then start the search    */
  /* from the beginning of the linked list.              */
  /* --------------------------------------------------- */

  if (from == NULL) { from = list_head(liste); }

  /* --------------------------------------------------- */
  /* Compare each element with 'data'                    */
  /* --------------------------------------------------- */

  while (from != NULL)
  {
    if (liste->corresp(data, list_data(from))) { return from; }
    *prec = from;
    from = list_next(from);
  }

  return NULL;
}

/*! \example test_list.c
    This file shows how to use the function list_find().
 */

make_char2hex.c

/*! \file make_char2int.c
    This program is used to generate C code (hexa codes) -- It is **NOT** part of the libraries. It is used to build the
    libraries. That's all.
 */

#include <stdio.h>


int main()
{
  int  i, v;
  char c, cc;

  printf ("int char2hex[256] = {\n");

  for (i=0; i<255; i++)
  {
    c = (char)i;
  

    switch (c)
    {
      case '0': v=0;   cc=c; break;
      case '1': v=1;   cc=c; break;
      case '2': v=2;   cc=c; break;
      case '3': v=3;   cc=c; break;
      case '4': v=4;   cc=c; break;
      case '5': v=5;   cc=c; break;
      case '6': v=6;   cc=c; break;
      case '7': v=7;   cc=c; break;
      case '8': v=8;   cc=c; break;
      case '9': v=9;   cc=c; break;
      case 'a': v=10;  cc=c; break;
      case 'b': v=11;  cc=c; break;
      case 'c': v=12;  cc=c; break;
      case 'd': v=13;  cc=c; break;
      case 'e': v=14;  cc=c; break; 
      case 'f': v=15;  cc=c; break;
      case 'A': v=10;  cc=c; break;
      case 'B': v=11;  cc=c; break;
      case 'C': v=12;  cc=c; break;
      case 'D': v=13;  cc=c; break;
      case 'E': v=14;  cc=c; break;
      case 'F': v=15;  cc=c; break;
      default:  v=-1;  cc='-'; 
    }

    printf ("                      %d, /* %d (%c) */\n", v, i, cc);
  }

  printf ("                      -1  /* 255 (-) */\n");
  printf ("                    };");


  return 0;
}

make_char2int.c

/*! \file make_char2int.c
    This program is used to generate C code (hexa codes) -- It is **NOT** part of the libraries. It is used to build the
    libraries. That's all.
 */

#include <stdio.h>


int main()
{
  int  i, v;
  char c, cc;

  printf ("int char2int[256] = {\n");

  for (i=0; i<255; i++)
  {
    c = (char)i;
  

    switch (c)
    {
      case '0': v=0;   cc=c; break;
      case '1': v=1;   cc=c; break;
      case '2': v=2;   cc=c; break;
      case '3': v=3;   cc=c; break;
      case '4': v=4;   cc=c; break;
      case '5': v=5;   cc=c; break;
      case '6': v=6;   cc=c; break;
      case '7': v=7;   cc=c; break;
      case '8': v=8;   cc=c; break;
      case '9': v=9;   cc=c; break;
      default:  v=-1;  cc='-'; 
    }

    printf ("                      %d, /* %d (%c) */\n", v, i, cc);
  }

  printf ("                      -1  /* 255 (-) */\n");
  printf ("                    };");


  return 0;
}

make_dates.c

/*! \file make_dates.c
    This is just a little utility to create arrays that contain: the days of the week and the months of the year. The
    output is nased on the current time setting of the host, so you can get a new parser very easely.
 */


#include <time.h>
#include <stdio.h>


int main ()
{
  char       strtime[256];
  struct tm  tt;
  int        i;

  tt.tm_sec   = 0;
  tt.tm_min   = 0;
  tt.tm_hour  = 0;
  tt.tm_mday  = 1;
  tt.tm_year  = 100;
  tt.tm_yday  = 0;
  tt.tm_isdst = 0;


  fprintf (stdout, "\nchar *days[7] = { ");

  for (i=0; i<6; i++)
  {
    tt.tm_wday = i;
    tt.tm_mon  = 0;
    strftime (strtime, 256, "%a", &tt);
    fprintf (stdout, "\"%s\",", strtime);
  }
  tt.tm_wday = 6;
  strftime (strtime, 256, "%a", &tt);
  fprintf (stdout, "\"%s\" };", strtime);

  fprintf (stdout, "\n\n");

  fprintf (stdout, "\nchar *months[12] = { ");

  for (i=0; i<11; i++)
  {
    tt.tm_wday = 0;
    tt.tm_mon  = i;
    strftime (strtime, 256, "%b", &tt);
    fprintf (stdout, "\"%s\",", strtime);
  }
  tt.tm_mon = 11;
  strftime (strtime, 256, "%b", &tt);
  fprintf (stdout, "\"%s\" };", strtime);

  fprintf (stdout, "\n\n");



  return 0;
}

make_hexa_codes.c

my_math.c

/*! \file my_math.c
    This file implements various specific mathematical tools.
 */

#include "my_math.h"

/*! \brief Given two integers <i>N</i> and <i>p</i>, the function returns the integer <i>r</i> such as:<BR>
           <UL>
              <li><i>r</i> is a multiple of <i>p</i>.
              <li>"<i>r</i> = <i>N</i> + <i>x</i>" with <i>x</i> such as "0 <= <i>x</i> < <i>N</i>"
           </UL>
           For example, if <i>N</i>=2 and <i>p</i>=4, then <i>r</i>=4.
    \param value This parameter matches <i>N</i> in the function's description above.
    \param factor This parameter matches <i>p</i> in the function's description above.
    \return The function returns the multiple of <i>factor</i>, that is closest to <i>value</i> (greater that <i>value</i>).
 */

unsigned int round_to_multiple_of (unsigned int value, unsigned int factor)
{
    unsigned int d;

    d = value / factor;

    if ((d * factor) != value) { d++; }
    return d * factor;
}

option.c

/*! \file option.c
    This file implements the options' reader.
 */

#include <strings.h>
#include <sys/types.h>
#include <regex.h>
#include "option.h"


#ifdef LINUX
#include <stdio.h>
#endif

/*! \brief Pointer used to set the argument of the options that do not require arguments (ex: --help).
 */

static char  self_option[] = "";

/*! \brief Returns a pointer to the <I>Option</I> data structure that represents a given option.
    \param opt Pointer to a <I>Option_set</I> data structure that defines all options.
    \param flag Pointer to a zero terminated string of characters that represents the option's flag to 
                locate.
    \return If the option represented by the string pointed by <I>flag</I> is found, then the function returns
            a non NULL pointer to the <I>Option</I> data structure that defines the option. Otherwize (the
            option was not found), the function returns the value NULL.
 */

static Option* find_option (Option_set *opt, char *flag)
{
  Option *opt_found;
  int    i;

  opt_found = opt->opt;
  for (i=0; i<opt->count; i++)
  {
    if (strcmp(opt_found->flag, flag) == 0) { return opt_found; }
    opt_found++;
  }

  return NULL;
}

/*! \brief Returns a pointer to the argument associated with a given option.
    \param opt Pointer to a <I>Option_set</I> data structure that defines all options.
    \param flag Pointer to a zero terminated string of characters that represents the option's flag that you
                want to get the argument.
    \param arg If the option is valid (defined in the list of options), then the content of <I>arg</I> pointes
               to the argument associated with the option. If the content of <I>arg</I> is equal to NULL, this
               means that the option is not activated in the command line.
    \return If the option is found (that is: the option is defined in the <I>Option_set</I> data structure
            pointed by <I>opt</I>), the function returns the value 0. In this case:
            <UL>
                <LI>if <I>arg</I> is NULL, it means that the option was not activated.
                <LI>if <I>arg</I> is not NULL, it means that the option was activated.
                    <UL>
                        <LI>If the option requires one argument, then <I>arg</I> pointes to a zero terminated
                            string of characters that represents the argument.
                        <LI>If the option does not require any argument, then you don't care about the string
                            of characters pointed by <I>arg</I> (this string exists, but it does not mean
                            anything).
                    </UL>
            </UL>
            If the option can not be found (the option is not defined in the <I>Option_set</I> data structure
            pointed by <I>opt</I>), the function returns the value 1. Please note that a return value of 1 means
            that you've made an programming error (in your code, you are testing for options that you did not
            define earlier).
 */

int get_argument (Option_set *opt, char *flag, char **arg)
{
  Option *opt_found;

  *arg = NULL;
  opt_found = find_option (opt, flag);

  if (opt_found == NULL) { return 1; }
  *arg = *(opt_found->pointer);

  return 0;
}

/*! \example test_options.c
    This file shows how to use all the function of the library libmy_option.
 */

/*! \brief This function returns a value that represents the number of arguments (0 or 1 argument) required by
           for a given option.
    \param opt Pointer to a <I>Option_set</I> data structure that contains the definitions of all options.
    \param flag Pointer to a zero terminated string of characters that represents the option's flag to test.
    \return The function may return one of the following values:
            <UL>
               <LI>-1: An error occured. The option's flag pointed by <I>flag</I> does not represent any
                       pre-defined options. This is a programming error. You are trying to test an option that
                       you did not define previously.
               <LI>0:  The option does not require any argument.
               <LI>1:  The option requires one argument.
            </UL>
 */

int is_argument_required (Option_set *opt, char *flag)
{
  Option *opt_found;

  opt_found = find_option (opt, flag);
  if (opt_found == NULL) { return -1; }

  if (opt_found->arg != 0) { return 1; }

  return 0;
}

/*! \example test_options.c
    This file shows how to use all the function of the library libmy_option.
 */

/*! \brief Initialize the array of option definitions.
    \param opt Pointer to a <I>Option_set</I> data structure that contains the definitions of all options.
    \return Upon successful completion the function returns the value 0. Otherwise it returns the value 1.
    \warning Please note that an option's flag should verify the following rules:
             <UL>
                <LI>At least 2 characters.
                <LI>Begin with a '-'.
                <LI>No spaces.
                <LI>Not all '-'.
             </UL>
*/

int init_options (Option_set *opt)
{
  int     i, j, s;
  Option  *o;
  char    *pt;

  /* ------------------------------------------------------------- */
  /* Initialize options' array                                     */
  /* ------------------------------------------------------------- */

  opt->last_index = -1;
  for (i=0; i<opt->count; i++) { *((opt->opt + i)->pointer) = NULL; }

  /* ------------------------------------------------------------- */
  /* Check the syntax of all option's tags                         */
  /*  - At least 2 characters.                                     */
  /*  - Begin with a '-'.                                          */
  /*  - No spaces.                                                 */
  /*  - Not all '-'.                                               */
  /*                                                               */
  /* Note: the algo is not fast, but who cares. Command line is    */
  /*       not very long and we parse it only once. At least, this */
  /*       algo is pretty simple.                                  */
  /* ------------------------------------------------------------- */

  for (i=0; i<opt->count; i++)
  {
    o  = opt->opt + i;
    pt = o->flag;
    s  = strlen(pt);

    if ((s < 2) || (*pt != '-')) { return 1; }
    for (j=0; j<s; j++) { if (*(pt+j) == ' ') { return 1; } }
    for (j=0; j<s; j++) { if (*(pt+j) != '-') { break;    } }
    if (j == s) { return 1; }
  }

  return 0;
}

/*! \example test_options.c
    This file shows how to use all the function of the library libmy_option.
 */

/*! \brief Parse the command line and set up the option's data structure.
    \param argv Array of sero terminated strings of characters that represents the command line. Please
                note that the first element of the array (indice 0) should point to the name of the process.
    \param argc Number of elements in the array <I>argv</I>.
    \param opt Pointer to the <I>Option_set</I> data structure that contains the option's definitions.
    \param err Pointer to a pointer that will be used to store the address of a zero terminated string of 
               characters. If an error occured, this string contains a literal description of the error.
    \param flag Pointer to a pointer that will be used to store the address of a zero terminated string of
                characters. If an error occured, this string contains the option that generated the error.
    \param arg Pointer to a pointer that will be used to store the address of a zero terminated string of
               characters. If an error occured, this string contains the argument that caused the error.
    \return Upon successful completion, the function returns the value 0. Otherwise the function returns the
            value 1.
    \warning A valid command line should look something like:<P>
             <process name> [-flag1 [arg1]] [-flag2 [arg2]] [...] <required arg 1> ...
 */

int parse_command_line (char *argv[], int argc, Option_set *opt, char **err, char **flag, char **arg)
{
  int         i, oflag, rv;
  static char err1[]     = "Success";
  static char err2[]     = "";
  static char err3[]     = "Unknown option";
  static char err4[]     = "Missing option's argument";
  static char err5[]     = "Duplicated option";
  static char err6[]     = "Argument too long";
  static char err7[]     = "Invalid regular expression";
  static char err8[]     = "Invalid argument (syntax error)";
  static char last_opt[] = "";
  regex_t     reg;
  regmatch_t  pmatch[1];
  Option      *ofound;
  char        *last_option;

  /* ------------------------------------------------------------- */
  /* Initialize variables                                          */
  /* ------------------------------------------------------------- */

  *err            = err1;
  *flag           = err2;
  *arg            = self_option;
  last_option     = last_opt;
  oflag           = 0;
  opt->last_index = 0;

  /* ------------------------------------------------------------- */
  /* Parse command line now                                        */
  /* ------------------------------------------------------------- */

  for (i=1; i<argc; i++)
  {
    if ((*(argv[i]) != '-') && (oflag == 0)) { return 0; }

    /* ----------------------------------------------------------- */
    /* Is it an option ?                                           */
    /* ----------------------------------------------------------- */

    if (*(argv[i]) == '-')
    {
      if (oflag == 1)
      {
        /* ------------------------------------------------------- */
        /* We get an option's flag, but we expected an argument    */
        /* ------------------------------------------------------- */

        *err  = err4;
        *flag = last_option;
        return 1;
      } 

      ofound = find_option (opt, argv[i]);
      if (ofound == NULL)
      {
        /* ------------------------------------------------------- */
        /* This option is bot defined                              */
        /* ------------------------------------------------------- */

        *err  = err3;
        *flag = argv[i];
        return 1;
      }

      if (*(ofound->pointer) != NULL)
      {
        /* ------------------------------------------------------- */
        /* This option is already activated                        */
        /* ------------------------------------------------------- */

        *err  = err5;
        *flag = argv[i];
        return 1;
      }

      /* --------------------------------------------------------- */
      /* Option found. Is it a "self option" ?                     */
      /* --------------------------------------------------------- */

      if (ofound->arg == 0) { oflag = 0; *(ofound->pointer) = self_option; }
      else { oflag = 1; }

      last_option = argv[i];
    }

    /* ----------------------------------------------------------- */
    /* Is it an argument ?                                         */
    /* ----------------------------------------------------------- */

    if (*(argv[i]) != '-')
    {
      if (oflag == 0) { return 0; }

      /* --------------------------------------------------------- */
      /* Testing the size of the argument                          */
      /* --------------------------------------------------------- */

      if (strlen(argv[i]) > ofound->max_size)
      {
        *err  = err6;
        *arg  = argv[i];
        *flag = last_option;
        return 1;
      }

      /* --------------------------------------------------------- */
      /* Check argumment against regular expression                */
      /* --------------------------------------------------------- */

      rv = regcomp (®, ofound->reg_exp, REG_EXTENDED);
      if (rv != 0)
      {
        *err  = err7;
        *flag = last_option;
        *arg  = argv[i];
        return 1;
      }

      rv = regexec (®, argv[i], 1, pmatch, 0);
      if (rv != 0)
      {
        *err  = err8;
        *flag = last_option;
        *arg  = argv[i];
        regfree (®);
        return 1;
      } 

      regfree (®);

      *(ofound->pointer) = argv[i];
      oflag = 0;
    }

    opt->last_index = i;
  }

  if (oflag == 1)
  {
    *err  = err4;
    *flag = last_option;
    return 1;
  }

  return 0;
}

/*! \example test_options.c
    This file shows how to use all the function of the library libmy_option.
 */

os_specific.c

#include <stdio.h>

int main (int argc, char* argv[])
{
  FILE *fd;

  if (argc != 2)
  {
    fprintf (stderr, "\nUsage: os_specific <output file>\n");
    return 1;
  }

  fd = fopen (argv[1], "w");
  if (fd == NULL)
  {
    fprintf (stderr, "\nos_specific can not open output file %s\n", argv[1]);
    return 1;
  }  

  fprintf (fd, "\n#ifndef DATA_STORAGE_SIZE_HD");

  /* --------------------------------------------------------------- */
  /*                              Scalar types                       */
  /* --------------------------------------------------------------- */

  fprintf (fd, "\n#define INT_SIZE                        %d", sizeof(int));
  fprintf (fd, "\n#define CHAR_SIZE                       %d", sizeof(char));
  fprintf (fd, "\n#define FLOAT_SIZE                      %d", sizeof(float));
  fprintf (fd, "\n#define DOUBLE_SIZE                     %d", sizeof(double));
  fprintf (fd, "\n#define SIGNED_INT_SIZE                 %d", sizeof(signed int));
  fprintf (fd, "\n#define SIGNED_CHAR_SIZE                %d", sizeof(signed char));
  fprintf (fd, "\n#define UNSIGNED_INT_SIZE               %d", sizeof(unsigned int));
  fprintf (fd, "\n#define UNSIGNED_CHAR_SIZE              %d", sizeof(unsigned char));
  fprintf (fd, "\n#define SHORT_INT_SIZE                  %d", sizeof(short int));
  fprintf (fd, "\n#define UNSIGNED_SHORT_INT_SIZE         %d", sizeof(unsigned short int));
  fprintf (fd, "\n#define SIGNED_SHORT_INT_SIZE           %d", sizeof(signed short int));
  fprintf (fd, "\n#define LONG_INT_SIZE                   %d", sizeof(long int));
  fprintf (fd, "\n#define LONG_DOUBLE_SIZE                %d", sizeof(long double));
  fprintf (fd, "\n#define UNSIGNED_LONG_INT_SIZE          %d", sizeof(unsigned long int));
  fprintf (fd, "\n#define SIGNED_LONG_INT_SIZE            %d", sizeof(signed long int));

  /* --------------------------------------------------------------- */
  /*                           Pointer types                         */
  /* --------------------------------------------------------------- */

  fprintf (fd, "\n#define PTR_INT_SIZE                    %d", sizeof(int*));
  fprintf (fd, "\n#define PTR_CHAR_SIZE                   %d", sizeof(char*));
  fprintf (fd, "\n#define PTR_FLOAT_SIZE                  %d", sizeof(float*));
  fprintf (fd, "\n#define PTR_DOUBLE_SIZE                 %d", sizeof(double*));
  fprintf (fd, "\n#define PTR_SIGNED_INT_SIZE             %d", sizeof(signed int*));
  fprintf (fd, "\n#define PTR_SIGNED_CHAR_SIZE            %d", sizeof(signed char*));
  fprintf (fd, "\n#define PTR_UNSIGNED_INT_SIZE           %d", sizeof(unsigned int*));
  fprintf (fd, "\n#define PTR_UNSIGNED_CHAR_SIZE          %d", sizeof(unsigned char*));
  fprintf (fd, "\n#define PTR_SHORT_INT_SIZE              %d", sizeof(short int*));
  fprintf (fd, "\n#define PTR_UNSIGNED_SHORT_INT_SIZE     %d", sizeof(unsigned short int*));
  fprintf (fd, "\n#define PTR_SIGNED_SHORT_INT_SIZE       %d", sizeof(signed short int*));
  fprintf (fd, "\n#define PTR_LONG_INT_SIZE               %d", sizeof(long int*));
  fprintf (fd, "\n#define PTR_LONG_DOUBLE_SIZE            %d", sizeof(long double*));
  fprintf (fd, "\n#define PTR_UNSIGNED_LONG_INT_SIZE      %d", sizeof(unsigned long int*));
  fprintf (fd, "\n#define PTR_SIGNED_LONG_INT_SIZE        %d", sizeof(signed long int*));

  fprintf (fd, "\n#define DATA_STORAGE_SIZE_HD");
  fprintf (fd, "\n#endif");

  fclose (fd);
  return 0;
}

qksort.c

/*! \file qksort.c
    This file implements the quick sort algorithm
 */

#include <stdlib.h>
#include <string.h>

#include <stdio.h>

#include "sort.h"

/* ------------------------------------------------------------ */
/* Compare two integers -- Not part of public API               */
/* ------------------------------------------------------------ */

static int compare_int(const void *int1, const void *int2)
{
  if (*(const int *)int1 > *(const int *)int2) { return 1; }
  if (*(const int *)int1 < *(const int *)int2) { return -1; }
  return 0; 
}

/* ------------------------------------------------------------ */
/* Partitions -- Not part of public API                         */
/* ------------------------------------------------------------ */

static int partition (
                       void *donnee,
                       int taille_elt,
                       int i,
                       int k, 
                       int (*compare) (const void *cle1, const void *cle2)
                     )
{
  char    *tab = donnee;
  void    *pivot, *temp;
  int     r[3];

  /* ----------------------------------------------------------- */
  /* Allocated memory                                            */
  /* ----------------------------------------------------------- */

  if ((pivot = malloc(taille_elt)) == NULL) { return -1; }
  if ((temp = malloc(taille_elt))  == NULL) { free(pivot); return -1; }

  /* ----------------------------------------------------------- */
  /* Find the pivot                                              */
  /* ----------------------------------------------------------- */

  r[0] = (rand() % (k - i + 1)) + i;
  r[1] = (rand() % (k - i + 1)) + i;
  r[2] = (rand() % (k - i + 1)) + i;
  issort(r, 3, sizeof(int), compare_int);
  memcpy(pivot, &tab[r[1] * taille_elt], taille_elt);

  /* ----------------------------------------------------------- */
  /* create 2 partitions around this value                       */
  /* ----------------------------------------------------------- */

  i--;
  k++;

  while (1)
  {
    /* --------------------------------------------------------- */
    /* Move to the left                                          */
    /* --------------------------------------------------------- */

   do { k--; } while (compare(&tab[k * taille_elt], pivot) > 0);

    /* --------------------------------------------------------- */
    /* Move to the right                                         */
    /* --------------------------------------------------------- */

   do { i++; } while (compare(&tab[i * taille_elt], pivot) < 0);

   if (i >= k) { break; }
   else {
          /* --------------------------------------------------- */
          /* Swap the two elements                               */
          /* --------------------------------------------------- */

          memcpy(temp, &tab[i * taille_elt], taille_elt);
          memcpy(&tab[i * taille_elt], &tab[k * taille_elt], taille_elt);
          memcpy(&tab[k * taille_elt], temp, taille_elt);
        }
  }

  /* ----------------------------------------------------------- */
  /* Free all allocated memory                                   */
  /* ----------------------------------------------------------- */

  free(pivot);
  free(temp);

  /* ----------------------------------------------------------- */
  /* Return the position                                         */
  /* ----------------------------------------------------------- */

  return k;

}


/*! \brief Sort data using the QuickSort algorithm.
    \param donnee Pointer to the beginning of the array to sort.
    \param nb_elts Number of elements to sort.
    \param taille_elt Size in bytes of an element.
    \param i <i>i</i> <B>MUST BE</B> set to 0.
    \param k <i>k</i> <B>MUST BE</B> set to <i>nb_elts - 1</i>.
    \param compare User defined function used to compare two elements of the array.
           If you want to sort according to increasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 > cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 < cle2</i>
           </UL>
           If you want to sort according to decreasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 < cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 > cle2</i>
           </UL>
     \return Upon successful completion the function returns 0, otherwise it returns -1
 */

int qksort (
             void *donnee,
             int  nb_elts, 
             int  taille_elt,
             int  i,
             int  k, 
             int  (*compare)(const void *cle1, const void *cle2)
           )
{
  int   j;


  while (i < k)
  {
    /* --------------------------------------------------------- */
    /* Find where to make a partition                            */
    /* --------------------------------------------------------- */

    if ((j = partition(donnee, taille_elt, i, k, compare)) < 0) { return -1; }

    /* --------------------------------------------------------- */
    /* Sort the left side of the partition                       */
    /* --------------------------------------------------------- */

    if (qksort(donnee, nb_elts, taille_elt, i, j, compare) < 0) { return -1; }

    /* --------------------------------------------------------- */
    /* Sort the right side of the partition                      */
    /* --------------------------------------------------------- */

    i = j + 1;
  }

  return 0;
}

/*! \example test_sort.c
    This file shows how to use the qksort function.
 */


/* ------------------------------------------------------------ */
/* Partitions -- Not part of public API                         */
/* ------------------------------------------------------------ */

static int extended_partition (
                                void  *donnee,
                                int   taille_elt,
                                int   i,
                                int   k, 
                                int   (*compare) (const void *cle1, const void *cle2),
                                int   (*copy_data)(void *src, void *dest),
                                int   (*init_elem)(void *elm)
                              )
{
  char    *tab = donnee;
  void    *pivot, *temp;
  int     r[3];

  /* ----------------------------------------------------------- */
  /* Allocated memory                                            */
  /* ----------------------------------------------------------- */

  if ((pivot = malloc(taille_elt)) == NULL) { return -1; }
  if ((temp  = malloc(taille_elt)) == NULL) { free(pivot); return -1; }

  if (init_elem != NULL)
  {
    if (init_elem(pivot) == 1) { free(pivot); free(temp); return -1; }
    if (init_elem(temp)  == 1) { free(pivot); free(temp); return -1; }
  }

  /* ----------------------------------------------------------- */
  /* Find the pivot                                              */
  /* ----------------------------------------------------------- */

  r[0] = (rand() % (k - i + 1)) + i;
  r[1] = (rand() % (k - i + 1)) + i;
  r[2] = (rand() % (k - i + 1)) + i;
  issort(r, 3, sizeof(int), compare_int);

  if (copy_data (&tab[r[1] * taille_elt], pivot) == 1) { free(pivot); free(temp); return -1; }

  /* ----------------------------------------------------------- */
  /* create 2 partitions around this value                       */
  /* ----------------------------------------------------------- */

  i--;
  k++;

  while (1)
  {
    /* --------------------------------------------------------- */
    /* Move to the left                                          */
    /* --------------------------------------------------------- */

   do { k--; } while (compare(&tab[k * taille_elt], pivot) > 0);

    /* --------------------------------------------------------- */
    /* Move to the right                                         */
    /* --------------------------------------------------------- */

   do { i++; } while (compare(&tab[i * taille_elt], pivot) < 0);

   if (i >= k) { break; }
   else {
          /* --------------------------------------------------- */
          /* Swap the two elements                               */
          /* --------------------------------------------------- */

          if (copy_data (&tab[i * taille_elt], temp) == 1) { free(pivot); free(temp); return -1; }
          if (copy_data (&tab[k * taille_elt], &tab[i * taille_elt]) == 1)  { free(pivot); free(temp); return -1; }
          if (copy_data (temp, &tab[k * taille_elt]) == 1) { free(pivot); free(temp); return -1; }
        }
  }

  /* ----------------------------------------------------------- */
  /* Free all allocated memory                                   */
  /* ----------------------------------------------------------- */

  free(pivot);
  free(temp);

  /* ----------------------------------------------------------- */
  /* Return the position                                         */
  /* ----------------------------------------------------------- */

  return k;
}


/*! \brief Sort data using the QuickSort algorithm.
    \param donnee Pointer to the beginning of the array to sort.
    \param nb_elts Number of elements to sort.
    \param taille_elt Size in bytes of an element.
    \param i <i>i</i> <B>MUST BE</B> set to 0.
    \param k <i>k</i> <B>MUST BE</B> set to <i>nb_elts - 1</i>.
    \param compare User defined function used to compare two elements of the array.
           If you want to sort according to increasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 > cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 < cle2</i>
           </UL>
           If you want to sort according to decreasing values, then the function <i>compare()</i> should return:
           <UL>
              <li>1 if <i>cle1 < cle2</i>
              <li>0 if <i>cle1 == cle2</i>
              <li>-1 if <i>cle1 > cle2</i>
           </UL>
    \param copy_data User defined function used to copy data. <B>The function must take care of memory management</B>.
                     This function must return:
                     <UL>
                        <li>0 upon successful completion.
                        <li>1 if an error occured.
                     </UL>
    \param init_elem User defined function used to initializen an element. This function must return:
                     <UL>
                        <li>0 upon successful completion.
                        <li>1 if an error occured.
                     </UL>
                     This function is called whenever a new element is allocated.
                     Please note that you can specify a NULL pointer if no initialization is needed.
    \return Upon successful completion the function returns 0, otherwise it returns -1
 */

int extended_qksort (
                      void  *donnee,
                      int   nb_elts, 
                      int   taille_elt,
                      int   i,
                      int   k, 
                      int   (*compare)(const void *cle1, const void *cle2),
                      int   (*copy_data)(void *src, void *dest),
                      int   (*init_elem)(void *elm)
                    )
{
  int   j;


  while (i < k)
  {
    /* --------------------------------------------------------- */
    /* Find where to make a partition                            */
    /* --------------------------------------------------------- */

    if ((j = extended_partition(donnee, taille_elt, i, k, compare, copy_data, init_elem)) < 0) { return -1; }

    /* --------------------------------------------------------- */
    /* Sort the left side of the partition                       */
    /* --------------------------------------------------------- */

    if (extended_qksort(donnee, nb_elts, taille_elt, i, j, compare, copy_data, init_elem) < 0) { return -1; }

    /* --------------------------------------------------------- */
    /* Sort the right side of the partition                      */
    /* --------------------------------------------------------- */

    i = j + 1;
  }

  return 0;
}

/*! \example test_ext_sort.c
    This file shows how to use the extended_qksort() function.
 */

rand_dates.c

/*! \file rand_dates.c
    This is just a simple utility used to generate random dates ... It can be used for testing the function that
    converts dates into timestamps.
 */


#include <time.h>
#include <stdio.h>
#include <stdlib.h>


int main (int argc, char *argv[])
{
  char       strtime[256];
  struct tm  tt;
  int        i;
  int        n;

  if (argc != 2)
  {
    fprintf (stdout, "\nUsage: rand_dates.test number\n");
    return 1;
  }

  n = atoi(argv[1]);

  for (i=0; i<n; i++)
  {
    tt.tm_sec   = rand() % 60;
    tt.tm_min   = rand() % 60;
    tt.tm_hour  = rand() % 24;
    tt.tm_mday  = rand() % 28;
    tt.tm_mon   = rand() % 12;
    tt.tm_year  = (rand() % 130)+1;
    tt.tm_wday  = rand() % 7;
    tt.tm_yday  = rand() % 365;
    tt.tm_isdst = 0;

    strftime (strtime, 256, "%a %b %m %H:%M:%S MET DST %Y", &tt);
    fprintf (stdout, "\n./date2timestamp.test \"%s\" >> timestamps", strtime);
  }

  return 0;
}

replacer.c

/*! \file replacer.c
    This file contains the implementation of the Search / Replace API.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "replacer.h"
#include "dstring.h"
#include "chtbl.h"

/*! \brief Array of strings. This variable is defined in the parser's module (see file 'replacer.lex').
           It will contain all the tokens extracted by the parser.
 */

extern char** txt_tokens;

/*! \brief Number of tokens in the array 'txt_tokens'. This variable is defined in the parser's module
           (see file 'replacer.lex').
 */

extern size_t nb_tokens;

/*! \brief Initial size for a dynamic string.
 */

#define INIT_DYNAMIC_STRING 100

/* ----------------------------------------------------- */
/* Hash table management                                 */
/* ----------------------------------------------------- */

/*! \brief Type of the elements strored into the hash table.
 */

struct couple {

                /*! \brief This point points to a zero terminated string of characters that represent a
                           tag. */

                char *key;

                /*! \brief This point points to a zero terminated string of characters that represent the
                           value of a tag. */

                char *value;
              };

/*! \brief Number of linked lists for the hash tables used to store the couples (tags, values).
 */

#define HASH_TABLE_ENTRIES   150

/*! \brief Hash function used by the hash table to hash the tags.
    \param key Pointer to a structure <i>couple</i> that contains the couple (tag, value).
    \return The function returns an integer.
    \warning Make sure that the structure pointed by <i>key</i> has been initialized!
 */

static int hash_function (const void *key)
{
  struct couple  *data;
  int            total, i;

  data = (struct couple*)key;
  total = 1;

  for (i=0; i<strlen(data->key); i++) { total *= (int)((data->key)[i]) ; }

  if (total < 0) { total *= -1; } 

  return total;
}

/*! \brief Function used to free memory allocated for the elements of the hash table.
    \param d Pointer to a structure <i>couple</i> to be freed.
 */

static void free_user_data (void *d)
{
  struct couple  *data;

  data = (struct couple*)d;
  free (data);
  return;
}

/*! \brief Function used to compare two elements of the hash table (two tags).
    \param d1 First element to compare.
    \param d2 Second element to compare.
    \return The function return 1 if d1 == d2, 0 otherwise.
 */

static int compare_user_data (const void *d1, const void *d2)
{
  struct couple *data1, *data2;

  data1 = (struct couple*)d1;
  data2 = (struct couple*)d2;

  return !strcmp(data1->key, data2->key);
}

/* ----------------------------------------------------- */
/* End of hash table management                          */
/* ----------------------------------------------------- */

/*! \brief Replace tags by their values in a text.
    \param text Pointer to a zero terminated string of characters. This string contains the original text. 
    \param tags Pointer to an array of tags (that will be searched in 'text').
    \param values Pointer to an array of values (a tag is replaced by a value). Please note that:
           'tags[i]' will be replaced by 'values[i]'.
    \param nb_tags Number of elements in the arrays 'text' and 'tags'.
    \return The function returns a pointer to a zero terminated string of characters that represents the
            final text. If the function could not allocate memory, then the returned value is NULL.
    \warning <ul>
                <li>The returned string of characters has been allocated within the function. Therefore you must
                    free it yourself (using free()).
                <li>This function is <b>NOT REENTRANT</b>, DO NOT use it with threads!
                <li>This function works in memory, so if the input text is too large, the function may fail
                    because the process is running out of memory. In this case the function returns the value
                    NULL. If you get NULL, you should abort the process execution, because the function does
                    not clean the memory allocated...
             </ul>
 */

char* replace_tags (char *text, char **tags, char **values, int nb_tags)
{
  int           res, i;
  char          *final, *pt, *aux;
  dstring       ds;
  size_t        s;
  CHTbl         htab;
  struct couple *elem, selem;
 
  /* --------------------------------------------------- */
  /* Initialize the hash table                           */
  /* --------------------------------------------------- */

  if (
       chtbl_init (
                    &htab,
                    HASH_TABLE_ENTRIES,
                    hash_function,
                    compare_user_data,
                    free_user_data
                  ) == -1
     )
     { return NULL; }

  /* --------------------------------------------------- */
  /* Load hash table with couples (tags => values)       */
  /* --------------------------------------------------- */

  for (i=0; i<nb_tags; i++)
  {
    elem = (struct couple*)malloc(sizeof(struct couple));
    if (elem == NULL)
    {
      chtbl_destroy (&htab);
      return NULL;
    }

    elem->key   = tags[i];
    elem->value = values[i];

    res = chtbl_insert (&htab, (void*)elem);

    switch (res)
    {
      case -1: {
                  chtbl_destroy (&htab);
                  return NULL;
               }; break;

      case 1: /* tag already in hash table */ break;
    }
  }

  /* --------------------------------------------------- */
  /* Parse the original text.                            */
  /* This operation will fill the array 'txt_tokens'     */
  /* all the tokens.                                     */
  /*                                                     */
  /* o Tags begins with a character '+'.                 */
  /* o Other values begins with a character '-'.         */
  /* --------------------------------------------------- */

  res = yylex_memory(text);

  if (res == RELACER_MEM_ERROR)
  {
    chtbl_destroy (&htab);
    return NULL;
  }

  /* --------------------------------------------------- */
  /* Initialize the dynamic string                       */
  /* --------------------------------------------------- */

  if (dstring_init (&ds, INIT_DYNAMIC_STRING) == 1)
  {
    chtbl_destroy (&htab);
    return NULL;
  }

  /* --------------------------------------------------- */
  /* Look at each token and replace it if necessary.     */
  /* --------------------------------------------------- */

  for (i=0; i<nb_tokens; i++)
  {
    pt = txt_tokens[i]+1;

    if ( *(txt_tokens[i]) == '-')
    {
       /* ---------------------------------------------- */
       /* '-' means that this is NOT a tag, we copy it   */
       /* "as is".                                       */
       /* ---------------------------------------------- */

       if (dstring_add (&ds, pt, strlen(pt)) == 1)
       {
         chtbl_destroy (&htab);
         return NULL;
       }
    }
    else
    {
       /* ---------------------------------------------- */
       /* This is a tag, lets replace it                 */
       /* ---------------------------------------------- */

       selem.key   = pt;
       selem.value = NULL;
       elem        = &selem;

       res = chtbl_lookup (&htab, (void**)&elem);

       switch (res)
       {
         case 0: {
                   /* element found */

                   if (dstring_add (&ds, elem->value, strlen(elem->value)) == 1)
                   {
                     chtbl_destroy (&htab);
                     return NULL;
                   }

                 }; break;

         default: {
                   /* element not found */

                   /* ######################################################## */
                   /* ###                                                  ### */
                   /* ### WARNING !!!!                                     ### */
                   /* ###                                                  ### */
                   /* ### The following code depends on the tag's defini-  ### */
                   /* ### -tion (see file 'replacer.lex'.                  ### */
                   /* ###                                                  ### */
                   /* ######################################################## */

                   aux = (char*)malloc(strlen(pt)+4);
                   if (aux == NULL)
                   {
                     dstring_free(&ds);
                     chtbl_destroy (&htab);
                     return NULL;
                   }

                   sprintf (aux, "${%s}", pt);

                   if (dstring_add (&ds, aux, strlen(aux)) == 1)
                   {
                     free (aux);
                     chtbl_destroy (&htab);
                     return NULL;
                   }

                   free (aux);

                 }; break;
       }
    }
  }

  /* --------------------------------------------------- */
  /* Free hash table                                     */
  /* --------------------------------------------------- */

  chtbl_destroy (&htab);

  /* --------------------------------------------------- */
  /* Free all allocated tokens.                          */
  /* --------------------------------------------------- */

  free_tokens();

  /* --------------------------------------------------- */
  /* Copy the content of the dynamic string              */
  /* --------------------------------------------------- */

  final = dstring_get_data (&ds, &s);
  if (final == NULL) { return NULL; }

  /* --------------------------------------------------- */
  /* Free the dynamic string                             */
  /* --------------------------------------------------- */

  dstring_free(&ds);

  return final;
}

/*! \example test_replacer_final.c
    This file shows how to use the function replace_tags().
 */

replacer.lex

%{

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "list.h"
#include "dstring.h"
#include "replacer.h"

/* -------------------------------------------------- */
/* this file contains the definitions of a 'tag' for  */
/* the Search / Replace facility.                     */
/* -------------------------------------------------- */


int hashwrap() { return 1; }

extern int hashlex();

#define KEEP_GOING       0
#define CREATE_NEW       1

static int element; /* KEEP_GOING / CREATE_NEW */

/* -------------------------------------------------- */
/* Linked list management                             */
/* We define a linked list of dynamic strings.        */
/*                                                    */
/* o hash_linked_list: the linked list.               */
/* o free_data: function used to free one element of  */
/*   the linked list.                                 */
/* o compare_element: function used to compare two    */
/*   elements of the linked list (not used).          */
/* o init_hash_linked_list: Initialize the linked     */
/*   list.                                            */
/* -------------------------------------------------- */

#define DSTRING_INI_SIZE 100

static List hash_linked_list;
static dstring *dds;
static char *buff;

static void free_data (void *d)
{
  dstring *ds;

  ds = (dstring*)d;

  dstring_free (ds);
  free (ds);
}

static int compare_element (const void* d1, const void* d2) { return 1; }

static void init_hash_linked_list ()
{ list_init (&hash_linked_list, free_data, compare_element); }





/* -------------------------------------------------- */
/* This function calls the flex parser to parse       */
/* in-memory text.                                    */
/* -------------------------------------------------- */

char **txt_tokens;  /* the result itself, made from the likned list */
size_t nb_tokens;   /* the number of elements in the result         */

void free_tokens()
{
  size_t i;

  if (txt_tokens != NULL)
  {
    for (i=0; i<nb_tokens; i++) { free(txt_tokens[i]); }
    free (txt_tokens);
  }
}

int yylex_memory (char *src)
{
  int             result;
  YY_BUFFER_STATE buf_state;
  size_t          i, s;
  ListElmt        *elem;

  /* ------------------------------------------------ */
  /* Initilaze global variables                       */
  /* ------------------------------------------------ */
  
  init_hash_linked_list();
  element    = CREATE_NEW;
  nb_tokens  = 0;
  txt_tokens = NULL;

  /* ------------------------------------------------ */
  /* Parse in-memory text and create the linked list  */
  /* ------------------------------------------------ */

  buf_state = yy_scan_string(src);
  result = hashlex();
  yy_delete_buffer(buf_state);
  if (result == RELACER_MEM_ERROR) { return RELACER_MEM_ERROR; }

  /* ------------------------------------------------ */
  /* Convert the linked list into an array of strings */
  /* ------------------------------------------------ */

  nb_tokens = list_size (&hash_linked_list);

  txt_tokens = (char**)malloc(nb_tokens*sizeof(char**));
  if (txt_tokens == NULL) 
  {
    list_destroy(&hash_linked_list);
    return RELACER_MEM_ERROR;
  }

  elem = list_head(&hash_linked_list);

  for (i=0; i<nb_tokens; i++)
  {
    dds = (dstring*) list_data(elem);
    txt_tokens[i] = dstring_get_data (dds, &s);
    if (txt_tokens[i] == NULL) { return RELACER_MEM_ERROR; }

    elem = list_next(elem);
  }

  /* ------------------------------------------------ */
  /* Free all memory allocated from the linked list   */
  /* ------------------------------------------------ */

  list_destroy(&hash_linked_list);

  return result;
}



/* ############################################################# */
/* ###                                                       ### */
/* ### WARNING !!!!                                          ### */
/* ###                                                       ### */
/* ### If you change the definition of the TAG, make sure to ### */
/* ### change the code of the flex action associated with a  ### */
/* ### tag detection.                                        ### */
/* ###                                                       ### */
/* ### You must also change the code of the file             ### */
/* ### 'replacer.c' (the section where you replace a tag by  ### */
/* ### its value.                                            ### */
/* ###                                                       ### */
/* ############################################################# */



%}

ALPHA         ([A-Z]|[a-z])
NUMERIC       [0-9]
ALPHANUM      ({ALPHA}|{NUMERIC})
CARACTER      ({ALPHANUM}|[_\-])
TAG           \$\{{CARACTER}+\}

%%

{TAG}   {
           /* -------------------------------------------------- */
           /* Allocate a new Dynamic string to store the tag.    */
           /* -------------------------------------------------- */

           dds = (dstring*)malloc(sizeof(dstring));
           if (dds == NULL) { return RELACER_MEM_ERROR; }

           /* -------------------------------------------------- */
           /* initialize the Dynamic String                      */
           /* -------------------------------------------------- */

           if (dstring_init (dds, DSTRING_INI_SIZE) == 1)
           { return RELACER_MEM_ERROR; }

           /* -------------------------------------------------- */
           /* Remove unwanted formating characters               */
           /* -------------------------------------------------- */

           buff = (char*)malloc(strlen(yytext)+1);
           if (buff == NULL) { return RELACER_MEM_ERROR; }

           strcpy (buff, yytext);
           buff[strlen(yytext)-1] = 0;

           /* -------------------------------------------------- */
           /* Add data into the Dynamic String                   */
           /*                                                    */
           /*     A tag begins with a +                          */
           /*                                                    */
           /* -------------------------------------------------- */

           if (dstring_add (dds, "+", 1) == 1)
           { free (buff); return RELACER_MEM_ERROR; }

           if (dstring_add (dds, buff+2, strlen(buff+2)) == 1)
           { free (buff); return RELACER_MEM_ERROR; }

           free (buff);

           /* -------------------------------------------------- */
           /* Add Dynamic String to linked list                  */
           /* -------------------------------------------------- */
           
           if (list_ins_next (&hash_linked_list, list_tail(&hash_linked_list), (void*)dds) == -1)
           { return RELACER_MEM_ERROR; }

           element = CREATE_NEW;
        }

(.|\n)  {
           if (element == CREATE_NEW)
           {
             /* -------------------------------------------------- */
             /* Allocate a new Dynamic string to store the tag.    */
             /* -------------------------------------------------- */

             dds = (dstring*)malloc(sizeof(dstring));
             if (dds == NULL) { return RELACER_MEM_ERROR; }

             /* -------------------------------------------------- */
             /* initialize the Dynamic String                      */
             /*                                                    */
             /*     A tag begins with a -                          */
             /*                                                    */
             /* -------------------------------------------------- */

             if (dstring_init (dds, DSTRING_INI_SIZE) == 1)
             { return RELACER_MEM_ERROR; }

             if (dstring_add (dds, "-", 1) == 1)
             { return RELACER_MEM_ERROR; }

             /* -------------------------------------------------- */
             /* Add Dynamic String to linked list                  */
             /* -------------------------------------------------- */

             if (list_ins_next (&hash_linked_list, list_tail(&hash_linked_list), (void*)dds) == -1)
             { return RELACER_MEM_ERROR; }
           }

           /* ---------------------------------------------------- */
           /* Add data to the last element of the linked list      */
           /* ---------------------------------------------------- */

           dds = (dstring*)list_data(list_tail(&hash_linked_list));

           if (dstring_add (dds, yytext, strlen(yytext)) == 1)
           { return RELACER_MEM_ERROR; }

           element = KEEP_GOING;
        }

%%

sem.c

/*! \file sem.c
    This file implements basic synchronosation toolkit.
 */

#include "my_sem.h"

/*! \brief System identifier for the set of semaphores. */
static int      semaphore_set = -1;

/*! \brief Number of semaphores in the set of semaphores. */
static int      set_size      = -1;

/*! \brief Default semaphores' permission used at creation time. */
static int      permission    = SEM_PERMISSION;


/*! \brief Set default access permissions for the set of semaphores.
    \param new_permission New permissions.
    \warning By default, the set of semaphores is created with the persmission mask 0x000001C0, that is, in binary:
             111 000 000. This grants all right to the process' user but nothing for other users (just like file permissions).
 */

void change_sem_access_permission (int new_permission) { permission = new_permission; }

/*! \brief Create a set of semaphores.
    \param ipc_key IPC key for the semaphore set. If you have a well known key (it should be a number greater or equal to
           zero), then you can specify it. Otherwise, if you want the kernel to find the first available key, then you must
           specify the value (key_t)-1.
    \param number_of_sem Number of semaphores in the set.
    \return This function may return one of the followinf values:
            <ul>
              <li>CREATE_SEMAPHORE_OK: The operation was successful.
              <li>CREATE_SEMAPHORE_CREATE_ERROR: A system error occured while creating the set of semaphores.
              <li>CREATE_SEMAPHORE_SET_VAL_ERROR: A system error occured while setting semaphores' values to 1.
            </ul>
    \warning By default, semaphores are created with the value 1 (like mutexes). You can change that later by using the
             function change_sem_access_permission().
 */

int create_semaphore_set (key_t ipc_key, int number_of_sem)
{
    int          i;
    union semun  sem_def;

    set_size = number_of_sem;

    /* =============================================================== */
    /* Create the set of semaphores                                    */
    /* =============================================================== */

    if (ipc_key != (key_t)-1) { semaphore_set = semget (ipc_key, number_of_sem, IPC_CREAT | permission); }
    else { semaphore_set = semget (IPC_PRIVATE, number_of_sem, IPC_CREAT | permission); }

    if (semaphore_set == (key_t)-1) { return CREATE_SEMAPHORE_CREATE_ERROR; }

    /* =============================================================== */
    /* Set all semaphore values to 1 (can be change later)             */
    /* =============================================================== */

    for (i=0; i<number_of_sem; i++)
    {
      sem_def.val = 1;
      if (semctl (semaphore_set, i, SETVAL, sem_def) == -1)
      { return CREATE_SEMAPHORE_SET_VAL_ERROR; }
    }

    return CREATE_SEMAPHORE_OK;
}

/*! \example test_shm.c
    This file shows how to use the function create_semaphore_set().
 */

/*! \brief Get a already created (by another process) set of semaphores.
    \param ipc_key Well known IPC key that identifies the set of semaphores.
    \param number_of_sem Number of semaphores in the set.
    \return The function may return one of the following value:
            <UL>
               <li>GET_SEM_OK: The operation was successful.
               <li>GET_SEM_ALREADY_GET: The process already got the set of semaphores.
               <li>GET_SEM_ERROR: An error occured while getting the semaphores.
            </UL>
    \warning Since you get a semaphores set created by another process, you should know the <b>well known</b> IPC key that
             represents the set of semaphores.
 */

int get_semaphore_set (key_t ipc_key, int number_of_sem)
{

  if (semaphore_set != -1) { return GET_SEM_ALREADY_GET; }

  semaphore_set = semaphore_set = semget (ipc_key, number_of_sem, 0);
  set_size = number_of_sem;

  if (semaphore_set == -1) { return GET_SEM_ERROR; }

  return GET_SEM_OK;
}

/*! \example test_shm.c
    This file shows how to use the function get_semaphore_set().
 */

/*! \brief Set semaphores' values (this update the entire set of semaphores).
    \param values Pointer to an array of integers that represents semaphores values.
    \return The function may return one of the followinf values:
            <ul>
              <li>SET_SEM_VALUES_OK: The operation was sucessful.
              <li>SET_SEM_VALUES_SEM_NOT_CREATED: You did not create (or get) the set of semaphores.
              <li>SET_SEM_VALUES_SET_ERROR: An error occured while setting the semaphores' values.
            </ul>
    \warning The number of elements of the array pointed by 'values' must be equal to the number of semaphores in the
             set.
 */

int set_semaphore_values (int *values)
{
   int          i;
   union semun  sem_def;

   if ((set_size == -1) || (semaphore_set == -1)) { return SET_SEM_VALUES_SEM_NOT_CREATED; }

   for (i=0; i<set_size; i++)
   {
     sem_def.val = values[i];
     if (semctl (semaphore_set, i, SETVAL, sem_def) == -1)
     { return SET_SEM_VALUES_SET_ERROR; }
   }

   return SET_SEM_VALUES_OK;
}

/*! \example test_shm.c
    This file shows how to use the function set_semaphore_values().
 */

/*! \brief Set the value of one semaphore (and only one of the set).
    \param value Integer that represents the semaphore's new value.
    \sem_number Integer that represents the semaphore's index (within the set of semaphores).
    \return The function may return one of the followinf values:
            <ul>
              <li>SET_SEM_VALUES_OK: The operation was sucessful.
              <li>SET_SEM_VALUES_SEM_NOT_CREATED: You did not create (or get) the set of semaphores.
              <li>SET_SEM_VALUES_SET_ERROR: An error occured while setting the semaphores' values.
            </ul>
    Please note that the functions set_semaphore_value() and set_semaphore_values() share the same set of return values.
 */

int set_semaphore_value (int value, int sem_number)
{
   union semun  sem_def;

   if ((set_size == -1) || (semaphore_set == -1)) { return SET_SEM_VALUES_SEM_NOT_CREATED; }

   sem_def.val = value;
   if (semctl (semaphore_set, sem_number, SETVAL, sem_def) == -1)
   { return SET_SEM_VALUES_SET_ERROR; }

   return SET_SEM_VALUES_OK;
}

/*! \example test_shm.c
    This file shows how to use the function set_semaphore_value().
 */

/*! \brief Take one semaphore. This action decrements the semaphore's counter by 1.
    \param sem_idx Index of the semaphore to take. The index of the first semaphore is 0.
    \return Upon successful completion, 0 is returned. Otherwise, -1 is returned.
    \warning If the set of semaphores you created contains N semaphores, then "0 <= sem_idx < N".
 */

int take_sem (int sem_idx)
{
  struct sembuf   Operation;

  Operation.sem_num = sem_idx;
  Operation.sem_flg = SEM_UNDO;
  Operation.sem_op  = -1;

  return (semop(semaphore_set, &Operation, 1));
}

/*! \example test_shm.c
    This file shows how to use the function take_sem().
 */

/*! \brief Release one semaphore. This action increments the semaphore's counter by 1.
    \param sem_idx Index of the semaphore to take. The index of the first semaphore is 0.
    \return Upon successful completion, 0 is returned. Otherwise, -1 is returned.
    \warning If the set of semaphores you created contains N semaphores, then "0 <= sem_idx < N".
             Please note that we do <B>NOT</B> specify the semaphore's flag <U>SEM_UNDO</U>. If you specify this flag,
             then you will have the following behaviour: when the program exits, the operation will be canceled. 
             Here the operation is "release the semaphore". So, if we set SEM_UNDO, and if the process exists,
             then the operation will be canceled: in other words, the semaphore will be taken (the oposite of released). 
 */

int release_sem (int sem_idx)
{
  struct sembuf   Operation;

  Operation.sem_num = sem_idx;
  Operation.sem_op  = +1;

  return (semop(semaphore_set, &Operation, 1));
}

/*! \example test_shm.c
    This file shows how to use the function release_sem().
 */

/*! \brief Destroy the set of semaphores.
    \return Upon successful completion, a positive value is returned. Otherwise, -1 is returned.
 */

int destroy_semaphore_set()
{ return (semctl (semaphore_set, 0, IPC_RMID, 0)); }

/*! \example test_shm.c
    This file shows how to use the function destroy_semaphore_set().
 */

sha.c

/*! \file sha.c
    This file implements the Secure Hash Algorithm.
 */

/* 
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is SHA 180-1 Reference Implementation (Compact version)
 * 
 * The Initial Developer of the Original Code is Paul Kocher of
 * Cryptography Research.  Portions created by Paul Kocher are 
 * Copyright (C) 1995-9 by Cryptography Research, Inc.  All
 * Rights Reserved.
 * 
 * Contributor(s):
 *
 *     Paul Kocher
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL"), in which case the provisions of the GPL are applicable 
 * instead of those above.  If you wish to allow use of your 
 * version of this file only under the terms of the GPL and not to
 * allow others to use your version of this file under the MPL,
 * indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by
 * the GPL.  If you do not delete the provisions above, a recipient
 * may use your version of this file under either the MPL or the
 * GPL.
 */

#include <string.h>
#include <stdio.h>
#include "sha.h"

static void shaHashBlock(SHA_CTX *ctx);

void shaInit(SHA_CTX *ctx) {
  int i;

  ctx->lenW = 0;
  ctx->sizeHi = ctx->sizeLo = 0;

  /* Initialize H with the magic constants (see FIPS180 for constants)
   */
  ctx->H[0] = 0x67452301L;
  ctx->H[1] = 0xefcdab89L;
  ctx->H[2] = 0x98badcfeL;
  ctx->H[3] = 0x10325476L;
  ctx->H[4] = 0xc3d2e1f0L;

  for (i = 0; i < 80; i++)
    ctx->W[i] = 0;
}


void shaUpdate(SHA_CTX *ctx, unsigned char *dataIn, int len) {
  int i;

  /* Read the data into W and process blocks as they get full
   */
  for (i = 0; i < len; i++) {
    ctx->W[ctx->lenW / 4] <<= 8;
    ctx->W[ctx->lenW / 4] |= (unsigned long)dataIn[i];
    if ((++ctx->lenW) % 64 == 0) {
      shaHashBlock(ctx);
      ctx->lenW = 0;
    }
    ctx->sizeLo += 8;
    ctx->sizeHi += (ctx->sizeLo < 8);
  }
}


void shaFinal(SHA_CTX *ctx, unsigned char hashout[20]) {
  unsigned char pad0x80 = 0x80;
  unsigned char pad0x00 = 0x00;
  unsigned char padlen[8];
  int i;

  /* Pad with a binary 1 (e.g. 0x80), then zeroes, then length
   */
  padlen[0] = (unsigned char)((ctx->sizeHi >> 24) & 255);
  padlen[1] = (unsigned char)((ctx->sizeHi >> 16) & 255);
  padlen[2] = (unsigned char)((ctx->sizeHi >> 8) & 255);
  padlen[3] = (unsigned char)((ctx->sizeHi >> 0) & 255);
  padlen[4] = (unsigned char)((ctx->sizeLo >> 24) & 255);
  padlen[5] = (unsigned char)((ctx->sizeLo >> 16) & 255);
  padlen[6] = (unsigned char)((ctx->sizeLo >> 8) & 255);
  padlen[7] = (unsigned char)((ctx->sizeLo >> 0) & 255);
  shaUpdate(ctx, &pad0x80, 1);
  while (ctx->lenW != 56)
    shaUpdate(ctx, &pad0x00, 1);
  shaUpdate(ctx, padlen, 8);

  /* Output hash
   */
  for (i = 0; i < 20; i++) {
    hashout[i] = (unsigned char)(ctx->H[i / 4] >> 24);
    ctx->H[i / 4] <<= 8;
  }

  /*
   *  Re-initialize the context (also zeroizes contents)
   */
  shaInit(ctx);
}


void shaBlock(unsigned char *dataIn, int len, unsigned char hashout[20]) {
  SHA_CTX ctx;

  shaInit(&ctx);
  shaUpdate(&ctx, dataIn, len);
  shaFinal(&ctx, hashout);
}


#define SHA_ROTL(X,n) (((X) << (n)) | ((X) >> (32-(n))))

static void shaHashBlock(SHA_CTX *ctx) {
  int t;
  unsigned long A,B,C,D,E,TEMP;

  for (t = 16; t <= 79; t++)
    ctx->W[t] =
      SHA_ROTL(ctx->W[t-3] ^ ctx->W[t-8] ^ ctx->W[t-14] ^ ctx->W[t-16], 1);

  A = ctx->H[0];
  B = ctx->H[1];
  C = ctx->H[2];
  D = ctx->H[3];
  E = ctx->H[4];

  for (t = 0; t <= 19; t++) {
    TEMP = SHA_ROTL(A,5) + (((C^D)&B)^D)     + E + ctx->W[t] + 0x5a827999L;
    E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP;
  }
  for (t = 20; t <= 39; t++) {
    TEMP = SHA_ROTL(A,5) + (B^C^D)           + E + ctx->W[t] + 0x6ed9eba1L;
    E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP;
  }
  for (t = 40; t <= 59; t++) {
    TEMP = SHA_ROTL(A,5) + ((B&C)|(D&(B|C))) + E + ctx->W[t] + 0x8f1bbcdcL;
    E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP;
  }
  for (t = 60; t <= 79; t++) {
    TEMP = SHA_ROTL(A,5) + (B^C^D)           + E + ctx->W[t] + 0xca62c1d6L;
    E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP;
  }

  ctx->H[0] += A;
  ctx->H[1] += B;
  ctx->H[2] += C;
  ctx->H[3] += D;
  ctx->H[4] += E;
}

/*----------------------------------------------------------------------------
 *
 * This code added by Thomas "temas" Muldowney for Jabber compatability
 *
 *---------------------------------------------------------------------------*/
char *shahash(char *str)
{
    static char final[41];
    char *pos;
    unsigned char hashval[20];
    int x;

    if(!str || strlen(str) == 0)
        return NULL;

    shaBlock((unsigned char *)str, strlen(str), hashval);

    pos = final;
    for(x=0;x<20;x++)
    {
        snprintf(pos, 3, "%02x", hashval[x]);
        pos += 2;
    }
    return (char *)final;
}


/*! \brief Calculate the SHA of a string.
    \param str Pointer to a NULL terminated string of characters that you want to calculate the SHA.
    \param hashbuf Pointer to a memory locattion that will receive the SHA calculated from 'str'. Please note that 
                   'hashbuf' should be at least 41 bytes long (40 bytes for the SHA result and 1 byte for the final 0).
 */

void shahash_r(const char* str, char hashbuf[41])
{
    int x;
    char *pos;
    unsigned char hashval[20];
    
    if(!str || strlen(str) == 0)
        return;

    shaBlock((unsigned char *)str, strlen(str), hashval);

    pos = hashbuf;
    for(x=0;x<20;x++)
    {
        snprintf(pos, 3, "%02x", hashval[x]);
        pos += 2;
    }

    return;
}

/*! \example test_sha.c
    This file shows how to use the function shahash_r().
 */

shm.c

/*! \file shm.c
    This file implements basic shared memory utilities.
 */

#include "my_shm.h"
#include <stdio.h>

/*! \brief System isentifier for the shared memory segment. This value is set by create_shared_memory_segment() or
           get_shared_memory_segment_sys_id().
 */
static int       shm_id = -1;

/*! \brief Address used by the process to access the top of the shared memory segment. This value is set by the function
           attache_shared_memory_segment().
 */
static SHM_addr  attachement_address = (SHM_addr)-1;

/*! \brief This variable defines the default permission for all newly created SHM. It can be modified using the function
           change_shm_access_permission().
 */
static int       permissions = SHM_PERMISSION;

/*! \brief Data structure that contains information about the shared memory segment (see nam shmctl).
 */
static struct shmid_ds shm_info;


/*! \brief Change the SHM's default permissions.
    \param new_permission New permissions to apply to the shared memory (at creation time).
    \warning By default the permission is 0x000001C0 (grant all rights for the process' user).
 */

void change_shm_access_permission (int new_permission)
{ permissions = new_permission; }

/*! \brief Create the shared memory segment.
    \param size Size in bytes of the segment.
    \param ipc_key This argument represents the IPC identifier of the shared memory segment. If you know the (well known)
           identifier's value, then you can specify it. Otherwise, if you want to let the system choose the first available
           identifier, then you should set 'ipc_key' to (key_t)-1. Please note that an IPC identifier is a value greater or
           equal to 0.
    \return On success, the function may return one of the following values:
            <UL>
              <li>CREATE_SHM_ALREADY_CREATED: The shared memory segment has already been created.
              <li>CREATE_SHM_ERROR: An error occured while creating the segment.
              <li>CREATE_SHM_OK: The shared memory segment has been successfully created.
            </UL>
            Once you called create_shared_memory_segment(), you should call get_shared_memory_segment_id() to get the
            system's identifier assigned to the newly created shared memory segment.
 */

int create_shared_memory_segment (key_t ipc_key, int size)
{
  /* ===================================================== */
  /* Make sure that 'shm_id' is not already associated     */
  /* with a shared memory segment.                         */
  /* ===================================================== */

  if (shm_id != -1) { return CREATE_SHM_ALREADY_CREATED; }

  /* ===================================================== */
  /* Create the shared memory segment                      */
  /* ===================================================== */

  if (ipc_key == (key_t)-1) { shm_id = shmget (IPC_PRIVATE, size, IPC_CREAT | permissions); }
  else { shm_id = shmget (ipc_key, size, IPC_CREAT | permissions); }

  if (shm_id == -1) { return CREATE_SHM_ERROR; }

  return CREATE_SHM_OK;
}

/*! \example test_shm.c
    This example shows how to use the function create_shared_memory_segment().
 */

/*! \brief Get the system's identifier of a shared memory segment that has already been created (by another process).
    \param size Size in bytes of the shared memory segment.
    \param ipc_key <b>Well known</b> IPC key that represents the shared memory segment. This key is shared between all 
           processes that access the shared memory segment.
    \return The function may return one of the following value:
            <UL>
              <li>GET_SHM_ALREADY_GET: You've already got the SHA system's identifier.
              <li>GET_SHM_ERROR: An error occured while getting the SHM system's identifier.
              <li>GET_SHM_OK: The operation was successful.
            </UL>
            Once you've called get_shared_memory_segment_sys_id(), you should call get_shared_memory_segment_id() to get the
            SHM system's identifier.
    \warning If you need to call this function, it means that you want to get the system ID of a SHM that has already been
             created by another process. Then you need to specify a <b>well known</b> IPC key.
 */

int get_shared_memory_segment_sys_id (key_t ipc_key, int size)
{
  /* ===================================================== */
  /* Make sure that the shared memory segement is not      */
  /* already attached.                                     */
  /* ===================================================== */

  if (shm_id != -1) { return GET_SHM_ALREADY_GET; }

  /* ===================================================== */
  /* Get the shared memory segment identifier              */
  /* ===================================================== */

  shm_id = shmget (ipc_key, size, 0);

  if (shm_id == -1) { return GET_SHM_ERROR; }

  return GET_SHM_OK;
}

/*! \brief Tell the IPC library to destroy the SHM on the last detachement.
    \return Upon successful completion, the function return 0, otherwise it returns -1.
    \warning There are 2 very important things to know:
             <UL>
                <li>This function should be called by the process that has created the SHM.
                <li>Once you've called this function, another process can NOT get the shared memory segment (the OS
                    consider that the segment is ready to be destroyed ... so no more process can get it). Therefore 
                    you must call this function when you are sure that no more process will try to get the shared memory
                    segment.
             </UL>
 */

int set_shm_auto_destroy()
{ return shmctl(shm_id, IPC_RMID, NULL); }

/*! \example test_shm.c
    This example shows how to use the function get_shared_memory_segment_sys_id().
 */

/*! \brief Returns the shared memory segment identifier.
    \return The function returns the identifier of the shared memory segment.
    \warning The identifier should be a value greater or equal to 0. If this function returns -1, it means that an error
             occured during the creation of the segment or that the segment has not been created.
 */

int get_shared_memory_segment_id() { return shm_id; }

/*! \example test_shm.c
    This example shows how to use the function get_shared_memory_segment_id().
 */

/*! \brief Returns the address used by the process to access the shared memory segment.
    \return The function returns the address used by the process to access the shared memory segment.
 */

SHM_addr get_shm_address() { return attachement_address; }

/*! \example test_shm.c
    This example shows how to use the function get_shm_address().
 */

/*! \brief Attache a previously created shared memory segment.
    \return Upon successful completion the function returns the process' address of the memory segment (that is, the address
            used by the process to access the memory segment). Otherwise, the function returns (SHM_addr)-1.
 */

SHM_addr attache_shared_memory_segment ()
{
  attachement_address = shmat(shm_id, (SHM_addr)0, 0);
  return attachement_address;
}

/*! \example test_shm.c
    This example shows how to use the function attache_shared_memory_segment().
 */

/*! \brief Return the data structure that describes the Shared Memory Segment (as documented in man shmget).
    \return Upon successful completion, the function returns that address of a structure "struct shmid_ds" that
            describes the SHM (see man shmctl for details about this structure). If an error occured, then the function
            returns NULL.
 */

struct shmid_ds* get_shm_info()
{
  if (shmctl (shm_id, IPC_STAT, &shm_info) == -1)
  { return NULL; }

  return &shm_info;
}

/*! \example test_shm.c
    This example shows how to use the function get_shm_info().
 */

/*! \brief Detache the Shared Memory Segment.
    \return If an error occured, the function returns -1. Otherwise, the SHM attachement address is returned.
 */

int detache_shm()
{ return  shmdt(attachement_address); }

signals.c

/*! \file signals.c
    This file contains all signals related functions.
 */

#include "signals.h"

/*! \brief Data structure used to put the new signals mask.
 */

static   sigset_t          new_set;

/*! \brief Signal to manipulate.
 */

static int my_sig = -1;

/*! \brief Set the signal to manipulate.
    \param sig Signal to manipulate.
 */

void set_signal (int sig)
{ my_sig = sig; }

/*! \example test_signals.c
    This file shows how to use the simple signal functions.
 */

/*! \brief Block the signal my_sig only. All other signals are allowed.
    \return If the operation was successful, the function returns 0. Otherwise tha function returns 1. Please note that
            this function should never fail. If it fails, then you are in deep trouble ... check your system.
    \warning You must call set_signal() before you can use this function !.
 */

int block_all_signal()
{
   int cr;

   if (sigemptyset (&new_set) == -1) { return 1; }

   if (sigaddset (&new_set, my_sig) == -1) { return 1; }

   /*****************************************************************/
   /* WARNING: This is weird, but sigprocmask() can be interrupted. */
   /* You must test errno.                                          */
   /*****************************************************************/

   cr = sigprocmask(SIG_BLOCK, &new_set, 0);

   while ((cr == -1) && (errno == EINTR))
   { cr = sigprocmask(SIG_BLOCK, &new_set, 0); }
   if (cr == -1) { return 1; }

   return 0;
}

/*! \example test_signals.c
    This file shows how to use the simple signal functions.
 */

/*! \brief Unblock the signal my_sig.
    \return If the operation was successful, the function returns 0. Otherwise tha function returns 1. Please note that
            this function should never fail. If it fails, then you are in deep trouble ... check your system.
    \warning You must call set_signal() before you can use this function !.
 */ 

int retore_signal()
{
   int cr;

   if (sigemptyset (&new_set) == -1) { return 1; }

   if (sigaddset (&new_set, my_sig) == -1) { return 1; }

   /*****************************************************************/
   /* WARNING: This is weird, but sigprocmask() can be interrupted. */
   /* You must test errno.                                          */
   /*****************************************************************/

   cr = sigprocmask(SIG_UNBLOCK, &new_set, 0);

   while ((cr == -1) && (errno == EINTR))
   { cr = sigprocmask(SIG_UNBLOCK, &new_set, 0); }
   if (cr == -1) { return 1; }

   return 0;
}

/*! \example test_signals.c
    This file shows how to use the simple signal functions.
 */

/*! \brief Look if there are any my_sig pending signals. If it is the case, the pensding signales are activated.
    \return If the operation was successful, the function returns 0. Otherwise tha function returns 1. Please note that
            this function should never fail. If it fails, then you are in deep trouble ... check your system.
    \warning If you look at the man page for the function 'sigsuspend()', you see that 'sigsuspend()' can set 'errno' to
             EINTR. But you must ignore it, otherwise you create an infinite loop. Indeed, every time 'sigsuspend()' raises a
             pending signal, 'sigsuspend()' is interrupted ... And therefore,  EINTR is set!. 
             You must call set_signal() before you can use this function !.
 */

int get_pending_signals()
{
  sigset_t    pendsig;
  sigset_t    sigint_set;

  if (sigfillset(&sigint_set) == -1) { return 1; }

  if (sigdelset(&sigint_set, my_sig) == -1) { return 1; }

  if (sigpending(&pendsig) == -1) { return 1; }

  if (sigismember (&pendsig, my_sig) == 1)
  { sigsuspend (&sigint_set); }

  return 0;
}

/*! \example test_signals.c
    This file shows how to use the simple signal functions.
 */

/*! \brief Set a signal handler on the signal my_sig.
    \param handler Pointer to the signal's handler. The function's prototype should look something like:
                   void function_name(int).
    \return If the operation was successful, the function returns 0. Otherwise tha function returns 1. Please note that
            this function should never fail. If it fails, then you are in deep trouble ... check your system.
    \warning You must call set_signal() before you can use this function !.
 */

int set_signal_handler(void (*handler)(int))
{
  struct sigaction  new_sig_settings;

  new_sig_settings.sa_handler = handler;

  /******************************************************************/
  /* 'sa_mask' represents the set of signals that should be blocked */
  /* while the current signal is being processed. By default the    */
  /* current signal is blocked too (unless SA_NODEFER or SA_NOMASK  */
  /* is set in 'sa_flags').                                         */
  /*                                                                */
  /* Here we say that *only* signals my_sig will be blocked while  */
  /* the current signal is being processed. And, of course, the     */
  /* current signal is blocked too while it is executed. This is    */
  /* the default behaviour and I think it is safe.                  */
  /******************************************************************/

  if (sigemptyset (&(new_sig_settings.sa_mask)) == -1) { return 1; }

  if (sigaddset (&(new_sig_settings.sa_mask), my_sig) == -1) { return 1; }

  /******************************************************************/
  /* No special mask needed.                                        */
  /******************************************************************/

  new_sig_settings.sa_flags = 0;

  /******************************************************************/
  /* We want to catch my_sig.                                      */
  /* I mean only this signal will be linked to an handler.          */
  /******************************************************************/

  if (sigaction(my_sig, &new_sig_settings, 0) == -1) { return 1; }

  /******************************************************************/
  /* OK, now this is the situation:                                 */
  /*                                                                */
  /* - We accept *ALL* signals.                                     */
  /* - When a signal is processed, all other signals are blocked,   */
  /*   including the current signal itself.                         */
  /* - We set a handler to my_sig only.                            */
  /******************************************************************/

  return 0;
}

/*! \example test_signals.c
    This file shows how to use the simple signal functions.
 */

smtp.c

/*! \file smtp.c
    This file implements the SMTP client API.
 */

#include <unistd.h>
#include "my_smtp.h"

/*! \brief Internet address of the SMTP server.
 */

static struct sockaddr_in tcp_add;

/*! \brief Socket descriptor associated with the TCP connexion.
 */

static int tcp_sock = -1;

/*! \brief This function is the flex parser itself. Please look at the file 'smtp.lex' for details.
 */

extern int smtp_yylex_memory (char *src);

/*! \brief Parse the response from the SMTP server.
    \param response Pointer to a <b>zero terminated</b> string of characters the response from the SMTP server.
    \param data Pointer to a <i>smtp_response</i> data structure that will be used to store information
           about the repsonse.
    \return The function returns one of the following value:
            <UL>
              <li>SMTP_SERVER_IDENTIFICATION_OK = 220
                  ("220 newsletter.tiscali.fr Simple Mail Transfer Service Ready" - follow the connexion)
              <li>SMTP_CLIENT_IDENTIFICATION_OK = 250
                  ("250 newsletter.tiscali.fr" - Follow the command HELO or EHLO)
              <li>SMTP_FROM_OK = 250
                  ("250 OK" - Follow the command MAIL FROM)
              <li>SMTP_RCPT_OK = 250
                  ("250 OK" - Follow the command RCPT TO)
              <li>SMTP_DATA_OK = 354
                  ("354 Start mail input; end with...", Follow the command DATA)
              <li>SMTP_END_OF_DATA_OK = 250
                  ("250 OK" - Follow the <CRLF>.&lr;CRLF> that marks the end of the data part.
              <li>SMTP_INVALID_ANSWER = -1
                  This means that the response is not well formated.
            </UL>
 */

static int response_parser (char *response, struct smtp_response *data)
{
  int rc;

  rc = smtp_yylex_memory(response);

  /* ---------------------------------------------- */
  /* Please look at the file 'smtp.lex': the value  */
  /* of rc can be:                                  */
  /*                                                */
  /*  o 220                                         */
  /*  o 250                                         */
  /*  o 354                                         */
  /*  o -1                                          */
  /*  o 0                                           */
  /* ---------------------------------------------- */

  if ((rc == 0) || (rc == -1)) { return SMTP_INVALID_ANSWER; }

  return rc;
}






/*! \brief Open a connexion to the SMTP server.
    \param conf Pointer to a configuration structure.
    \param result Pointer to <i>smtp_res</i> structure.
    \return Upon successful completion, the function returns a positive number that represents the socket
            descriptor associated with the connexion. In this case, the field <i>ellapsed</i> contains
            the ellapsed time of the connexion in milli-seconds.

            Otherwise the function returns the value -1. In this case the field <i>error_code</i> of
            <i>result</i> contains a value that identifies the failure. This value may be:

            <UL>
              <li>An error code from the function <i>open_tcp_connexion()</i> (of the Common C Library). See the
                  detailed description of <i>open_tcp_connexion()</i> for full details.
              <li>An error code from the function <i>read_from_socket()</i>(of the Common C Library). See the
                  detailed description of <i>read_from_socket()</i> for full details.
              <li>The value SMTP_WRITE_ERROR. This means that the system call write failed.
              <li>The value SMTP_BAD_ANSWER. This means that the response from the SMTP server was not valid.
            </UL>
 */

int client_smtp_connect ( 
                          struct smtp_connexion_config *conf,
                          struct smtp_res *result
                        )
{
  int                   sock, rc;
  char                  iobuff[SMTP_BUFFER_SIZE];
  size_t                read_bytes;
  struct smtp_response  smtp_res;
  long                  ellapsed;
  

  result->error_code = 0;
  result->ellapsed   = 0;
  tcp_sock           = -1;

  /* ----------------------------------------------- */
  /* Open the TCP connexion                          */
  /* ----------------------------------------------- */

  sock = open_tcp_connexion(
                             &tcp_add,
                             conf->host,
                             conf->port,
                             conf->connect_timeout_sec,
                             conf->connect_timeout_micro,
                             &ellapsed
                           );

  if (sock < 0)
  {
    result->error_code = sock;
    return -1;
  }

  result->ellapsed += ellapsed;

  /* ----------------------------------------------- */
  /* Read server's identification                    */
  /* ----------------------------------------------- */

  rc = read_from_socket (
                           sock,
                           iobuff,
                           SMTP_BUFFER_SIZE-1,
                           &read_bytes,
                           conf->read_timeout_sec,
                           conf->read_timeout_micro,
                           &ellapsed
                        );

  if (rc != SCK_READ_OK)
  {
    smtp_disconnect();
    result->error_code = rc;
    return -1;
  }

  result->ellapsed += ellapsed;

  iobuff[read_bytes] = 0;

  /* ----------------------------------------------- */
  /* Check the answer                                */
  /* ----------------------------------------------- */

  rc = response_parser (iobuff, &smtp_res);

  if (rc != SMTP_SERVER_IDENTIFICATION_OK)
  {
    smtp_disconnect();
    result->error_code = SMTP_BAD_ANSWER;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Send client's identificator                     */
  /* ----------------------------------------------- */

  if (write (sock, conf->id, strlen(conf->id)) !=  strlen(conf->id))
  {
    smtp_disconnect();
    result->error_code = SMTP_WRITE_ERROR;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Read the answer from the SMTP server            */
  /* ----------------------------------------------- */

  rc = read_from_socket (
                           sock,
                           iobuff,
                           SMTP_BUFFER_SIZE-1,
                           &read_bytes,
                           conf->read_timeout_sec,
                           conf->read_timeout_micro,
                           &ellapsed
                        );

  if (rc != SCK_READ_OK)
  {
    smtp_disconnect();
    result->error_code = rc;
    return -1;
  }

  result->ellapsed += ellapsed;

  iobuff[read_bytes] = 0;

  /* ----------------------------------------------- */
  /* Check the answer                                */
  /* ----------------------------------------------- */

  rc = response_parser (iobuff, &smtp_res);

  if (rc != SMTP_CLIENT_IDENTIFICATION_OK)
  {
    smtp_disconnect();
    result->error_code = SMTP_BAD_ANSWER;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Everything is OK, set 'tcp_sock' to the socket  */
  /* descriptor.                                     */
  /* ----------------------------------------------- */

  tcp_sock = sock;

  return 0;
}

/*! \brief Close the connexion between the SMTP client ant the server.
 */

void smtp_disconnect() { if (tcp_sock >= 0) { close(tcp_sock); } }

/*! \brief Send an email to the SMTP server.
    \param conf Pointer to a configuration structure.
    \param email Pointer to a <i>smtp_mail</i> structure that contains the mail's data.
    \param result Pointer to <i>smtp_res</i> structure.
    \return Upon successfull completion the function returns 0, therwise it returns -1 and <b>the connexion is
            closed</b>.

            If the returned value is 0 (success), then the field <i>ellapsed</i> of the structure pointed by
            <i>result</i> contains the ellapsed time of the action in milli-seconds.

            If the returned value is -1 (error), then the field <i>error_code</i> of the structure pointed by
            <i>result</i> contains an error code that describes the failure. This value may be:

            <UL>
              <li>An error code from the function <i>read_from_socket()</i>(of the Common C Library). See the
                  detailed description of <i>read_from_socket()</i> for full details.
              <li>The value SMTP_WRITE_ERROR. This means that the system call write failed.
              <li>The value SMTP_BAD_ANSWER. This means that the response from the SMTP server was not valid.
              <li>The value SMTP_BUFFER_OVERFLOW. This means that one of the input arguments "from" or "rcpt"
                  is too long.
            </UL>


 */

int smtp_send_email (
                      struct smtp_connexion_config  *conf,
                      struct smtp_mail              *email,
                      struct smtp_res               *result
                    )
{
  int                   i, rc;
  char                  iobuff[SMTP_BUFFER_SIZE];
  size_t                read_bytes;
  struct smtp_response  smtp_res;
  long                  ellapsed;

  result->error_code = 0;
  result->ellapsed   = 0;

  /* ----------------------------------------------- */
  /* Check for buffer overflows                      */  
  /* ----------------------------------------------- */

  if (
       (
         strlen(email->from)
         +
         strlen(SMTP_FROM_TAG_START)
         +
         strlen(SMTP_FROM_TAG_STOP)
       )
       >
       SMTP_BUFFER_SIZE - 1
     )
     { 
       smtp_disconnect();
       result->error_code = SMTP_BUFFER_OVERFLOW;
       return -1;
     }

  sprintf (iobuff, "%s%s%s", SMTP_FROM_TAG_START, email->from, SMTP_FROM_TAG_STOP); 

  /* ----------------------------------------------- */
  /* Send the FROM command                           */  
  /* ----------------------------------------------- */

  if (write (tcp_sock, iobuff, strlen(iobuff)) !=  strlen(iobuff))
  {
    smtp_disconnect();
    result->error_code = SMTP_WRITE_ERROR;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Read answer from SMTP server                    */
  /* ----------------------------------------------- */

  rc = read_from_socket (
                           tcp_sock,
                           iobuff,
                           SMTP_BUFFER_SIZE-1,
                           &read_bytes,
                           conf->read_timeout_sec,
                           conf->read_timeout_micro,
                           &ellapsed
                        );

  if (rc != SCK_READ_OK)
  {
    smtp_disconnect();
    result->error_code = rc;
    return -1;
  }

  result->ellapsed += ellapsed;

  iobuff[read_bytes] = 0;

  /* ----------------------------------------------- */
  /* Check the answer from the SMTP server           */
  /* ----------------------------------------------- */

  rc = response_parser (iobuff, &smtp_res);

  if (rc != SMTP_FROM_OK)
  {
    smtp_disconnect();
    result->error_code = SMTP_BAD_ANSWER;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Send all RCPT data                              */
  /* ----------------------------------------------- */

  for (i=0; i<email->rcpt_number; i++)
  {

    /* --------------------------------------------- */
    /* Check for buffer overflows                    */
    /* --------------------------------------------- */

    if (
         (
           strlen(email->rcpt)
           +
           strlen(SMTP_RCPT_TAG_START)
           +
           strlen(SMTP_RCPT_TAG_STOP)
         )
         >
         SMTP_BUFFER_SIZE - 1
       )
       {
         smtp_disconnect();
         result->error_code = SMTP_BUFFER_OVERFLOW;
         return -1;
       }

    sprintf (iobuff, "%s%s%s", SMTP_RCPT_TAG_START, email->rcpt, SMTP_RCPT_TAG_STOP);

    /* --------------------------------------------- */
    /* Send the RCPT command                         */
    /* --------------------------------------------- */

    if (write (tcp_sock, iobuff, strlen(iobuff)) !=  strlen(iobuff))
    {
      smtp_disconnect();
      result->error_code = SMTP_WRITE_ERROR;
      return -1;
    }

    /* --------------------------------------------- */
    /* Read the response from the SMTP server        */
    /* --------------------------------------------- */

    rc = read_from_socket (
                             tcp_sock,
                             iobuff,
                             SMTP_BUFFER_SIZE-1,
                             &read_bytes,
                             conf->read_timeout_sec,
                             conf->read_timeout_micro,
                             &ellapsed
                          );

    if (rc != SCK_READ_OK)
    {
      smtp_disconnect();
      result->error_code = rc;
      return -1;
    }

    result->ellapsed += ellapsed;

    iobuff[read_bytes] = 0;

    /* --------------------------------------------- */
    /* Check the answer from the SMTP server         */
    /* --------------------------------------------- */

    rc = response_parser (iobuff, &smtp_res);

    if (rc != SMTP_RCPT_OK)
    {
      smtp_disconnect();
      result->error_code = SMTP_BAD_ANSWER;
      return -1;
    }
  }

  /* ----------------------------------------------- */
  /* Now send the DATA command                       */
  /* ----------------------------------------------- */

  strcpy (iobuff, "DATA\r\n");

  if (write (tcp_sock, iobuff, strlen(iobuff)) !=  strlen(iobuff))
  {
    smtp_disconnect();
    result->error_code = SMTP_WRITE_ERROR;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Read answer from SMTP server                    */
  /* ----------------------------------------------- */

  rc = read_from_socket (
                           tcp_sock,
                           iobuff,
                           SMTP_BUFFER_SIZE-1,
                           &read_bytes,
                           conf->read_timeout_sec,
                           conf->read_timeout_micro,
                           &ellapsed
                        );

  if (rc != SCK_READ_OK)
  {
    smtp_disconnect();
    result->error_code = rc;
    return -1;
  }

  result->ellapsed += ellapsed;

  iobuff[read_bytes] = 0;

  /* ----------------------------------------------- */
  /* Check the answer from the SMTP server           */
  /* ----------------------------------------------- */

  rc = response_parser (iobuff, &smtp_res);

  if (rc != SMTP_DATA_OK)
  {
    smtp_disconnect();
    result->error_code = SMTP_BAD_ANSWER;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Send the body itself                            */
  /* ----------------------------------------------- */

  if (write (tcp_sock, email->data, strlen(email->data)) !=  strlen(email->data))
  {
    smtp_disconnect();
    result->error_code = SMTP_WRITE_ERROR;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Read answer from SMTP server                    */
  /* ----------------------------------------------- */

  rc = read_from_socket (
                           tcp_sock,
                           iobuff,
                           SMTP_BUFFER_SIZE-1,
                           &read_bytes,
                           conf->read_timeout_sec,
                           conf->read_timeout_micro,
                           &ellapsed
                        );

  if (rc != SCK_READ_OK)
  {
    smtp_disconnect();
    result->error_code = rc;
    return -1;
  }

  result->ellapsed += ellapsed;

  iobuff[read_bytes] = 0;

  /* ----------------------------------------------- */
  /* Check the answer from the SMTP server           */
  /* ----------------------------------------------- */

  rc = response_parser (iobuff, &smtp_res);

  if (rc != SMTP_END_OF_DATA_OK)
  {
    smtp_disconnect();
    result->error_code = SMTP_BAD_ANSWER;
    return -1;
  }

  /* ----------------------------------------------- */
  /* Send the QUIT command and close the connexion   */
  /* ----------------------------------------------- */

  strcpy (iobuff, "QUIT\r\n");

  if (write (tcp_sock, iobuff, strlen(iobuff)) !=  strlen(iobuff))
  {
    smtp_disconnect();
    result->error_code = SMTP_WRITE_ERROR;
    return -1;
  }

  smtp_disconnect();

  return 0;
}

smtp.lex

%{

int smtpwrap() { return 1; }

extern int smtplex();


/* -------------------------------------------------------- */
/* This function calls the flex parsed in order to scan the */
/* answer from the SMTP server. The returned value may be:  */
/* o 220                                                    */
/* o 350                                                    */
/* o 354                                                    */
/* o -1                                                     */
/* o 0 (if the input string is empty)                       */
/* -------------------------------------------------------- */

int smtp_yylex_memory (char *src)
{
  int             result;
  YY_BUFFER_STATE buf_state;

  buf_state = yy_scan_string(src);
  result = smtplex();
  yy_delete_buffer(buf_state);

  return result;
}



%}

ALPHA         ([A-Z]|[a-z])
NUMERIC       [0-9]
NOT_NUMERIC   [^0-9]
ALPHANUM      ({ALPHA}|{NUMERIC})

%%

^220\x20.*\r\n    { return 220; }
^250\x20.*\r\n    { return 250; }
^354\x20.*\r\n    { return 354; }
^.*               { return -1;  }
\n                { return -1;  }

%%

sockets.c

/*! \file sockets.c
    This file implements basic TCP/IP functionalities.
 */ 

#include <sys/wait.h> 
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/time.h>

#include <errno.h>
#include <stdio.h>
#include "my_sockets.h"




/*! \brief Open a TCP connexion to a remote server.
    \param tcp_add Pointer to a structure that will receive the server's IP address. You probably don't need it, but sometimes
           you must have it.
    \param tcp_host Pointer to a zero terminated string of characters that contains the name (or IP address) of the server
           running the host.
    \param tcp_port TCP port used by the server to a listen incoming connections.
    \param tt_sec Number of second for the timeout.
    \param tt_micro Number of micro second for the timeout.
    \param ellapsed_time Ellapsed time - in milli seconds - for the connect() system call.
    \return If the connection succed, the function returns the newly created socket descriptor (which is a positive value).
            Otherwise, if the connection failed, the function returns one of the following codes (negative value):
            <UL>
              <li>SCK_CREATE_ERROR: Can not create the socket (the function socket() failed).
              <li>SCK_CONNECT_ERROR: Can not connect to the remote server (the function connect() failed).
              <li>SCK_GET_IP_ERROR: Can not get the remote server's IP address, the function gethostbyname() failed.
              <li>SCK_TIMEOUT_CONNECT: The connect() call has been broken by a signal - timeout.
              <li>SCK_TIMER_ERROR: An error occured with the high precision timer.
              <li>SCK_CHRONO_ERROR: An error occured with the high precision chronometer.
            </UL>
     \warning Please note that:
              <UL>
                 <li>To use this function you <B>MUST</B> set a handler on the signal SIGALRM. The signal SIGALRM is used to implement the
                     connect() timeout. 
                 <li>This use its own timers, so you can still use the timing library that comes with the Common C Library.
              </UL>
 */

int open_tcp_connexion (struct sockaddr_in *tcp_add, char *tcp_host, int tcp_port, long tt_sec, long tt_micro, unsigned long int* ellapsed_time)
{
  int			desc;
  int			cr;
  struct hostent	*name;
  char			ip[16];
  int			err;
  struct timeval        start, stop;
  struct itimerval      one_shot_timer, old_one_shot_timer;

  *ellapsed_time = 0;

  /* --------------------------------------------------------------------- */
  /* Get the remote server's IP address (using DNS)                        */
  /* --------------------------------------------------------------------- */

  name = gethostbyname (tcp_host);
  if (name == NULL) { return SCK_GET_IP_ERROR; }

  sprintf (ip, "%d.%d.%d.%d", (unsigned char)(name->h_addr_list)[0][0],
                              (unsigned char)(name->h_addr_list)[0][1],
                              (unsigned char)(name->h_addr_list)[0][2],
                              (unsigned char)(name->h_addr_list)[0][3]);

  /* --------------------------------------------------------------------- */
  /* Create client's socket                                                */
  /* --------------------------------------------------------------------- */

  desc = socket(AF_INET, SOCK_STREAM, 0);
  if (desc == -1) { return (SCK_CREATE_ERROR); };
  Get_Sock_Adress (ip, tcp_port, tcp_add);

  /* --------------------------------------------------------------------- */
  /* Get the current timestamp                                             */
  /* --------------------------------------------------------------------- */

  if (gettimeofday(&start, NULL) == -1) { close(desc); return SCK_CHRONO_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Set the one shot timer (that raises SIGALRM)                          */
  /* --------------------------------------------------------------------- */

  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = tt_sec;
  one_shot_timer.it_value.tv_usec     = tt_micro;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1) { close(desc); return SCK_TIMER_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Connect to the remote server                                          */
  /* --------------------------------------------------------------------- */

  cr  = connect(desc, (struct sockaddr*)tcp_add, sizeof(struct sockaddr_in));
  err = errno;

  /* --------------------------------------------------------------------- */
  /* Cancel the one shot timer                                             */
  /* --------------------------------------------------------------------- */

  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = 0;
  one_shot_timer.it_value.tv_usec     = 0;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1) { close(desc); return SCK_TIMER_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Get the current timestamp                                             */
  /* --------------------------------------------------------------------- */

  if (gettimeofday(&stop, NULL) == -1) { close(desc); return SCK_CHRONO_ERROR; }
  
  if (cr == -1)
  {
    close(desc);
    if (err == EINTR) { return SCK_TIMEOUT_CONNECT; } 
    return SCK_CONNECT_ERROR;
  } 

  /* --------------------------------------------------------------------- */
  /* Calculate the ellapsed time and return                                */
  /* --------------------------------------------------------------------- */

  *ellapsed_time = (stop.tv_sec*1000 + stop.tv_usec/1000) - (start.tv_sec*1000 + start.tv_usec/1000);
  return (desc);
};

/*! \example test_sockets.c
    This file shows hos to use the function open_tcp_connexion().
 */

/*! \brief Get the Internet address of a service.
    \param Machine_serveur Host IP address.
    \param port_serveur TCP port.
    \param TCP_address Pointer to a "sockaddr_in" used to store the internet address.
    \return The function always return SCK_OK.
 */

void Get_Sock_Adress (char *Machine_serveur, int port_serveur, struct sockaddr_in *TCP_address) 
{
  memset ((void*)TCP_address, 0, sizeof(struct sockaddr_in));
  TCP_address->sin_family        = AF_INET;
  TCP_address->sin_port          = htons((u_short)port_serveur);
  (TCP_address->sin_addr).s_addr = inet_addr(Machine_serveur);
}

/*! \brief Read data from an open socket descriptor (read timeout in micro seconds + ellapsed time in milli seconds).
    \param sockfd Socket descriptor (this must be a descriptor to an open socket).
    \param buffer Pointer to that memory location that will receive the data extracted from the socket.
    \param buffer_size Size of the memory location pointed by <i>buffer</i> (in other words, the maximum amount of bytes that can be read).
    \param extracted Pointer to an interger that will be used to store the number of extracted bytes.
    \param tt_sec Number of seconds of the timeout.
    \param tt_micro Number of micro seconds of the timeout.
    \param ellapsed_time Pointer to an unsigned long integer that will be used to store the ellapsed time.
    \return The function may return one of the following values:
            <UL>
              <li>SCK_READ_CHRONO_ERROR: an error occured while manipulating the high precesion chronometer.
              <li>SCK_READ_TIMER_ERROR: an error occured while manipulating the high precesion timer.
              <li>SCK_READ_TIMEOUT: Read timeout.
              <li>SCK_READ_READ_ERROR: The system call <i>read()</i> failed.
              <li>SCK_READ_OK: sucess.
            </UL>
 */

int read_from_socket (int sockfd, char *buffer, size_t buffer_size, size_t* extracted, long tt_sec, long tt_micro, unsigned long int* ellapsed_time)
{
  int                   err;
  size_t                cr;
  struct timeval        start, stop;
  struct itimerval      one_shot_timer, old_one_shot_timer;


  *extracted     = -1;
  *ellapsed_time = -1;

  /* --------------------------------------------------------------------- */
  /* Get the current timestamp                                             */
  /* --------------------------------------------------------------------- */

  if (gettimeofday(&start, NULL) == -1) { return SCK_READ_CHRONO_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Set the one shot timer (that raises SIGALRM)                          */
  /* --------------------------------------------------------------------- */

  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = tt_sec;
  one_shot_timer.it_value.tv_usec     = tt_micro;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1) { return SCK_READ_TIMER_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Read data from socket                                                 */
  /* --------------------------------------------------------------------- */

  cr = read (sockfd, (void*)buffer, buffer_size);
  err = errno;

  /* --------------------------------------------------------------------- */
  /* Cancel the one shot timer                                             */
  /* --------------------------------------------------------------------- */

  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = 0;
  one_shot_timer.it_value.tv_usec     = 0;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1) { return SCK_READ_TIMER_ERROR; }

  /* --------------------------------------------------------------------- */
  /* Get the current timestamp                                             */
  /* --------------------------------------------------------------------- */

  if (gettimeofday(&stop, NULL) == -1) { return SCK_READ_CHRONO_ERROR; }

  if (cr == (size_t)-1) 
  { 
    if (err == EINTR) { return SCK_READ_TIMEOUT; }
    return SCK_READ_READ_ERROR;
  }

  /* --------------------------------------------------------------------- */
  /* Calculate ellapsed time in milli seconds and exit                     */
  /* --------------------------------------------------------------------- */

  *ellapsed_time = (stop.tv_sec*1000 + stop.tv_usec/1000) - (start.tv_sec*1000 + start.tv_usec/1000);
  *extracted = cr;

  return SCK_READ_OK;
}

/*! \brief Read from a socket, until the connexion is closed.
    \param sockfd Socket descriptor.
    \param buffer Pointer to a pointer that will be used to point to a dynamically allocated memory space. This memory space will contain
                  a zero terminated string of characters which is the peer's reponse.
    \param tt_sec Number of seconds for the timeout.
    \param tt_micro Number of micro seconds for the timeout.
    \param ellapsed_time Pointer to an <i>unsigned long int</i> that will be used to store the ellapsed time.
    \param size Pointer to an <i>unsigned long int</i> that will be used to store the number of bytes read from the peer.
    \return The function may return the following values:
            <UL>
              <li>SCK_READ_OK: the action was succesful. <i>buffer</i> points to a zero terminated string of characters.
              <li>SCK_READ_NO_MEM: the function could not allocate memory.
              <li>SCK_READ_READ_ERROR: The system call read() failed.
              <li>SCK_READ_TIMEOUT: Read timeout.
              <li>SCK_READ_CHRONO_ERROR: A problem occured with the high precision chronometer.
              <li>SCK_READ_TIMER_ERROR: A problem occured with the high precision timer.
            </UL>
    \warning <UL>
              <li>If the returned value is SCK_READ_OK, then the <i>buffer</i> points to a string of characters that has been allocated 
                  within the function. You must free it yourself (using free()).
              <li>This function assumes that the peer closes the connexion when the transfer is finished. This is the case for example if
                  you read the answer from a HTTP server (with no <i>keep alive</i>). 
             </UL>

 */

int read_all_socket (int sockfd, char** buffer, long tt_sec, long tt_micro, unsigned long int* ellapsed_time, unsigned long int* size)
{
  size_t                lu, total_lu, total_allocated;
  char                  buff[SCK_BUFFER_INIT_SIZE];
  int                   cr;
  unsigned long int     et;


  /* --------------------------------------------------------------------- */
  /* Initialize variables                                                  */
  /* --------------------------------------------------------------------- */

  et              = 0;
  lu              = 0;
  total_lu        = 0;
  *ellapsed_time  = 0;
  *size           = 0;
  total_allocated = SCK_BUFFER_INIT_SIZE;
  *buffer         = NULL;

  /* --------------------------------------------------------------------- */
  /* Allocate memory                                                       */
  /* --------------------------------------------------------------------- */

  *buffer = (char*)malloc(total_allocated);
  if (*buffer == NULL) { return SCK_READ_NO_MEM; }

  do {
        /* --------------------------------------------------------------- */
        /* Read data from socket                                           */
        /* --------------------------------------------------------------- */

        cr = read_from_socket (sockfd, buff, SCK_BUFFER_INIT_SIZE, &lu, tt_sec, tt_micro, &et);

        /* --------------------------------------------------------------- */
        /* Please remember that cr could be:                               */
        /*    -  SCK_READ_CHRONO_ERROR.                                    */
        /*    -  SCK_READ_TIMER_ERROR                                      */
        /*    -  SCK_READ_TIMEOUT                                          */
        /*    -  SCK_READ_READ_ERROR                                       */
        /*    -  SCK_READ_OK                                               */
        /*                                                                 */
        /* These values are shared between read_from_socket() and          */
        /* read_all_socket().                                              */
        /*                                                                 */
        /* read_all_socket() may also return SCK_READ_NO_MEM.              */
        /* --------------------------------------------------------------- */

        if (cr != SCK_READ_OK) { free (*buffer); return cr; }

        *ellapsed_time += et;

        /* --------------------------------------------------------------- */
        /* Increase buffer size if necessary and add data to the end of    */
        /* the buffer.                                                     */
        /* --------------------------------------------------------------- */

        while (total_lu+lu > total_allocated)
        {
          total_allocated *= 2;
          *buffer = (char*)realloc((void*)*buffer, total_allocated);
          if (*buffer == NULL)
          {
            free (*buffer);
            return SCK_READ_NO_MEM;
          }
        }

        memcpy ((void*)(*buffer + total_lu), (void*)buff, lu);

        total_lu += lu;

     } while (lu > 0);

  /* --------------------------------------------------------------------- */
  /* Add zero to terminate the string of chatacters                        */
  /* --------------------------------------------------------------------- */


  *size = total_lu;

  /* add the final zero */
  if (total_lu+1 > total_allocated)
  {
    total_allocated += 1;
    *buffer = (char*)realloc( (void*)*buffer, total_allocated);
    if (*buffer == NULL)
    {
       free (*buffer);
       return SCK_READ_NO_MEM;
    }
  }

  *(*buffer + total_lu) = 0;

  return SCK_READ_OK;
}

/*! \example test_sockets.c
    This file shows hos to use the function read_all_socket().
 */

/*! \brief Get the IP address and port number associated with a given connection.
    \param Address_Sender Pointer to a structure sockaddr_in that describes the peer's connection.
    \param IP_Address Pointer to a string (SCK_ADDR_LEN character long) used to store the IP address.
    \param Port Pointer to an integer used to store the port number.
    \return N/A.
 */

void get_ip_addr(struct sockaddr_in *Address_Sender, char *IP_Address, int *Port)
{
  int  i;
  char *a;

  a = inet_ntoa(Address_Sender->sin_addr);
  for (i=0; i<SCK_ADDR_LEN-1; i++) {IP_Address[i] = *(a+i); };
  IP_Address[SCK_ADDR_LEN-1] = 0;

  *Port = ntohs (Address_Sender->sin_port);

  return;
}

stack.c

/*! \file stack.c
    This file implements a basic stack API.
 */


#include <stdlib.h>

#include "list.h"
#include "stack.h"

/*! \brief Stack up data at the top of the stack.
    \param pile Pointer to a stack data structure.
    \param donnee Pointer to the data to stack up.
    \return Upon successful completion the function return the value 0. Otherwise the function returns -1.
    \warning The inserted data is <B>NOT</B> copied into the linked list! Therefore you should not free it unless you know exactly what you
             are doing.
 */

int stack_push(Stack *pile, const void *donnee) { return list_ins_next(pile, NULL, donnee); }

/*! \example test_stack.c
    This test prpgram shows how to use the stack API.
 */

/*! \brief Extract data from the top of the stack.
    \param pile Pointer to a stack data structure.
    \param donnee Pointer to a pointer the will point to the extracted data.
    \return Upon successful completion the function return the value 0. Otherwise the function returns -1.
    \warning This function does <B>NOT</B> free the element's data (it only frees the element's structure). Therefore you should use
             <i>donnee</i> to free the element's data yourself.
 */

int stack_pop(Stack *pile, void **donnee) { return list_rem_next(pile, NULL, donnee); }

/*! \example test_stack.c
    This test prpgram shows how to use the stack API.
 */

strings_utils.c

/*! \file strings_utils.c
    This file contains various string utilities.
 */


#include "strings_utils.h"



/*! \brief Replace all series of '\n' by one ';' and all series of spaces by one space.
    \param st Pointer to a zero terminated string of characters that represents the original string.
    \return Upon successful completion the function returns a pointer to a zero terminated string of charaters
            that represents the resulting string. If an error occured (no memory), then the function returns
            NULL.
    \warning The returned pointer points to a memory location allocated within the function. Therefore you
             <B>MUST</B> free it (using free()). Before you free it, make sure that the pointer is not NULL.
 */

char *make_one_line (char *st)
{
  char *res;
  int  size, i, j, space, nl;

  /***************************************************************/
  /* Allocated memory for the result                             */
  /***************************************************************/

  size = strlen(st);
  res = (char*) malloc(sizeof(char) * (size + 1));
  if (res == NULL) { return NULL; }

  /***************************************************************/
  /* Start replacement                                           */
  /***************************************************************/
 
  j     = 0; 
  space = 0;
  nl    = 0;

  for (i=0; i<size; i++)
  {
    if (st[i] == ' ')
    {
      if (space == 0) { res[j++] = ' '; }
      space = 1;
      nl    = 0;
      continue;
    }

    space = 0;

    if (st[i] == '\n')
    {
      if (nl == 0) { res[j++] = ';'; }
      nl = 1;
      continue;
    }

    nl = 0;

    res[j++] = st[i];
  }


  res[j] = 0;
  return res;
}

/*! \example test_make_one_line.c
    This example shows how to use the function make_one_line().
 */

/*! \brief Contains hexadecimal codes for the 256 values from 0 to 255. Values are written using 3 digits (01, 02, ...).
 */

extern char *bin2hex_hexa[256];


/*! \brief Split a string into fields.
    \param st Pointer to a string of characters to split.
    \param delimitor Pointer to a string of characters that defines the delimitor used to separate fieds.
    \param f Pointer to a structure 'fields' that contains the fields extracted from the string 'st'.
    \return The function returns the number of fields extracted. If an error occurs, the the function returns -1.
    \warning <UL>
               <LI>The structure 'f' contains elements that have been allocated within the function. So you must
                   free these elements when you don't need them any more. To do this, you should use the function
                   'free_fields()'.
               <LI>For this function, 2 (or more) delimitors in a row are seen as one and only one delimitor.
                   Example: the string "A;;;B" has 2 fields ("A" and "B"), not 4
                   (assuming that the delimitor is the character ";").
             </UL>
 */

int s_split(char *st, char* delimitor, struct fields *f)
{
  char*    pt;
  int      nb_field, field_size, i, size;
  char**   tab;   

  /***************************************************************/
  /* Allocate initial number of fields - INITIAL_NUMBER_OF_FIELD */
  /***************************************************************/

  size = INITIAL_NUMBER_OF_FIELD;
  tab = (char**)malloc(size*sizeof(char*));
  if (tab == NULL)
  {
    f->number_of_fields = -1;
    f->size             = -1;
    f->tabs             = NULL;
    return -1;
  }

  nb_field = 0; 
  pt       = strtok(st, delimitor);
  
  while (pt != NULL)
  {
    if (nb_field == size)
    {
      size *= 2;
      tab = (char**)realloc((void*)tab, size*sizeof(char*));
      if (tab == NULL)
      {
        for (i=0; i<nb_field; i++) { free ((void*)(tab[i])); }
        free ((void*)tab);
        f->number_of_fields = -1;
        f->size             = -1;
        f->tabs             = NULL;
        return -1;
      }
    } 

    field_size = strlen(pt)+1;
    tab[nb_field] = (char*)malloc(field_size*sizeof(char));
    if (tab[nb_field] == NULL)
    {
      for (i=0; i<nb_field; i++) { free ((void*)(tab[i])); }
      free ((void*)tab);
      f->number_of_fields = -1;
      f->size             = -1;
      f->tabs             = NULL;
      return -1;
    }

    strcpy (tab[nb_field], pt);
    nb_field++;

    pt = strtok (NULL, delimitor);
  }
  
  f->number_of_fields = nb_field;
  f->size             = size;
  f->tabs             = tab;
  
  return nb_field; 
}

/*! \example test_s_split.c
    This file shows how to use the function s_split().
 */


/*! \brief Split a string into fields.
    \param st Pointer to a string of characters to split.
    \param delimitor Pointer to a string of characters that defines the delimitor used to separate fieds.
    \param f Pointer to a structure 'fields' that contains the fields extracted from the string 'st'.
    \return The function returns the number of fields extracted. If an error occurs, the the function returns -1.
    \warning <UL>
               <LI>The structure 'f' contains elements that have been allocated within the function. So you must
                   free these elements when you don't need them any more. To do this, you should use the function
                   'free_fields()'.
               <LI>This function does NOT behave like the function s_split().
                   Example: the string "A;;;B" has 4 fields ("A", "", ""
                   and "B"), not 2 (assuming that the
                   delimitor is the character ";").
             </UL>
 */

int s_split_exact(char *st, char* delimitor, struct fields *f)
{
  char     *pt, *start, *stop;
  int      nb_field, field_size, i, j, size, pfields;
  char     **tab, **delimitors, **mem;

  /***************************************************************/
  /* Set fields' structure to error values                       */
  /***************************************************************/

  f->number_of_fields = -1;
  f->size             = -1;
  f->tabs             = NULL;

  /***************************************************************/
  /* Allocate initial number of fields - INITIAL_NUMBER_OF_FIELD */
  /***************************************************************/

  size = INITIAL_NUMBER_OF_FIELD;

  delimitors = (char**)malloc(size*sizeof(char*));
  if (delimitors == NULL) { return -1; }

  /***************************************************************/
  /* Search the string for all delimitors                        */
  /***************************************************************/

  nb_field = 0;
  start    = st;

  pt = strstr (start, delimitor);
  while (pt != NULL)
  {
    /*************************************************************/
    /* Re-allocate memory if necessary                           */
    /*************************************************************/

    if (nb_field == size)
    {
      size *= 2;
      mem = (char**)realloc((void*)delimitors, size * sizeof(char*));
      if (mem == NULL) { free(delimitors); return -1; }
      delimitors = mem;
    }

    /*************************************************************/
    /* Save delimitor's position                                 */
    /*************************************************************/

    delimitors[nb_field] = pt;
    nb_field++;

    start = pt + strlen(delimitor);

    pt = strstr (start, delimitor);
  }

  /***************************************************************/
  /* note: "A;B;"   => 2 fields                                  */
  /*       "A;B"    => 2 fields                                  */
  /***************************************************************/

  if (*start != 0)
  {
    if (nb_field == size)
    {
      size *= 2;
      mem = (char**)realloc((void*)delimitors, size * sizeof(char*));
      if (mem == NULL) { free(delimitors); return -1; }
      delimitors = mem;
    }

    delimitors[nb_field] = st + strlen(st);

    nb_field++;
  }

  /***************************************************************/
  /* Allocate fields' structure                                  */
  /***************************************************************/

  tab = (char**)malloc(nb_field * sizeof(char*));
  if (tab == NULL)
  {
    free (delimitors);
    return -1;
  }

  f->number_of_fields = nb_field;
  f->size             = nb_field;
  f->tabs             = tab;

  /***************************************************************/
  /* Now extract fields and store them into fields' structure    */
  /***************************************************************/

  pfields = 0;
  start   = st;
  for (j=0; j<nb_field; j++)
  {
    stop       = delimitors[j];
    field_size = (int)(stop-start);

    pt         = (char*) malloc ((field_size+1) * sizeof(char));
    if (pt == NULL)
    {
      f->number_of_fields = -1;
      f->size             = -1;
      free (delimitors);
      for (i=0; i<pfields; i++) { free ((void*)tab[i]); }
      return -1;
    } 

    strncpy (pt, start, field_size);
    pt[field_size] = 0;

    tab[pfields] = pt;
    pfields += 1;

    start = stop + strlen(delimitor);
  }


  free (delimitors);
  return nb_field;
}

/*! \example test_s_split_exact.c
    This file shows how to use the function s_split_exact().
 */

/*! \brief Free allocated memory used to put fields extracted from a string of characters.
    \param fd Pointer to a structure 'fields'.
    \warning You should call this function after a call to s_split(). Please note that if s_split() failes,
             then you don't have to free the resulting structure 'fields'. But you can do it, it won't harm.
 */

void free_fields (struct fields *fd)
{
  int i;

  for (i=0; i<fd->number_of_fields; i++) { free ((void*)((fd->tabs)[i])); }
  free (fd->tabs);
  fd->number_of_fields = -1;
  fd->size             = -1;
  fd->tabs             = NULL;
}

/*! \brief Extract everything between the string " = " and the end of the string.
    \param src Pointer to the string to parse.
    \param dst Pointer to a memory location used to put the extracted string.
    \param nbcar Maximum number of characters the function can put into 'dst'.
    \return The function return a pointer to 'dst', or NULL if an error occured.
 */

char* get_end_of_string (char *src, char *dst, int nbcar)
{
  char *pt;
  int  size;
 
  if (nbcar <= 0) { return NULL; }  /* be paranoid */
 
  pt = strstr (src, " = ");
  if (pt == NULL) { dst[0]=0; return dst; }
  pt += 3;

  size = strlen(pt);
  if (nbcar < size+1) { dst[0]=0; return NULL; }

  strcpy (dst, pt);

  return dst;
}

/*! \example test_get_end_of_string.c
    This file shows how to use the function get_end_of_string().
 */

/*! \brief Transform a IP address "XXX.XXX.XXX.XXX" into a hexadecimal representation "HHHHHHHH".
    \param src Pointer to a string of characters that contains an IP address written as "XXX.XXX.XXX.XXX".
    \param dst Pointer to a memory location used to put the resulting IP address in hexadecimal notation.
    \param nbcar Maximum number of characters the function can put into 'dst'.
    \return The function returns a pointer to 'dst', or NULL if an error occured.
 */

char* IP2hex (char *src, char *dst, int nbcar)
{
  char          *pt;
  struct fields fd;
  int           n;
  int           ip1, ip2, ip3, ip4;
  
  if (nbcar < 12) { return NULL; }  /* be paranoid */
  memset ((void*)dst, 0, 12);

  pt = (char*)malloc((strlen(src)+1)*sizeof(char));
  if (pt == NULL) { return NULL; }
  strcpy (pt, src);

  n = s_split(pt, ".", &fd);
  if (n != 4)
  {
    free (pt);
    return NULL;
  }
  free (pt);

  ip1 = atoi (fd.tabs[0]);
  ip2 = atoi (fd.tabs[1]);
  ip3 = atoi (fd.tabs[2]);
  ip4 = atoi (fd.tabs[3]);

  if ((ip1 < 0) || (ip1 > 255)) { free_fields(&fd); return NULL; } 
  if ((ip2 < 0) || (ip2 > 255)) { free_fields(&fd); return NULL; } 
  if ((ip3 < 0) || (ip3 > 255)) { free_fields(&fd); return NULL; } 
  if ((ip4 < 0) || (ip4 > 255)) { free_fields(&fd); return NULL; } 

  sprintf (dst, "%s%s%s%s", bin2hex_hexa[ip1], bin2hex_hexa[ip2], bin2hex_hexa[ip3], bin2hex_hexa[ip4]);
 
  free_fields(&fd);
  return dst;
}

/*! \example test_IP2hex.c
    This file shows how to ude the function IP2hex().
 */


/*! \brief Delete spaces (or tabulations) at the end of a string. 
    \param src pointer to the string to parser.
    \return The function returns a pointer to 'src'.
    \warning The string 'src' is modified.
 */

char* post_chop(char *src)
{
  int  last_idx;
  int  i;

  last_idx = strlen(src);
  if (last_idx == 0) { return src; }

  last_idx--;
  for (i=last_idx; i>=0; i--)
  { 
     if ((src[i]==' ') || (src[i]==9)) { src[i]=0; }
     else { return src; }
  }
  return src;
}

/*! \brief Delete spaces (or tabulations) at the begining of a string.
    \param src Pointer to a string of of characters that contains the string to parser.
    \return value the function returns a pointer to 'src', or NULL if an error occured.
    \warning the string 'src' is modified.
 */

char* pre_chop(char *src)
{
  int  size;
  int  i, passed, count;
  char *aux;

  size = strlen(src);
  if (size == 0) { return src; }

  aux = (char*)malloc((size+1)*sizeof(char));
  if (aux == NULL) { return NULL; }

  passed = 0;
  count  = 0;
  for (i=0; i<size; i++)
  {
     if (passed == 0)
     {
       if ((src[i] != ' ') && (src[i] != 9))
       { aux[count++]=src[i]; passed = 1; }
     }
     else { aux[count++]=src[i]; }
  }
  aux[count]=0;
  strcpy (src, aux);
  free (aux);
  return src;
}

/*! \brief Delete spaces (or tabulations) at the begining and at the end of a string.
    \param src Pointer to the string to parse.
    \return The function returns a pointer to 'src', or NULL if an error occured.
    \warning The string 'src' is modified.
 */


char* chop(char *src)
{ return pre_chop(post_chop(src)); }

/*! \example test_chop.c
    This file shows how to use the function chop().
 */

/*! \brief Replace all charater 'new line' (that is '\n'), by the sequence '\n#'.
    \param src Pointer to the string to convert into comment.
    \param dst Pointer to a pointer that will be used to store the resulting string.
    \return The function returns a pointer to the resulting string, or NULL if an error occured.
    \warning The returned pointer has been allocated using 'malloc()'. So you must free the allocated memory yourself
             (using 'free()').
 */ 

char* add_comment (char *src, char **dst)
{
  int   src_size, i, j, nnline, dst_size;
  char  c;


  src_size = strlen(src);

  /* Count the number of new lines */
  nnline = 0;
  for (i=0; i<src_size; i++) { if (src[i] == '\n') { nnline++; } }

  /* Allocate memory for the destination */
  dst_size = src_size + nnline;
  *dst = (char*)malloc((dst_size+1)*sizeof(char));
  if (*dst == NULL) { return NULL; }
 
  /* Replace all '\n' by "\n#" */
  j = 0;
  for (i=0; i<src_size; i++)
  {
    c = src[i];
    (*dst)[j++] = c;
    if (c == '\n') { (*dst)[j++] = '#'; }
  }

  (*dst)[j] = 0; 

  return *dst;
}

/*! \example test_add_comment.c
    This file shows how to use the function add_comment().
 */

/*! \brief Extract a field's value from a configuration file.
    \param buffer Pointer to a NULL terminated string of characters that contains the line extracted from the configuration
           file.
    \param delim Pointer to a NULL terminated string of characters that defines the delimitor between the field' label and
           the field's value.
    \return The function returns a pointer to the field's value. If an error occured, the function returns NULL.
 */


char* get_config_value (char *buffer, char *delim)
{
  char *res, *pt;

  pt = strstr (buffer, delim);
  if (pt == NULL) { return NULL; }
  pt += 1;

  res = (char*)malloc((strlen(pt)+1)*sizeof(char));
  if (res == NULL) { return NULL; }
  strcpy (res, pt);

  if (chop(res) == NULL) {
                           free(res);
                           return NULL;
                         };
  return res;
}

/*! \brief The maximum number of characters of an interger (in decimal). For example the value "134" takes 3 characters.
 */

#define INTEGER_STR_MAX_SIZE 32

/*! \brief Replace a tag by an integer in a string.
    \param src Pointer to NULL terminated string of characters that contains the tag to replace.
    \param tag Tag to replace.
    \param value Integer value that will replace the tag.
    \return The function returns a pointer to the resulting string of characters. If an error occured, then the function
            returns a NULL pointer (this means that the program is running out of memory).
 */

char* replace_tag_by_integer (char* src, char *tag, int value)
{
  char *res, *start, *stop, c;
  int  tag_size, size;
  char buff[INTEGER_STR_MAX_SIZE];

  /* Look for the tag to replace */
  start = strstr(src, tag);
  if (start == NULL)
  {
    size = strlen(src)+1;
    res = (char*)malloc(size * sizeof(char)); 
    if (res == NULL) { return NULL; }
    strcpy (res, src);
    return res;
  }

  tag_size = strlen(tag);
  stop = start + tag_size;

  sprintf (buff, "%d", value);
  size = (strlen(src) - tag_size) + strlen(buff) + 1;

  res = (char*)malloc(size * sizeof(char));
  if (res == NULL) { return NULL; }
  c = *start;
  *start = 0;
  sprintf (res, "%s%s%s", src, buff, stop);
  *start = c;

  return res;
}

/*! \brief The array is used to make the relation between characters and intergers ('0'->0, '1'->1, ...).
 */

extern int char2int[256];

/*! \brief The array is used to make the relation between characters and hexadecimal ('0'->0, '1'->1, ..., 'a'->10, ...)
 */

extern int char2hex[256];




/*! \brief Convert a string of characters into an 'unsigned int'.
    \param st Pointer to a NULL terminated string of characters that will be converted into "u_int'.
    \param error Pointer to an interger used to signal an error.
    \return The function returns the value represented bu the string 'st' (if sucess, then 'error' is equal to 0). Please
            note that if an error occures, then the returned value is equal to -1 (all in binary - in this case 'error'
            is equal to 1).
 */

unsigned int string2unsigned_int (char *st, int *error)
{
  int           last_idx, i, digit;
  unsigned int  value, factor;


  value    = 0;
  factor   = 1;
  *error   = 0;

  last_idx = strlen(st)-1;
  for (i=last_idx; i>=0; i--)
  {
    digit = char2int[(unsigned int)st[i]];
    if (digit == -1) { *error = 1; return (unsigned int)-1; }
    value += (unsigned int)digit*factor;
    factor *= 10;
  }

  return value;
}


/*! \brief Convert a string of characters into a 'time_t'.
    \param st Pointer to a NULL terminated string of characters that will be converted into "time_t".
    \param error Pointer to an interger used to signal an error.
    \return The function returns the value represented bu the string 'st' (if sucess, then 'error' is equal to 0). Please
            note that if an error occures, then the returned value is equal to -1 (all in binary - in this case 'error'
            is equal to 1).
 */

time_t string2time_t (char *st, int *error)
{
  int     last_idx, i, digit;
  time_t  value, factor;


  value    = 0;
  factor   = 1;
  *error   = 0;

  last_idx = strlen(st)-1;
  for (i=last_idx; i>=0; i--)
  {
    digit = char2int[(unsigned int)st[i]];
    if (digit == -1) { *error = 1; return (unsigned int)-1; }
    value += (unsigned int)digit*factor;
    factor *= 10;
  }

  return value;
}

/*! \brief Convert a string of characters into an 'int'.
    \param st Pointer to a NULL terminated string of characters that will be converted into "int'.
    \param error Pointer to an interger used to signal an error.
    \return The function returns the value represented bu the string 'st' (if sucess, then 'error' is equal to 0). Please
            note that if an error occures, then the returned value is equal to -1 (in this case 'error' is equal to 1).
 */

int string2int (char *st, int *error)
{
  int    last_idx, i, digit;
  int    value, factor;


  value    = 0;
  factor   = 1;
  *error   = 0;

  last_idx = strlen(st)-1;
  for (i=last_idx; i>=0; i--)
  {
    digit = char2int[(unsigned int)st[i]];
    if (digit == -1) { *error = 1; return -1; }
    value += digit*factor;
    factor *= 10;
  }

  return value;
}

/*! \example test_string2int.c
    This file shows how to use the function string2int().
 */


/*! \brief Test if a string of characters represents an interger.
    \param st Pointer to a NULL terminated string of characters that should represent an integer.
    \return The function returns 0 if the string 'st' represents an interger. Otherwise, it returns 1.
 */

int is_integer (char *st)
{
  int i, size, digit;

  if (st == NULL) { return 1; }
  if (st[0] == 0) { return 1; } 

  size = strlen (st);

  for (i=0; i<size; i++)
  {
    digit = char2int[(unsigned int)st[i]];
    if (digit == -1) { return 1; }
  }

  return 0;
}

/*! \example test_is_integer.c
    This file shows how to use the function is_integer().
 */

/*! \brief Test if a string of characters represents a hexadecimal.
    \param st Pointer to a NULL terminated string of characters that should represent a hexadecimal.
    \return The function returns 0 if the string 'st' represents an interger. Otherwise, it returns 1.
 */

int is_hexa (char *st)
{
  int i, size, digit;

  if (st == NULL) { return 1; }
  if (st[0] == 0) { return 1; }

  size = strlen (st);

  for (i=0; i<size; i++)
  {
    digit = char2hex[(unsigned int)st[i]];
    if (digit == -1) { return 1; }
  }

  return 0;
}

/*! \example test_is_hexa.c
    This file shows how to use the function is_hexa().
 */

/*! \brief Test if a string of characters represents an IP address.
    \param st Pointer to a zero terminated string of characters that might represents an IP address.
    \return The function return 0 is 'st' represents an IP address. Otherwise, the function returns 1.
    \warning An error code 1 could also mean "Out of memory". But it should not happen.
 */

int is_ip_address (char *st)
{
  struct fields fd;
  int           n, i, err;
  char          *aux; 

  if (st == NULL) { return 1; }
  if (st[0] == 0) { return 1; }

  aux = (char*)malloc((strlen(st)+1)*sizeof(char));
  if (aux == NULL) { return 1; }
  strcpy (aux, st);

  n = s_split(aux, ".", &fd);
  if (n == -1)
  { 
    free(aux);
    return 1;
  }

  if (fd.number_of_fields != 4)
  {
    free (aux);
    free_fields(&fd);
    return 1;
  }  

  for (i=0; i<fd.number_of_fields; i++)
  {
    n = string2int(fd.tabs[i], &err);
    if (err == 1)
    {
      free (aux);
      free_fields(&fd);
      return 1;
    }
    if ((n<0) || (n>255))
    {
      free (aux);
      free_fields(&fd);
      return 1;
    }
  }

  free(aux);
  free_fields(&fd);
  return 0;
}

/*! \example test_is_ip_address.c
    This file shows how to use the function is_ip_address()
 */


/*! \brief Convert an IPV4 address to its numerical equivalent.
    \param st Pointer to a zero terminated string of characters that represents the IP address (X.X.X.X).
    \param num Pointer to a array of - at least - 4 unsigned char.
    \return The function returns 0 if the operation was successfull, 1 otherwise.
 */

int ip_address_to_num (char *st, unsigned char *num)
{
  struct fields fd;
  int           n;


  if (st == NULL) { return 1; }
  if (st[0] == 0) { return 1; }

  if (is_ip_address(st) == 1) { return 1; }

  /********************************************/
  /* Split the IP address                     */
  /********************************************/

  n = s_split(st, ".", &fd);
  if (n == -1) { return 1; }

  if (fd.number_of_fields != 4)
  {
    free_fields(&fd);
    return 1;
  }

  /********************************************/
  /* First byte X.x.x.x                       */
  /********************************************/

  num[0] = (unsigned char) (atoi(fd.tabs[0]));

  /********************************************/
  /* Second byte x.X.x.x                      */
  /********************************************/

  num[1] = (unsigned char) (atoi(fd.tabs[1]));

  /********************************************/
  /* Third byte x.x.X.x                       */
  /********************************************/

  num[2] = (unsigned char) (atoi(fd.tabs[2]));

  /********************************************/
  /* Fourth byte x.x.x.X                      */
  /********************************************/

  num[3] = (unsigned char) (atoi(fd.tabs[3]));

  free_fields(&fd);
  return 0;
}

/*! \example test_ip_address_to_num.c
    This file shows how to use the function ip_address_to_num().
 */

/*! \brief Convert a string of ASCII bytes into hexa representation.
    \param src Pointer to a zero terminated string of characters to convert.
    \param dst Pointer to a memory buffer used to store the converted string.
    \param dst_size Size, in bytes, of the destination buffer.
    \return Upon successful completion the function returns the value 1 (the destination buffer is not big
            enough). Otherwize, the function returns the value 0.
 */

int bin2hex (char *src, char *dst, int dst_size)
{
  int i;

  if ((strlen(src) * 2) >= dst_size) { return 0; } 

  memset ((void*)dst, 0, dst_size);

  for (i=0; i<strlen(src); i++)
  {
    unsigned int c;
    c = (unsigned int)src[i];
    strcat (dst, bin2hex_hexa[c]); 
  }

  return 1;
}

/*! \brief Convert a binary buffer into hexa representation.
    \param src Pointer to a list of bytes to convert.
    \param dst Pointer to a memory buffer used to store the converted string.
    \param src_size Size, in bytes, of the source buffer.
    \param dst_size Size, in bytes, of the destination buffer.
    \return Upon successful completion the function returns the value 1 (the destination buffer is not big
            enough). Otherwize, the function returns the value 0.
 */

int bin2hex_binary (unsigned char *src, unsigned char *dst, int src_size, int dst_size)
{
  int i;

  if ((src_size * 2) >= dst_size) { return 0; }

  memset ((void*)dst, 0, dst_size);

  for (i=0; i<src_size; i++)
  {
    unsigned int c;
    c = (unsigned int)src[i];
    strcat (dst, bin2hex_hexa[c]);
  }

  return 1;
}

timing.c

/*! \file timing.c
    This file contains functions for time management.
 */

#include "timing.h"
#include <stdio.h>

/*! \brief Static variable used by start_chrono() to save the starting timestamp.
 */
static struct timeval   start;

/*! \brief Static variable used by stop_chrono() to save the stoping timestamp.
 */
static struct timeval   stop;

/*! \brief Start the stopwatch.
    \return Upon successful completion, the function returns 0. Otherwise the function returns -1;
 */
int start_chrono() { return (gettimeofday(&start, NULL)); }

/*! \example test_stopwatch.c
    This example shows how to use the function start_chrono()
 */

/*! \brief Stop the  stopwatch.
    \return Upon successful completion, the function returns 0. Otherwise the function returns -1;
 */
int stop_chrono() { return (gettimeofday(&stop, NULL)); } 

/*! \example test_stopwatch.c
    This example shows how to use the function stop_chrono()
 */

/*! \brief Get the measured time in ms.
    \return The function returns the number of mili seceond.
 */
unsigned long int get_ms()
{
  long   t;

  t = (stop.tv_sec*1000 + stop.tv_usec/1000) - (start.tv_sec*1000 + start.tv_usec/1000);

  return (unsigned long int)t;
}

/*! \example test_stopwatch.c
    This example shows how to use the function get_ms()
 */  

/*! \brief This structure is used to specify the timer's delay (for a one shot timer).
 */
static struct itimerval   one_shot_timer;

/*! \brief This variable is used by the system call setitimer(). This system call requires a structure itimerval to save
           the current timer configuration (it is not used here).
 */
static struct itimerval   old_one_shot_timer;

/*! \brief This variable is used by the functions pause_one_shot_timer() and restart_one_shot_timer(). It is used to save the current
           timer's state (i.e: the remaining time).
 */
static struct itimerval   current_one_shot_timer;


/*! \brief Create a one shot timer which precision is the micro second. The timer raises the signal SIGALRM when the timout
           expired.
    \param sec Number of second
    \param micro_second Number of micro seconds.
    \return The function returns one of the following values:
            <UL>
                <li>SET_ONE_SHOT_TIMER_ERROR: An error occured while creating the timer.
                <li>SET_ONE_SHOT_TIMER_OK: The timer is successfuly created.
            </UL>
 */

int set_one_shot_timer (long sec, long micro_second)
{
  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = sec;
  one_shot_timer.it_value.tv_usec     = micro_second;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1)
  { return SET_ONE_SHOT_TIMER_ERROR; }

  return SET_ONE_SHOT_TIMER_OK; 
}

/*! \example test_one_shot_timer.c
    This file shows how to use the function set_one_shot_timer().
 */

/*! \brief Cancel the previously activated one shot timer.
        \return The function returns one of the following values:
            <UL>
                <li>CANCEL_ONE_SHOT_TIMER_ERROR: An error occured while canceling the timer.
                <li>CANCEL_ONE_SHOT_TIMER_OK: The timer is successfuly canceled.
            </UL>
 */

int cancel_one_shot_timer ()
{
  one_shot_timer.it_interval.tv_sec   = 0;
  one_shot_timer.it_interval.tv_usec  = 0;
  one_shot_timer.it_value.tv_sec      = 0;
  one_shot_timer.it_value.tv_usec     = 0;
  if (setitimer (ITIMER_REAL, &one_shot_timer, &old_one_shot_timer) == -1)
  { return CANCEL_ONE_SHOT_TIMER_ERROR; }

  return CANCEL_ONE_SHOT_TIMER_OK; 
}

/*! \example test_one_shot_timer.c
    This file shows how to use the function cancel_one_shot_timer().
 */

/*! \brief Pause the one shot timer.
    \return The function return one of the following values:
            <UL>
              <li>PAUSE_ONE_SHOT_TIMER_ERROR: An error occured with the high precision timer.
              <li>PAUSE_ONE_SHOT_TIMER_OK: The operation was successful.
            </UL>
    \warning You can restart the timer with restart_one_shot_timer().
 */

int pause_one_shot_timer ()
{
  if (getitimer (ITIMER_REAL, ¤t_one_shot_timer) == -1)
  { return PAUSE_ONE_SHOT_TIMER_ERROR; }

  if (cancel_one_shot_timer() != CANCEL_ONE_SHOT_TIMER_OK)
  { return PAUSE_ONE_SHOT_TIMER_ERROR; }

  return PAUSE_ONE_SHOT_TIMER_OK;
}

/*! \example test_one_shot_timer.c
    This file shows how to use the function pause_one_shot_timer().
 */

/*! \brief Restart the one shot timer.
    \return The function return one of the following values:
            <UL>
              <li>RESTART_ONE_SHOT_TIMER_ERROR: An error occured with the high precision timer.
              <li>RESTART_ONE_SHOT_TIMER_OK: The operation was successful.
            </UL>
    \warning The timer should have been paused with the function pause_one_shot_timer().
 */

int restart_one_shot_timer ()
{
  if (setitimer (ITIMER_REAL, ¤t_one_shot_timer, &old_one_shot_timer) == -1)
  { return RESTART_ONE_SHOT_TIMER_ERROR; }

  return RESTART_ONE_SHOT_TIMER_OK;
}

/*! \example test_one_shot_timer.c
    This file shows how to use the function restart_one_shot_timer().
 */

ttref.lex

%{

#include <stdio.h>
#include <string.h>
#include "date.h"
#include "strings_utils.h"

extern int                ttref_line_num;
extern struct ttref_tab   ttrefs;


static int                ttref_num = 0;
static int                n;
static struct fields      fd; 
static char*              text_p;


int ttrefwrap() { return 1; }


%}

ALPHA         ([A-Z]|[a-z])
NUMERIC       [0-9]
ALPHANUM      ({ALPHA}|{NUMERIC})
SPACE         \x20
TABUL         \t
BLANK         [\x20\t]
NUMBER        [0-9]
INTEGER       {NUMBER}+
BLANK_LINE    ^{BLANK}+\n
COMMENT       ^{BLANK}*#.+\n
EMPTY_LINE    ^\n

TIMEZONE      {ALPHA}+
DAYLIGHT      {ALPHA}+
SHIFT         (\+{INTEGER})|(\-{INTEGER})

REFERENCE     [^=#]+{BLANK}*={BLANK}*{INTEGER}{BLANK}*$

%%

{REFERENCE}   {
                text_p =  (char*)malloc((strlen(yytext)+1)*sizeof(char));
                if (text_p == NULL) { return TTREF_NO_MEM; }
                strcpy (text_p, yytext);

                if (ttref_num >= MAX_TTREF_ENTRIES) { free(text_p); return TTREF_TOO_MANY_REF; }
                n = s_split(text_p, "=", &fd);
                free(text_p);
                if (n == -1) { return TTREF_NO_MEM; }
                if (n != 2)  { return TTREF_SYNTAX_ERROR; }

                if (chop (fd.tabs[0]) == NULL) { return TTREF_NO_MEM; }
                if (chop (fd.tabs[1]) == NULL) { return TTREF_NO_MEM; }

                #ifdef DEBUG
                fprintf (stdout, "\n => [%s]", fd.tabs[0]);
                fprintf (stdout, "\n => [%s]", fd.tabs[1]);
                #endif

                if (strlen(fd.tabs[0]) >= TTREF_MAX_DATE_SIZE) { return TTREF_DATE_TOO_LONG; }
                strcpy (((ttrefs.ttref)[ttref_num]).date, fd.tabs[0]);

                if (strlen(fd.tabs[1]) >= TTREF_MAX_TIMESTAMP_SIZE) { return TTREF_REF_TOO_LONG; }
                strcpy (((ttrefs.ttref)[ttref_num]).timestamp, fd.tabs[1]);

                ttref_num += 1;
                ttrefs.entry_number = ttref_num;
                free_fields(&fd);
              }


{BLANK_LINE} { ttref_line_num++; }
{EMPTY_LINE} { ttref_line_num++; }
{COMMENT}    { ttref_line_num++; }
\n           { ttref_line_num++; }
.*           { return TTREF_SYNTAX_ERROR; }

%%

Makefile

######################################################################
#             Makefile for all the common C libraries                #
#                       Author: Denis BEURIVE                        #
######################################################################










######################################################################
# The variable 'MAKE_TARGET' could be set to "SUN" or "LINUX". Make  #
# sure to put double quotes (") around the target's identifier.      #
######################################################################

MAKE_TARGET   = "LINUX"
BUILD_TARGET  = LINUX

######################################################################
# LOCAL directory tree                                               #
######################################################################

LOCAL_INCLUDES = ./includes
LOCAL_SRC      = ./src
LOCAL_OBJS     = ./objs
LOCAL_TESTS    = ./tests
LOCAL_BINS     = ./bins
LOCAL_LIB      = ./libs
EXAMPLES       = ./examples

######################################################################
# Network libraries                                                  #
# Note: For SUN, there is another network library that must be added #
#       to the list of libraries: -lresolv.                          #
#       We don't need it right now, but it could be used for future  #
#       evolution.                                                   # 
######################################################################

ifeq (${MAKE_TARGET}, "SUN")
SOCKET_LIBS    = -lsocket -lnsl
endif

ifeq (${MAKE_TARGET}, "LINUX")
SOCKET_LIBS    = 
endif

######################################################################
# Math libraries                                                     #
######################################################################

MATH_LIBS      = -lm

######################################################################
# Dynamic libraries.                                                 #
######################################################################

ifeq (${MAKE_TARGET}, "SUN")
DL_LIBS    = 
endif

ifeq (${MAKE_TARGET}, "LINUX")
DL_LIBS    = -ldl
endif

######################################################################
# FLEX utility configuration                                         #
######################################################################

FLEX           = /usr/bin/flex
FLEX_FLAGS     =  
FLEX_LIB       = /home/users/dbeurive/BIN/FLEX/lib

######################################################################
# AR configuration                                                   #
######################################################################

AR             = ar
ARFLAGS        = rcs

######################################################################
# C Compiler's options                                               #
# -fpic: If supported for the target machines, generate              #
#        position-independent code, suitable for use in a shared     #
#        library.                                                    #
# -ggdb: Add GDB (the GNU debuger) data.                             #
# -Wall: Activate all compiler's warnings.                           #
######################################################################

EXTRA_DEFINES  = 
CC             = gcc
CCFLAGS        = -Wall -ggdb -D${BUILD_TARGET} ${EXTRA_DEFINES} -I${LOCAL_INCLUDES} -L${LOCAL_LIB} -L${FLEX_LIB} -o $@

######################################################################
# DOXYGEN (documentation parser) utility configuration               #
######################################################################

DOXYGEN        = /home/users/dbeurive/BIN/doxygen/bin/doxygen

######################################################################
# Object files                                                       #
######################################################################

${LOCAL_OBJS}/strings_utils.o: ${LOCAL_SRC}/strings_utils.c \
                               ${LOCAL_INCLUDES}/strings_utils.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/strings_utils.c

${LOCAL_OBJS}/config.o: ${LOCAL_SRC}/config.c \
                        ${LOCAL_INCLUDES}/config.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/config.c

${LOCAL_OBJS}/dates.o: ${LOCAL_SRC}/dates.c
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/dates.c 

${LOCAL_OBJS}/date.o: ${LOCAL_SRC}/date.c \
                      ${LOCAL_INCLUDES}/date.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/date.c

${LOCAL_OBJS}/hexa_codes.o: ${LOCAL_SRC}/hexa_codes.c
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/hexa_codes.c

${LOCAL_OBJS}/config.lex.o: ${LOCAL_SRC}/config.lex.c \
                            ${LOCAL_INCLUDES}/config.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/config.lex.c 

${LOCAL_OBJS}/date.lex.o: ${LOCAL_SRC}/date.lex.c \
                          ${LOCAL_INCLUDES}/date.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/date.lex.c

${LOCAL_OBJS}/ttref.lex.o: ${LOCAL_SRC}/ttref.lex.c \
                           ${LOCAL_INCLUDES}/date.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/ttref.lex.c

${LOCAL_OBJS}/char2int.o: ${LOCAL_SRC}/char2int.c
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/char2int.c

${LOCAL_OBJS}/char2hex.o: ${LOCAL_SRC}/char2hex.c
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/char2hex.c

${LOCAL_OBJS}/sha.o: ${LOCAL_SRC}/sha.c \
                     ${LOCAL_INCLUDES}/sha.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/sha.c 

${LOCAL_OBJS}/flock.o: ${LOCAL_SRC}/flock.c \
                       ${LOCAL_INCLUDES}/flock.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/flock.c

${LOCAL_OBJS}/file.o: ${LOCAL_SRC}/files.c \
                      ${LOCAL_INCLUDES}/files.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/files.c

${LOCAL_OBJS}/dir.o: ${LOCAL_SRC}/dir.c \
                     ${LOCAL_INCLUDES}/my_dir.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/dir.c

${LOCAL_OBJS}/signals.o: ${LOCAL_SRC}/signals.c \
                         ${LOCAL_INCLUDES}/signals.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/signals.c

${LOCAL_OBJS}/timing.o: ${LOCAL_SRC}/timing.c \
                        ${LOCAL_INCLUDES}/timing.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/timing.c

${LOCAL_OBJS}/cgi.o: ${LOCAL_SRC}/cgi.c \
                     ${LOCAL_INCLUDES}/cgi.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/cgi.c

${LOCAL_OBJS}/hashfunc.o: ${LOCAL_SRC}/hashfunc.c \
                          ${LOCAL_INCLUDES}/hashfunc.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/hashfunc.c


${LOCAL_OBJS}/endian.o: ${LOCAL_SRC}/endian.c \
                        ${LOCAL_INCLUDES}/my_endian.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/endian.c

${LOCAL_OBJS}/sockets.o: ${LOCAL_SRC}/sockets.c \
                         ${LOCAL_INCLUDES}/my_sockets.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/sockets.c

${LOCAL_OBJS}/cyclic_buffer.o: ${LOCAL_SRC}/cyclic_buffer.c \
                               ${LOCAL_INCLUDES}/cyclic_buffer.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/cyclic_buffer.c

${LOCAL_OBJS}/shm.o: ${LOCAL_SRC}/shm.c \
                     ${LOCAL_INCLUDES}/my_shm.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/shm.c

${LOCAL_OBJS}/sem.o: ${LOCAL_SRC}/sem.c \
                     ${LOCAL_INCLUDES}/my_sem.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/sem.c

${LOCAL_OBJS}/my_math.o: ${LOCAL_SRC}/my_math.c \
                         ${LOCAL_INCLUDES}/my_math.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/my_math.c

${LOCAL_OBJS}/list.o: ${LOCAL_SRC}/list.c \
                      ${LOCAL_INCLUDES}/list.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/list.c

${LOCAL_OBJS}/double_list.o: ${LOCAL_SRC}/list.c \
                             ${LOCAL_INCLUDES}/list.h \
                             ${LOCAL_INCLUDES}/double_list.h
	${CC} ${CCFLAGS} -DDOUBLE_LINK -c ${LOCAL_SRC}/list.c

${LOCAL_OBJS}/chtbl.o: ${LOCAL_SRC}/chtbl.c \
                       ${LOCAL_INCLUDES}/chtbl.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/chtbl.c

${LOCAL_OBJS}/stack.o: ${LOCAL_SRC}/stack.c \
                       ${LOCAL_INCLUDES}/stack.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/stack.c

${LOCAL_OBJS}/array.o: ${LOCAL_SRC}/array.c \
                       ${LOCAL_INCLUDES}/array.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/array.c

${LOCAL_OBJS}/qksort.o: ${LOCAL_SRC}/qksort.c \
                        ${LOCAL_INCLUDES}/sort.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/qksort.c

${LOCAL_OBJS}/issort.o: ${LOCAL_SRC}/issort.c \
                        ${LOCAL_INCLUDES}/sort.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/issort.c

${LOCAL_OBJS}/dmalloc.o: ${LOCAL_SRC}/dmalloc.c \
                         ${LOCAL_INCLUDES}/dmalloc.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/dmalloc.c

${LOCAL_OBJS}/dstring.o: ${LOCAL_SRC}/dstring.c \
                         ${LOCAL_INCLUDES}/dstring.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/dstring.c

${LOCAL_OBJS}/replacer.lex.o: ${LOCAL_SRC}/replacer.lex.c \
                              ${LOCAL_INCLUDES}/dstring.h \
                              ${LOCAL_INCLUDES}/list.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/replacer.lex.c

${LOCAL_OBJS}/replacer.o: ${LOCAL_SRC}/replacer.c \
                          ${LOCAL_INCLUDES}/replacer.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/replacer.c

${LOCAL_OBJS}/smtp.o: ${LOCAL_SRC}/smtp.c \
                      ${LOCAL_INCLUDES}/my_smtp.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/smtp.c

${LOCAL_OBJS}/option.o: ${LOCAL_SRC}/option.c \
                        ${LOCAL_INCLUDES}/option.h
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/option.c

${LOCAL_OBJS}/deamon.o: ${LOCAL_SRC}/deamon.c \
                        ${LOCAL_INCLUDES}/deamon.h
	${CC} ${CCFLAGS} -c ${LOCAL_SRC}/deamon.c

${LOCAL_OBJS}/smtp.lex.o: ${LOCAL_SRC}/smtp.lex.c
	${CC} ${CCFLAGS} -c  ${LOCAL_SRC}/smtp.lex.c

######################################################################
# Libraries                                                          #
######################################################################

${LOCAL_LIB}/libmy_dates.a: ${LOCAL_OBJS}/date.o \
                            ${LOCAL_OBJS}/dates.o \
                            ${LOCAL_OBJS}/date.lex.o \
                            ${LOCAL_OBJS}/ttref.lex.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_dates.a ${LOCAL_OBJS}/date.o ${LOCAL_OBJS}/dates.o ${LOCAL_OBJS}/date.lex.o ${LOCAL_OBJS}/ttref.lex.o

${LOCAL_LIB}/libmy_strings.a: ${LOCAL_OBJS}/strings_utils.o \
                              ${LOCAL_OBJS}/hexa_codes.o \
                              ${LOCAL_OBJS}/char2int.o \
                              ${LOCAL_OBJS}/char2hex.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_strings.a ${LOCAL_OBJS}/strings_utils.o ${LOCAL_OBJS}/hexa_codes.o ${LOCAL_OBJS}/char2int.o ${LOCAL_OBJS}/char2hex.o

${LOCAL_LIB}/libmy_config.a: ${LOCAL_OBJS}/config.o \
                             ${LOCAL_OBJS}/config.lex.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_config.a ${LOCAL_OBJS}/config.o ${LOCAL_OBJS}/config.lex.o 

${LOCAL_LIB}/libmy_files.a: ${LOCAL_OBJS}/flock.o \
                            ${LOCAL_OBJS}/file.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_files.a ${LOCAL_OBJS}/flock.o ${LOCAL_OBJS}/file.o

${LOCAL_LIB}/libmy_dir.a: ${LOCAL_OBJS}/dir.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_dir.a ${LOCAL_OBJS}/dir.o

${LOCAL_LIB}/libmy_sha.a: ${LOCAL_OBJS}/sha.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_sha.a ${LOCAL_OBJS}/sha.o

${LOCAL_LIB}/libmy_signals.a: ${LOCAL_OBJS}/signals.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_signals.a ${LOCAL_OBJS}/signals.o

${LOCAL_LIB}/libmy_timing.a: ${LOCAL_OBJS}/timing.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_timing.a ${LOCAL_OBJS}/timing.o

${LOCAL_LIB}/libmy_cgi.a: ${LOCAL_OBJS}/cgi.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_cgi.a ${LOCAL_OBJS}/cgi.o

${LOCAL_LIB}/libmy_hashfunctions.a: ${LOCAL_OBJS}/hashfunc.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_hashfunctions.a ${LOCAL_OBJS}/hashfunc.o

${LOCAL_LIB}/libmy_bitmanip.a: ${LOCAL_OBJS}/endian.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_bitmanip.a ${LOCAL_OBJS}/endian.o

${LOCAL_LIB}/libmy_sockets.a: ${LOCAL_OBJS}/sockets.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_sockets.a ${LOCAL_OBJS}/sockets.o

${LOCAL_LIB}/libmy_buffers.a: ${LOCAL_OBJS}/cyclic_buffer.o 
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_buffers.a ${LOCAL_OBJS}/cyclic_buffer.o

${LOCAL_LIB}/libmy_shm.a: ${LOCAL_OBJS}/shm.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_shm.a ${LOCAL_OBJS}/shm.o

${LOCAL_LIB}/libmy_sem.a: ${LOCAL_OBJS}/sem.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_sem.a ${LOCAL_OBJS}/sem.o

${LOCAL_LIB}/libmy_math.a: ${LOCAL_OBJS}/my_math.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_math.a ${LOCAL_OBJS}/my_math.o

${LOCAL_LIB}/libmy_list.a: ${LOCAL_OBJS}/list.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_list.a ${LOCAL_OBJS}/list.o

${LOCAL_LIB}/libmy_double_list.a: ${LOCAL_OBJS}/double_list.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_double_list.a ${LOCAL_OBJS}/double_list.o

${LOCAL_LIB}/libmy_hash_table.a: ${LOCAL_OBJS}/chtbl.o 
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_hash_table.a ${LOCAL_OBJS}/chtbl.o 

${LOCAL_LIB}/libmy_stack.a: ${LOCAL_OBJS}/stack.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_stack.a ${LOCAL_OBJS}/stack.o

${LOCAL_LIB}/libmy_array.a: ${LOCAL_OBJS}/array.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_array.a ${LOCAL_OBJS}/array.o

${LOCAL_LIB}/libmy_sort.a: ${LOCAL_OBJS}/qksort.o \
                           ${LOCAL_OBJS}/issort.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_sort.a ${LOCAL_OBJS}/qksort.o ${LOCAL_OBJS}/issort.o 

${LOCAL_LIB}/libmy_dmalloc.a: ${LOCAL_OBJS}/dmalloc.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_dmalloc.a ${LOCAL_OBJS}/dmalloc.o

${LOCAL_LIB}/libmy_dstring.a: ${LOCAL_OBJS}/dstring.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_dstring.a ${LOCAL_OBJS}/dstring.o

${LOCAL_LIB}/libmy_replace.a: ${LOCAL_OBJS}/replacer.lex.o \
                              ${LOCAL_OBJS}/replacer.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_replace.a ${LOCAL_OBJS}/replacer.lex.o ${LOCAL_OBJS}/replacer.o

${LOCAL_LIB}/libmy_smtp.a: ${LOCAL_OBJS}/smtp.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_smtp.a ${LOCAL_OBJS}/smtp.o

${LOCAL_LIB}/libmy_option.a: ${LOCAL_OBJS}/option.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_option.a ${LOCAL_OBJS}/option.o

${LOCAL_LIB}/libmy_deamon.a: ${LOCAL_OBJS}/deamon.o
	${AR} ${ARFLAGS} ${LOCAL_LIB}/libmy_deamon.a ${LOCAL_OBJS}/deamon.o

######################################################################
# Header files                                                       #
######################################################################

${LOCAL_BINS}/os_specific: ${LOCAL_SRC}/os_specific.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/os_specific.c

${LOCAL_INCLUDES}/os_specific.h: ${LOCAL_BINS}/os_specific
	${LOCAL_BINS}/os_specific ${LOCAL_INCLUDES}/os_specific.h

######################################################################
# C files                                                            #
######################################################################

${LOCAL_BINS}/make_dates.test: ${LOCAL_SRC}/make_dates.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/make_dates.c

${LOCAL_SRC}/dates.c: ${LOCAL_BINS}/make_dates.test
	${LOCAL_BINS}/make_dates.test > ${LOCAL_SRC}/dates.c

${LOCAL_BINS}/make_hexa_codes.test: ${LOCAL_SRC}/make_hexa_codes.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/make_hexa_codes.c

${LOCAL_SRC}/hexa_codes.c: ${LOCAL_BINS}/make_hexa_codes.test
	${LOCAL_BINS}/make_hexa_codes.test > ${LOCAL_SRC}/hexa_codes.c

${LOCAL_SRC}/date.lex.c: ${LOCAL_SRC}/date.lex
	${FLEX} ${FLEX_FLAGS} -Pdateyy -o${LOCAL_SRC}/date.lex.c ${LOCAL_SRC}/date.lex

${LOCAL_SRC}/config.lex.c: ${LOCAL_SRC}/config.lex
	${FLEX} ${FLEX_FLAGS} -Pconfig -o${LOCAL_SRC}/config.lex.c ${LOCAL_SRC}/config.lex

${LOCAL_SRC}/ttref.lex.c: ${LOCAL_SRC}/ttref.lex
	${FLEX} ${FLEX_FLAGS} -Pttref -o${LOCAL_SRC}/ttref.lex.c ${LOCAL_SRC}/ttref.lex

${LOCAL_SRC}/char2int.c: ${LOCAL_BINS}/make_char2int
	${LOCAL_BINS}/make_char2int > ${LOCAL_SRC}/char2int.c

${LOCAL_SRC}/char2hex.c: ${LOCAL_BINS}/make_char2hex
	${LOCAL_BINS}/make_char2hex > ${LOCAL_SRC}/char2hex.c

${LOCAL_SRC}/replacer.lex.c: ${LOCAL_SRC}/replacer.lex
	${FLEX} ${FLEX_FLAGS} -Phash -o${LOCAL_SRC}/replacer.lex.c ${LOCAL_SRC}/replacer.lex

${LOCAL_SRC}/smtp.lex.c: ${LOCAL_SRC}/smtp.lex
	${FLEX} ${FLEX_FLAGS} -Psmtp -o${LOCAL_SRC}/smtp.lex.c ${LOCAL_SRC}/smtp.lex

######################################################################
# Test programs                                                      #
######################################################################

${LOCAL_BINS}/make_char2int: ${LOCAL_SRC}/make_char2int.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/make_char2int.c

${LOCAL_BINS}/make_char2hex: ${LOCAL_SRC}/make_char2hex.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/make_char2hex.c

${LOCAL_BINS}/s_split.test: ${LOCAL_TESTS}/test_s_split.c \
                            ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_s_split.c -lmy_strings 

${LOCAL_BINS}/s_split_exact.test: ${LOCAL_TESTS}/test_s_split_exact.c \
                                  ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_s_split_exact.c -lmy_strings

${LOCAL_BINS}/make_one_line.test: ${LOCAL_TESTS}/test_make_one_line.c \
                                  ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_make_one_line.c -lmy_strings

${LOCAL_BINS}/date2timestamp.test: ${LOCAL_TESTS}/test_date2timestamp.c \
                                   ${LOCAL_LIB}/libmy_strings.a \
                                   ${LOCAL_LIB}/libmy_dates.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_date2timestamp.c -lmy_dates -lmy_strings

${LOCAL_BINS}/get_utc_timestamp.test: ${LOCAL_TESTS}/test_get_utc_timestamp.c \
                                      ${LOCAL_LIB}/libmy_strings.a \
                                      ${LOCAL_LIB}/libmy_dates.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_get_utc_timestamp.c -lmy_dates -lmy_strings

${LOCAL_BINS}/get_tsm_date.test: ${LOCAL_TESTS}/test_get_tsm_date.c \
                                 ${LOCAL_LIB}/libmy_strings.a \
                                 ${LOCAL_LIB}/libmy_dates.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_get_tsm_date.c -lmy_dates -lmy_strings

${LOCAL_BINS}/load_ttref.test: ${LOCAL_TESTS}/test_load_ttref.c \
                               ${LOCAL_LIB}/libmy_strings.a \
                               ${LOCAL_LIB}/libmy_dates.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_load_ttref.c -lmy_dates -lmy_strings

${LOCAL_BINS}/rand_dates.test: ${LOCAL_SRC}/rand_dates.c
	${CC} ${CCFLAGS} ${LOCAL_SRC}/rand_dates.c

${LOCAL_BINS}/get_end_of_string.test: ${LOCAL_TESTS}/test_get_end_of_string.c \
                                      ${LOCAL_LIB}/libmy_strings.a 
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_get_end_of_string.c -lmy_strings

${LOCAL_BINS}/IP2hex.test: ${LOCAL_TESTS}/test_IP2hex.c \
                           ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_IP2hex.c -lmy_strings

${LOCAL_BINS}/add_comment.test: ${LOCAL_TESTS}/test_add_comment.c \
                                ${LOCAL_LIB}/libmy_strings.a 
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_add_comment.c -lmy_strings

${LOCAL_BINS}/chop.test: ${LOCAL_TESTS}/test_chop.c \
                         ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_chop.c -lmy_strings

${LOCAL_BINS}/sha.test: ${LOCAL_TESTS}/test_sha.c \
                        ${LOCAL_LIB}/libmy_sha.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_sha.c -lmy_sha

${LOCAL_BINS}/flock.test: ${LOCAL_TESTS}/test_flock.c \
                          ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_flock.c -lmy_files

${LOCAL_BINS}/load_tz.test: ${LOCAL_TESTS}/test_load_tz.c \
                            ${LOCAL_LIB}/libmy_dates.a \
                            ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_load_tz.c -lmy_dates -lfl -lmy_strings 

${LOCAL_BINS}/wait_for_file.test: ${LOCAL_TESTS}/test_wait_for_file.c \
                                  ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_wait_for_file.c -lmy_files

${LOCAL_BINS}/wait_for_multiple_files.test: ${LOCAL_TESTS}/test_wait_for_multiple_files.c \
                                            ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_wait_for_multiple_files.c -lmy_files

${LOCAL_BINS}/dir.test: ${LOCAL_TESTS}/test_dir.c \
                        ${LOCAL_LIB}/libmy_dir.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_dir.c -lmy_dir

${LOCAL_BINS}/replace.test: ${LOCAL_TESTS}/test_replace.c \
                            ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_replace.c -lmy_strings

${LOCAL_BINS}/basename.test: ${LOCAL_TESTS}/test_basename.c \
                             ${LOCAL_LIB}/libmy_dir.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_basename.c -lmy_dir

${LOCAL_BINS}/signal.test: ${LOCAL_TESTS}/test_signals.c \
                           ${LOCAL_LIB}/libmy_signals.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_signals.c -lmy_signals

${LOCAL_BINS}/copy_lock.test: ${LOCAL_TESTS}/test_copy_lock.c \
                              ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_copy_lock.c -lmy_files

${LOCAL_BINS}/log_rotate.test: ${LOCAL_TESTS}/test_log_rotate.c \
                               ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_log_rotate.c -lmy_files

${LOCAL_BINS}/is_integer.test: ${LOCAL_TESTS}/test_is_integer.c \
                               ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_is_integer.c -lmy_strings

${LOCAL_BINS}/is_ip_address.test: ${LOCAL_TESTS}/test_is_ip_address.c \
                                  ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_is_ip_address.c -lmy_strings

${LOCAL_BINS}/is_hexa.test: ${LOCAL_TESTS}/test_is_hexa.c \
                            ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_is_hexa.c -lmy_strings

${LOCAL_BINS}/ip_address_to_num.test: ${LOCAL_TESTS}/test_ip_address_to_num.c \
                                      ${LOCAL_LIB}/libmy_strings.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_ip_address_to_num.c -lmy_strings

${LOCAL_BINS}/stopwatch.test: ${LOCAL_TESTS}/test_stopwatch.c \
                              ${LOCAL_LIB}/libmy_timing.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_stopwatch.c -lmy_timing

${LOCAL_BINS}/url_encoding.test: ${LOCAL_TESTS}/test_url_encoding.c \
                                 ${LOCAL_LIB}/libmy_cgi.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_url_encoding.c -lmy_cgi 

${LOCAL_BINS}/read_file.test: ${LOCAL_TESTS}/test_read_file.c \
                              ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_read_file.c -lmy_files

${LOCAL_BINS}/hash_func.test: ${LOCAL_TESTS}/test_hash_func.c \
                              ${LOCAL_LIB}/libmy_hashfunctions.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_hash_func.c -lmy_hashfunctions

${LOCAL_BINS}/timeout_file.test: ${LOCAL_TESTS}/test_timeout_file.c \
                                 ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_timeout_file.c -lmy_files

${LOCAL_BINS}/one_shot_timer.test: ${LOCAL_TESTS}/test_one_shot_timer.c \
                                   ${LOCAL_LIB}/libmy_timing.a \
                                   ${LOCAL_LIB}/libmy_signals.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_one_shot_timer.c -lmy_timing -lmy_signals

${LOCAL_BINS}/sockets.test: ${LOCAL_TESTS}/test_sockets.c \
                            ${LOCAL_LIB}/libmy_sockets.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_sockets.c -lmy_sockets ${SOCKET_LIBS} -lmy_signals -lmy_timing

${LOCAL_BINS}/cyclic_buffer.test: ${LOCAL_TESTS}/test_cyclic_buffer.c \
                                  ${LOCAL_LIB}/libmy_buffers.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_cyclic_buffer.c -lmy_buffers

${LOCAL_BINS}/shm.test: ${LOCAL_TESTS}/test_shm.c \
                        ${LOCAL_LIB}/libmy_shm.a \
                        ${LOCAL_LIB}/libmy_sem.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_shm.c -lmy_shm -lmy_sem

${LOCAL_BINS}/round_to_multiple_of.test: ${LOCAL_TESTS}/test_round_to_multiple_of.c \
                                         ${LOCAL_LIB}/libmy_math.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_round_to_multiple_of.c -lmy_math

${LOCAL_BINS}/list.test: ${LOCAL_TESTS}/test_list.c \
                         ${LOCAL_LIB}/libmy_list.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_list.c -lmy_list

${LOCAL_BINS}/hash_table.test: ${LOCAL_TESTS}/test_hash_table.c \
                               ${LOCAL_LIB}/libmy_hash_table.a \
                               ${LOCAL_LIB}/libmy_list.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_hash_table.c -lmy_hash_table -lmy_list

${LOCAL_BINS}/stack.test: ${LOCAL_TESTS}/test_stack.c \
                          ${LOCAL_LIB}/libmy_list.a \
                          ${LOCAL_LIB}/libmy_stack.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_stack.c -lmy_stack -lmy_list

${LOCAL_BINS}/double_list.test: ${LOCAL_TESTS}/test_double_list.c \
                                ${LOCAL_LIB}/libmy_double_list.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_double_list.c -lmy_double_list

${LOCAL_BINS}/array.test: ${LOCAL_TESTS}/test_array.c \
                          ${LOCAL_LIB}/libmy_array.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_array.c -lmy_array -lmy_sort

${LOCAL_BINS}/sort.test: ${LOCAL_TESTS}/test_sort.c \
                         ${LOCAL_LIB}/libmy_sort.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_sort.c -lmy_sort

${LOCAL_BINS}/ext_sort.test: ${LOCAL_TESTS}/test_ext_sort.c \
                             ${LOCAL_LIB}/libmy_sort.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_ext_sort.c -lmy_sort

${LOCAL_BINS}/dmalloc.test: ${LOCAL_TESTS}/test_dmalloc.c \
                            ${LOCAL_LIB}/libmy_sort.a \
                            ${LOCAL_LIB}/libmy_files.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_dmalloc.c -lmy_dmalloc -lmy_files

${LOCAL_BINS}/dstring.test: ${LOCAL_TESTS}/test_dstring.c \
                            ${LOCAL_LIB}/libmy_dstring.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_dstring.c -lmy_dstring

${LOCAL_BINS}/replacer.test: ${LOCAL_TESTS}/test_replacer.c \
                             ${LOCAL_OBJS}/replacer.lex.o \
                             ${LOCAL_LIB}/libmy_dstring.a \
                             ${LOCAL_LIB}/libmy_list.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_replacer.c ${LOCAL_OBJS}/replacer.lex.o -lfl -lmy_dstring -lmy_list

${LOCAL_BINS}/replacer_mem.test: ${LOCAL_TESTS}/test_replacer_mem.c \
                             ${LOCAL_OBJS}/replacer.lex.o \
                             ${LOCAL_LIB}/libmy_dstring.a \
                             ${LOCAL_LIB}/libmy_list.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_replacer_mem.c ${LOCAL_OBJS}/replacer.lex.o -lfl -lmy_dstring -lmy_list

${LOCAL_BINS}/replacer_final.test: ${LOCAL_TESTS}/test_replacer_final.c \
                                   ${LOCAL_LIB}/libmy_dstring.a \
                                   ${LOCAL_LIB}/libmy_list.a \
                                   ${LOCAL_LIB}/libmy_hash_table.a \
                                   ${LOCAL_LIB}/libmy_replace.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_replacer_final.c -lfl -lmy_replace -lmy_dstring -lmy_list -lmy_hash_table

${LOCAL_BINS}/replacer_final_mem.test: ${LOCAL_TESTS}/test_replacer_final_mem.c \
                                       ${LOCAL_LIB}/libmy_dstring.a \
                                       ${LOCAL_LIB}/libmy_list.a \
                                       ${LOCAL_LIB}/libmy_hash_table.a \
                                       ${LOCAL_LIB}/libmy_replace.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_replacer_final_mem.c -lfl -lmy_replace -lmy_dstring -lmy_list -lmy_hash_table


${LOCAL_BINS}/smtp_client.test: ${LOCAL_TESTS}/test_smtp_client.c \
                                ${LOCAL_LIB}/libmy_sockets.a \
                                ${LOCAL_LIB}/libmy_signals.a \
                                ${LOCAL_LIB}/libmy_timing.a \
                                ${LOCAL_LIB}/libmy_smtp.a \
                                ${LOCAL_OBJS}/smtp.lex.o
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_smtp_client.c ${LOCAL_OBJS}/smtp.lex.o -lmy_signals -lmy_timing -lmy_smtp ${SOCKET_LIBS} -lmy_sockets -lfl

${LOCAL_BINS}/smtp_lex.test: ${LOCAL_TESTS}/test_smtp_lex.c \
                             ${LOCAL_OBJS}/smtp.lex.o
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_smtp_lex.c ${LOCAL_OBJS}/smtp.lex.o -lfl

${LOCAL_BINS}/options.test: ${LOCAL_TESTS}/test_options.c \
                            ${LOCAL_LIB}/libmy_option.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_options.c -lmy_option

${LOCAL_BINS}/config.test: ${LOCAL_TESTS}/test_config.c \
                           ${LOCAL_LIB}/libmy_config.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_config.c -lmy_config -lmy_strings -lfl -lmy_hash_table -lmy_list

${LOCAL_BINS}/deamon.test: ${LOCAL_TESTS}/test_deamon.c \
                           ${LOCAL_LIB}/libmy_deamon.a
	${CC} ${CCFLAGS} ${LOCAL_TESTS}/test_deamon.c -lmy_deamon

######################################################################
# Sample programs                                                    #
######################################################################



ifeq (${MAKE_TARGET}, "LINUX")
${LOCAL_BINS}/threads.test: ${EXAMPLES}/threads/threads.c
	${CC} ${CCFLAGS} ${EXAMPLES}/threads/threads.c -lpthread
endif

${LOCAL_BINS}/messsage_queue.test: ${EXAMPLES}/IPCs/messsage_queue.c
	${CC} ${CCFLAGS} ${EXAMPLES}/IPCs/messsage_queue.c -o ${LOCAL_BINS}/messsage_queue.test

######################################################################
# Generic rules                                                      #
######################################################################

headers: ${LOCAL_INCLUDES}/os_specific.h

libs: ${LOCAL_LIB}/libmy_bitmanip.a \
      ${LOCAL_LIB}/libmy_buffers.a \
      ${LOCAL_LIB}/libmy_cgi.a \
      ${LOCAL_LIB}/libmy_dates.a \
      ${LOCAL_LIB}/libmy_dir.a \
      ${LOCAL_LIB}/libmy_files.a \
      ${LOCAL_LIB}/libmy_hashfunctions.a \
      ${LOCAL_LIB}/libmy_sem.a \
      ${LOCAL_LIB}/libmy_sha.a \
      ${LOCAL_LIB}/libmy_shm.a \
      ${LOCAL_LIB}/libmy_signals.a \
      ${LOCAL_LIB}/libmy_sockets.a \
      ${LOCAL_LIB}/libmy_strings.a \
      ${LOCAL_LIB}/libmy_timing.a \
      ${LOCAL_LIB}/libmy_math.a \
      ${LOCAL_LIB}/libmy_list.a \
      ${LOCAL_LIB}/libmy_hash_table.a \
      ${LOCAL_LIB}/libmy_stack.a \
      ${LOCAL_LIB}/libmy_double_list.a \
      ${LOCAL_LIB}/libmy_array.a \
      ${LOCAL_LIB}/libmy_sort.a \
      ${LOCAL_LIB}/libmy_dmalloc.a \
      ${LOCAL_LIB}/libmy_dstring.a \
      ${LOCAL_LIB}/libmy_replace.a \
      ${LOCAL_LIB}/libmy_smtp.a \
      ${LOCAL_LIB}/libmy_option.a \
      ${LOCAL_LIB}/libmy_config.a \
      ${LOCAL_LIB}/libmy_deamon.a

test: ${LOCAL_BINS}/s_split.test \
      ${LOCAL_BINS}/s_split_exact.test \
      ${LOCAL_BINS}/date2timestamp.test \
      ${LOCAL_BINS}/rand_dates.test \
      ${LOCAL_BINS}/get_end_of_string.test \
      ${LOCAL_BINS}/IP2hex.test \
      ${LOCAL_BINS}/chop.test \
      ${LOCAL_BINS}/add_comment.test \
      ${LOCAL_BINS}/sha.test \
      ${LOCAL_BINS}/flock.test \
      ${LOCAL_BINS}/load_tz.test \
      ${LOCAL_BINS}/wait_for_file.test \
      ${LOCAL_BINS}/dir.test \
      ${LOCAL_BINS}/replace.test \
      ${LOCAL_BINS}/basename.test \
      ${LOCAL_BINS}/signal.test \
      ${LOCAL_BINS}/copy_lock.test \
      ${LOCAL_BINS}/wait_for_multiple_files.test \
      ${LOCAL_BINS}/load_ttref.test \
      ${LOCAL_BINS}/log_rotate.test \
      ${LOCAL_BINS}/is_integer.test \
      ${LOCAL_BINS}/is_ip_address.test \
      ${LOCAL_BINS}/is_hexa.test \
      ${LOCAL_BINS}/ip_address_to_num.test \
      ${LOCAL_BINS}/stopwatch.test \
      ${LOCAL_BINS}/url_encoding.test \
      ${LOCAL_BINS}/read_file.test \
      ${LOCAL_BINS}/hash_func.test \
      ${LOCAL_BINS}/timeout_file.test \
      ${LOCAL_BINS}/one_shot_timer.test \
      ${LOCAL_BINS}/sockets.test \
      ${LOCAL_BINS}/cyclic_buffer.test \
      ${LOCAL_BINS}/shm.test \
      ${LOCAL_BINS}/round_to_multiple_of.test \
      ${LOCAL_BINS}/list.test \
      ${LOCAL_BINS}/hash_table.test \
      ${LOCAL_BINS}/stack.test \
      ${LOCAL_BINS}/double_list.test \
      ${LOCAL_BINS}/array.test \
      ${LOCAL_BINS}/sort.test \
      ${LOCAL_BINS}/ext_sort.test \
      ${LOCAL_BINS}/dmalloc.test \
      ${LOCAL_BINS}/dstring.test \
      ${LOCAL_BINS}/replacer.test \
      ${LOCAL_BINS}/replacer_mem.test \
      ${LOCAL_BINS}/replacer_final.test \
      ${LOCAL_BINS}/replacer_final_mem.test \
      ${LOCAL_BINS}/smtp_client.test \
      ${LOCAL_BINS}/smtp_lex.test \
      ${LOCAL_BINS}/get_utc_timestamp.test \
      ${LOCAL_BINS}/get_tsm_date.test \
      ${LOCAL_BINS}/make_one_line.test \
      ${LOCAL_BINS}/options.test \
      ${LOCAL_BINS}/config.test \
      ${LOCAL_BINS}/deamon.test


examples_linux: ${LOCAL_BINS}/threads.test \
                ${LOCAL_BINS}/messsage_queue.test

examples_sun: 

ifeq (${MAKE_TARGET}, "LINUX")
samples: examples_linux
endif

ifeq (${MAKE_TARGET}, "SUN")
samples: examples_sun
endif

all: libs test headers samples ${LOCAL_OBJS}/smtp.o 

clean: 
	rm -f ${LOCAL_OBJS}/*.o
	rm -f ${LOCAL_BINS}/*.test
	rm -f ${LOCAL_BINS}/make_char2int
	rm -f ${LOCAL_BINS}/make_char2hex
	rm -f ${LOCAL_BINS}/os_specific
	rm -f ${LOCAL_SRC}/char2int.c
	rm -f ${LOCAL_SRC}/hexa_codes.c
	rm -f ${LOCAL_SRC}/date.lex.c
	rm -f ${LOCAL_SRC}/ttref.lex.c
	rm -f ${LOCAL_SRC}/config.lex.c
	rm -f ${LOCAL_SRC}/replacer.lex.c
	rm -f ${LOCAL_SRC}/smtp.lex.c
	rm -f ${LOCAL_LIB}/*.a
	rm -f ${LOCAL_INCLUDES}/os_specific.h
	rm -f doxygen.war

html:
	${DOXYGEN} doxygen.conf
	cp -R ./doc/html /home/users/dbeurive/BIN/apache/htdocs/tickets/

Bison: Interpréteur RPC

Le code suivant est extrait d’un moteur de Workflow que j’ai développé pour un opérateur télécom. L’analyseur grammatical implémente les fonctions suivantes :

Opérateur OR, AND, XOR, NOT.
Gestion des priorités entre les opérateurs.
Gestion des parenthèses (niveau arbitraire d’imbrication).
Détection de toutes les erreurs.

L’analyseur transforme une expression arithmétique en expression RPN (Revers Polish Notation).

Exemple:

INPUT BOOLEAN EXPRESSION: "b1 OR b2 AND b3 OR (b4 AND b5) XOR NOT b6"

	OUTPUT (RPN representation): 
	b1
	b2
	b3
	and()
	or()
	b4
	b5
	and()
	b6
	not()
	xor()
	or()

L'analyseur grammatical: bool.y

%{
   #include <stdio.h>
   #include <string.h>



   /* Author: Denis BEURIVE */

   #define BOOLEAN_ANALIZER

   #include "boolean_analyzer.h"

   /* ----------------------------------------------------- */
   /* Error handling                                        */
   /* ----------------------------------------------------- */

   #define MAX_ERROR 2048
   char boolean_parsing_error[MAX_ERROR];

   void boolerror (char *m)
   {
     strncpy (
               boolean_parsing_error,
               m,
               strlen(m)+1 <= MAX_ERROR ? strlen(m)+1 : MAX_ERROR-1
             );
     boolean_parsing_error[MAX_ERROR-1]=0;
   }

   /* ----------------------------------------------------- */
   /* The following code is used to interface with the in-  */
   /* -memory lexical parser.                               */
   /* ----------------------------------------------------- */

   extern int boollex();
   int boolparse(void);
   extern void init_lexical_parser(char *src);
   extern void close_lexical_parser();

   static List *list;

   /* ----------------------------------------------------- */
   /* The boolean expression analyser itsef                 */
   /* ----------------------------------------------------- */

   int boolean_spliter(char *src, List *l)
   {
     int res;

     /* --------------------------------------------------- */
     /* Initialize the linked list                          */
     /* --------------------------------------------------- */

     list = l;

     /* --------------------------------------------------- */
     /* Parse in memory buffer pointed by 'src'             */
     /* --------------------------------------------------- */

     init_lexical_parser(src);
     res = boolparse();
     close_lexical_parser();

     return res;
   }


%}

                
                Defines the type of the token returned by the lexical parser (that is Flex). This is a C union.
                

%union {
         char* mot;
         enum operator_name operatorval;
         enum delimitor_name delimitorval;
       }

                
                Defines the type of each token.
                



%token <mot> MOT
%token <operatorval> AND
%token <operatorval> OR
%token <operatorval> XOR
%token <operatorval> NOT
%token <delimitorval> OPEN_BRAKET
%token <delimitorval> CLOSE_BRAKET

%%


expression:
    expression OR terme {
                          if (add_element (list, operator, or, NULL))
                          { return 1; }
                        }
  | terme
  ;

terme:
    terme AND facteur {
                        if (add_element (list, operator, and, NULL))
                        { return 1; }
                      }
  | terme XOR facteur {
                        if (add_element (list, operator, xor, NULL))
                        { return 1; }
                      }
  | facteur
  ;

facteur:
    OPEN_BRAKET expression CLOSE_BRAKET {}
  | NOT facteur {
                  if (add_element (list, operator, not, NULL))
                  { return 1; }
                }
  | MOT {
           if (add_element (list, word, undef, $1)) { return 1; }
         }
  ;


%%

L'analyseur lexical: bool.lex

%{
   #include <stdlib.h>
   #include "grammar_types.h"
   #include "bool.bison.h"
   
   /* Auhtor: Denis BEURIVE */

   int boolwrap() { return 1; }

   /* ----------------------------------------------------- */
   /* The following code is used to parse in-memory data    */
   /* -> init_lexical_parser: must be called before the     */
   /* grammatical analyzer.                                 */
   /* -> close_lexical_parser: must be called after the     */
   /* end of the grammatical analyzer.                      */
   /* ----------------------------------------------------- */

   static YY_BUFFER_STATE buf_state;
   void init_lexical_parser(char *src) { buf_state = yy_scan_string(src); }
   void close_lexical_parser() { yy_delete_buffer(buf_state); }

   /* ----------------------------------------------------- */
   /* Allocatd memory for words                             */
   /* ----------------------------------------------------- */

   char *found_mot;
%}

SPACES [\t ]+
LEX_MOT [^\t\n\(\) ]+
LEX_AND "AND"
LEX_OR "OR"
LEX_XOR "XOR"
LEX_NOT "NOT"
LEX_OPEN_BRAKET \(
LEX_CLOSE_BRAKET \)

%%

{LEX_AND} {
            boollval.operatorval = and;
            return AND;
          }

{LEX_OR} {
            boollval.operatorval = or;
            return OR;
          }

{LEX_XOR} {
            boollval.operatorval = xor;
            return XOR;
          }

{LEX_NOT} {
            boollval.operatorval = not;
            return NOT;
          }

{LEX_OPEN_BRAKET} {
                    boollval.delimitorval = open_braket;
                    return OPEN_BRAKET;
                  }

{LEX_CLOSE_BRAKET} {
                     boollval.delimitorval = close_braket;
                     return CLOSE_BRAKET;
                   }

{LEX_MOT} {
            found_mot = (char*)malloc(sizeof(char) * (strlen(yytext)+1));
            if (found_mot == NULL) { return 1; }
            strcpy (found_mot, yytext);
            boollval.mot = found_mot;
            return MOT;
          }

{SPACES} { }

\n { return 0; }

%%

Gestion de chaînes dynamiques: linked_list.c

/*! \file linked_list.c
    \author Denis BEURIVE
    Linked list management for the boolean interpretor.
 */

#include <stdlib.h>
#include "linked_list.h"

/*! \brief User provided function used to free one element of the linked list.
    \param d Pointer to the element to free.
 */

static void free_data (void *d)
{
  struct list_data *data;

  data = (struct list_data*)d;
  if (data->type == word) { free (data->word); }

  free (data);
}

/*! \brief User provided function used to compare two elements of the linked
           list.
    \param d1 Pointer to the first element to compare.
    \warning This function is required by the linked list API. But it is not
             used by the interpretor.
    \param d2 Pointer to the second element to compare.
    \return The function returns 1 if the elements pointed by d1 and d2 are
            identical. It returns 0 otherwise.
 */

static int compare_element (const void* d1, const void* d2) { return 0; }

/*! \brief Initialize a given linked list so it can be used to save the result of the boolean analysis.
    \param l Pointer to the linked list to initialize.
 */

void init_lined_list (List *l)
{ list_init (l, free_data, compare_element); }

/*! \example test_bool.c */

/*! \brief Free all memory allocated for a linked list.
    \param l Pointer to the linked list to destroy.
 */

void destroy_linked_list (List *l)
{ list_destroy (l); }

/*! \example test_bool.c */

/*! \brief Add an element to the linked list.
    \param l Pointer to the linked list that will receive the new element.
    \param type Type of the new element. It could be:
           <UL>
              <li>word: for a word.
              <li>operator: for an operator.
           </UL>
    \param op If the value of <i>type</i> is <i>operator</i>, then the value
              of <i>op</i> could be:
              <UL>
                <li>and: for the operator <i>AND</i>.
                <li>or: for the operator <i>OR</i>.
              </UL>
              If the value of <i>type</i> is <i>word</i>, then the value
              of <i>op</i> should be set to <i>undef</i>.
    \param w If the value of <i>type</i> is <i>word</i>, then the pointer <i>
             w</i> should point to a zero terminated string of characters that
             represents a word. If the value of <i>type</i> is <i>operator</i>
             then the pointer <i>w</i> should be set to NULL.
    \return Upon sucessful completion the function returns 0, otherwise it
            returns 1 (this means that the program is running out of memory).
 */

int add_element (
                   List *l,
                   enum expr_elem type,
                   enum operator_name op,
                   char *w
                )
{
  struct list_data *d;

  /* --------------------------------------------------- */
  /* Allocate memory */
  /* --------------------------------------------------- */

  d = (struct list_data*)malloc(sizeof(struct list_data));
  if (d == NULL) { return 1; }

  /* --------------------------------------------------- */
  /* Initialize data */
  /* --------------------------------------------------- */

  d->type = type;

  switch (type)
  {
    case word: {
                 d->word = w;
                 d->operator = undef;
               }; break;

    case operator: {
                     d->word = NULL;
                     d->operator = op;
                   }; break;
  }

  /* --------------------------------------------------- */
  /* Insert data to the end of the linked list */
  /* --------------------------------------------------- */

  if (list_ins_next (l, list_tail(l), d) == -1)
  {
    free (d);
    return 1;
  }

  return 0;
}

/*! \example test_bool.c */

Programme de test: test_bool.c

/* ----------------------------------------------------- */
/* This program illustrates the use of the boolean ex-   */
/* -pression analyzer.                                   */
/* ----------------------------------------------------- */

#include <stdio.h>
#include <stdlib.h>
#include "boolean_analyzer.h"

/* ----------------------------------------------------- */
/* This is the in-memory grammatical parser              */
/* ----------------------------------------------------- */

#define NUMBER_OF_TEST 5

char *expr[] = {
                 "b1 OR b2 AND b3 OR (b4 AND b5) XOR NOT b6",
                 "b1 OR b2 AND b3 OR (b4 AND b5)",
                 "b1 OR b2 AND",
                 "b1 OR b2 AND b3 OR ((b4 AND b5) OR b1)", "(b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1)) AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) XOR NOT test AND b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) OR NOT b1 OR b2 AND b3 OR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) XOR ((b4 AND b5) OR b1) AND NOT toto OR gros_test_de_la_mort XOR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 XOR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 XOR ((b4 AND b5) OR b1) AND b1 OR b2 AND b3 AND ((b4 AND b5) OR b1) AND b1 OR b2 AND b3" }; 

int main (int argc, char *argv[])
{
  int res, i;
  List list;
  ListElmt *element;

  for (i=0; i<NUMBER_OF_TEST; i++)
  {

    /* --------------------------------------------------- */
    /* Initialize the linked list                          */
    /* --------------------------------------------------- */

    init_lined_list (&list);

    /* --------------------------------------------------- */
    /* Call the boolean expression analyzer                */
    /* --------------------------------------------------- */

    fprintf (stdout, "\n--> %s:\n", expr[i]);
    fflush (stdout);

    res = boolean_spliter(expr[i], &list);

    if (res == 1)
    {
      fprintf (stdout, "\nParsing error: %s\n", boolean_parsing_error);
      fflush (stdout);
      destroy_linked_list (&list);
      continue;
    }

    /* --------------------------------------------------- */
    /* Now print the RPN conversion                        */
    /* --------------------------------------------------- */

    element = list_head (&list);

    while (element != NULL)
    {
      switch (GET_TYPE(element))
      {
        case word: { fprintf (stdout, "\n%s", GET_WORD(element)); }; break;
        case operator: {
                         switch (GET_OPERATOR(element))
                         {
                           case or: { fprintf (stdout, "\nor()"); }; break;
                           case and: { fprintf (stdout, "\nand()"); }; break;
                           case xor: { fprintf (stdout, "\nxor()"); }; break;
                           case not: { fprintf (stdout, "\nnot()"); }; break;
                           case undef: { fprintf (stdout, "\nundef"); }; break;
                         }
                       }; break;
      }

      element = list_next(element);
    }

    fprintf (stdout, "\n");

    /* --------------------------------------------------- */
    /* Destroy the linked list                             */
    /* --------------------------------------------------- */

    destroy_linked_list (&list);
    fflush (stdout);
  }

  return 0;
}

boolean_analyzer.h

/*! \file boolean_analyzer.h
    This file defines the interface of the boolean expression analyzer.
 */

#ifndef BOOLEAN_ANALYSER_HEADER

#include "grammar_types.h"
#include "linked_list.h"

#define MAX_ERROR 2048

#ifndef BOOLEAN_ANALIZER

/*! \brief If the parser finds an sintaxic error, then the array boolean_parsing_error contains a zero
           terminated sequence of characters that describes the error.
 */

extern char boolean_parsing_error[MAX_ERROR];

/*! \brief The boolean analyser itself.
    \param src Pointer to a zero terminated string of characters that represnts the boolean expression.
    \param l Pointer to a linked list that will be used to store the RPN representation of the boolean
           expression.
    \return Upon successfull completion, the function returns the value 0. Otherwise, the function returns
            the value 1. If the returned value is 1, then the array boolean_parsing_error contains a description
            of the error.
 */

int boolean_spliter(char *src, List *l);

/*! \example test_bool.c
    This simple test program shows how to use the analyser of boolean expressions.
 */

#endif

#define BOOLEAN_ANALYSER_HEADER
#endif

grammar_types.h

/*! \file grammar_types.h
    This file defines all data types used for the BISON grammar parser.
 */

#ifndef OPRATOR_HEADER_FILE

  /*! \brief Defines the type of data used by the BISON parser to assign a
             type to all opreator tokens.
   */

  enum operator_name {
                       /*! \brief Operator <i>AND</i>. */
                       and,
                       /*! \brief Operator <i>OR</i>. */
                       or,
                       /*! \brief Operator <i>XOR</i>. */
                       xor,
                       /*! \brief Operator <i>NOT</i>. */
                       not,
                       /*! \brief This value is used to qualify a token which
                                  does not represent an operator (that is, a
                                  word). */
                       undef
                     };

  /*! \brief Defines the type of data used by the BISON parser to assign a
             type to the tockens associated with the characters <i>(</i> and
             <i>)</i>.
   */

  enum delimitor_name {
                        /*! \brief Character <i>(</i>. */
                        open_braket,
                        /*! \brief Character <i>)</i>. */
                        close_braket
                      };

#define OPRATOR_HEADER_FILE
#endif

linked_list.h

/*! \file linked_list.h
    This file defines all data types used to store elements into the
    linked list.
    \author Denis BEURIVE
 */

#ifndef LINKED_LIST_HEADER

  #include "grammar_types.h"
  #include "list.h"

  /*! \brief Defines the content of an element. An element may contain:
             <UL>
                <li>A word.
                <li>An operator.
             </UL>
   */

  enum expr_elem {
                   /*! \brief This type defines an element that contains a
                              word. */
                   word,

                   /*! \brief This type defines an element that contains an
                              operator. */
                   operator
                 };

  /*! \brief Defines the structure of an element of the linked list. */

  struct list_data {
                     /*! \brief If the element is a word, then this value points
                                to a zero terminated string of characters that
                                represents the word. Otherwise, it should be set
                                to the value NULL. */
                     char *word;

                     /*! \brief If the element is an operator, then this value
                                could be:
                                <UL>
                                  <li>or
                                  <li>and
                                  <li>xor
                                  <li>not
                                </UL>
                                Otherwise, it should be set to <i>undef</i>. */
                     enum operator_name operator;

                     /*! \brief Define the type of the element. If could be a
                                word or an opreator. */
                     enum expr_elem type;
                   };

  int add_element (
                    List *l,
                    enum expr_elem type,
                    enum operator_name op,
                    char *w
                 );
  void init_lined_list (List *l);
  void destroy_linked_list (List *l);

   /*! \brief This macro returns the type of data stored into an element.
       \param e Pointer to the element of the linked list.
       \return The macro returns one of the following values:
               <UL>
                 <li>word (see <i>enum expr_elem</i>)
                 <li>operator (see <i>enum expr_elem</i>)
               </UL>
     */

   #define GET_TYPE(e) (((struct list_data*)list_data(e))->type)

   /*! \brief This macro returns the word stored into an element.
       \param e Pointer to the element of the linked list.
       \return The macro returns a pointer to a zero terminated string of
               characters that represents the word.
       \warning You should call GET_TYPE(e) first.
   */

   #define GET_WORD(e) (((struct list_data*)list_data(e))->word)

   /*! \brief This macro returns the operator stored into an element.
       \param e Pointer to the element of the linked list.
       \return The macro returns one of the following values:
               <UL>
                 <li>or (see <i>enum operator_name</i>)
                 <li>and (see <i>enum operator_name</i>)
                 <li>xor (see <i>enum operator_name</i>)
                 <li>not (see <i>enum operator_name</i>)
                 <li>undef (see <i>enum operator_name</i>)
               </UL>
       \warning You should call GET_TYPE(e) first.
   */
   #define GET_OPERATOR(e) (((struct list_data*)list_data(e))->operator)

#define LINKED_LIST_HEADER
#endif

Makefile

# -----------------------------------------------
# Makefile for the boolean interpretor
# -----------------------------------------------



include ../Makefile.conf


PARSER_PREFIX = bool

# -----------------------------------------------
# Tree organization
# -----------------------------------------------

SRC_DIR = ./src
INCLUDE_DIR = ./includes
FLEX_DIR = ./flex
BISON_DIR = ./bison
TMP_DIR = ./tmp
TEST_DIR = ./tests
BIN_DIR = ./bin
LIB_DIR = ./lib
DOC_DIR = ./doc

# -----------------------------------------------
# Local C compiler options
# -----------------------------------------------

LOCAL_CCFLAGS = -L${LIB_DIR} -I${INCLUDE_DIR} -I${TMP_DIR} ${CCFLAGS}

# -----------------------------------------------
# Building the grammar analizer
# -----------------------------------------------

${TMP_DIR}/bool.bison.h ${TMP_DIR}/bool.bison.c: ${BISON_DIR}/bool.y
        ${YACC} -p ${PARSER_PREFIX} -o ${TMP_DIR}/bool.bison.c -d ${BISON_DIR}/bool.y

${TMP_DIR}/bool.bison.o: ${TMP_DIR}/bool.bison.c \
                         ${TMP_DIR}/bool.bison.h \
                         ${INCLUDE_DIR}/grammar_types.h
        ${CC} ${LOCAL_CCFLAGS} -c ${TMP_DIR}/bool.bison.c

# -----------------------------------------------
# Building the lexical parser
# -----------------------------------------------

${TMP_DIR}/bool.lex.c: ${FLEX_DIR}/bool.lex
        ${LEX} ${LEX_FLAGS} -P${PARSER_PREFIX} -o${@} ${FLEX_DIR}/bool.lex

${TMP_DIR}/bool.lex.o: ${TMP_DIR}/bool.lex.c \
                       ${TMP_DIR}/bool.bison.h
        ${CC} ${LOCAL_CCFLAGS} -c ${TMP_DIR}/bool.lex.c

# -----------------------------------------------
# Linked list management
# -----------------------------------------------

${TMP_DIR}/linked_list.o: ${SRC_DIR}/linked_list.c \
                          ${INCLUDE_DIR}/linked_list.h
        ${CC} ${LOCAL_CCFLAGS} -c ${SRC_DIR}/linked_list.c

# -----------------------------------------------
# Build the library
# -----------------------------------------------

${LIB_DIR}/libbool.a: ${TMP_DIR}/bool.lex.o \
                      ${TMP_DIR}/bool.bison.o \
                      ${TMP_DIR}/linked_list.o
        ${AR} ${ARFLAGS} ${LIB_DIR}/libbool.a ${TMP_DIR}/bool.lex.o ${TMP_DIR}/bool.bison.o ${TMP_DIR}/linked_list.o

# -----------------------------------------------
# Build the top level application
# -----------------------------------------------

${BIN_DIR}/bool.test: ${TEST_DIR}/test_bool.c \
                      ${LIB_DIR}/libbool.a
        ${CC} ${LOCAL_CCFLAGS} ${TEST_DIR}/test_bool.c -lbool -lfl -lmy_list

# -----------------------------------------------
# Build rules
# -----------------------------------------------

test: ${BIN_DIR}/bool.test

all: test

html:
        ${DOXYGEN} doxygen.conf

clean:
        rm -f ${TMP_DIR}/*
        rm -f doxygen.war

Code source

Le code est disponible sur ce lien.

GNU G++ (GCC) vs Visual C++ (VCC)

Les outils de compilation

Tool	GNU	Microsoft Visual C++
The compiler	g++ (alias gcc)	cl.exe
The linker	ld	link.exe
The make utility	gmake (alias make)	nmake.exe
Dumping binary content	objdump	dumpbin.exe
Library dumping	nm	dumpbin.exe
Building a library	ar (and optionally ranlib)	lib.exe

Les Makefiles

The text below is my first Visual C++ "Makefile":

It looks pretty much like a standard UNIX Makefile. The following "Makefile" illustrates the GNU version of a Makefile.

Configuration de compilation

The following table illustrates common compiler's configuration options.

What to do	GCC	Visual C++
Where to look for extra header files	-Iinclude_path	Tools => Options => "show directories for" => "include files" /Iinclude_path
Where to look for extra libraries	-Llibrary_path	Tools => Options => "show directories for" => "library files" /link /LIBPATH:library_path
Linking a library:	-lname This will link the library libname.a	Project => settings => link Just add the library name to the compiler's command line. Any files with name extension other than .C, .CXX, .CPP, or .DEF are passed to the linker.
Specify an output file name	-ofile_name	Project => settings => link /Fefile_name (to create an executable). /Fofile_name.obj (to create an onject file).
Compile only, produce an object file.	-c This will create a ".o" file.	/c /Fofile_name.obj This will create a ".obj" file.
Produce full warning output	-Wall	Project => settings => C/C++ => category => General /W4
Define a macro	-Dmacro[=...]	Project => settings => C/C++ => category => preprocessor /Dmacro[=...]
Undefine a macro	-Umacro	Project => settings => C/C++ => category => preprocessor /Umacro
Building a static library	ar rcs library_name.a file1.o file2.o file3.o ...	lib.exe file1.obj file2.obj ... /OUT:library_name.lib
Building a dynamic library	gcc -shared -fPIC -ldl -o library_name.so file1.o file2.o ...	link.exe /DLL file1.obj file2.obj ... /OUT:library_name.dll

Berkeley DB 1

Cet exemple illustre les opérations de base:

Création d'une base de donnée.
Insertion d’enregistrements.
Recherche.
Suppression.
Fermeture de la base.

/* ---------------------------------------------------------------------- */
/* This simple program illustrates the use of Berkley DB for simple data- */
/* -base management.                                                      */
/*                                                                        */
/* o Open (and create if necessary) a database.                           */
/* o Insert data into the database.                                       */
/* o Extract data from the database.                                      */
/* o Delete records from the database.                                    */
/* o Closing the database.                                                */
/* ---------------------------------------------------------------------- */


#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "db.h"


#define BUFF_SIZE 1000
#define REC_NUMBER 500

int main (int argc, char *argv[])
{
  DB *dbd;
  DBT key, data;
  int cr, i;
  char vkey[BUFF_SIZE], vdata[BUFF_SIZE];

  /* ------------------------------------------------ */
  /* Check command line                               */
  /* ------------------------------------------------ */

  if (argc != 2)
  {
    fprintf (stderr, "\nUsage: testdb <file name>\n");
    return 1;
  }

  /* ------------------------------------------------ */
  /* Create a data base handler                       */
  /* ------------------------------------------------ */

  cr = db_create (
                   &dbd, /* Database hanler to initialize */
                   NULL, /* No special environement */
                   0 /* No special flag */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not create DB handler - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Open a database                                  */
  /* ------------------------------------------------ */

  cr = dbd->open (
                   dbd, /* Previously created DB handler */
                   argv[1], /* Name of the file that hold the database */
                   NULL, /* No database name specified */
                   DB_BTREE, /* Creeate a binary tree structure */
                   DB_CREATE, /* If the file does not exist, create it */
                   0 /* Set default UNIX access permissions */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not open database - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Put data into database                           */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nPutting data into the database");
  fprintf (stdout, "\n------------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);
    sprintf (vdata, "data%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    data.data = vdata;
    data.size = strlen(vdata)+1;

    cr = dbd->put (
                    dbd, /* DB handler */
                    NULL, /* No transaction required */
                    &key, /* Pointer to the record's key */
                    &data, /* Pointer to the record's data */
                    DB_NOOVERWRITE /* Does not add data if the key already exists */
                  );

    switch (cr)
    {
      case 0: break;
      case DB_KEYEXIST: { fprintf (stderr, "\nWarning: key %s already exists\n", vkey); }
                          break;
      default: {
                            fprintf (stderr, "\nERROR: Can not add record - %s", db_strerror(cr));
                            return 1;
                          }
    }
  }

  /* ------------------------------------------------ */
  /* Extract data from the database                   */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nExtracting data from database");
  fprintf (stdout, "\n-----------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    cr = dbd->get (
                    dbd, /* DB handler */
                    NULL, /* No transaction required */
                    &key, /* Pointer to the record's key */
                    &data, /* Pointer to the record's data */
                    0 /* No special options */
                  );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\nKey %s found, value is %s (%d bytes)",
                                   (char*)key.data,
                                   (char*)data.data,
                                   (int)data.size);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\nKey %s not found", (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not get data - %s", db_strerror(cr));
                           return 1;
                         }
    }
  }

  /* ------------------------------------------------ */
  /* Delete records from database                     */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nDeleting data from database");
  fprintf (stdout, "\n---------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    cr = dbd->del (
                    dbd, /* DB handler */
                    NULL, /* No transaction required */
                    &key, /* Pointer to the record's key */
                    0 /* No special options */
                  );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\nRecord(%s) deleted",
                                   (char*)key.data);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\nRecord(%s) not found",
                                   (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not delete record - %s", db_strerror(cr));
                           return 1;
                         }
    }
  }


  /* ------------------------------------------------ */
  /* Close the database handler                       */
  /* ------------------------------------------------ */

  cr = dbd->close (
                    dbd,
                    0
                  );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Error while closing the DB handler - %s", db_strerror(cr));
    return 1;
  }



  return 0;
}

Berkeley DB 2

Création de deux bases au sein d'un même fichier.

/* ---------------------------------------------------------------------- */
/* This simple program illustrates how to create two databases in a single*/
/* file                                                                   */
/*                                                                        */
/* o Open (and create if necessary) a 2 databases.                        */
/* o Insert data into the database.                                       */
/* o Extract data from the database.                                      */
/* o Delete records from the database.                                    */
/* o Closing the database.                                                */
/* ---------------------------------------------------------------------- */


#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "db.h"


#define BUFF_SIZE 1000
#define REC_NUMBER 5

int main (int argc, char *argv[])
{
  DB *dbd1, *dbd2;
  DBT key, data;
  int cr, i;
  char vkey[BUFF_SIZE], vdata[BUFF_SIZE];

  /* ------------------------------------------------ */
  /* Check command line                               */
  /* ------------------------------------------------ */

  if (argc != 2)
  {
    fprintf (stderr, "\nUsage: testdb <file name>\n");
    return 1;
  }

  /* ------------------------------------------------ */
  /* Create the first data base handler               */
  /* ------------------------------------------------ */

  cr = db_create (
                   &dbd1, /* Database hanler to initialize */
                   NULL, /* No special environement */
                   0 /* No special flag */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not create DB handler - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Create the second data base handle               */
  /* ------------------------------------------------ */

  cr = db_create (
                   &dbd2, /* Database hanler to initialize */
                   NULL, /* No special environement */
                   0 /* No special flag */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not create DB handler - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Open the firt database                           */
  /* ------------------------------------------------ */

  cr = dbd1->open (
                    dbd1, /* Previously created DB handler */
                    argv[1], /* Name of the file that hold the database */
                    "db1", /* No database name specified */
                    DB_BTREE, /* Creeate a binary tree structure */
                    DB_CREATE, /* If the file does not exist, create it */
                    0 /* Set default UNIX access permissions */
                  );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not open database - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Open the second database                         */
  /* ------------------------------------------------ */

  cr = dbd2->open (
                    dbd2, /* Previously created DB handler */
                    argv[1], /* Name of the file that hold the database */
                    "db2", /* No database name specified */
                    DB_BTREE, /* Creeate a binary tree structure */
                    DB_CREATE, /* If the file does not exist, create it */
                    0 /* Set default UNIX access permissions */
                  );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not open database - %s", db_strerror(cr));
    return 1;
  }

  /* ------------------------------------------------ */
  /* Put data into first database                     */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nPutting data into the first database");
  fprintf (stdout, "\n------------------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);
    sprintf (vdata, "data%d", i);

    fprintf (stdout, "\nAdding record (%s,%s)", vkey, vdata);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    data.data = vdata;
    data.size = strlen(vdata)+1;

    cr = dbd1->put (
                     dbd1, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     &data, /* Pointer to the record's data */
                     DB_NOOVERWRITE /* Does not add data if the key already exists */
                   );

    switch (cr)
    {
      case 0: break;
      case DB_KEYEXIST: { fprintf (stderr, "\nWarning: key %s already exists\n", vkey); }
                          break;
      default: {
                            fprintf (stderr, "\nERROR: Can not add record - %s", db_strerror(cr));
                            return 1;
                          }
    }
  }

  /* ------------------------------------------------ */
  /* Put data into second database                    */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nPutting data into the second database");
  fprintf (stdout, "\n-------------------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);
    sprintf (vdata, "data_%d", i);

    fprintf (stdout, "\nAdding record (%s,%s)", vkey, vdata);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    data.data = vdata;
    data.size = strlen(vdata)+1;

    cr = dbd2->put (
                     dbd2, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     &data, /* Pointer to the record's data */
                     DB_NOOVERWRITE /* Does not add data if the key already exists */
                   );

    switch (cr)
    {
      case 0: break;
      case DB_KEYEXIST: { fprintf (stderr, "\nWarning: key %s already exists\n", vkey); }
                          break;
      default: {
                            fprintf (stderr, "\nERROR: Can not add record - %s", db_strerror(cr));
                            return 1;
                          }
    }
  }

  /* ------------------------------------------------ */
  /* Extract data from the first database             */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nExtracting data from the first database");
  fprintf (stdout, "\n---------------------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    cr = dbd1->get (
                     dbd1, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     &data, /* Pointer to the record's data */
                     0 /* No special options */
                   );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\nKey %s found, value is %s (%d bytes)",
                                   (char*)key.data,
                                   (char*)data.data,
                                   (int)data.size);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\nKey %s not found", (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not get data - %s", db_strerror(cr));
                           return 1;
                         }
    }
  }

  /* ------------------------------------------------ */
  /* Extract data from the second database            */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nExtracting data from the second database");
  fprintf (stdout, "\n----------------------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    cr = dbd2->get (
                     dbd2, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     &data, /* Pointer to the record's data */
                     0 /* No special options */
                   );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\nKey %s found, value is %s (%d bytes)",
                                   (char*)key.data,
                                   (char*)data.data,
                                   (int)data.size);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\nKey %s not found", (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not get data - %s", db_strerror(cr));
                           return 1;
                         }
    }
  }



  /* ------------------------------------------------ */
  /* Delete records from databases                    */
  /* ------------------------------------------------ */

  fprintf (stdout, "\n");
  fprintf (stdout, "\nDeleting data from databases");
  fprintf (stdout, "\n----------------------------");
  fprintf (stdout, "\n");

  for (i=0; i<REC_NUMBER; i++)
  {
    sprintf (vkey, "key%d", i);

    memset(&key, 0, sizeof(key)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(data)); /* WARNING: you MUST set database data to all zeros */

    key.data = vkey;
    key.size = strlen(vkey)+1;

    cr = dbd1->del (
                     dbd1, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     0 /* No special options */
                   );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\ndatabase 1: Record(%s) deleted",
                                   (char*)key.data);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\ndatabase 1: Record(%s) not found",
                                   (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not delete record - %s", db_strerror(cr));
                           return 1;
                         }
    }

    cr = dbd2->del (
                     dbd2, /* DB handler */
                     NULL, /* No transaction required */
                     &key, /* Pointer to the record's key */
                     0 /* No special options */
                   );

    switch (cr)
    {
      case 0: {
                           fprintf (stdout, "\ndatabase 2: Record(%s) deleted",
                                   (char*)key.data);
                         }; break;
      case DB_NOTFOUND: {
                           fprintf (stdout, "\ndatabase 2: Record(%s) not found",
                                   (char*)key.data);
                         }; break;
      default: {
                           fprintf (stderr, "\nERROR: Can not delete record - %s", db_strerror(cr));
                           return 1;
                         }
    }
  }


  /* ------------------------------------------------ */
  /* Close the database handlers                      */
  /* ------------------------------------------------ */

  cr = dbd1->close (
                     dbd1,
                     0
                   );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Error while closing the DB handler - %s", db_strerror(cr));
    return 1;
  }

  cr = dbd2->close (
                     dbd2,
                     0
                   );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Error while closing the DB handler - %s", db_strerror(cr));
    return 1;
  }




  return 0;
}

############################################################
# Source tree                                              #
############################################################

INCLUDE_DIR = .
SRC_DIR = .
OBJ_DIR = .
BIN_DIR = .

############################################################
# Berkeley DB header files and libraries                   #
############################################################

BERKELEY_HEADERS_DIR = /home/users/dbeurive/BIN/berkeley_db/include
BERKELEY_LIBS_DIR = /home/users/dbeurive/BIN/berkeley_db/lib

############################################################
# Compiler options                                         #
############################################################

CC = gcc
CCFLAGS = -Wall -I${BERKELEY_HEADERS_DIR} -L${BERKELEY_LIBS_DIR} -o $@

############################################################
# Binaries                                                 #
############################################################

${BIN_DIR}/testdb1: ${SRC_DIR}/testdb1.c
        ${CC} ${CCFLAGS} ${SRC_DIR}/testdb1.c -ldb

${BIN_DIR}/testdb2: ${SRC_DIR}/testdb2.c
        ${CC} ${CCFLAGS} ${SRC_DIR}/testdb2.c -ldb

############################################################
# Rules                                                    #
############################################################

all: ${BIN_DIR}/testdb1 \
     ${BIN_DIR}/testdb2

clean:
        rm -f ${BIN_DIR}/testdb1
        rm -f ${BIN_DIR}/testdb2

Berkeley DB 3

Cet exemple illustre les opérations de base:

Ajout d’un enregistrement à la fin d’une base de type RECNO.
Utilisation de curseurs.

/* ----------------------------------------------- */
/* This simple program performs the following      */
/* operations:                                     */
/*                                                 */
/* (1) Create a RECNO database.                    */
/* (2) Insert records into the database. Insersion */
/* is done at the end of the DB file.              */
/* (3) Dump a record using a cursor that moves     */
/* from the begining to the end of the             */
/* databasei. Once a record is dumped, its         */
/* value is doubled.                               */
/*                                                 */
/* This shows:                                     */
/*                                                 */
/* + How to append records to the end of a RECNO.  */
/* + How to use cursors to move across a database. */
/* + How to use cursors to update a given records. */
/* ----------------------------------------------- */

#include <string.h>
#include "db.h"

#define DB_NAME "output.db"

/* ----------------------------------------------- */
/* Define data to insert                           */
/* ----------------------------------------------- */

#define NUMBER_OF_RECORDS 4

struct sdata {
               db_recno_t record_number;
               int value;
             };

struct sdata SDATA[NUMBER_OF_RECORDS] = {
                                          { 1, 10 },
                                          { 2, 20 },
                                          { 3, 30 },
                                          { 4, 40 }
                                        };

/* ----------------------------------------------- */
/* Main entry point                                */
/* ----------------------------------------------- */


int main (int argc, char *argv[])
{
  int cr, i;
  DB *dbd;
  DBT key, data;
  DBC *cursor;
  db_recno_t rn;
  struct sdata *prec, nrec;

  /* --------------------------------------------- */
  /* Create Berkeley DB handler                    */
  /* --------------------------------------------- */

  cr = db_create (
                   &dbd, /* Database hanler to initialize */
                   NULL, /* No special environement */
                   0 /* No special flag */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not create DB handler - %s", db_strerror(cr));
    return 1;
  }

  /* --------------------------------------------- */
  /* Open the Berkeley database                    */
  /* --------------------------------------------- */

  cr = dbd->open (
                   dbd, /* Previously created DB handler */
                   DB_NAME, /* Name of the file that hold the database */
                   NULL, /* No database name specified */
                   DB_RECNO, /* Creeate a binary tree structure */
                   DB_CREATE, /* If the file does not exist, create it */
                   0 /* Set default UNIX access permissions */
                 );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not open database - %s", db_strerror(cr));
    return 1;
  }

  /* --------------------------------------------- */
  /* Insert records                                */
  /* --------------------------------------------- */

  for (i=0; i<NUMBER_OF_RECORDS; i++)
  {
    memset(&key, 0, sizeof(DBT)); /* WARNING: you MUST set database data to all zeros */
    memset(&data, 0, sizeof(DBT)); /* WARNING: you MUST set database data to all zeros */

    rn = (db_recno_t)(i+1);

    key.data = &rn;
    key.size = sizeof(db_recno_t);

    data.data = SDATA+i;
    data.size = sizeof(struct sdata);

    cr = dbd->put (
                    dbd, /* DB handler */
                    NULL, /* No transaction required */
                    &key, /* Pointer to the record's key */
                    &data, /* Pointer to the record's data */
                    DB_APPEND /* Add record to the end of the DB file */
                  );

    switch (cr)
    {
      case 0: break;
      case DB_KEYEXIST: break;
      default: {
                            fprintf (stderr, "\nERROR: Can not add record - %s", db_strerror(cr));
                            return 1;
                          }
    }
  }

  /* --------------------------------------------- */
  /* Dump the database using a cursor              */
  /* AND                                           */
  /* Double each value                             */
  /* --------------------------------------------- */

        /* --------------------------------------- */
        /* Create the cursor                       */
        /* --------------------------------------- */

  cr = dbd->cursor (
                     dbd,
                     NULL,
                     &cursor,
                     0
                   );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Can not create cursor - %s", db_strerror(cr));
    return 1;
  }

        /* --------------------------------------- */
        /* Set the cursor to the first record      */
        /* --------------------------------------- */

  memset(&key, 0, sizeof(DBT));
  memset(&data, 0, sizeof(DBT));

  cr = cursor->c_get (
                       cursor,
                       &key,
                       &data,
                       DB_FIRST
                     );

  switch (cr)
  {
    case 0: break;
    case DB_NOTFOUND: {
                           fprintf (stdout, "\nTable Frequency_recno is empty");
                        }; break;
    default: {
                           cursor->c_close(cursor);
                           fprintf (stderr, "\nERROR: cursor operation failed - %s", db_strerror(cr));
                           return 1;
                        }
  }

        /* --------------------------------------- */
        /* Now move cursor until the last record   */
        /* --------------------------------------- */

  while (cr == 0)
  {

                 /* ------------------------------ */
                 /* Print actual value             */
                 /* ------------------------------ */

    prec = (struct sdata*)(data.data);
    fprintf (stdout, "\nRECNO: %u", prec->record_number);
    fprintf (stdout, "\n %d\n", prec->value);

                 /* ------------------------------ */
                 /* Double actual value            */
                 /* ------------------------------ */

    nrec.record_number = prec->record_number;
    nrec.value = prec->value * 2;
    rn = *((db_recno_t*)(key.data));

    memset(&key, 0, sizeof(DBT));
    memset(&data, 0, sizeof(DBT));

    key.data = &rn;
    key.size = sizeof(db_recno_t);

    data.data = &nrec;
    data.size = sizeof(struct sdata);

    cr = cursor->c_put (
                         cursor,
                         &key,
                         &data,
                         DB_CURRENT
                       );

    if (cr != 0)
    {
      fprintf (stderr, "\nERROR: cursor operation failed - %s", db_strerror(cr));
      return 1;
    }

                 /* ------------------------------ */
                 /* Move to the next record        */
                 /* ------------------------------ */

    memset(&key, 0, sizeof(DBT));
    memset(&data, 0, sizeof(DBT));

    cr = cursor->c_get (
                         cursor,
                         &key,
                         &data,
                         DB_NEXT
                       );
  }

  if (cr != DB_NOTFOUND)
  {
    fprintf (stderr, "\nERROR: cursor operation failed - %s", db_strerror(cr));
    return 1;
  }

        /* --------------------------------------- */
        /* Close the cursor                        */
        /* --------------------------------------- */

  cr = cursor->c_close(cursor);

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Error while closing cursor - %s", db_strerror(cr));
    return 1;
  }

  /* --------------------------------------------- */
  /* Close all open handlers                       */
  /* --------------------------------------------- */

  cr = dbd->close (
                    dbd,
                    0
                  );

  if (cr != 0)
  {
    fprintf (stderr, "\nERROR: Error while closing the DB handler - %s", db_strerror(cr));
    return 1;
  }


  return 0;
}