/*
================================================================================
  RPL/2 (R) version 4.1.36
  Copyright (C) 1989-2024 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Fonction de récupération des paramètres de connexion à une base SQL
================================================================================
  Entrées : objet de type liste
--------------------------------------------------------------------------------
  Sorties : pointeur sur un struct_connecteur_swl
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

struct_objet *
parametres_sql(struct_processus *s_etat_processus, struct_objet *s_parametres)
{
	struct_liste_chainee			*l_element_courant;

	struct_objet					*s_connecteur;

	unsigned char					*locale;
	unsigned char					*type_base;
	unsigned char					*serveur;
#	if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)
	unsigned char					*base;
	unsigned char					*utilisateur;
	unsigned char					*mot_de_passe;
#	ifdef POSTGRESQL_SUPPORT
	unsigned char					*sport;
#	endif

	unsigned int					port;
#	endif

	if ((*s_parametres).type != LST)
	{
		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return(NULL);
	}

	l_element_courant = (struct_liste_chainee *) (*s_parametres).objet;

	if (l_element_courant == NULL)
	{
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((*(*l_element_courant).donnee).type != CHN)
	{
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((type_base = conversion_majuscule(s_etat_processus, (unsigned char *)
			(*(*l_element_courant).donnee).objet)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	locale = index(type_base, ':');

	if (locale != NULL)
	{
		(*locale) = d_code_fin_chaine;
		locale++;
	}

	/*
	 * Vérifications des types de base de données
	 */

	if ((strcmp(type_base, "MYSQL") != 0) &&
			(strcmp(type_base, "POSTGRESQL") != 0) &&
			(strcmp(type_base, "SQLITE") != 0))
	{
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((s_connecteur = allocation(s_etat_processus, SQL)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	(*((struct_connecteur_sql *) (*s_connecteur).objet)).type = type_base;

	if (locale != NULL)
	{
		if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale
				= malloc((strlen(locale) + 1) * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(NULL);
		}

		strcpy((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale,
				locale);

		if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).type
				= realloc((*((struct_connecteur_sql *) (*s_connecteur).objet))
				.type, (strlen((*((struct_connecteur_sql *) (*s_connecteur)
				.objet)).type) + 1) * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(NULL);
		}
	}
	else
	{
		(*((struct_connecteur_sql *) (*s_connecteur).objet)).locale = NULL;
	}

	(*((struct_connecteur_sql *) (*s_connecteur).objet)).pid = getpid();
	(*((struct_connecteur_sql *) (*s_connecteur).objet)).tid = pthread_self();

	// Recherche du nom ou de l'adresse du serveur

	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant == NULL)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((*(*l_element_courant).donnee).type != CHN)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	serveur = (unsigned char *) (*(*l_element_courant).donnee).objet;

	// Dans le cas d'une base de données SQLite, seul le nom du fichier
	// importe.

	if (strcmp(type_base, "SQLITE") == 0)
	{
		if ((*l_element_courant).suivant != NULL)
		{
			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return(NULL);
		}

		(*((struct_connecteur_sql *) (*s_connecteur).objet)).descripteur.sqlite
				= NULL;

		if (sqlite3_open_v2(serveur, &((*((struct_connecteur_sql *)
				(*s_connecteur).objet)).descripteur.sqlite),
				SQLITE_OPEN_READWRITE, NULL) != SQLITE_OK)
		{
			if ((*((struct_connecteur_sql *) (*s_connecteur).objet))
					.descripteur.sqlite != NULL)
			{
				sqlite3_close((*((struct_connecteur_sql *)
						(*s_connecteur).objet)).descripteur.sqlite);
			}

			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_erreur_sql;
			return(NULL);
		}

		return(s_connecteur);
	}
	else
	{
#   	if !(defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT))
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Attention : Support de %s non compilé !\n", type_base);
		}
		else
		{
			printf("+++Warning : %s support not available !\n", type_base);
		}
#		endif
	}

#	if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)
	// Recherche du nom de la base de données

	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant == NULL)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((*(*l_element_courant).donnee).type != CHN)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	base = (unsigned char *) (*(*l_element_courant).donnee).objet;

	// Recherche de l'utilisateur

	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant == NULL)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((*(*l_element_courant).donnee).type != CHN)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	utilisateur = (unsigned char *) (*(*l_element_courant).donnee).objet;

	// Recherche du mot de passe

	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant == NULL)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	if ((*(*l_element_courant).donnee).type != CHN)
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}

	mot_de_passe = (unsigned char *) (*(*l_element_courant).donnee).objet;

	// Recherche du port le cas échéant

	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant != NULL)
	{
		if ((*(*l_element_courant).donnee).type != INT)
		{
			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return(NULL);
		}

		if (((*((integer8 *) (*(*l_element_courant).donnee).objet)) < 0)
				|| ((*((integer8 *) (*(*l_element_courant).donnee)
				.objet)) > 65535))
		{
			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return(NULL);
		}

		port = (unsigned int) (*((integer8 *)
				(*(*l_element_courant).donnee).objet));

		if ((*l_element_courant).suivant != NULL)
		{
			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return(NULL);
		}
	}
	else
	{
		port = 0;
	}

	if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
				"MYSQL") == 0)
	{
#		ifdef MYSQL_SUPPORT
		(*((struct_connecteur_sql *) (*s_connecteur).objet))
				.descripteur.mysql = NULL;

		if (((*((struct_connecteur_sql *) (*s_connecteur).objet))
				.descripteur.mysql = mysql_init(NULL)) == NULL)
		{
			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(NULL);
		}

		if (mysql_real_connect((*((struct_connecteur_sql *) (*s_connecteur)
				.objet)).descripteur.mysql, serveur, utilisateur, mot_de_passe,
				base, port, NULL, 0) == NULL)
		{
			mysql_close((*((struct_connecteur_sql *) (*s_connecteur).objet))
					.descripteur.mysql);

			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_erreur_sql;
			return(NULL);
		}
#		else
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Attention : Support de MySQL non compilé !\n");
		}
		else
		{
			printf("+++Warning : MySQL support not available !\n");
		}

		fflush(stdout);

		(*s_etat_processus).erreur_execution = d_ex_instruction_indisponible;
