Return to sql.c CVS log

Up to [local] / rpl / src

En route pour la 4.1.5. Correction d'un bug mineur sur les mutexes.
Préparation d'un mécanisme pour éviter qu'un mutex soit déverrouillé
depuis un thread qui ne l'a pas verrouillé.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.5
    4:   Copyright (C) 1989-2011 Dr. BERTRAND Joël
    5: 
    6:   This file is part of RPL/2.
    7: 
    8:   RPL/2 is free software; you can redistribute it and/or modify it
    9:   under the terms of the CeCILL V2 License as published by the french
   10:   CEA, CNRS and INRIA.
   11:  
   12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
   13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
   15:   for more details.
   16:  
   17:   You should have received a copy of the CeCILL License
   18:   along with RPL/2. If not, write to info@cecill.info.
   19: ================================================================================
   20: */
   21: 
   22: 
   23: #include "rpl-conv.h"
   24: 
   25: 
   26: /*
   27: ================================================================================
   28:   Fonction de récupération des paramètres de connexion à une base SQL
   29: ================================================================================
   30:   Entrées : objet de type liste
   31: --------------------------------------------------------------------------------
   32:   Sorties : pointeur sur un struct_connecteur_swl
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: struct_objet *
   39: parametres_sql(struct_processus *s_etat_processus, struct_objet *s_parametres)
   40: {
   41: #if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)
   42:     struct_liste_chainee            *l_element_courant;
   43: 
   44:     struct_objet                    *s_connecteur;
   45: 
   46:     unsigned char                   *locale;
   47:     unsigned char                   *type_base;
   48:     unsigned char                   *serveur;
   49:     unsigned char                   *base;
   50:     unsigned char                   *utilisateur;
   51:     unsigned char                   *mot_de_passe;
   52: #   ifdef POSTGRESQL_SUPPORT
   53:     unsigned char                   *sport;
   54: #   endif
   55: 
   56:     unsigned int                    port;
   57: 
   58:     if ((*s_parametres).type != LST)
   59:     {
   60:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
   61:         return(NULL);
   62:     }
   63: 
   64:     l_element_courant = (struct_liste_chainee *) (*s_parametres).objet;
   65: 
   66:     if (l_element_courant == NULL)
   67:     {
   68:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
   69:         return(NULL);
   70:     }
   71: 
   72:     if ((*(*l_element_courant).donnee).type != CHN)
   73:     {
   74:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
   75:         return(NULL);
   76:     }
   77: 
   78:     if ((type_base = conversion_majuscule((unsigned char *)
   79:             (*(*l_element_courant).donnee).objet)) == NULL)
   80:     {
   81:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   82:         return(NULL);
   83:     }
   84: 
   85:     locale = index(type_base, ':');
   86: 
   87:     if (locale != NULL)
   88:     {
   89:         (*locale) = d_code_fin_chaine;
   90:         locale++;
   91:     }
   92: 
   93:     /*
   94:      * Vérifications des types de base de données
   95:      */
   96: 
   97:     if ((strcmp(type_base, "MYSQL") != 0) &&
   98:             (strcmp(type_base, "POSTGRESQL") != 0))
   99:     {
  100:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  101:         return(NULL);
  102:     }
  103: 
  104:     if ((s_connecteur = allocation(s_etat_processus, SQL)) == NULL)
  105:     {
  106:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  107:         return(NULL);
  108:     }
  109: 
  110:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).type = type_base;
  111: 
  112:     if (locale != NULL)
  113:     {
  114:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale
  115:                 = malloc((strlen(locale) + 1) * sizeof(unsigned char))) == NULL)
  116:         {
  117:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  118:             return(NULL);
  119:         }
  120: 
  121:         strcpy((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale,
  122:                 locale);
  123: 
  124:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).type
  125:                 = realloc((*((struct_connecteur_sql *) (*s_connecteur).objet))
  126:                 .type, (strlen((*((struct_connecteur_sql *) (*s_connecteur)
  127:                 .objet)).type) + 1) * sizeof(unsigned char))) == NULL)
  128:         {
  129:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  130:             return(NULL);
  131:         }
  132:     }
  133:     else
  134:     {
  135:         (*((struct_connecteur_sql *) (*s_connecteur).objet)).locale = NULL;
  136:     }
  137: 
  138:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).pid = getpid();
  139:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).tid = pthread_self();
  140: 
  141:     // Recherche du nom ou de l'adresse du serveur
  142: 
  143:     l_element_courant = (*l_element_courant).suivant;
  144: 
  145:     if (l_element_courant == NULL)
  146:     {
  147:         liberation(s_etat_processus, s_connecteur);
  148:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  149:         return(NULL);
  150:     }
  151: 
  152:     if ((*(*l_element_courant).donnee).type != CHN)
  153:     {
  154:         liberation(s_etat_processus, s_connecteur);
  155:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  156:         return(NULL);
  157:     }
  158: 
  159:     serveur = (unsigned char *) (*(*l_element_courant).donnee).objet;
  160: 
  161:     // Recherche du nom de la base de données
  162: 
  163:     l_element_courant = (*l_element_courant).suivant;
  164: 
  165:     if (l_element_courant == NULL)
  166:     {
  167:         liberation(s_etat_processus, s_connecteur);
  168:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  169:         return(NULL);
  170:     }
  171: 
  172:     if ((*(*l_element_courant).donnee).type != CHN)
  173:     {
  174:         liberation(s_etat_processus, s_connecteur);
  175:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  176:         return(NULL);
  177:     }
  178: 
  179:     base = (unsigned char *) (*(*l_element_courant).donnee).objet;
  180: 
  181:     // Recherche de l'utilisateur
  182: 
  183:     l_element_courant = (*l_element_courant).suivant;
  184: 
  185:     if (l_element_courant == NULL)
  186:     {
  187:         liberation(s_etat_processus, s_connecteur);
  188:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  189:         return(NULL);
  190:     }
  191: 
  192:     if ((*(*l_element_courant).donnee).type != CHN)
  193:     {
  194:         liberation(s_etat_processus, s_connecteur);
  195:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  196:         return(NULL);
  197:     }
  198: 
  199:     utilisateur = (unsigned char *) (*(*l_element_courant).donnee).objet;
  200: 
  201:     // Recherche du mot de passe
  202: 
  203:     l_element_courant = (*l_element_courant).suivant;
  204: 
  205:     if (l_element_courant == NULL)
  206:     {
  207:         liberation(s_etat_processus, s_connecteur);
  208:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  209:         return(NULL);
  210:     }
  211: 
  212:     if ((*(*l_element_courant).donnee).type != CHN)
  213:     {
  214:         liberation(s_etat_processus, s_connecteur);
  215:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  216:         return(NULL);
  217:     }
  218: 
  219:     mot_de_passe = (unsigned char *) (*(*l_element_courant).donnee).objet;
  220: 
  221:     // Recherche du port le cas échéant
  222: 
  223:     l_element_courant = (*l_element_courant).suivant;
  224: 
  225:     if (l_element_courant != NULL)
  226:     {
  227:         if ((*(*l_element_courant).donnee).type != INT)
  228:         {
  229:             liberation(s_etat_processus, s_connecteur);
  230:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  231:             return(NULL);
  232:         }
  233: 
  234:         if (((*((integer8 *) (*(*l_element_courant).donnee).objet)) < 0)
  235:                 || ((*((integer8 *) (*(*l_element_courant).donnee)
  236:                 .objet)) > 65535))
  237:         {
  238:             liberation(s_etat_processus, s_connecteur);
  239:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  240:             return(NULL);
  241:         }
  242: 
  243:         port = (unsigned int) (*((integer8 *)
  244:                 (*(*l_element_courant).donnee).objet));
  245: 
  246:         if ((*l_element_courant).suivant != NULL)
  247:         {
  248:             liberation(s_etat_processus, s_connecteur);
  249:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  250:             return(NULL);
  251:         }
  252:     }
  253:     else
  254:     {
  255:         port = 0;
  256:     }
  257: 
  258:     if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
  259:                 "MYSQL") == 0)
  260:     {
  261: #       ifdef MYSQL_SUPPORT
  262:         (*((struct_connecteur_sql *) (*s_connecteur).objet))
  263:                 .descripteur.mysql = NULL;
  264: 
  265:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet))
  266:                 .descripteur.mysql = mysql_init(NULL)) == NULL)
  267:         {
  268:             liberation(s_etat_processus, s_connecteur);
  269:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  270:             return(NULL);
  271:         }
  272: 
  273:         if (mysql_real_connect((*((struct_connecteur_sql *) (*s_connecteur)
  274:                 .objet)).descripteur.mysql, serveur, utilisateur, mot_de_passe,
  275:                 base, port, NULL, 0) == NULL)
  276:         {
  277:             mysql_close((*((struct_connecteur_sql *) (*s_connecteur).objet))
  278:                     .descripteur.mysql);
  279: 
  280:             liberation(s_etat_processus, s_connecteur);
  281:             (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
  282:             return(NULL);
  283:         }
  284: #       else
  285:         if ((*s_etat_processus).langue == 'F')
  286:         {
  287:             printf("+++Attention : Support de MySQL non compilé !\n");
  288:         }
  289:         else
  290:         {
  291:             printf("+++Warning : MySQL support not available !\n");
  292:         }
  293: 
  294:         fflush(stdout);
  295: #       endif
  296:     }
  297:     else if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
  298:                 "POSTGRESQL") == 0)
  299:     {
  300: #       ifdef POSTGRESQL_SUPPORT
  301:         if (port == 0)
  302:         {
  303:             sport = NULL;
  304:         }
  305:         else
  306:         {
  307:             if ((sport = malloc(32 * sizeof(unsigned char))) == NULL)
  308:             {
  309:                 liberation(s_etat_processus, s_connecteur);
  310:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  311:                 return(NULL);
  312:             }
  313: 
  314:             sprintf(sport, "%u", port);
  315:         }
  316: 
  317:         (*((struct_connecteur_sql *) (*s_connecteur).objet)).descripteur
  318:                 .postgresql = PQsetdbLogin(serveur, sport, NULL, NULL,
  319:                 base, utilisateur, mot_de_passe);
  320: 
  321:         free(sport);
  322: 
  323:         if (PQstatus((*((struct_connecteur_sql *) (*s_connecteur).objet))
  324:                 .descripteur.postgresql) != CONNECTION_OK)
  325:         {
  326:             PQfinish((*((struct_connecteur_sql *) (*s_connecteur).objet))
  327:                     .descripteur.postgresql);
  328: 
  329:             liberation(s_etat_processus, s_connecteur);
  330:             (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
  331:             return(NULL);
  332:         }
  333: #       else
  334:         if ((*s_etat_processus).langue == 'F')
  335:         {
  336:             printf("+++Attention : Support de PostgreSQL non compilé !\n");
  337:         }
  338:         else
  339:         {
  340:             printf("+++Warning : PostgreSQL support not available !\n");
  341:         }
  342: 
  343:         fflush(stdout);
  344: #       endif
  345:     }
  346:     else
  347:     {
  348:         liberation(s_etat_processus, s_connecteur);
  349:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  350:         return(NULL);
  351:     }
  352: 
  353:     return(s_connecteur);
  354: #else
  355:     return(NULL);
  356: #endif
  357: }
  358: 
  359: // vim: ts=4