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