#		endif
	}
	else if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
				"POSTGRESQL") == 0)
	{
#		ifdef POSTGRESQL_SUPPORT
		if (port == 0)
		{
			sport = NULL;
		}
		else
		{
			if ((sport = malloc(32 * sizeof(unsigned char))) == NULL)
			{
				liberation(s_etat_processus, s_connecteur);
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(NULL);
			}

			sprintf(sport, "%u", port);
		}

		(*((struct_connecteur_sql *) (*s_connecteur).objet)).descripteur
				.postgresql = PQsetdbLogin(serveur, sport, NULL, NULL,
				base, utilisateur, mot_de_passe);

		free(sport);

		if (PQstatus((*((struct_connecteur_sql *) (*s_connecteur).objet))
				.descripteur.postgresql) != CONNECTION_OK)
		{
			PQfinish((*((struct_connecteur_sql *) (*s_connecteur).objet))
					.descripteur.postgresql);

			liberation(s_etat_processus, s_connecteur);
			(*s_etat_processus).erreur_execution = d_ex_erreur_sql;
			return(NULL);
		}
#		else
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Attention : Support de PostgreSQL non compilé !\n");
		}
		else
		{
			printf("+++Warning : PostgreSQL support not available !\n");
		}

		fflush(stdout);

		(*s_etat_processus).erreur_execution = d_ex_instruction_indisponible;
#		endif
	}
	else
	{
		liberation(s_etat_processus, s_connecteur);
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return(NULL);
	}
#	endif

	return(s_connecteur);
}

// vim: ts=4