1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.3
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 'splash'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_splash(struct_processus *s_etat_processus)
40: {
41: real8 attente;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n SPLASH ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(écran RPL/2)\n\n");
54: }
55: else
56: {
57: printf("(RPL/2 splash screen)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_INT, d_REL);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if (((*s_objet).type == INT) ||
86: ((*s_objet).type == REL))
87: {
88: if ((*s_objet).type == INT)
89: {
90: attente = (real8) (*((integer8 *) (*s_objet).objet));
91: }
92: else
93: {
94: attente = (*((real8 *) (*s_objet).objet));
95: }
96:
97: if (attente < 0)
98: {
99: liberation(s_etat_processus, s_objet);
100:
101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
102: return;
103: }
104:
105: encart(s_etat_processus, (unsigned long) (attente * 1E6));
106: }
107: else
108: {
109: liberation(s_etat_processus, s_objet);
110:
111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
112: return;
113: }
114:
115: liberation(s_etat_processus, s_objet);
116:
117: return;
118: }
119:
120:
121: /*
122: ================================================================================
123: Fonction 'send'
124: ================================================================================
125: Entrées :
126: --------------------------------------------------------------------------------
127: Sorties :
128: --------------------------------------------------------------------------------
129: Effets de bord : néant
130: ================================================================================
131: */
132:
133: void
134: instruction_send(struct_processus *s_etat_processus)
135: {
136: pid_t pid;
137:
138: pthread_t tid;
139:
140: sig_atomic_t registre;
141:
142: ssize_t longueur_ecriture;
143:
144: struct_objet *s_objet;
145:
146: struct timespec attente;
147:
148: unsigned char tampon;
149:
150: (*s_etat_processus).erreur_execution = d_ex;
151:
152: if ((*s_etat_processus).affichage_arguments == 'Y')
153: {
154: printf("\n SEND ");
155:
156: if ((*s_etat_processus).langue == 'F')
157: {
158: printf("(envoi de données au processus père)\n\n");
159: }
160: else
161: {
162: printf("(send data to parent process)\n\n");
163: }
164:
165: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
166: " %s, %s, %s, %s, %s,\n"
167: " %s, %s, %s, %s, %s\n",
168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
170:
171: return;
172: }
173: else if ((*s_etat_processus).test_instruction == 'Y')
174: {
175: (*s_etat_processus).nombre_arguments = -1;
176: return;
177: }
178:
179: if (test_cfsf(s_etat_processus, 31) == d_vrai)
180: {
181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
182: {
183: return;
184: }
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet) == d_erreur)
189: {
190: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
191: return;
192: }
193:
194: if ((*s_etat_processus).presence_pipes == d_faux)
195: {
196: liberation(s_etat_processus, s_objet);
197:
198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
199: return;
200: }
201:
202: if (((*s_objet).type != INT) &&
203: ((*s_objet).type != REL) &&
204: ((*s_objet).type != CPL) &&
205: ((*s_objet).type != VIN) &&
206: ((*s_objet).type != VRL) &&
207: ((*s_objet).type != VCX) &&
208: ((*s_objet).type != MIN) &&
209: ((*s_objet).type != MRL) &&
210: ((*s_objet).type != MCX) &&
211: ((*s_objet).type != BIN) &&
212: ((*s_objet).type != NOM) &&
213: ((*s_objet).type != CHN) &&
214: ((*s_objet).type != LST) &&
215: ((*s_objet).type != ALG) &&
216: ((*s_objet).type != RPN) &&
217: ((*s_objet).type != TBL))
218: {
219: liberation(s_etat_processus, s_objet);
220:
221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
222: return;
223: }
224:
225: /*
226: * On signale au processus père qu'il y a un objet de plus
227: * dans le pipe de données.
228: */
229:
230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
232:
233: if ((*s_etat_processus).processus_detache == d_vrai)
234: {
235: if ((*s_etat_processus).profilage == d_vrai)
236: {
237: profilage(s_etat_processus, "Interprocess communications (SEND)");
238:
239: if ((*s_etat_processus).erreur_systeme != d_es)
240: {
241: return;
242: }
243: }
244:
245: pid = -3;
246:
247: attente.tv_sec = 0;
248: attente.tv_nsec = GRANULARITE_us * 1000;
249:
250: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
251: {
252: (*s_etat_processus).erreur_systeme = d_es_processus;
253: return;
254: }
255:
256: while((longueur_ecriture = write_atomic(s_etat_processus,
257: (*s_etat_processus).pipe_nombre_objets_attente,
258: &pid, sizeof(pid))) != sizeof(pid))
259: {
260: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
261: {
262: if (errno != EINTR)
263: {
264: (*s_etat_processus).erreur_systeme = d_es_processus;
265: return;
266: }
267: }
268:
269: if (longueur_ecriture == -1)
270: {
271: if ((*s_etat_processus).profilage == d_vrai)
272: {
273: profilage(s_etat_processus, NULL);
274: }
275:
276: (*s_etat_processus).erreur_systeme = d_es_processus;
277: return;
278: }
279:
280: nanosleep(&attente, NULL);
281: INCR_GRANULARITE(attente.tv_nsec);
282:
283: if (sem_post(&((*s_etat_processus).semaphore_fork))
284: != 0)
285: {
286: (*s_etat_processus).erreur_systeme = d_es_processus;
287: return;
288: }
289:
290: scrutation_interruptions(s_etat_processus);
291: }
292:
293: pid = getpid();
294:
295: attente.tv_sec = 0;
296: attente.tv_nsec = GRANULARITE_us * 1000;
297:
298: while((longueur_ecriture = write_atomic(s_etat_processus,
299: (*s_etat_processus).pipe_nombre_objets_attente,
300: &pid, sizeof(pid))) != sizeof(pid))
301: {
302: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
303: {
304: if (errno != EINTR)
305: {
306: (*s_etat_processus).erreur_systeme = d_es_processus;
307: return;
308: }
309: }
310:
311: if (longueur_ecriture == -1)
312: {
313: if ((*s_etat_processus).profilage == d_vrai)
314: {
315: profilage(s_etat_processus, NULL);
316: }
317:
318: (*s_etat_processus).erreur_systeme = d_es_processus;
319: return;
320: }
321:
322: nanosleep(&attente, NULL);
323: INCR_GRANULARITE(attente.tv_nsec);
324:
325: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_processus;
328: return;
329: }
330:
331: scrutation_interruptions(s_etat_processus);
332: }
333:
334: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
335: {
336: if (errno != EINTR)
337: {
338: (*s_etat_processus).erreur_systeme = d_es_processus;
339: return;
340: }
341: }
342: }
343: else
344: {
345: if ((*s_etat_processus).profilage == d_vrai)
346: {
347: profilage(s_etat_processus, "Interthread communications (SEND)");
348:
349: if ((*s_etat_processus).erreur_systeme != d_es)
350: {
351: return;
352: }
353: }
354:
355: tid = -3;
356:
357: attente.tv_sec = 0;
358: attente.tv_nsec = GRANULARITE_us * 1000;
359:
360: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
361: {
362: (*s_etat_processus).erreur_systeme = d_es_processus;
363: return;
364: }
365:
366: while((longueur_ecriture = write_atomic(s_etat_processus,
367: (*s_etat_processus).pipe_nombre_objets_attente,
368: &tid, sizeof(tid))) != sizeof(tid))
369: {
370: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
371: {
372: (*s_etat_processus).erreur_systeme = d_es_processus;
373: return;
374: }
375:
376: if (longueur_ecriture == -1)
377: {
378: if ((*s_etat_processus).profilage == d_vrai)
379: {
380: profilage(s_etat_processus, NULL);
381: }
382:
383: (*s_etat_processus).erreur_systeme = d_es_processus;
384: return;
385: }
386:
387: nanosleep(&attente, NULL);
388: INCR_GRANULARITE(attente.tv_nsec);
389:
390: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
391: {
392: (*s_etat_processus).erreur_systeme = d_es_processus;
393: return;
394: }
395:
396: scrutation_interruptions(s_etat_processus);
397: }
398:
399: tid = pthread_self();
400:
401: attente.tv_sec = 0;
402: attente.tv_nsec = GRANULARITE_us * 1000;
403:
404: while((longueur_ecriture = write_atomic(s_etat_processus,
405: (*s_etat_processus).pipe_nombre_objets_attente,
406: &tid, sizeof(tid))) != sizeof(tid))
407: {
408: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
409: {
410: if (errno != EINTR)
411: {
412: (*s_etat_processus).erreur_systeme = d_es_processus;
413: return;
414: }
415: }
416:
417: if (longueur_ecriture == -1)
418: {
419: if ((*s_etat_processus).profilage == d_vrai)
420: {
421: profilage(s_etat_processus, NULL);
422: }
423:
424: (*s_etat_processus).erreur_systeme = d_es_processus;
425: return;
426: }
427:
428: nanosleep(&attente, NULL);
429: INCR_GRANULARITE(attente.tv_nsec);
430:
431: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
432: {
433: (*s_etat_processus).erreur_systeme = d_es_processus;
434: return;
435: }
436:
437: scrutation_interruptions(s_etat_processus);
438: }
439:
440: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
441: {
442: (*s_etat_processus).erreur_systeme = d_es_processus;
443: return;
444: }
445: }
446:
447: (*s_etat_processus).nombre_objets_envoyes_non_lus++;
448:
449: attente.tv_sec = 0;
450: attente.tv_nsec = GRANULARITE_us * 1000;
451:
452: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
453: {
454: (*s_etat_processus).erreur_systeme = d_es_processus;
455: return;
456: }
457:
458: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
459: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
460: {
461: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
462: {
463: if (errno != EINTR)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_processus;
466: return;
467: }
468: }
469:
470: nanosleep(&attente, NULL);
471: INCR_GRANULARITE(attente.tv_nsec);
472:
473: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
474: {
475: (*s_etat_processus).erreur_systeme = d_es_processus;
476: return;
477: }
478:
479: scrutation_interruptions(s_etat_processus);
480: }
481:
482: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
483: {
484: if (errno != EINTR)
485: {
486: (*s_etat_processus).erreur_systeme = d_es_processus;
487: return;
488: }
489: }
490:
491: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
492: // de surveillance.
493:
494: if ((*s_etat_processus).processus_detache == d_vrai)
495: {
496: pid = -1;
497:
498: attente.tv_sec = 0;
499: attente.tv_nsec = GRANULARITE_us * 1000;
500:
501: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
502: {
503: (*s_etat_processus).erreur_systeme = d_es_processus;
504: return;
505: }
506:
507: while((longueur_ecriture = write_atomic(s_etat_processus,
508: (*s_etat_processus).pipe_nombre_interruptions_attente,
509: &pid, sizeof(pid))) != sizeof(pid))
510: {
511: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
512: {
513: (*s_etat_processus).erreur_systeme = d_es_processus;
514: return;
515: }
516:
517: if (longueur_ecriture == -1)
518: {
519: if ((*s_etat_processus).profilage == d_vrai)
520: {
521: profilage(s_etat_processus, NULL);
522: }
523:
524: (*s_etat_processus).erreur_systeme = d_es_processus;
525: return;
526: }
527:
528: nanosleep(&attente, NULL);
529: INCR_GRANULARITE(attente.tv_nsec);
530:
531: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
532: {
533: (*s_etat_processus).erreur_systeme = d_es_processus;
534: return;
535: }
536: }
537:
538: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
539: {
540: if (errno != EINTR)
541: {
542: (*s_etat_processus).erreur_systeme = d_es_processus;
543: return;
544: }
545: }
546:
547: scrutation_interruptions(s_etat_processus);
548: }
549: else
550: {
551: tid = -1;
552:
553: attente.tv_sec = 0;
554: attente.tv_nsec = GRANULARITE_us * 1000;
555:
556: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
557: {
558: (*s_etat_processus).erreur_systeme = d_es_processus;
559: return;
560: }
561:
562: while((longueur_ecriture = write_atomic(s_etat_processus,
563: (*s_etat_processus).pipe_nombre_interruptions_attente,
564: &tid, sizeof(tid))) != sizeof(tid))
565: {
566: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
567: {
568: if (errno != EINTR)
569: {
570: (*s_etat_processus).erreur_systeme = d_es_processus;
571: return;
572: }
573: }
574:
575: if (longueur_ecriture == -1)
576: {
577: if ((*s_etat_processus).profilage == d_vrai)
578: {
579: profilage(s_etat_processus, NULL);
580: }
581:
582: (*s_etat_processus).erreur_systeme = d_es_processus;
583: return;
584: }
585:
586: nanosleep(&attente, NULL);
587: INCR_GRANULARITE(attente.tv_nsec);
588:
589: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
590: {
591: (*s_etat_processus).erreur_systeme = d_es_processus;
592: return;
593: }
594:
595: scrutation_interruptions(s_etat_processus);
596: }
597:
598: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
599: {
600: if (errno != EINTR)
601: {
602: (*s_etat_processus).erreur_systeme = d_es_processus;
603: return;
604: }
605: }
606: }
607:
608: // ecriture_pipe() ne peut être interrompu par un signal.
609:
610: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
611: {
612: (*s_etat_processus).erreur_systeme = d_es_processus;
613: return;
614: }
615:
616: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
617: s_objet) == d_erreur)
618: {
619: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
620: {
621: if (errno != EINTR)
622: {
623: (*s_etat_processus).erreur_systeme = d_es_processus;
624: return;
625: }
626: }
627:
628: if ((*s_etat_processus).profilage == d_vrai)
629: {
630: profilage(s_etat_processus, NULL);
631: }
632:
633: liberation(s_etat_processus, s_objet);
634: return;
635: }
636:
637: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
638: {
639: if (errno != EINTR)
640: {
641: (*s_etat_processus).erreur_systeme = d_es_processus;
642: return;
643: }
644: }
645:
646: if ((*s_etat_processus).profilage == d_vrai)
647: {
648: profilage(s_etat_processus, NULL);
649: }
650:
651: if (registre == 0)
652: {
653: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
654: {
655: (*s_etat_processus).var_volatile_requete_arret = -1;
656: }
657:
658: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
659: }
660:
661: liberation(s_etat_processus, s_objet);
662: return;
663: }
664:
665:
666: /*
667: ================================================================================
668: Fonction 'sqlquery'
669: ================================================================================
670: Entrées :
671: --------------------------------------------------------------------------------
672: Sorties :
673: --------------------------------------------------------------------------------
674: Effets de bord : néant
675: ================================================================================
676: */
677:
678: void
679: instruction_sqlquery(struct_processus *s_etat_processus)
680: {
681: # define d_LONGUEUR 1024
682:
683: logical1 connexion_permanente;
684: logical1 presence_resultat;
685:
686: struct_objet *s_copie_1;
687: struct_objet *s_objet_1;
688: struct_objet *s_copie_2;
689: struct_objet *s_objet_2;
690: struct_objet *s_objet_resultat;
691:
692: struct_liste_chainee *l_element_courant;
693: struct_liste_chainee *l_element_courant_ligne;
694:
695: unsigned char *tampon;
696:
697: unsigned int i;
698: unsigned int j;
699: unsigned int nombre_colonnes;
700: unsigned int nombre_lignes;
701:
702: (*s_etat_processus).erreur_execution = d_ex;
703:
704: if ((*s_etat_processus).affichage_arguments == 'Y')
705: {
706: printf("\n SQLQUERY ");
707:
708: if ((*s_etat_processus).langue == 'F')
709: {
710: printf("(requête SQL)\n\n");
711: }
712: else
713: {
714: printf("(SQL query)\n\n");
715: }
716:
717: printf(" 2: %s\n", d_CHN);
718: printf(" 1: %s\n", d_LST);
719: printf("-> 1: %s\n\n", d_LST);
720:
721: printf(" 2: %s\n", d_CHN);
722: printf(" 1: %s\n", d_SQL);
723: printf("-> 1: %s\n\n", d_LST);
724:
725: if ((*s_etat_processus).langue == 'F')
726: {
727: printf(" Utilisation :\n\n");
728: }
729: else
730: {
731: printf(" Usage:\n\n");
732: }
733:
734: printf(" \"select * from table\"\n");
735: printf(" { \"mysql\" \"server\" \"database\" "
736: "\"user\" \"password\" } SQLQUERY\n");
737: printf(" \"select field from table\"\n");
738: printf(" { \"postgresql:iso-8859-1\" \"server\" "
739: "\"database\" \"user\" \"password\" port }\n");
740: printf(" SQLQUERY\n");
741:
742: return;
743: }
744: else if ((*s_etat_processus).test_instruction == 'Y')
745: {
746: (*s_etat_processus).nombre_arguments = -1;
747: return;
748: }
749:
750: if (test_cfsf(s_etat_processus, 31) == d_vrai)
751: {
752: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
753: {
754: return;
755: }
756: }
757:
758: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
759: &s_objet_1) == d_erreur)
760: {
761: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
762: return;
763: }
764:
765: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
766: &s_objet_2) == d_erreur)
767: {
768: liberation(s_etat_processus, s_objet_1);
769:
770: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
771: return;
772: }
773:
774: if ((*s_objet_1).type == LST)
775: {
776: connexion_permanente = d_faux;
777:
778: s_copie_1 = s_objet_1;
779:
780: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
781: {
782: liberation(s_etat_processus, s_copie_1);
783: liberation(s_etat_processus, s_objet_2);
784: return;
785: }
786:
787: liberation(s_etat_processus, s_copie_1);
788: }
789: else
790: {
791: if ((*s_objet_1).type == SQL)
792: {
793: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
794: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
795: (*s_objet_1).objet)).tid, pthread_self()) == 0))
796: {
797: (*s_etat_processus).erreur_execution =
798: d_ex_fichier_hors_contexte;
799:
800: liberation(s_etat_processus, s_objet_1);
801: liberation(s_etat_processus, s_objet_2);
802: return;
803: }
804: }
805:
806: connexion_permanente = d_vrai;
807: }
808:
809: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
810: {
811: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
812: {
813: /*
814: * Transcodage de la commande SQL
815: */
816:
817: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
818: == NULL)
819: {
820: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
821: return;
822: }
823:
824: liberation(s_etat_processus, s_objet_2);
825: s_objet_2 = s_copie_2;
826:
827: tampon = (*s_objet_2).objet;
828:
829: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
830: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
831: d_locale)) == NULL)
832: {
833: return;
834: }
835:
836: free(tampon);
837: }
838:
839: /*
840: * Pilote MySQL
841: */
842:
843: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
844: "MYSQL") == 0)
845: {
846: # ifdef MYSQL_SUPPORT
847:
848: MYSQL_RES *resultat_mysql;
849: MYSQL_ROW ligne;
850:
851: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
852: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
853: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
854: {
855: if (connexion_permanente == d_faux)
856: {
857: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
858: .objet)).descripteur.mysql);
859: }
860:
861: liberation(s_etat_processus, s_objet_1);
862: liberation(s_etat_processus, s_objet_2);
863:
864: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
865: return;
866: }
867:
868: if ((resultat_mysql = mysql_store_result(
869: (*((struct_connecteur_sql *) (*s_objet_1).objet))
870: .descripteur.mysql)) == NULL)
871: {
872: // La requête ne renvoie rien (exemple : INSERT)
873: presence_resultat = d_faux;
874: nombre_colonnes = 0;
875: }
876: else
877: {
878: // La requête renvoie une ou plusieurs valeurs.
879: presence_resultat = d_vrai;
880: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
881: (*s_objet_1).objet)).descripteur.mysql);
882: }
883:
884: if ((s_objet_resultat = allocation(s_etat_processus, LST))
885: == NULL)
886: {
887: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
888: return;
889: }
890:
891: (*s_objet_resultat).objet = NULL;
892: l_element_courant = (*s_objet_resultat).objet;
893:
894: while(((presence_resultat == d_vrai) ?
895: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
896: {
897: unsigned long *longueurs;
898:
899: longueurs = mysql_fetch_lengths(resultat_mysql);
900:
901: if (l_element_courant == NULL)
902: {
903: if (((*s_objet_resultat).objet =
904: allocation_maillon(s_etat_processus)) == NULL)
905: {
906: (*s_etat_processus).erreur_systeme =
907: d_es_allocation_memoire;
908: return;
909: }
910:
911: l_element_courant = (struct_liste_chainee *)
912: (*s_objet_resultat).objet;
913: }
914: else
915: {
916: if (((*l_element_courant).suivant =
917: allocation_maillon(s_etat_processus)) == NULL)
918: {
919: (*s_etat_processus).erreur_systeme =
920: d_es_allocation_memoire;
921: return;
922: }
923:
924: l_element_courant = (*l_element_courant).suivant;
925: }
926:
927: (*l_element_courant).suivant = NULL;
928:
929: if (((*l_element_courant).donnee = allocation(s_etat_processus,
930: LST)) == NULL)
931: {
932: (*s_etat_processus).erreur_systeme =
933: d_es_allocation_memoire;
934: return;
935: }
936:
937: (*(*l_element_courant).donnee).objet = NULL;
938: l_element_courant_ligne = NULL;
939:
940: for(i = 0; i < nombre_colonnes; i++)
941: {
942: if (l_element_courant_ligne == NULL)
943: {
944: if (((*(*l_element_courant).donnee).objet =
945: allocation_maillon(s_etat_processus)) == NULL)
946: {
947: (*s_etat_processus).erreur_systeme =
948: d_es_allocation_memoire;
949: return;
950: }
951:
952: l_element_courant_ligne = (struct_liste_chainee *)
953: (*(*l_element_courant).donnee).objet;
954: }
955: else
956: {
957: if (((*l_element_courant_ligne).suivant =
958: allocation_maillon(s_etat_processus)) == NULL)
959: {
960: (*s_etat_processus).erreur_systeme =
961: d_es_allocation_memoire;
962: return;
963: }
964:
965: l_element_courant_ligne =
966: (*l_element_courant_ligne).suivant;
967: }
968:
969: (*l_element_courant_ligne).suivant = NULL;
970:
971: if (((*l_element_courant_ligne).donnee =
972: allocation(s_etat_processus, CHN)) == NULL)
973: {
974: (*s_etat_processus).erreur_systeme =
975: d_es_allocation_memoire;
976: return;
977: }
978:
979: if (ligne[i] == NULL)
980: {
981: if (((*(*l_element_courant_ligne).donnee).objet =
982: malloc(5 * sizeof(unsigned char))) == NULL)
983: {
984: (*s_etat_processus).erreur_systeme =
985: d_es_allocation_memoire;
986: return;
987: }
988:
989: strcpy((unsigned char *) (*(*l_element_courant_ligne)
990: .donnee).objet, "NULL");
991: }
992: else
993: {
994: if (((*(*l_element_courant_ligne).donnee).objet =
995: malloc((longueurs[i] + 1) *
996: sizeof(unsigned char))) == NULL)
997: {
998: (*s_etat_processus).erreur_systeme =
999: d_es_allocation_memoire;
1000: return;
1001: }
1002:
1003: strcpy((unsigned char *) (*(*l_element_courant_ligne)
1004: .donnee).objet, ligne[i]);
1005: }
1006: }
1007: }
1008:
1009: mysql_free_result(resultat_mysql);
1010:
1011: if (connexion_permanente == d_faux)
1012: {
1013: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1014: .descripteur.mysql);
1015: }
1016:
1017: if (presence_resultat == d_vrai)
1018: {
1019: if (empilement(s_etat_processus,
1020: &((*s_etat_processus).l_base_pile),
1021: s_objet_resultat) == d_erreur)
1022: {
1023: return;
1024: }
1025: }
1026:
1027: # else
1028:
1029: if ((*s_etat_processus).langue == 'F')
1030: {
1031: printf("+++Attention : Support de MySQL non compilé !\n");
1032: }
1033: else
1034: {
1035: printf("+++Warning : MySQL support not available !\n");
1036: }
1037:
1038: fflush(stdout);
1039: # endif
1040: }
1041:
1042: /*
1043: * Pilote PostgreSQL
1044: */
1045:
1046: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1047: "POSTGRESQL") == 0)
1048: {
1049: # ifdef POSTGRESQL_SUPPORT
1050:
1051: PGresult *resultat_postgresql;
1052:
1053: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
1054: .descripteur.postgresql) != CONNECTION_OK)
1055: {
1056: if (connexion_permanente == d_faux)
1057: {
1058: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1059: .descripteur.postgresql);
1060: }
1061:
1062: liberation(s_etat_processus, s_objet_1);
1063: liberation(s_etat_processus, s_objet_2);
1064:
1065: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1066: return;
1067: }
1068:
1069: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
1070: (*s_objet_1).objet)).descripteur.postgresql,
1071: (unsigned char *) (*s_objet_2).objet);
1072: presence_resultat = d_faux;
1073:
1074: switch(PQresultStatus(resultat_postgresql))
1075: {
1076: case PGRES_COMMAND_OK :
1077: { // Commande qui ne renvoit rien
1078: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1079: == NULL)
1080: {
1081: (*s_etat_processus).erreur_systeme =
1082: d_es_allocation_memoire;
1083: return;
1084: }
1085:
1086: (*s_objet_resultat).objet = NULL;
1087: l_element_courant = (*s_objet_resultat).objet;
1088: presence_resultat = d_vrai;
1089:
1090: break;
1091: }
1092:
1093: case PGRES_TUPLES_OK :
1094: { // Commande renvoyant des données
1095: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1096: == NULL)
1097: {
1098: (*s_etat_processus).erreur_systeme =
1099: d_es_allocation_memoire;
1100: return;
1101: }
1102:
1103: (*s_objet_resultat).objet = NULL;
1104: l_element_courant = (*s_objet_resultat).objet;
1105: presence_resultat = d_vrai;
1106:
1107: nombre_colonnes = PQnfields(resultat_postgresql);
1108: nombre_lignes = PQntuples(resultat_postgresql);
1109:
1110: for(i = 0; i < nombre_lignes; i++)
1111: {
1112: // Chaînage d'un nouveau maillon de la liste résultat
1113:
1114: if (l_element_courant == NULL)
1115: {
1116: if (((*s_objet_resultat).objet =
1117: allocation_maillon(s_etat_processus))
1118: == NULL)
1119: {
1120: (*s_etat_processus).erreur_systeme =
1121: d_es_allocation_memoire;
1122: return;
1123: }
1124:
1125: l_element_courant = (struct_liste_chainee *)
1126: (*s_objet_resultat).objet;
1127: }
1128: else
1129: {
1130: if (((*l_element_courant).suivant =
1131: allocation_maillon(s_etat_processus))
1132: == NULL)
1133: {
1134: (*s_etat_processus).erreur_systeme =
1135: d_es_allocation_memoire;
1136: return;
1137: }
1138:
1139: l_element_courant = (*l_element_courant).suivant;
1140: }
1141:
1142: (*l_element_courant).suivant = NULL;
1143:
1144: // Création de la liste fille
1145:
1146: if (((*l_element_courant).donnee =
1147: allocation(s_etat_processus, LST)) == NULL)
1148: {
1149: (*s_etat_processus).erreur_systeme =
1150: d_es_allocation_memoire;
1151: return;
1152: }
1153:
1154: (*(*l_element_courant).donnee).objet = NULL;
1155: l_element_courant_ligne = NULL;
1156:
1157: for(j = 0; j < nombre_colonnes; j++)
1158: {
1159: if (l_element_courant_ligne == NULL)
1160: {
1161: if (((*(*l_element_courant).donnee).objet =
1162: allocation_maillon(s_etat_processus))
1163: == NULL)
1164: {
1165: (*s_etat_processus).erreur_systeme =
1166: d_es_allocation_memoire;
1167: return;
1168: }
1169:
1170: l_element_courant_ligne =
1171: (struct_liste_chainee *)
1172: (*(*l_element_courant).donnee).objet;
1173: }
1174: else
1175: {
1176: if (((*l_element_courant_ligne).suivant =
1177: allocation_maillon(s_etat_processus))
1178: == NULL)
1179: {
1180: l_element_courant_ligne =
1181: (*l_element_courant_ligne).suivant;
1182: }
1183:
1184: l_element_courant_ligne =
1185: (*l_element_courant_ligne).suivant;
1186: }
1187:
1188: (*l_element_courant_ligne).suivant = NULL;
1189:
1190: if (((*l_element_courant_ligne).donnee =
1191: allocation(s_etat_processus, CHN))
1192: == NULL)
1193: {
1194: (*s_etat_processus).erreur_systeme =
1195: d_es_allocation_memoire;
1196: return;
1197: }
1198:
1199: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1200: {
1201: if (((*(*l_element_courant_ligne).donnee).objet
1202: = malloc(5 * sizeof(unsigned char)))
1203: == NULL)
1204: {
1205: (*s_etat_processus).erreur_systeme =
1206: d_es_allocation_memoire;
1207: return;
1208: }
1209:
1210: strcpy((unsigned char *)
1211: (*(*l_element_courant_ligne).donnee)
1212: .objet, "NULL");
1213: }
1214: else
1215: {
1216: if (((*(*l_element_courant_ligne).donnee).objet
1217: = malloc((PQgetlength(
1218: resultat_postgresql, i, j) + 1) *
1219: sizeof(unsigned char))) == NULL)
1220: {
1221: (*s_etat_processus).erreur_systeme =
1222: d_es_allocation_memoire;
1223: return;
1224: }
1225:
1226: strcpy((unsigned char *)
1227: (*(*l_element_courant_ligne).donnee)
1228: .objet, PQgetvalue(resultat_postgresql,
1229: i, j));
1230: }
1231: }
1232: }
1233:
1234: break;
1235: }
1236:
1237: case PGRES_EMPTY_QUERY :
1238: case PGRES_COPY_OUT :
1239: case PGRES_COPY_IN :
1240: case PGRES_BAD_RESPONSE :
1241: case PGRES_NONFATAL_ERROR :
1242: case PGRES_FATAL_ERROR :
1243: default :
1244: {
1245: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1246: PQclear(resultat_postgresql);
1247:
1248: if (connexion_permanente == d_faux)
1249: {
1250: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1251: .objet)).descripteur.postgresql);
1252: }
1253:
1254: liberation(s_etat_processus, s_objet_1);
1255: liberation(s_etat_processus, s_objet_2);
1256:
1257: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1258:
1259: return;
1260: break;
1261: }
1262: }
1263:
1264: PQclear(resultat_postgresql);
1265:
1266: if (connexion_permanente == d_faux)
1267: {
1268: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1269: .descripteur.postgresql);
1270: }
1271:
1272: if (presence_resultat == d_vrai)
1273: {
1274: if (empilement(s_etat_processus, &((*s_etat_processus)
1275: .l_base_pile), s_objet_resultat) == d_erreur)
1276: {
1277: return;
1278: }
1279: }
1280:
1281: # else
1282:
1283: if ((*s_etat_processus).langue == 'F')
1284: {
1285: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1286: }
1287: else
1288: {
1289: printf("+++Warning : PostgreSQL support not available !\n");
1290: }
1291:
1292: fflush(stdout);
1293: # endif
1294: }
1295: else
1296: {
1297: liberation(s_etat_processus, s_objet_1);
1298: liberation(s_etat_processus, s_objet_2);
1299:
1300: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1301: return;
1302: }
1303: }
1304: else
1305: {
1306: liberation(s_etat_processus, s_objet_1);
1307: liberation(s_etat_processus, s_objet_2);
1308:
1309: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1310: return;
1311: }
1312:
1313: liberation(s_etat_processus, s_objet_1);
1314: liberation(s_etat_processus, s_objet_2);
1315:
1316: return;
1317: }
1318:
1319:
1320: /*
1321: ================================================================================
1322: Fonction 'stop'
1323: ================================================================================
1324: Entrées :
1325: --------------------------------------------------------------------------------
1326: Sorties :
1327: --------------------------------------------------------------------------------
1328: Effets de bord : néant
1329: ================================================================================
1330: */
1331:
1332: void
1333: instruction_stop(struct_processus *s_etat_processus)
1334: {
1335: struct_liste_chainee *l_element_courant;
1336:
1337: struct_objet *s_objet;
1338:
1339: (*s_etat_processus).erreur_execution = d_ex;
1340:
1341: if ((*s_etat_processus).affichage_arguments == 'Y')
1342: {
1343: printf("\n STOP ");
1344:
1345: if ((*s_etat_processus).langue == 'F')
1346: {
1347: printf("(arrêt d'un processus)\n\n");
1348: }
1349: else
1350: {
1351: printf("(kill process)\n\n");
1352: }
1353:
1354: printf(" 1: %s\n", d_PRC);
1355:
1356: return;
1357: }
1358: else if ((*s_etat_processus).test_instruction == 'Y')
1359: {
1360: (*s_etat_processus).nombre_arguments = -1;
1361: return;
1362: }
1363:
1364: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1365: {
1366: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1367: {
1368: return;
1369: }
1370: }
1371:
1372: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1373: &s_objet) == d_erreur)
1374: {
1375: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1376: return;
1377: }
1378:
1379: if ((*s_objet).type == PRC)
1380: {
1381: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1382: .processus_detache == d_vrai)
1383: {
1384: envoi_signal_processus((*(*((struct_processus_fils *)
1385: (*s_objet).objet)).thread).pid, rpl_sigstop);
1386: }
1387: else
1388: {
1389: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1390: {
1391: (*s_etat_processus).erreur_systeme = d_es_processus;
1392: return;
1393: }
1394:
1395: l_element_courant = (struct_liste_chainee *)
1396: (*s_etat_processus).l_base_pile_processus;
1397:
1398: while(l_element_courant != NULL)
1399: {
1400: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1401: .donnee).objet)).thread).processus_detache == d_faux)
1402: {
1403: if ((pthread_equal((*(*((struct_processus_fils *)
1404: (*(*l_element_courant).donnee).objet)).thread).tid,
1405: (*(*((struct_processus_fils *)
1406: (*s_objet).objet)).thread).tid) != 0) &&
1407: ((*(*((struct_processus_fils *)
1408: (*(*l_element_courant).donnee).objet)).thread).pid
1409: == (*(*((struct_processus_fils *)
1410: (*s_objet).objet)).thread).pid))
1411: {
1412: break;
1413: }
1414: }
1415:
1416: l_element_courant = (*l_element_courant).suivant;
1417: }
1418:
1419: if (l_element_courant != NULL)
1420: {
1421: // Le champ thread_actif est un pointeur sur un champ de la
1422: // structure s_argument_thread libéré par la fonction
1423: // retrait_thread_surveillance().
1424:
1425: if ((*(*((struct_processus_fils *)
1426: (*s_objet).objet)).thread).thread_actif == d_vrai)
1427: {
1428: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1429: (*s_objet).objet)).thread).mutex)) != 0)
1430: {
1431: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1432: != 0)
1433: {
1434: (*s_etat_processus).erreur_systeme = d_es_processus;
1435: return;
1436: }
1437:
1438: (*s_etat_processus).erreur_systeme = d_es_processus;
1439: return;
1440: }
1441:
1442: if ((*(*((struct_processus_fils *)
1443: (*s_objet).objet)).thread).thread_actif == d_vrai)
1444: {
1445: envoi_signal_thread((*(*((struct_processus_fils *)
1446: (*s_objet).objet)).thread).tid, rpl_sigstop);
1447: }
1448:
1449: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1450: (*s_objet).objet)).thread).mutex)) != 0)
1451: {
1452: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1453: != 0)
1454: {
1455: (*s_etat_processus).erreur_systeme = d_es_processus;
1456: return;
1457: }
1458:
1459: (*s_etat_processus).erreur_systeme = d_es_processus;
1460: return;
1461: }
1462: }
1463: }
1464:
1465: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1466: {
1467: (*s_etat_processus).erreur_systeme = d_es_processus;
1468: return;
1469: }
1470: }
1471: }
1472: else
1473: {
1474: liberation(s_etat_processus, s_objet);
1475:
1476: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1477: return;
1478: }
1479:
1480: liberation(s_etat_processus, s_objet);
1481:
1482: return;
1483: }
1484:
1485: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src