Return to sql.c CVS log

Up to [local] / rpl / src

Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.2
    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:     struct_liste_chainee            *l_element_courant;
   42: 
   43:     struct_objet                    *s_connecteur;
   44: 
   45:     unsigned char                   *base;
   46:     unsigned char                   *locale;
   47:     unsigned char                   *mot_de_passe;
   48:     unsigned char                   *serveur;
   49:     unsigned char                   *sport;
   50:     unsigned char                   *type_base;
   51:     unsigned char                   *utilisateur;
   52: 
   53:     unsigned int                    port;
   54: 
   55:     if ((*s_parametres).type != LST)
   56:     {
   57:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
   58:         return(NULL);
   59:     }
   60: 
   61:     l_element_courant = (struct_liste_chainee *) (*s_parametres).objet;
   62: 
   63:     if (l_element_courant == NULL)
   64:     {
   65:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
   66:         return(NULL);
   67:     }
   68: 
   69:     if ((*(*l_element_courant).donnee).type != CHN)
   70:     {
   71:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
   72:         return(NULL);
   73:     }
   74: 
   75:     if ((type_base = conversion_majuscule((unsigned char *)
   76:             (*(*l_element_courant).donnee).objet)) == NULL)
   77:     {
   78:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   79:         return(NULL);
   80:     }
   81: 
   82:     locale = index(type_base, ':');
   83: 
   84:     if (locale != NULL)
   85:     {
   86:         (*locale) = d_code_fin_chaine;
   87:         locale++;
   88:     }
   89: 
   90:     /*
   91:      * Vérifications des types de base de données
   92:      */
   93: 
   94:     if ((strcmp(type_base, "MYSQL") != 0) &&
   95:             (strcmp(type_base, "POSTGRESQL") != 0))
   96:     {
   97:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
   98:         return(NULL);
   99:     }
  100: 
  101:     if ((s_connecteur = allocation(s_etat_processus, SQL)) == NULL)
  102:     {
  103:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  104:         return(NULL);
  105:     }
  106: 
  107:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).type = type_base;
  108: 
  109:     if (locale != NULL)
  110:     {
  111:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale
  112:                 = malloc((strlen(locale) + 1) * sizeof(unsigned char))) == NULL)
  113:         {
  114:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  115:             return(NULL);
  116:         }
  117: 
  118:         strcpy((*((struct_connecteur_sql *) (*s_connecteur).objet)).locale,
  119:                 locale);
  120: 
  121:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet)).type
  122:                 = realloc((*((struct_connecteur_sql *) (*s_connecteur).objet))
  123:                 .type, (strlen((*((struct_connecteur_sql *) (*s_connecteur)
  124:                 .objet)).type) + 1) * sizeof(unsigned char))) == NULL)
  125:         {
  126:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  127:             return(NULL);
  128:         }
  129:     }
  130:     else
  131:     {
  132:         (*((struct_connecteur_sql *) (*s_connecteur).objet)).locale = NULL;
  133:     }
  134: 
  135:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).pid = getpid();
  136:     (*((struct_connecteur_sql *) (*s_connecteur).objet)).tid = pthread_self();
  137: 
  138:     // Recherche du nom ou de l'adresse du serveur
  139: 
  140:     l_element_courant = (*l_element_courant).suivant;
  141: 
  142:     if (l_element_courant == NULL)
  143:     {
  144:         liberation(s_etat_processus, s_connecteur);
  145:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  146:         return(NULL);
  147:     }
  148: 
  149:     if ((*(*l_element_courant).donnee).type != CHN)
  150:     {
  151:         liberation(s_etat_processus, s_connecteur);
  152:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  153:         return(NULL);
  154:     }
  155: 
  156:     serveur = (unsigned char *) (*(*l_element_courant).donnee).objet;
  157: 
  158:     // Recherche du nom de la base de données
  159: 
  160:     l_element_courant = (*l_element_courant).suivant;
  161: 
  162:     if (l_element_courant == NULL)
  163:     {
  164:         liberation(s_etat_processus, s_connecteur);
  165:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  166:         return(NULL);
  167:     }
  168: 
  169:     if ((*(*l_element_courant).donnee).type != CHN)
  170:     {
  171:         liberation(s_etat_processus, s_connecteur);
  172:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  173:         return(NULL);
  174:     }
  175: 
  176:     base = (unsigned char *) (*(*l_element_courant).donnee).objet;
  177: 
  178:     // Recherche de l'utilisateur
  179: 
  180:     l_element_courant = (*l_element_courant).suivant;
  181: 
  182:     if (l_element_courant == NULL)
  183:     {
  184:         liberation(s_etat_processus, s_connecteur);
  185:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  186:         return(NULL);
  187:     }
  188: 
  189:     if ((*(*l_element_courant).donnee).type != CHN)
  190:     {
  191:         liberation(s_etat_processus, s_connecteur);
  192:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  193:         return(NULL);
  194:     }
  195: 
  196:     utilisateur = (unsigned char *) (*(*l_element_courant).donnee).objet;
  197: 
  198:     // Recherche du mot de passe
  199: 
  200:     l_element_courant = (*l_element_courant).suivant;
  201: 
  202:     if (l_element_courant == NULL)
  203:     {
  204:         liberation(s_etat_processus, s_connecteur);
  205:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  206:         return(NULL);
  207:     }
  208: 
  209:     if ((*(*l_element_courant).donnee).type != CHN)
  210:     {
  211:         liberation(s_etat_processus, s_connecteur);
  212:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  213:         return(NULL);
  214:     }
  215: 
  216:     mot_de_passe = (unsigned char *) (*(*l_element_courant).donnee).objet;
  217: 
  218:     // Recherche du port le cas échéant
  219: 
  220:     l_element_courant = (*l_element_courant).suivant;
  221: 
  222:     if (l_element_courant != NULL)
  223:     {
  224:         if ((*(*l_element_courant).donnee).type != INT)
  225:         {
  226:             liberation(s_etat_processus, s_connecteur);
  227:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  228:             return(NULL);
  229:         }
  230: 
  231:         if (((*((integer8 *) (*(*l_element_courant).donnee).objet)) < 0)
  232:                 || ((*((integer8 *) (*(*l_element_courant).donnee)
  233:                 .objet)) > 65535))
  234:         {
  235:             liberation(s_etat_processus, s_connecteur);
  236:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  237:             return(NULL);
  238:         }
  239: 
  240:         port = (unsigned int) (*((integer8 *)
  241:                 (*(*l_element_courant).donnee).objet));
  242: 
  243:         if ((*l_element_courant).suivant != NULL)
  244:         {
  245:             liberation(s_etat_processus, s_connecteur);
  246:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  247:             return(NULL);
  248:         }
  249:     }
  250:     else
  251:     {
  252:         port = 0;
  253:     }
  254: 
  255:     if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
  256:                 "MYSQL") == 0)
  257:     {
  258: #       ifdef MYSQL_SUPPORT
  259:         (*((struct_connecteur_sql *) (*s_connecteur).objet))
  260:                 .descripteur.mysql = NULL;
  261: 
  262:         if (((*((struct_connecteur_sql *) (*s_connecteur).objet))
  263:                 .descripteur.mysql = mysql_init(NULL)) == NULL)
  264:         {
  265:             liberation(s_etat_processus, s_connecteur);
  266:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  267:             return(NULL);
  268:         }
  269: 
  270:         if (mysql_real_connect((*((struct_connecteur_sql *) (*s_connecteur)
  271:                 .objet)).descripteur.mysql, serveur, utilisateur, mot_de_passe,
  272:                 base, port, NULL, 0) == NULL)
  273:         {
  274:             mysql_close((*((struct_connecteur_sql *) (*s_connecteur).objet))
  275:                     .descripteur.mysql);
  276: 
  277:             liberation(s_etat_processus, s_connecteur);
  278:             (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
  279:             return(NULL);
  280:         }
  281: #       else
  282:         if ((*s_etat_processus).langue == 'F')
  283:         {
  284:             printf("+++Attention : Support de MySQL non compilé !\n");
  285:         }
  286:         else
  287:         {
  288:             printf("+++Warning : MySQL support not available !\n");
  289:         }
  290: 
  291:         fflush(stdout);
  292: #       endif
  293:     }
  294:     else if (strcmp((*((struct_connecteur_sql *) (*s_connecteur).objet)).type,
  295:                 "POSTGRESQL") == 0)
  296:     {
  297: #       ifdef POSTGRESQL_SUPPORT
  298:         if (port == 0)
  299:         {
  300:             sport = NULL;
  301:         }
  302:         else
  303:         {
  304:             if ((sport = malloc(32 * sizeof(unsigned char))) == NULL)
  305:             {
  306:                 liberation(s_etat_processus, s_connecteur);
  307:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  308:                 return(NULL);
  309:             }
  310: 
  311:             sprintf(sport, "%u", port);
  312:         }
  313: 
  314:         (*((struct_connecteur_sql *) (*s_connecteur).objet)).descripteur
  315:                 .postgresql = PQsetdbLogin(serveur, sport, NULL, NULL,
  316:                 base, utilisateur, mot_de_passe);
  317: 
  318:         free(sport);
  319: 
  320:         if (PQstatus((*((struct_connecteur_sql *) (*s_connecteur).objet))
  321:                 .descripteur.postgresql) != CONNECTION_OK)
  322:         {
  323:             PQfinish((*((struct_connecteur_sql *) (*s_connecteur).objet))
  324:                     .descripteur.postgresql);
  325: 
  326:             liberation(s_etat_processus, s_connecteur);
  327:             (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
  328:             return(NULL);
  329:         }
  330: #       else
  331:         if ((*s_etat_processus).langue == 'F')
  332:         {
  333:             printf("+++Attention : Support de PostgreSQL non compilé !\n");
  334:         }
  335:         else
  336:         {
  337:             printf("+++Warning : PostgreSQL support not available !\n");
  338:         }
  339: 
  340:         fflush(stdout);
  341: #       endif
  342:     }
  343:     else
  344:     {
  345:         liberation(s_etat_processus, s_connecteur);
  346:         (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  347:         return(NULL);
  348:     }
  349: 
  350:     return(s_connecteur);
  351: }
  352: 
  353: // vim: ts=4