Annotation of rpl/src/gestion_fichiers.c, revision 1.6
1.1 bertrand 1: /*
2: ================================================================================
1.5 bertrand 3: RPL/2 (R) version 4.0.12
1.1 bertrand 4: Copyright (C) 1989-2010 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: Routines de gestion des fichiers
29: ================================================================================
30: Entrées : nom du fichier
31: --------------------------------------------------------------------------------
32: Sorties : 0, le fichier n'existe pas, -1, il existe.
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: /*
39: * Génère un nom de fichier
40: */
41:
42: unsigned char *
43: creation_nom_fichier(struct_processus *s_etat_processus,
44: unsigned char *chemin)
45: {
46: /*
47: * Le nom du fichier est créé à l'aide du pid du processus et
48: * d'un numéro d'ordre pour ce processus.
49: */
50:
51: logical1 erreur;
52:
53: logical1 existence;
54: logical1 ouverture;
55:
56: pthread_mutex_t exclusion = PTHREAD_MUTEX_INITIALIZER;
57:
58: unsigned char *nom;
59: unsigned char tampon[256 + 1];
60:
61: unsigned long ordre_initial;
62: unsigned long unite;
63:
64: static unsigned long ordre = 0;
65:
66: if (pthread_mutex_lock(&exclusion) != 0)
67: {
68: return(NULL);
69: }
70:
71: ordre_initial = ordre;
72:
73: if (pthread_mutex_unlock(&exclusion) != 0)
74: {
75: return(NULL);
76: }
77:
78: do
79: {
80: sprintf(tampon, "RPL2-%lu-%lu-%lu", (unsigned long) getpid(),
81: (unsigned long) pthread_self(), ordre);
82:
83: if (chemin == NULL)
84: {
85: if ((nom = malloc((strlen(tampon) + 1) *
86: sizeof(unsigned char))) == NULL)
87: {
88: return(NULL);
89: }
90:
91: strcpy(nom, tampon);
92: }
93: else
94: {
95: if ((nom = malloc((strlen(chemin) + strlen(tampon) + 2) *
96: sizeof(unsigned char))) == NULL)
97: {
98: return(NULL);
99: }
100:
101: sprintf(nom, "%s/%s", chemin, tampon);
102: }
103:
104: if (pthread_mutex_lock(&exclusion) != 0)
105: {
106: return(NULL);
107: }
108:
109: ordre++;
110:
111: if (pthread_mutex_unlock(&exclusion) != 0)
112: {
113: return(NULL);
114: }
115:
116: if (ordre == ordre_initial)
117: {
118: // Il n'existe plus aucun nom de fichier disponible...
119:
120: free(nom);
121: return(NULL);
122: }
123:
124: erreur = caracteristiques_fichier(s_etat_processus,
125: nom, &existence, &ouverture, &unite);
126:
127: if (erreur != 0)
128: {
129: free(nom);
130: return(NULL);
131: }
132:
133: if (existence == d_vrai)
134: {
135: free(nom);
136: }
137: } while(existence == d_vrai);
138:
139: return(nom);
140: }
141:
142: /*
143: * Efface un fichier
144: */
145:
146: logical1
147: destruction_fichier(unsigned char *nom_fichier)
148: {
149: return((unlink(nom_fichier) == 0) ? d_absence_erreur : d_erreur);
150: }
151:
152: /*
153: * Renvoie le descripteur en fonction de la structure de contrôle du fichier
154: */
155:
1.6 ! bertrand 156: struct_descripteur_fichier *
1.1 bertrand 157: descripteur_fichier(struct_processus *s_etat_processus,
158: struct_fichier *s_fichier)
159: {
160: logical1 concordance_descripteurs;
161:
162: struct_liste_chainee *l_element_courant;
163:
164: l_element_courant = (*s_etat_processus).s_fichiers;
165: concordance_descripteurs = d_faux;
166:
167: while(l_element_courant != NULL)
168: {
169: if ((*((struct_descripteur_fichier *) (*l_element_courant).donnee))
170: .identifiant == (*s_fichier).descripteur)
171: {
172: if (((*((struct_descripteur_fichier *) (*l_element_courant).donnee))
173: .pid == (*s_fichier).pid) && (pthread_equal(
174: (*((struct_descripteur_fichier *) (*l_element_courant)
175: .donnee)).tid, pthread_self()) != 0))
176: {
1.6 ! bertrand 177: return((struct_descripteur_fichier *)
! 178: (*l_element_courant).donnee);
1.1 bertrand 179: }
180: else
181: {
182: concordance_descripteurs = d_vrai;
183: }
184: }
185:
186: l_element_courant = (*l_element_courant).suivant;
187: }
188:
189: if (concordance_descripteurs == d_vrai)
190: {
191: (*s_etat_processus).erreur_execution = d_ex_fichier_hors_contexte;
192: }
193: else
194: {
195: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
196: }
197:
198: return(NULL);
199: }
200:
201: /*
202: * Recherche un chemin pour les fichiers temporaires
203: */
204:
205: unsigned char *
206: recherche_chemin_fichiers_temporaires(struct_processus *s_etat_processus)
207: {
208: file *fichier;
209:
210: unsigned char *candidat;
211: unsigned char *chemin;
212: unsigned char *chemins[] = { "$RPL_TMP_PATH",
213: "/tmp", "/var/tmp", NULL };
214: unsigned char *nom_candidat;
215:
216: unsigned long int i;
217:
218: i = 0;
219: chemin = NULL;
220:
221: while(chemin == NULL)
222: {
223: if (chemins[i][0] == '$')
224: {
225: candidat = getenv("RPL_TMP_PATH");
226:
227: if (candidat != NULL)
228: {
229: if ((nom_candidat = creation_nom_fichier(s_etat_processus,
230: candidat)) == NULL)
231: {
232: return NULL;
233: }
234:
235: if ((fichier = fopen(nom_candidat, "w+")) != NULL)
236: {
237: fclose(fichier);
238: unlink(nom_candidat);
239: free(nom_candidat);
240:
241: if ((chemin = malloc((strlen(candidat) + 1)
242: * sizeof(unsigned char))) != NULL)
243: {
244: strcpy(chemin, candidat);
245: }
246: else
247: {
248: return NULL;
249: }
250: }
251: else
252: {
253: free(nom_candidat);
254: }
255: }
256: }
257: else
258: {
259: if ((nom_candidat = creation_nom_fichier(s_etat_processus,
260: chemins[i])) == NULL)
261: {
262: return NULL;
263: }
264:
265: if ((fichier = fopen(nom_candidat, "w+")) != NULL)
266: {
267: fclose(fichier);
268: unlink(nom_candidat);
269: free(nom_candidat);
270:
271: if ((chemin = malloc((strlen(chemins[i]) + 1)
272: * sizeof(unsigned char))) != NULL)
273: {
274: strcpy(chemin, chemins[i]);
275: }
276: else
277: {
278: return NULL;
279: }
280: }
281: else
282: {
283: free(nom_candidat);
284: }
285: }
286:
287: i++;
288: }
289:
290: return chemin;
291: }
292:
293:
294: /*
1.6 ! bertrand 295: * Fonction d'interrogation du fichier
! 296: */
1.1 bertrand 297:
298: logical1
299: caracteristiques_fichier(struct_processus *s_etat_processus,
300: unsigned char *nom, logical1 *existence, logical1 *ouverture,
301: unsigned long *unite)
302: {
303: int descripteur;
304:
305: logical1 erreur;
306:
307: struct_liste_chainee *l_element_courant;
308:
309: (*unite) = 0;
310: (*ouverture) = d_faux;
311: (*existence) = d_faux;
312:
1.4 bertrand 313: if ((descripteur = open(nom, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)) == -1)
1.1 bertrand 314: {
315: if (errno == EEXIST)
316: {
317: // Le fichier préexiste.
318:
319: erreur = d_absence_erreur;
320: (*existence) = d_vrai;
321:
322: // On chercher à savoir si le fichier est ouvert. S'il est ouvert,
323: // on renvoie son unité de rattachement.
324:
325: l_element_courant = (*s_etat_processus).s_fichiers;
326:
327: while(l_element_courant != NULL)
328: {
329: if (strcmp((*((struct_descripteur_fichier *)
330: (*l_element_courant).donnee)).nom, nom) == 0)
331: {
332: if (((*((struct_descripteur_fichier *) (*l_element_courant)
333: .donnee)).pid == getpid()) &&
334: (pthread_equal((*((struct_descripteur_fichier *)
335: (*l_element_courant).donnee)).tid, pthread_self())
336: != 0))
337: {
338: (*ouverture) = d_vrai;
1.6 ! bertrand 339:
1.1 bertrand 340: (*unite) = (unsigned long)
341: fileno((*((struct_descripteur_fichier *)
1.6 ! bertrand 342: (*l_element_courant).donnee))
! 343: .descripteur_c);
1.1 bertrand 344: break;
345: }
346: }
347:
348: l_element_courant = (*l_element_courant).suivant;
349: }
350: }
351: else
352: {
353: erreur = d_erreur;
354: }
355: }
356: else
357: {
358: close(descripteur);
359: unlink(nom);
360: erreur = d_absence_erreur;
361: }
362:
363: return(erreur);
364: }
365:
1.6 ! bertrand 366:
! 367: /*
! 368: ================================================================================
! 369: Routines d'initialisation des fichiers à accès direct et indexé
! 370: ================================================================================
! 371: Entrées : pointeur sur le fichier SQLITE
! 372: --------------------------------------------------------------------------------
! 373: Sorties : drapeau d'erreur
! 374: --------------------------------------------------------------------------------
! 375: Effets de bord : néant
! 376: ================================================================================
! 377: */
! 378:
! 379: /*
! 380: * Un fichier à accès direct se compose d'une seule table :
! 381: * 1: identifiant (entier sur 64 bits) -> enregistrement
! 382: *
! 383: * Un fichier à accès indexé comporte trois tables :
! 384: * 1 : contrôle
! 385: * 2 : clef (unique) -> identifiant (entier sur 64 bits)
! 386: * 3 : identifiant -> collection d'enregistrements
! 387: *
! 388: * La table de contrôle contient
! 389: * 1/ la position de la clef pour les fichiers à accès indexés
! 390: */
! 391:
! 392: static logical1
! 393: initialisation_controle(struct_processus *s_etat_processus, sqlite3 *sqlite,
! 394: logical1 fichier_indexe)
! 395: {
! 396: const char commande1[] =
! 397: "create table control(id integer primary key asc, lock text)";
! 398: const char commande2[] =
! 399: "insert into control (id, lock) values (2, '0')";
! 400: const char *queue;
! 401:
! 402: sqlite3_stmt *ppStmt;
! 403:
! 404: if (sqlite3_prepare_v2(sqlite, commande1, strlen(commande1), &ppStmt,
! 405: &queue) != SQLITE_OK)
! 406: {
! 407: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 408: return(d_erreur);
! 409: }
! 410:
! 411: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 412: {
! 413: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 414: return(d_erreur);
! 415: }
! 416:
! 417: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 418: {
! 419: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 420: return(d_erreur);
! 421: }
! 422:
! 423: if (fichier_indexe == d_vrai)
! 424: {
! 425: if (sqlite3_prepare_v2(sqlite, commande2, strlen(commande2), &ppStmt,
! 426: &queue) != SQLITE_OK)
! 427: {
! 428: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 429: return(d_erreur);
! 430: }
! 431:
! 432: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 433: {
! 434: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 435: return(d_erreur);
! 436: }
! 437:
! 438: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 439: {
! 440: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 441: return(d_erreur);
! 442: }
! 443: }
! 444:
! 445: return(d_absence_erreur);
! 446: }
! 447:
! 448: logical1
! 449: initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
! 450: sqlite3 *sqlite, logical1 binaire)
! 451: {
! 452: const char commande1[] =
! 453: "create table data(id integer primary key asc, key_id integer, "
! 454: "lock text)";
! 455: const char commande10[] =
! 456: "create table key(id integer primary key asc, key text)";
! 457: const char commande2[] =
! 458: "create table data(id integer primary key asc, key_id integer, "
! 459: "lock blob)";
! 460: const char commande20[] =
! 461: "create table key(id integer primary key asc, key blob)";
! 462: const char commande3[] =
! 463: "create index data_idx on data(key_id)";
! 464: const char commande4[] =
! 465: "create index key_idx on key(key)";
! 466: const char *queue;
! 467:
! 468: sqlite3_stmt *ppStmt;
! 469:
! 470: if (initialisation_controle(s_etat_processus, sqlite, d_vrai)
! 471: != d_absence_erreur)
! 472: {
! 473: return(d_erreur);
! 474: }
! 475:
! 476: if (binaire == d_faux)
! 477: {
! 478: if (sqlite3_prepare_v2(sqlite, commande1, strlen(commande1), &ppStmt,
! 479: &queue) != SQLITE_OK)
! 480: {
! 481: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 482: return(d_erreur);
! 483: }
! 484:
! 485: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 486: {
! 487: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 488: return(d_erreur);
! 489: }
! 490:
! 491: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 492: {
! 493: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 494: return(d_erreur);
! 495: }
! 496:
! 497: if (sqlite3_prepare_v2(sqlite, commande10, strlen(commande10), &ppStmt,
! 498: &queue) != SQLITE_OK)
! 499: {
! 500: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 501: return(d_erreur);
! 502: }
! 503:
! 504: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 505: {
! 506: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 507: return(d_erreur);
! 508: }
! 509:
! 510: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 511: {
! 512: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 513: return(d_erreur);
! 514: }
! 515: }
! 516: else
! 517: {
! 518: if (sqlite3_prepare_v2(sqlite, commande2, strlen(commande2), &ppStmt,
! 519: &queue) != SQLITE_OK)
! 520: {
! 521: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 522: return(d_erreur);
! 523: }
! 524:
! 525: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 526: {
! 527: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 528: return(d_erreur);
! 529: }
! 530:
! 531: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 532: {
! 533: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 534: return(d_erreur);
! 535: }
! 536:
! 537: if (sqlite3_prepare_v2(sqlite, commande20, strlen(commande20), &ppStmt,
! 538: &queue) != SQLITE_OK)
! 539: {
! 540: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 541: return(d_erreur);
! 542: }
! 543:
! 544: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 545: {
! 546: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 547: return(d_erreur);
! 548: }
! 549:
! 550: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 551: {
! 552: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 553: return(d_erreur);
! 554: }
! 555: }
! 556:
! 557: if (sqlite3_prepare_v2(sqlite, commande3, strlen(commande3), &ppStmt,
! 558: &queue) != SQLITE_OK)
! 559: {
! 560: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 561: return(d_erreur);
! 562: }
! 563:
! 564: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 565: {
! 566: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 567: return(d_erreur);
! 568: }
! 569:
! 570: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 571: {
! 572: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 573: return(d_erreur);
! 574: }
! 575:
! 576: if (sqlite3_prepare_v2(sqlite, commande4, strlen(commande4), &ppStmt,
! 577: &queue) != SQLITE_OK)
! 578: {
! 579: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 580: return(d_erreur);
! 581: }
! 582:
! 583: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 584: {
! 585: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 586: return(d_erreur);
! 587: }
! 588:
! 589: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 590: {
! 591: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 592: return(d_erreur);
! 593: }
! 594:
! 595: return(d_absence_erreur);
! 596: }
! 597:
! 598: logical1
! 599: initialisation_fichier_acces_direct(struct_processus *s_etat_processus,
! 600: sqlite3 *sqlite, logical1 binaire)
! 601: {
! 602: const char commande1[] =
! 603: "create table data(id integer primary key asc, lock text)";
! 604: const char commande2[] =
! 605: "create table data(id integer primary key asc, lock blob)";
! 606: const char commande3[] =
! 607: "create index data_idx on data(id)";
! 608: const char *queue;
! 609:
! 610: sqlite3_stmt *ppStmt;
! 611:
! 612: if (initialisation_controle(s_etat_processus, sqlite, d_faux)
! 613: != d_absence_erreur)
! 614: {
! 615: return(d_erreur);
! 616: }
! 617:
! 618: if (binaire == d_faux)
! 619: {
! 620: if (sqlite3_prepare_v2(sqlite, commande1, strlen(commande1), &ppStmt,
! 621: &queue) != SQLITE_OK)
! 622: {
! 623: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 624: return(d_erreur);
! 625: }
! 626:
! 627: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 628: {
! 629: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 630: return(d_erreur);
! 631: }
! 632:
! 633: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 634: {
! 635: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 636: return(d_erreur);
! 637: }
! 638: }
! 639: else
! 640: {
! 641: if (sqlite3_prepare_v2(sqlite, commande2, strlen(commande2), &ppStmt,
! 642: &queue) != SQLITE_OK)
! 643: {
! 644: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 645: return(d_erreur);
! 646: }
! 647:
! 648: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 649: {
! 650: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 651: return(d_erreur);
! 652: }
! 653:
! 654: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 655: {
! 656: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 657: return(d_erreur);
! 658: }
! 659: }
! 660:
! 661: if (sqlite3_prepare_v2(sqlite, commande3, strlen(commande3), &ppStmt,
! 662: &queue) != SQLITE_OK)
! 663: {
! 664: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 665: return(d_erreur);
! 666: }
! 667:
! 668: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 669: {
! 670: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 671: return(d_erreur);
! 672: }
! 673:
! 674: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 675: {
! 676: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 677: return(d_erreur);
! 678: }
! 679:
! 680: return(d_absence_erreur);
! 681: }
! 682:
! 683: unsigned char *
! 684: verrouillage_fichier_sqlite(struct_processus *s_etat_processus,
! 685: sqlite3 *sqlite, unsigned char *operation)
! 686: {
! 687: const char commande1[] =
! 688: "select lock from control where id = 1";
! 689: const char commande2[] =
! 690: "update control set lock = '%s'";
! 691: const char *queue;
! 692:
! 693: const unsigned char *resultat;
! 694:
! 695: sqlite3_stmt *ppStmt;
! 696:
! 697: unsigned char *verrou;
! 698:
! 699: resultat = NULL;
! 700:
! 701: if (operation == NULL)
! 702: {
! 703: // Lecture du verrou
! 704:
! 705: if (sqlite3_prepare_v2(sqlite, commande1, strlen(commande1), &ppStmt,
! 706: &queue) != SQLITE_OK)
! 707: {
! 708: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 709: return(NULL);
! 710: }
! 711:
! 712: if (sqlite3_step(ppStmt) != SQLITE_ROW)
! 713: {
! 714: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 715: return(NULL);
! 716: }
! 717:
! 718: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
! 719: {
! 720: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 721: return(NULL);
! 722: }
! 723:
! 724: resultat = sqlite3_column_text(ppStmt, 0);
! 725:
! 726: if ((verrou = malloc((strlen(resultat) + 1) * sizeof(unsigned char)))
! 727: == NULL)
! 728: {
! 729: return(NULL);
! 730: }
! 731:
! 732: strcpy(verrou, resultat);
! 733:
! 734: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 735: {
! 736: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 737: return(NULL);
! 738: }
! 739: }
! 740: else
! 741: {
! 742: // Positionnement d'un verrou
! 743:
! 744: if (alsprintf(&verrou, commande2, operation) < 0)
! 745: {
! 746: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 747: return(NULL);
! 748: }
! 749:
! 750: if (sqlite3_prepare_v2(sqlite, verrou, strlen(verrou), &ppStmt,
! 751: &queue) != SQLITE_OK)
! 752: {
! 753: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 754: return(NULL);
! 755: }
! 756:
! 757: if (sqlite3_step(ppStmt) != SQLITE_DONE)
! 758: {
! 759: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 760: return(NULL);
! 761: }
! 762:
! 763: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
! 764: {
! 765: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 766: return(NULL);
! 767: }
! 768:
! 769: free(verrou);
! 770: verrou = NULL;
! 771: }
! 772:
! 773: return(verrou);
! 774: }
! 775:
1.1 bertrand 776: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_fichiers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src