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 'while'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_while(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).erreur_execution = d_ex;
42:
43: if ((*s_etat_processus).affichage_arguments == 'Y')
44: {
45: printf("\n WHILE ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(structure de contrôle)\n\n");
50: printf(" Utilisation :\n\n");
51: }
52: else
53: {
54: printf("(control statement)\n\n");
55: printf(" Usage:\n\n");
56: }
57:
58: printf(" WHILE\n");
59: printf(" (clause)\n");
60: printf(" REPEAT\n");
61: printf(" (expression 1)\n");
62: printf(" EXIT\n");
63: printf(" (expression 2)\n");
64: printf(" END\n\n");
65:
66: printf(" WHILE\n");
67: printf(" (clause)\n");
68: printf(" REPEAT\n");
69: printf(" (expression)\n");
70: printf(" END\n");
71:
72: return;
73: }
74: else if ((*s_etat_processus).test_instruction == 'Y')
75: {
76: (*s_etat_processus).nombre_arguments = -1;
77: return;
78: }
79:
80: empilement_pile_systeme(s_etat_processus);
81:
82: if ((*s_etat_processus).erreur_systeme != d_es)
83: {
84: return;
85: }
86:
87: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'W';
88: (*(*s_etat_processus).l_base_pile_systeme).clause = 'W';
89:
90: if ((*s_etat_processus).mode_execution_programme == 'Y')
91: {
92: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
93: (*s_etat_processus).position_courante;
94: }
95: else
96: {
97: if ((*s_etat_processus).expression_courante == NULL)
98: {
99: (*s_etat_processus).erreur_execution =
100: d_ex_erreur_traitement_boucle;
101: return;
102: }
103:
104: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
105: (*s_etat_processus).expression_courante;
106: }
107:
108: return;
109: }
110:
111:
112: /*
113: ================================================================================
114: Fonction 'warranty'
115: ================================================================================
116: Entrées :
117: --------------------------------------------------------------------------------
118: Sorties :
119: --------------------------------------------------------------------------------
120: Effets de bord : néant
121: ================================================================================
122: */
123:
124: void
125: instruction_warranty(struct_processus *s_etat_processus)
126: {
127: # include "garanties-conv.h"
128:
129: (*s_etat_processus).erreur_execution = d_ex;
130:
131: if ((*s_etat_processus).affichage_arguments == 'Y')
132: {
133: printf("\n WARRANTY ");
134:
135: if ((*s_etat_processus).langue == 'F')
136: {
137: printf("(garantie)\n\n");
138: printf(" Aucun argument\n");
139: }
140: else
141: {
142: printf("(warranty)\n\n");
143: printf(" No argument\n");
144: }
145:
146: return;
147: }
148: else if ((*s_etat_processus).test_instruction == 'Y')
149: {
150: (*s_etat_processus).nombre_arguments = -1;
151: return;
152: }
153:
154: printf("%s\n", warranty);
155:
156: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
157: {
158: printf("\n");
159: }
160:
161: return;
162: }
163:
164:
165: /*
166: ================================================================================
167: Fonction 'wait'
168: ================================================================================
169: Entrées :
170: --------------------------------------------------------------------------------
171: Sorties :
172: --------------------------------------------------------------------------------
173: Effets de bord : néant
174: ================================================================================
175: */
176:
177: void
178: instruction_wait(struct_processus *s_etat_processus)
179: {
180: int code_retour;
181: int erreur;
182:
183: real8 attente;
184:
185: struct_objet *s_objet;
186:
187: struct timespec temporisation;
188:
189: (*s_etat_processus).erreur_execution = d_ex;
190:
191: if ((*s_etat_processus).affichage_arguments == 'Y')
192: {
193: printf("\n WAIT ");
194:
195: if ((*s_etat_processus).langue == 'F')
196: {
197: printf("(attente exprimée en secondes)\n\n");
198: }
199: else
200: {
201: printf("(wait a number of seconds)\n\n");
202: }
203:
204: printf(" 1: %s, %s\n", d_INT, d_REL);
205:
206: return;
207: }
208: else if ((*s_etat_processus).test_instruction == 'Y')
209: {
210: (*s_etat_processus).nombre_arguments = -1;
211: return;
212: }
213:
214: if (test_cfsf(s_etat_processus, 31) == d_vrai)
215: {
216: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
217: {
218: return;
219: }
220: }
221:
222: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
223: &s_objet) == d_erreur)
224: {
225: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
226: return;
227: }
228:
229: if (((*s_objet).type == INT) || ((*s_objet).type == REL))
230: {
231: if ((*s_objet).type == INT)
232: {
233: attente = (real8) (*((integer8 *) (*s_objet).objet));
234: }
235: else
236: {
237: attente = (*((real8 *) (*s_objet).objet));
238: }
239:
240: if (attente < 0)
241: {
242: liberation(s_etat_processus, s_objet);
243:
244: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
245: return;
246: }
247:
248: temporisation.tv_sec = (long) floor((double) attente);
249: temporisation.tv_nsec = (attente - temporisation.tv_sec) *
250: (long) 1000000000;
251:
252: if ((*s_etat_processus).profilage == d_vrai)
253: {
254: profilage(s_etat_processus, "Sleep function (WAIT)");
255:
256: if ((*s_etat_processus).erreur_systeme != d_es)
257: {
258: return;
259: }
260: }
261:
262: do
263: {
264: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
265: {
266: (*s_etat_processus).erreur_systeme = d_es_processus;
267: return;
268: }
269:
270: code_retour = nanosleep(&temporisation, &temporisation);
271: erreur = errno;
272:
273: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
274: {
275: (*s_etat_processus).erreur_systeme = d_es_processus;
276: return;
277: }
278:
279: scrutation_injection(s_etat_processus);
280:
281: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
282: {
283: affectation_interruptions_logicielles(s_etat_processus);
284: }
285:
286: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
287: {
288: traitement_interruptions_logicielles(s_etat_processus);
289: }
290: } while(((code_retour == -1) && (erreur == EINTR))
291: && ((*s_etat_processus).var_volatile_requete_arret == 0));
292:
293: if ((*s_etat_processus).profilage == d_vrai)
294: {
295: profilage(s_etat_processus, NULL);
296: }
297: }
298: else
299: {
300: liberation(s_etat_processus, s_objet);
301:
302: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
303: return;
304: }
305:
306: liberation(s_etat_processus, s_objet);
307:
308: return;
309: }
310:
311:
312: /*
313: ================================================================================
314: Fonction 'wireframe' (passe en mode d'affichage échantillonné)
315: ================================================================================
316: Entrées : structure processus
317: --------------------------------------------------------------------------------
318: Sorties :
319: --------------------------------------------------------------------------------
320: Effets de bord : néant
321: ================================================================================
322: */
323:
324: void
325: instruction_wireframe(struct_processus *s_etat_processus)
326: {
327: (*s_etat_processus).erreur_execution = d_ex;
328:
329: if ((*s_etat_processus).affichage_arguments == 'Y')
330: {
331: printf("\n WIREFRAME ");
332:
333: if ((*s_etat_processus).langue == 'F')
334: {
335: printf("(graphique tridimensionnel grillagé)\n\n");
336: printf(" Aucun argument\n");
337: }
338: else
339: {
340: printf("(wireframe 3D graph)\n\n");
341: printf(" No argument\n");
342: }
343:
344: return;
345: }
346: else if ((*s_etat_processus).test_instruction == 'Y')
347: {
348: (*s_etat_processus).nombre_arguments = -1;
349: return;
350: }
351:
352: strcpy((*s_etat_processus).type_trace_eq, "GRILLE 3D");
353:
354: return;
355: }
356:
357:
358: /*
359: ================================================================================
360: Fonction 'write'
361: ================================================================================
362: Entrées : structure processus
363: --------------------------------------------------------------------------------
364: Sorties :
365: --------------------------------------------------------------------------------
366: Effets de bord : néant
367: ================================================================================
368: */
369:
370: void
371: instruction_write(struct_processus *s_etat_processus)
372: {
373: const char *queue;
374:
375: int adresse[16];
376: int port;
377:
378: integer8 clef;
379: integer8 compteur;
380: integer8 id;
381: integer8 ordre;
382:
383: logical1 mise_a_jour;
384:
385: long longueur_effective;
386: long recursivite;
387:
388: sqlite3_stmt *ppStmt;
389:
390: ssize_t ios;
391:
392: struct_descripteur_fichier *descripteur;
393:
394: struct_liste_chainee *l_element_courant;
395: struct_liste_chainee *l_element_courant_format;
396:
397: struct_objet *s_format;
398: struct_objet *s_element;
399: struct_objet *s_objet_argument_1;
400: struct_objet *s_objet_argument_2;
401: struct_objet *s_objet_argument_3;
402:
403: struct sigaction action;
404: struct sigaction registre;
405:
406: struct sockaddr_in adresse_ipv4;
407: # ifdef IPV6
408: struct sockaddr_in6 adresse_ipv6;
409: # endif
410: struct sockaddr_un adresse_unix;
411:
412: struct flock lock;
413:
414: uint32_t calcul_adresse;
415:
416: unsigned char *chaine;
417: unsigned char *chaine_utf8;
418: unsigned char *clef_utf8;
419: unsigned char *commande;
420:
421: unsigned long i;
422:
423: (*s_etat_processus).erreur_execution = d_ex;
424:
425: if ((*s_etat_processus).affichage_arguments == 'Y')
426: {
427: printf("\n WRITE ");
428:
429: if ((*s_etat_processus).langue == 'F')
430: {
431: printf("(écriture d'un enregistrement d'un fichier)\n\n");
432: }
433: else
434: {
435: printf("(write a record of a file)\n\n");
436: }
437:
438: printf(" 2: %s\n", d_LST);
439: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
440:
441: printf(" 3: %s\n", d_LST);
442: printf(" 2: %s\n", d_INT);
443: printf(" 1: %s\n", d_FCH);
444: return;
445: }
446: else if ((*s_etat_processus).test_instruction == 'Y')
447: {
448: (*s_etat_processus).nombre_arguments = -1;
449: return;
450: }
451:
452: if (test_cfsf(s_etat_processus, 31) == d_vrai)
453: {
454: if ((*s_etat_processus).l_base_pile == NULL)
455: {
456: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
457: return;
458: }
459:
460: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
461: {
462: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
463: .donnee).objet)).acces == 'D')
464: {
465: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
466: {
467: return;
468: }
469: }
470: else
471: {
472: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
473: {
474: return;
475: }
476: }
477: }
478: else
479: {
480: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
481: {
482: return;
483: }
484: }
485: }
486:
487: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
488: &s_objet_argument_1) == d_erreur)
489: {
490: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
491: return;
492: }
493:
494: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
495: &s_objet_argument_2) == d_erreur)
496: {
497: liberation(s_etat_processus, s_objet_argument_1);
498:
499: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
500: return;
501: }
502:
503: if ((*s_objet_argument_1).type == FCH)
504: {
505: if ((descripteur = descripteur_fichier(s_etat_processus,
506: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
507: {
508: return;
509: }
510:
511: /*
512: * Vérification des verrous
513: */
514:
515: lock.l_type = F_WRLCK;
516: lock.l_whence = SEEK_SET;
517: lock.l_start = 0;
518: lock.l_len = 0;
519: lock.l_pid = getpid();
520: recursivite = 0;
521:
522: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
523: == -1)
524: {
525: liberation(s_etat_processus, s_objet_argument_2);
526: liberation(s_etat_processus, s_objet_argument_1);
527:
528: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
529: return;
530: }
531:
532: if (lock.l_type != F_UNLCK)
533: {
534: liberation(s_etat_processus, s_objet_argument_2);
535: liberation(s_etat_processus, s_objet_argument_1);
536:
537: (*s_etat_processus).erreur_execution =
538: d_ex_fichier_verrouille;
539: return;
540: }
541:
542: /*
543: * Vérification de l'autorisation d'écriture
544: */
545:
546: if ((*((struct_fichier *) (*s_objet_argument_1).objet))
547: .protection == 'R')
548: {
549: liberation(s_etat_processus, s_objet_argument_2);
550: liberation(s_etat_processus, s_objet_argument_1);
551:
552: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
553: return;
554: }
555:
556: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
557: {
558: /*
559: * Fichiers formatés
560: */
561:
562: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
563: == 'S')
564: {
565: if ((*s_objet_argument_2).type != LST)
566: {
567: liberation(s_etat_processus, s_objet_argument_2);
568: liberation(s_etat_processus, s_objet_argument_1);
569:
570: (*s_etat_processus).erreur_execution =
571: d_ex_erreur_type_argument;
572: return;
573: }
574:
575: if ((chaine = formateur_fichier(s_etat_processus,
576: s_objet_argument_2, (*((struct_fichier *)
577: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
578: &longueur_effective, &recursivite)) == NULL)
579: {
580: liberation(s_etat_processus, s_objet_argument_2);
581: liberation(s_etat_processus, s_objet_argument_1);
582:
583: return;
584: }
585:
586: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
587:
588: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
589: != 0)
590: {
591: liberation(s_etat_processus, s_objet_argument_2);
592: liberation(s_etat_processus, s_objet_argument_1);
593:
594: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
595: return;
596: }
597:
598: if ((chaine_utf8 = transliteration(s_etat_processus,
599: chaine, d_locale, "UTF-8")) == NULL)
600: {
601: free(chaine);
602:
603: liberation(s_etat_processus, s_objet_argument_2);
604: liberation(s_etat_processus, s_objet_argument_1);
605:
606: return;
607: }
608:
609: free(chaine);
610:
611: if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8)
612: < 0)
613: {
614: free(chaine_utf8);
615:
616: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
617: return;
618: }
619:
620: free(chaine_utf8);
621: }
622: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
623: == 'D')
624: {
625: BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
626:
627: if ((*s_objet_argument_2).type != INT)
628: {
629: liberation(s_etat_processus, s_objet_argument_2);
630: liberation(s_etat_processus, s_objet_argument_1);
631:
632: (*s_etat_processus).erreur_execution =
633: d_ex_erreur_type_argument;
634: return;
635: }
636:
637: if (depilement(s_etat_processus, &((*s_etat_processus)
638: .l_base_pile), &s_objet_argument_3) == d_erreur)
639: {
640: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
641: return;
642: }
643:
644: if ((*s_objet_argument_3).type != LST)
645: {
646: liberation(s_etat_processus, s_objet_argument_3);
647: liberation(s_etat_processus, s_objet_argument_2);
648: liberation(s_etat_processus, s_objet_argument_1);
649:
650: (*s_etat_processus).erreur_execution =
651: d_ex_erreur_type_argument;
652: return;
653: }
654:
655: // Modification ou création d'un nouvel enregistrement
656:
657: if ((chaine = formateur_fichier(s_etat_processus,
658: s_objet_argument_3, (*((struct_fichier *)
659: (*s_objet_argument_1).objet)).format, 0, 0, ' ',
660: 'F', &longueur_effective, &recursivite)) == NULL)
661: {
662: liberation(s_etat_processus, s_objet_argument_3);
663: liberation(s_etat_processus, s_objet_argument_2);
664: liberation(s_etat_processus, s_objet_argument_1);
665:
666: return;
667: }
668:
669: if ((chaine_utf8 = transliteration(s_etat_processus,
670: chaine, d_locale, "UTF-8")) == NULL)
671: {
672: free(chaine);
673:
674: liberation(s_etat_processus, s_objet_argument_3);
675: liberation(s_etat_processus, s_objet_argument_2);
676: liberation(s_etat_processus, s_objet_argument_1);
677:
678: return;
679: }
680:
681: free(chaine);
682:
683: if (alsprintf(&commande, "insert or replace into data "
684: "(id, data) values (%lld, '%s')", (*((integer8 *)
685: (*s_objet_argument_2).objet)), chaine_utf8) < 0)
686: {
687: (*s_etat_processus).erreur_systeme =
688: d_es_allocation_memoire;
689: return;
690: }
691:
692: free(chaine_utf8);
693:
694: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
695: commande, strlen(commande), &ppStmt, &queue)
696: != SQLITE_OK)
697: {
698: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
699: return;
700: }
701:
702: if (sqlite3_step(ppStmt) != SQLITE_DONE)
703: {
704: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
705: return;
706: }
707:
708: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
709: {
710: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
711: return;
712: }
713:
714: liberation(s_etat_processus, s_objet_argument_3);
715: free(commande);
716: }
717: else // Fichiers indexés
718: {
719: BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
720:
721: if ((*s_objet_argument_2).type != LST)
722: {
723: liberation(s_etat_processus, s_objet_argument_2);
724: liberation(s_etat_processus, s_objet_argument_1);
725:
726: (*s_etat_processus).erreur_execution =
727: d_ex_erreur_type_argument;
728: return;
729: }
730:
731: // Récupération de la position de la clef
732:
733: if (alsprintf(&commande, "select key from control "
734: "where id = 1") < 0)
735: {
736: (*s_etat_processus).erreur_systeme =
737: d_es_allocation_memoire;
738: return;
739: }
740:
741: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
742: commande, strlen(commande), &ppStmt, &queue)
743: != SQLITE_OK)
744: {
745: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
746: return;
747: }
748:
749: if (sqlite3_step(ppStmt) != SQLITE_ROW)
750: {
751: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
752: return;
753: }
754:
755: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
756: {
757: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
758: return;
759: }
760:
761: clef = sqlite3_column_int64(ppStmt, 0);
762:
763: if (sqlite3_step(ppStmt) != SQLITE_DONE)
764: {
765: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
766: return;
767: }
768:
769: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
770: {
771: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
772: return;
773: }
774:
775: free(commande);
776:
777: l_element_courant = (struct_liste_chainee *)
778: (*s_objet_argument_2).objet;
779: l_element_courant_format = (struct_liste_chainee *)
780: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
781: .format).objet;
782: compteur = 1;
783:
784: while((l_element_courant != NULL) &&
785: (l_element_courant_format != NULL))
786: {
787: if (compteur == clef)
788: {
789: break;
790: }
791:
792: l_element_courant = (*l_element_courant).suivant;
793: l_element_courant_format = (*l_element_courant_format)
794: .suivant;
795: compteur++;
796: }
797:
798: if ((l_element_courant == NULL) ||
799: (l_element_courant_format == NULL))
800: {
801: (*s_etat_processus).erreur_execution =
802: d_ex_clef_inexistante;
803:
804: liberation(s_etat_processus, s_objet_argument_2);
805: liberation(s_etat_processus, s_objet_argument_1);
806:
807: return;
808: }
809:
810: if ((s_element = allocation(s_etat_processus, LST)) == NULL)
811: {
812: (*s_etat_processus).erreur_systeme =
813: d_es_allocation_memoire;
814: return;
815: }
816:
817: if (((*s_element).objet = allocation_maillon(s_etat_processus))
818: == NULL)
819: {
820: (*s_etat_processus).erreur_systeme =
821: d_es_allocation_memoire;
822: return;
823: }
824:
825: (*((struct_liste_chainee *) (*s_element).objet)).suivant = NULL;
826:
827: if (((*((struct_liste_chainee *) (*s_element).objet))
828: .donnee = copie_objet(s_etat_processus,
829: (*l_element_courant).donnee, 'N')) == NULL)
830: {
831: (*s_etat_processus).erreur_systeme =
832: d_es_allocation_memoire;
833: return;
834: }
835:
836: if ((s_format = allocation(s_etat_processus, LST)) == NULL)
837: {
838: (*s_etat_processus).erreur_systeme =
839: d_es_allocation_memoire;
840: return;
841: }
842:
843: if (((*s_format).objet = allocation_maillon(s_etat_processus))
844: == NULL)
845: {
846: (*s_etat_processus).erreur_systeme =
847: d_es_allocation_memoire;
848: return;
849: }
850:
851: (*((struct_liste_chainee *) (*s_format).objet)).suivant = NULL;
852:
853: if (((*((struct_liste_chainee *) (*s_format).objet))
854: .donnee = copie_objet(s_etat_processus,
855: (*l_element_courant_format).donnee, 'N')) == NULL)
856: {
857: (*s_etat_processus).erreur_systeme =
858: d_es_allocation_memoire;
859: return;
860: }
861:
862: if ((chaine = formateur_fichier(s_etat_processus,
863: s_element, s_format, 0, 0, ' ',
864: 'F', &longueur_effective, &recursivite)) == NULL)
865: {
866: liberation(s_etat_processus, s_element);
867: liberation(s_etat_processus, s_format);
868: liberation(s_etat_processus, s_objet_argument_2);
869: liberation(s_etat_processus, s_objet_argument_1);
870:
871: return;
872: }
873:
874: liberation(s_etat_processus, s_element);
875: liberation(s_etat_processus, s_format);
876:
877: if ((clef_utf8 = transliteration(s_etat_processus,
878: chaine, d_locale, "UTF-8")) == NULL)
879: {
880: liberation(s_etat_processus, s_objet_argument_2);
881: liberation(s_etat_processus, s_objet_argument_1);
882:
883: return;
884: }
885:
886: free(chaine);
887:
888: // Récupération de l'identifiant de la clef
889:
890: if (alsprintf(&commande, "select id from key where key = "
891: "'%s'", clef_utf8) < 0)
892: {
893: (*s_etat_processus).erreur_systeme =
894: d_es_allocation_memoire;
895: return;
896: }
897:
898: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
899: commande, strlen(commande), &ppStmt, &queue)
900: != SQLITE_OK)
901: {
902: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
903: return;
904: }
905:
906: switch(sqlite3_step(ppStmt))
907: {
908: case SQLITE_ROW:
909: {
910: // Une clef existe.
911:
912: mise_a_jour = d_vrai;
913: break;
914: }
915:
916: case SQLITE_DONE:
917: {
918: // Aucune clef n'existe.
919:
920: mise_a_jour = d_faux;
921:
922: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
923: {
924: (*s_etat_processus).erreur_systeme =
925: d_es_erreur_fichier;
926: return;
927: }
928:
929: free(commande);
930:
931: if (alsprintf(&commande, "insert into key "
932: "(key) values ('%s')", clef_utf8) < 0)
933: {
934: (*s_etat_processus).erreur_systeme =
935: d_es_allocation_memoire;
936: return;
937: }
938:
939: if (sqlite3_prepare_v2((*descripteur)
940: .descripteur_sqlite,
941: commande, strlen(commande), &ppStmt, &queue)
942: != SQLITE_OK)
943: {
944: (*s_etat_processus).erreur_systeme =
945: d_es_erreur_fichier;
946: return;
947: }
948:
949: if (sqlite3_step(ppStmt) != SQLITE_DONE)
950: {
951: (*s_etat_processus).erreur_systeme =
952: d_es_erreur_fichier;
953: return;
954: }
955:
956: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
957: {
958: (*s_etat_processus).erreur_systeme =
959: d_es_erreur_fichier;
960: return;
961: }
962:
963: free(commande);
964:
965: if (alsprintf(&commande, "select id from key "
966: "where key = '%s'", clef_utf8) < 0)
967: {
968: (*s_etat_processus).erreur_systeme =
969: d_es_allocation_memoire;
970: return;
971: }
972:
973: if (sqlite3_prepare_v2((*descripteur)
974: .descripteur_sqlite,
975: commande, strlen(commande), &ppStmt, &queue)
976: != SQLITE_OK)
977: {
978: (*s_etat_processus).erreur_systeme =
979: d_es_erreur_fichier;
980: return;
981: }
982:
983: if (sqlite3_step(ppStmt) != SQLITE_ROW)
984: {
985: (*s_etat_processus).erreur_systeme =
986: d_es_erreur_fichier;
987: return;
988: }
989:
990: break;
991: }
992:
993: default:
994: {
995: (*s_etat_processus).erreur_systeme =
996: d_es_erreur_fichier;
997: return;
998: }
999: }
1000:
1001: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1002: {
1003: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1004: return;
1005: }
1006:
1007: id = sqlite3_column_int64(ppStmt, 0);
1008:
1009: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1010: {
1011: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1012: return;
1013: }
1014:
1015: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1016: {
1017: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1018: return;
1019: }
1020:
1021: free(commande);
1022:
1023: // Modification de la clef
1024:
1025: if (mise_a_jour == d_vrai)
1026: {
1027: if (alsprintf(&commande, "update key set key = '%s' where "
1028: "id = %lld", clef_utf8, id) < 0)
1029: {
1030: (*s_etat_processus).erreur_systeme =
1031: d_es_allocation_memoire;
1032: return;
1033: }
1034:
1035: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1036: commande, strlen(commande), &ppStmt, &queue)
1037: != SQLITE_OK)
1038: {
1039: (*s_etat_processus).erreur_systeme =
1040: d_es_erreur_fichier;
1041: return;
1042: }
1043:
1044: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1045: {
1046: (*s_etat_processus).erreur_systeme =
1047: d_es_erreur_fichier;
1048: return;
1049: }
1050:
1051: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1052: {
1053: (*s_etat_processus).erreur_systeme =
1054: d_es_erreur_fichier;
1055: return;
1056: }
1057:
1058: free(commande);
1059: }
1060:
1061: // Effacement de l'enregistrement existant
1062:
1063: if (alsprintf(&commande, "delete from data where "
1064: "key_id = %lld", id) < 0)
1065: {
1066: (*s_etat_processus).erreur_systeme =
1067: d_es_allocation_memoire;
1068: return;
1069: }
1070:
1071: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1072: commande, strlen(commande), &ppStmt, &queue)
1073: != SQLITE_OK)
1074: {
1075: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1076: return;
1077: }
1078:
1079: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1080: {
1081: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1082: return;
1083: }
1084:
1085: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1086: {
1087: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1088: return;
1089: }
1090:
1091: free(commande);
1092:
1093: // Modification ou création d'un nouvel enregistrement
1094:
1095: l_element_courant = (struct_liste_chainee *)
1096: (*s_objet_argument_2).objet;
1097: l_element_courant_format = (struct_liste_chainee *)
1098: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
1099: .format).objet;
1100: compteur = 1;
1101: ordre = 1;
1102:
1103: while((l_element_courant != NULL) &&
1104: (l_element_courant_format != NULL))
1105: {
1106: if (compteur == clef)
1107: {
1108: l_element_courant = (*l_element_courant).suivant;
1109: l_element_courant_format = (*l_element_courant_format)
1110: .suivant;
1111: compteur++;
1112: continue;
1113: }
1114:
1115: if ((s_element = allocation(s_etat_processus, LST)) == NULL)
1116: {
1117: (*s_etat_processus).erreur_systeme =
1118: d_es_allocation_memoire;
1119: return;
1120: }
1121:
1122: if (((*s_element).objet =
1123: allocation_maillon(s_etat_processus)) == NULL)
1124: {
1125: (*s_etat_processus).erreur_systeme =
1126: d_es_allocation_memoire;
1127: return;
1128: }
1129:
1130: (*((struct_liste_chainee *) (*s_element).objet)).suivant
1131: = NULL;
1132:
1133: if ((s_format = allocation(s_etat_processus, LST)) == NULL)
1134: {
1135: (*s_etat_processus).erreur_systeme =
1136: d_es_allocation_memoire;
1137: return;
1138: }
1139:
1140: if (((*s_format).objet =
1141: allocation_maillon(s_etat_processus)) == NULL)
1142: {
1143: (*s_etat_processus).erreur_systeme =
1144: d_es_allocation_memoire;
1145: return;
1146: }
1147:
1148: (*((struct_liste_chainee *) (*s_format).objet)).suivant
1149: = NULL;
1150:
1151: if (((*((struct_liste_chainee *) (*s_element).objet))
1152: .donnee = copie_objet(s_etat_processus,
1153: (*l_element_courant).donnee, 'N')) == NULL)
1154: {
1155: (*s_etat_processus).erreur_systeme =
1156: d_es_allocation_memoire;
1157: return;
1158: }
1159:
1160: if (((*((struct_liste_chainee *) (*s_format).objet))
1161: .donnee = copie_objet(s_etat_processus,
1162: (*l_element_courant_format).donnee, 'N')) == NULL)
1163: {
1164: (*s_etat_processus).erreur_systeme =
1165: d_es_allocation_memoire;
1166: return;
1167: }
1168:
1169: if ((chaine = formateur_fichier(s_etat_processus,
1170: s_element, s_format, 0, 0, ' ',
1171: 'F', &longueur_effective, &recursivite)) == NULL)
1172: {
1173: free(clef_utf8);
1174:
1175: liberation(s_etat_processus, s_element);
1176: liberation(s_etat_processus, s_format);
1177: liberation(s_etat_processus, s_objet_argument_2);
1178: liberation(s_etat_processus, s_objet_argument_1);
1179:
1180: return;
1181: }
1182:
1183: if ((chaine_utf8 = transliteration(s_etat_processus,
1184: chaine, d_locale, "UTF-8")) == NULL)
1185: {
1186: free(clef_utf8);
1187: free(chaine);
1188:
1189: liberation(s_etat_processus, s_objet_argument_2);
1190: liberation(s_etat_processus, s_objet_argument_1);
1191:
1192: return;
1193: }
1194:
1195: free(chaine);
1196:
1197: if (alsprintf(&commande, "insert into data "
1198: "(data, key_id, sequence) values "
1199: "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)
1200: {
1201: (*s_etat_processus).erreur_systeme =
1202: d_es_allocation_memoire;
1203: return;
1204: }
1205:
1206: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1207: commande, strlen(commande), &ppStmt, &queue)
1208: != SQLITE_OK)
1209: {
1210: (*s_etat_processus).erreur_systeme =
1211: d_es_erreur_fichier;
1212: return;
1213: }
1214:
1215: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1216: {
1217: (*s_etat_processus).erreur_systeme =
1218: d_es_erreur_fichier;
1219: return;
1220: }
1221:
1222: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1223: {
1224: (*s_etat_processus).erreur_systeme =
1225: d_es_erreur_fichier;
1226: return;
1227: }
1228:
1229: free(commande);
1230: free(chaine_utf8);
1231:
1232: liberation(s_etat_processus, s_element);
1233: liberation(s_etat_processus, s_format);
1234:
1235: l_element_courant = (*l_element_courant).suivant;
1236: l_element_courant_format = (*l_element_courant_format)
1237: .suivant;
1238:
1239: compteur++;
1240: ordre++;
1241: }
1242:
1243: free(clef_utf8);
1244:
1245: if ((l_element_courant != NULL) ||
1246: (l_element_courant_format != NULL))
1247: {
1248: liberation(s_etat_processus, s_objet_argument_1);
1249: liberation(s_etat_processus, s_objet_argument_2);
1250:
1251: (*s_etat_processus).erreur_execution =
1252: d_ex_erreur_format_fichier;
1253: return;
1254: }
1255: }
1256: }
1257: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1258: == 'Y')
1259: {
1260: /*
1261: * Fichiers non formatés
1262: */
1263:
1264: if ((chaine = formateur_fichier(s_etat_processus,
1265: s_objet_argument_2, (*((struct_fichier *)
1266: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
1267: &longueur_effective, &recursivite)) == NULL)
1268: {
1269: liberation(s_etat_processus, s_objet_argument_2);
1270: liberation(s_etat_processus, s_objet_argument_1);
1271:
1272: return;
1273: }
1274:
1275: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1276: == 'S')
1277: {
1278: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
1279:
1280: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
1281: != 0)
1282: {
1283: liberation(s_etat_processus, s_objet_argument_2);
1284: liberation(s_etat_processus, s_objet_argument_1);
1285:
1286: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1287: return;
1288: }
1289:
1290: if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
1291: (*descripteur).descripteur_c) !=
1292: (size_t) longueur_effective)
1293: {
1294: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1295: return;
1296: }
1297: }
1298: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1299: == 'D')
1300: {
1301: }
1302: else
1303: {
1304: /* Fichiers indexés : panique totale ! */
1305: }
1306:
1307: free(chaine);
1308: }
1309: else
1310: {
1311: /*
1312: * Fichiers de type FLOW
1313: */
1314:
1315: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1316: == 'S')
1317: {
1318: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
1319:
1320: if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
1321: .donnee)).type != CHN)
1322: {
1323: liberation(s_etat_processus, s_objet_argument_2);
1324: liberation(s_etat_processus, s_objet_argument_1);
1325:
1326: (*s_etat_processus).erreur_execution =
1327: d_ex_erreur_type_argument;
1328: return;
1329: }
1330:
1331: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1332: (*((*((struct_liste_chainee *) (*s_objet_argument_2)
1333: .objet)).donnee)).objet, &longueur_effective)) == NULL)
1334: {
1335: (*s_etat_processus).erreur_systeme =
1336: d_es_allocation_memoire;
1337: return;
1338: }
1339:
1340: if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
1341: (*descripteur).descripteur_c) !=
1342: (size_t) longueur_effective)
1343: {
1344: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1345: return;
1346: }
1347:
1348: free(chaine);
1349: }
1350: else
1351: {
1352: liberation(s_etat_processus, s_objet_argument_1);
1353: liberation(s_etat_processus, s_objet_argument_2);
1354:
1355: (*s_etat_processus).erreur_execution =
1356: d_ex_erreur_type_fichier;
1357: return;
1358: }
1359: }
1360: }
1361: else if (((*s_objet_argument_2).type == LST) &&
1362: ((*s_objet_argument_1).type == SCK))
1363: {
1364: /*
1365: * Vérification de l'autorisation d'écriture
1366: */
1367:
1368: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1369: .protection == 'R')
1370: {
1371: liberation(s_etat_processus, s_objet_argument_2);
1372: liberation(s_etat_processus, s_objet_argument_1);
1373:
1374: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1375: return;
1376: }
1377:
1378: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1379: {
1380: /*
1381: * Sockets formatées
1382: */
1383:
1384: if ((chaine = formateur_fichier(s_etat_processus,
1385: s_objet_argument_2, (*((struct_socket *)
1386: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
1387: &longueur_effective, &recursivite)) == NULL)
1388: {
1389: liberation(s_etat_processus, s_objet_argument_2);
1390: liberation(s_etat_processus, s_objet_argument_1);
1391:
1392: return;
1393: }
1394: }
1395: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
1396: == 'Y')
1397: {
1398: /*
1399: * Sockets non formatées
1400: */
1401:
1402: chaine = NULL;
1403: }
1404: else
1405: {
1406: /*
1407: * Sockets de type FLOW
1408: */
1409:
1410: if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
1411: .donnee)).type != CHN)
1412: {
1413: liberation(s_etat_processus, s_objet_argument_2);
1414: liberation(s_etat_processus, s_objet_argument_1);
1415:
1416: (*s_etat_processus).erreur_execution =
1417: d_ex_erreur_type_argument;
1418: return;
1419: }
1420:
1421: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1422: (*((*((struct_liste_chainee *) (*s_objet_argument_2)
1423: .objet)).donnee)).objet, &longueur_effective)) == NULL)
1424: {
1425: liberation(s_etat_processus, s_objet_argument_2);
1426: liberation(s_etat_processus, s_objet_argument_1);
1427:
1428: return;
1429: }
1430: }
1431:
1432: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1433: "STREAM") == 0) || (strcmp((*((struct_socket *)
1434: (*s_objet_argument_1).objet)).type,
1435: "SEQUENTIAL DATAGRAM") == 0))
1436: { // Sockets connectées
1437:
1438: action.sa_handler = SIG_IGN;
1439: action.sa_flags = SA_ONSTACK;
1440:
1441: if (sigaction(SIGPIPE, &action, ®istre) != 0)
1442: {
1443: (*s_etat_processus).erreur_systeme = d_es_signal;
1444: return;
1445: }
1446:
1447: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
1448: {
1449: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1450: {
1451: (*s_etat_processus).erreur_systeme = d_es_signal;
1452: return;
1453: }
1454:
1455: (*s_etat_processus).erreur_systeme = d_es_processus;
1456: return;
1457: }
1458:
1459: if (send((*((struct_socket *) (*s_objet_argument_1).objet))
1460: .socket, chaine, longueur_effective, 0) < 0)
1461: {
1462: ios = errno;
1463:
1464: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1465: {
1466: (*s_etat_processus).erreur_systeme = d_es_signal;
1467: return;
1468: }
1469:
1470: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
1471: {
1472: (*s_etat_processus).erreur_systeme = d_es_processus;
1473: return;
1474: }
1475:
1476: if ((ios == EPIPE) || (ios == ECONNRESET))
1477: {
1478: (*s_etat_processus).erreur_execution =
1479: d_ex_erreur_acces_fichier;
1480: return;
1481: }
1482:
1483: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1484: return;
1485: }
1486:
1487: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
1488: {
1489: if (errno != EINTR)
1490: {
1491: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1492: {
1493: (*s_etat_processus).erreur_systeme = d_es_signal;
1494: return;
1495: }
1496:
1497: (*s_etat_processus).erreur_systeme = d_es_processus;
1498: return;
1499: }
1500: }
1501:
1502: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1503: {
1504: (*s_etat_processus).erreur_systeme = d_es_signal;
1505: return;
1506: }
1507: }
1508: else
1509: { // Sockets non connectées
1510:
1511: /*
1512: * Vérification de l'adresse distante
1513: */
1514:
1515: if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1516: .adresse_distante, "") == 0)
1517: {
1518: liberation(s_etat_processus, s_objet_argument_1);
1519: liberation(s_etat_processus, s_objet_argument_2);
1520:
1521: (*s_etat_processus).erreur_execution =
1522: d_ex_erreur_acces_fichier;
1523: return;
1524: }
1525:
1526: /*
1527: * Création de l'adresse logique
1528: */
1529:
1530: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1531: .domaine == PF_UNIX)
1532: {
1533: adresse_unix.sun_family = AF_UNIX;
1534: strncpy(adresse_unix.sun_path, (*((struct_socket *)
1535: (*s_objet_argument_1).objet)).adresse_distante,
1536: UNIX_PATH_MAX);
1537: adresse_unix.sun_path[UNIX_PATH_MAX - 1] =
1538: d_code_fin_chaine;
1539:
1540: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork))
1541: != 0)
1542: {
1543: (*s_etat_processus).erreur_systeme = d_es_processus;
1544: return;
1545: }
1546:
1547: if (sendto((*((struct_socket *)
1548: (*s_objet_argument_1).objet)).socket, chaine,
1549: longueur_effective, 0, (struct sockaddr *)
1550: &adresse_unix, sizeof(adresse_unix)) < 0)
1551: {
1552: ios = errno;
1553:
1554: if (pthread_mutex_lock(&((*s_etat_processus)
1555: .mutex_fork)) != 0)
1556: {
1557: (*s_etat_processus).erreur_systeme = d_es_processus;
1558: return;
1559: }
1560:
1561: if ((ios == EPIPE) || (ios == ECONNRESET))
1562: {
1563: (*s_etat_processus).erreur_execution =
1564: d_ex_erreur_acces_fichier;
1565: return;
1566: }
1567:
1568:
1569: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1570: return;
1571: }
1572:
1573: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
1574: {
1575: (*s_etat_processus).erreur_systeme = d_es_processus;
1576: return;
1577: }
1578: }
1579: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1580: .domaine == PF_INET)
1581: {
1582: if (sscanf((*((struct_socket *)
1583: (*s_objet_argument_1).objet))
1584: .adresse_distante, "%d.%d.%d.%d(%d)",
1585: &(adresse[0]), &(adresse[1]), &(adresse[2]),
1586: &(adresse[3]), &port) == 5)
1587: { // Adresse IPv4
1588: calcul_adresse = 0;
1589: for(i = 0; i < 4; calcul_adresse =
1590: (256 * calcul_adresse) + adresse[i++]);
1591:
1592: memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
1593: adresse_ipv4.sin_family = AF_INET;
1594: adresse_ipv4.sin_port = htons(port);
1595: adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
1596:
1597: if (pthread_mutex_unlock(&((*s_etat_processus)
1598: .mutex_fork)) != 0)
1599: {
1600: (*s_etat_processus).erreur_systeme = d_es_processus;
1601: return;
1602: }
1603:
1604: if (sendto((*((struct_socket *)
1605: (*s_objet_argument_1).objet)).socket, chaine,
1606: longueur_effective, 0, (struct sockaddr *)
1607: &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
1608: {
1609: if (pthread_mutex_lock(&((*s_etat_processus)
1610: .mutex_fork)) != 0)
1611: {
1612: (*s_etat_processus).erreur_systeme = d_es_processus;
1613: return;
1614: }
1615:
1616: (*s_etat_processus).erreur_systeme =
1617: d_es_erreur_fichier;
1618: return;
1619: }
1620:
1621: if (pthread_mutex_lock(&((*s_etat_processus)
1622: .mutex_fork)) != 0)
1623: {
1624: (*s_etat_processus).erreur_systeme = d_es_processus;
1625: return;
1626: }
1627: }
1628: else
1629: {
1630: liberation(s_etat_processus, s_objet_argument_1);
1631: liberation(s_etat_processus, s_objet_argument_2);
1632:
1633: (*s_etat_processus).erreur_execution =
1634: d_ex_erreur_parametre_fichier;
1635: return;
1636: }
1637: }
1638: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1639: .domaine == PF_INET6)
1640: {
1641: if (sscanf((*((struct_socket *) (*s_objet_argument_1)
1642: .objet)).adresse_distante, "%X:%X:%X:%X:%X:"
1643: "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
1644: &(adresse[0]), &(adresse[1]), &(adresse[2]),
1645: &(adresse[3]), &(adresse[4]), &(adresse[5]),
1646: &(adresse[6]), &(adresse[7]), &(adresse[8]),
1647: &(adresse[9]), &(adresse[10]), &(adresse[11]),
1648: &(adresse[12]), &(adresse[13]), &(adresse[14]),
1649: &(adresse[15]), &port)== 17)
1650: { // Adresse IPv6
1651: # ifdef IPV6
1652: memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
1653: adresse_ipv6.sin6_family = AF_INET6;
1654: adresse_ipv6.sin6_port = htons((uint16_t) port);
1655:
1656: for(i = 0; i < 16;
1657: adresse_ipv6.sin6_addr.s6_addr[i] =
1658: adresse[i], i++);
1659:
1660: if (pthread_mutex_unlock(&((*s_etat_processus)
1661: .mutex_fork)) != 0)
1662: {
1663: (*s_etat_processus).erreur_systeme = d_es_processus;
1664: return;
1665: }
1666:
1667: if (sendto((*((struct_socket *)
1668: (*s_objet_argument_1).objet)).socket, chaine,
1669: longueur_effective, 0, (struct sockaddr *)
1670: &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
1671: {
1672: if (pthread_mutex_lock(&((*s_etat_processus)
1673: .mutex_fork)) != 0)
1674: {
1675: (*s_etat_processus).erreur_systeme =
1676: d_es_processus;
1677: return;
1678: }
1679:
1680: (*s_etat_processus).erreur_systeme =
1681: d_es_erreur_fichier;
1682: return;
1683: }
1684:
1685: if (pthread_mutex_lock(&((*s_etat_processus)
1686: .mutex_fork)) != 0)
1687: {
1688: (*s_etat_processus).erreur_systeme =
1689: d_es_processus;
1690: return;
1691: }
1692: # else
1693: if ((*s_etat_processus).langue == 'F')
1694: {
1695: printf("+++Attention : Support du protocole"
1696: " IPv6 indisponible\n");
1697: }
1698: else
1699: {
1700: printf("+++Warning : IPv6 support "
1701: "unavailable\n");
1702: }
1703: # endif
1704: }
1705: else
1706: {
1707: liberation(s_etat_processus, s_objet_argument_1);
1708: liberation(s_etat_processus, s_objet_argument_2);
1709:
1710: (*s_etat_processus).erreur_execution =
1711: d_ex_erreur_parametre_fichier;
1712: return;
1713: }
1714: }
1715: else
1716: {
1717: liberation(s_etat_processus, s_objet_argument_1);
1718: liberation(s_etat_processus, s_objet_argument_2);
1719:
1720: (*s_etat_processus).erreur_execution =
1721: d_ex_erreur_parametre_fichier;
1722: return;
1723: }
1724: }
1725:
1726: free(chaine);
1727: }
1728: else
1729: {
1730: liberation(s_etat_processus, s_objet_argument_2);
1731: liberation(s_etat_processus, s_objet_argument_1);
1732:
1733: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1734: return;
1735: }
1736:
1737: liberation(s_etat_processus, s_objet_argument_2);
1738: liberation(s_etat_processus, s_objet_argument_1);
1739:
1740: return;
1741: }
1742:
1743:
1744: /*
1745: ================================================================================
1746: Fonction 'wflock'
1747: ================================================================================
1748: Entrées : pointeur sur une structure struct_processus
1749: --------------------------------------------------------------------------------
1750: Sorties :
1751: --------------------------------------------------------------------------------
1752: Effets de bord : néant
1753: ================================================================================
1754: */
1755:
1756: void
1757: instruction_wflock(struct_processus *s_etat_processus)
1758: {
1759: logical1 drapeau;
1760:
1761: struct flock lock;
1762:
1763: struct timespec attente;
1764:
1765: struct_descripteur_fichier *descripteur;
1766:
1767: struct_objet *s_objet_argument_1;
1768: struct_objet *s_objet_argument_2;
1769:
1770: unsigned char *chaine;
1771: unsigned char registre_instruction_valide;
1772:
1773: attente.tv_sec = 0;
1774: attente.tv_nsec = GRANULARITE_us * 1000;
1775:
1776: (*s_etat_processus).erreur_execution = d_ex;
1777:
1778: if ((*s_etat_processus).affichage_arguments == 'Y')
1779: {
1780: printf("\n WFLOCK ");
1781:
1782: if ((*s_etat_processus).langue == 'F')
1783: {
1784: printf("(attente du positionnement d'un verrou sur un fichier)"
1785: "\n\n");
1786: }
1787: else
1788: {
1789: printf("(wait for file lock)\n\n");
1790: }
1791:
1792: printf(" 2: %s\n", d_FCH);
1793: printf(" 1: %s (READ/WRITE/NONE)\n", d_CHN);
1794:
1795: return;
1796: }
1797: else if ((*s_etat_processus).test_instruction == 'Y')
1798: {
1799: (*s_etat_processus).nombre_arguments = -1;
1800: return;
1801: }
1802:
1803: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1804: {
1805: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1806: {
1807: return;
1808: }
1809: }
1810:
1811: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1812: &s_objet_argument_1) == d_erreur)
1813: {
1814: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1815: return;
1816: }
1817:
1818: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1819: &s_objet_argument_2) == d_erreur)
1820: {
1821: liberation(s_etat_processus, s_objet_argument_1);
1822:
1823: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1824: return;
1825: }
1826:
1827: if (((*s_objet_argument_2).type == FCH) &&
1828: ((*s_objet_argument_1).type == CHN))
1829: {
1830: drapeau = d_faux;
1831:
1832: do
1833: {
1834: if ((chaine = conversion_majuscule((unsigned char *)
1835: (*s_objet_argument_1).objet)) == NULL)
1836: {
1837: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1838: return;
1839: }
1840:
1841: if (strcmp(chaine, "WRITE") == 0)
1842: {
1843: lock.l_type = F_WRLCK;
1844: }
1845: else if (strcmp(chaine, "READ") == 0)
1846: {
1847: lock.l_type = F_RDLCK;
1848: }
1849: else if (strcmp(chaine, "NONE") == 0)
1850: {
1851: lock.l_type = F_UNLCK;
1852: }
1853: else
1854: {
1855: free(chaine);
1856:
1857: liberation(s_etat_processus, s_objet_argument_1);
1858: liberation(s_etat_processus, s_objet_argument_2);
1859:
1860: (*s_etat_processus).erreur_execution = d_ex_verrou_indefini;
1861: return;
1862: }
1863:
1864: free(chaine);
1865:
1866: lock.l_whence = SEEK_SET;
1867: lock.l_start = 0;
1868: lock.l_len = 0;
1869: lock.l_pid = getpid();
1870:
1871: if ((descripteur = descripteur_fichier(s_etat_processus,
1872: (struct_fichier *) (*s_objet_argument_2).objet)) == NULL)
1873: {
1874: return;
1875: }
1876:
1877: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
1878: == -1)
1879: {
1880: liberation(s_etat_processus, s_objet_argument_1);
1881: liberation(s_etat_processus, s_objet_argument_2);
1882:
1883: (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille;
1884: return;
1885: }
1886:
1887: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
1888: {
1889: (*s_etat_processus).erreur_systeme = d_es_processus;
1890: return;
1891: }
1892:
1893: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
1894: {
1895: (*s_etat_processus).erreur_systeme = d_es_processus;
1896: return;
1897: }
1898:
1899: if (lock.l_type == F_UNLCK)
1900: {
1901: drapeau = d_vrai;
1902: }
1903: else
1904: {
1905: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
1906: {
1907: affectation_interruptions_logicielles(s_etat_processus);
1908: }
1909:
1910: if ((*s_etat_processus).nombre_interruptions_en_queue
1911: != 0)
1912: {
1913: registre_instruction_valide =
1914: (*s_etat_processus).instruction_valide;
1915: traitement_interruptions_logicielles(
1916: s_etat_processus);
1917: (*s_etat_processus).instruction_valide =
1918: registre_instruction_valide;
1919: }
1920:
1921: nanosleep(&attente, NULL);
1922: scrutation_injection(s_etat_processus);
1923:
1924: INCR_GRANULARITE(attente.tv_nsec);
1925: }
1926: } while((drapeau == d_faux) && ((*s_etat_processus)
1927: .var_volatile_requete_arret != -1));
1928: }
1929: else
1930: {
1931: liberation(s_etat_processus, s_objet_argument_1);
1932: liberation(s_etat_processus, s_objet_argument_2);
1933:
1934: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1935: return;
1936: }
1937:
1938: return;
1939: }
1940:
1941:
1942: /*
1943: ================================================================================
1944: Fonction 'wfproc'
1945: ================================================================================
1946: Entrées : pointeur sur une structure struct_processus
1947: --------------------------------------------------------------------------------
1948: Sorties :
1949: --------------------------------------------------------------------------------
1950: Effets de bord : néant
1951: ================================================================================
1952: */
1953:
1954: void
1955: instruction_wfproc(struct_processus *s_etat_processus)
1956: {
1957: logical1 drapeau_fin;
1958:
1959: struct_liste_chainee *l_element_courant;
1960:
1961: struct_objet *s_objet_argument;
1962:
1963: struct timespec attente;
1964:
1965: unsigned char registre_instruction_valide;
1966:
1967: (*s_etat_processus).erreur_execution = d_ex;
1968:
1969: attente.tv_sec = 0;
1970: attente.tv_nsec = GRANULARITE_us * 1000;
1971:
1972: if ((*s_etat_processus).affichage_arguments == 'Y')
1973: {
1974: printf("\n WFPROC ");
1975:
1976: if ((*s_etat_processus).langue == 'F')
1977: {
1978: printf("(attente de la fin d'un processus fils)\n\n");
1979: }
1980: else
1981: {
1982: printf("(wait for child process end)\n\n");
1983: }
1984:
1985: printf(" 1: %s\n", d_PRC);
1986:
1987: return;
1988: }
1989: else if ((*s_etat_processus).test_instruction == 'Y')
1990: {
1991: (*s_etat_processus).nombre_arguments = -1;
1992: return;
1993: }
1994:
1995: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1996: {
1997: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1998: {
1999: return;
2000: }
2001: }
2002:
2003: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2004: &s_objet_argument) == d_erreur)
2005: {
2006: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2007: return;
2008: }
2009:
2010: if ((*s_objet_argument).type == PRC)
2011: {
2012: drapeau_fin = d_faux;
2013:
2014: if ((*s_etat_processus).profilage == d_vrai)
2015: {
2016: profilage(s_etat_processus, "Interprocess or interthread "
2017: "communications (WFPROC)");
2018:
2019: if ((*s_etat_processus).erreur_systeme != d_es)
2020: {
2021: return;
2022: }
2023: }
2024:
2025: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2026: {
2027: if ((*s_etat_processus).profilage == d_vrai)
2028: {
2029: profilage(s_etat_processus, NULL);
2030: }
2031:
2032: (*s_etat_processus).erreur_systeme = d_es_processus;
2033: return;
2034: }
2035:
2036: while(drapeau_fin == d_faux)
2037: {
2038: l_element_courant = (struct_liste_chainee *)
2039: (*s_etat_processus).l_base_pile_processus;
2040:
2041: while(l_element_courant != NULL)
2042: {
2043: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2044: .donnee).objet)).thread).processus_detache == d_vrai)
2045: {
2046: if ((*(*((struct_processus_fils *)
2047: (*s_objet_argument).objet)).thread)
2048: .processus_detache == d_vrai)
2049: {
2050: if ((*(*((struct_processus_fils *)
2051: (*(*l_element_courant)
2052: .donnee).objet)).thread).pid ==
2053: (*(*((struct_processus_fils *)
2054: (*s_objet_argument).objet)).thread).pid)
2055: {
2056: break;
2057: }
2058: }
2059: }
2060: else
2061: {
2062: if ((*(*((struct_processus_fils *)
2063: (*s_objet_argument).objet)).thread)
2064: .processus_detache == d_faux)
2065: {
2066: if ((pthread_equal((*(*((struct_processus_fils *)
2067: (*(*l_element_courant).donnee).objet)).thread)
2068: .tid, (*(*((struct_processus_fils *)
2069: (*s_objet_argument).objet)).thread).tid) != 0)
2070: && ((*(*((struct_processus_fils *)
2071: (*(*l_element_courant).donnee).objet)).thread)
2072: .pid == (*(*((struct_processus_fils *)
2073: (*s_objet_argument).objet)).thread).pid))
2074: {
2075: break;
2076: }
2077: }
2078: }
2079:
2080: l_element_courant = (*l_element_courant).suivant;
2081: }
2082:
2083: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2084: {
2085: if ((*s_etat_processus).profilage == d_vrai)
2086: {
2087: profilage(s_etat_processus, NULL);
2088: }
2089:
2090: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2091: {
2092: (*s_etat_processus).erreur_systeme = d_es_processus;
2093: return;
2094: }
2095:
2096: liberation(s_etat_processus, s_objet_argument);
2097: return;
2098: }
2099:
2100: if (l_element_courant == NULL)
2101: {
2102: /*
2103: * Si l_element_courant vaut NULL, le processus n'existe plus.
2104: */
2105:
2106: drapeau_fin = d_vrai;
2107: }
2108: else
2109: {
2110: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2111: .donnee).objet)).thread).processus_detache == d_vrai)
2112: {
2113: if (envoi_signal_processus((*(*((struct_processus_fils *)
2114: (*(*l_element_courant).donnee).objet)).thread).pid,
2115: rpl_signull) != 0)
2116: {
2117: drapeau_fin = d_vrai;
2118: }
2119: else
2120: {
2121: drapeau_fin = d_faux;
2122: }
2123: }
2124: else
2125: {
2126: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2127: (*(*l_element_courant).donnee).objet)).thread)
2128: .mutex)) != 0)
2129: {
2130: if ((*s_etat_processus).profilage == d_vrai)
2131: {
2132: profilage(s_etat_processus, NULL);
2133: }
2134:
2135: (*s_etat_processus).erreur_systeme = d_es_processus;
2136: return;
2137: }
2138:
2139: if ((*(*((struct_processus_fils *)
2140: (*(*l_element_courant).donnee).objet)).thread)
2141: .thread_actif == d_faux)
2142: {
2143: drapeau_fin = d_vrai;
2144: }
2145: else
2146: {
2147: drapeau_fin = d_faux;
2148: }
2149:
2150: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2151: (*(*l_element_courant).donnee).objet)).thread)
2152: .mutex)) != 0)
2153: {
2154: if ((*s_etat_processus).profilage == d_vrai)
2155: {
2156: profilage(s_etat_processus, NULL);
2157: }
2158:
2159: (*s_etat_processus).erreur_systeme = d_es_processus;
2160: return;
2161: }
2162: }
2163:
2164: if (drapeau_fin == d_faux)
2165: {
2166: /*
2167: * Le processus n'est pas terminé
2168: */
2169:
2170: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2171: {
2172: if ((*s_etat_processus).profilage == d_vrai)
2173: {
2174: profilage(s_etat_processus, NULL);
2175: }
2176:
2177: (*s_etat_processus).erreur_systeme =
2178: d_es_processus;
2179: return;
2180: }
2181:
2182: if ((*s_etat_processus).nombre_interruptions_non_affectees
2183: != 0)
2184: {
2185: affectation_interruptions_logicielles(s_etat_processus);
2186: }
2187:
2188: if ((*s_etat_processus).nombre_interruptions_en_queue
2189: != 0)
2190: {
2191: registre_instruction_valide =
2192: (*s_etat_processus).instruction_valide;
2193: traitement_interruptions_logicielles(
2194: s_etat_processus);
2195: (*s_etat_processus).instruction_valide =
2196: registre_instruction_valide;
2197: }
2198:
2199: if (pthread_mutex_unlock(&((*s_etat_processus)
2200: .mutex_fork)) != 0)
2201: {
2202: (*s_etat_processus).erreur_systeme = d_es_processus;
2203: return;
2204: }
2205:
2206: nanosleep(&attente, NULL);
2207:
2208: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2209: != 0)
2210: {
2211: (*s_etat_processus).erreur_systeme = d_es_processus;
2212: return;
2213: }
2214:
2215: scrutation_injection(s_etat_processus);
2216:
2217: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2218: {
2219: if ((*s_etat_processus).profilage == d_vrai)
2220: {
2221: profilage(s_etat_processus, NULL);
2222: }
2223:
2224: (*s_etat_processus).erreur_systeme =
2225: d_es_processus;
2226: return;
2227: }
2228: }
2229: }
2230:
2231: INCR_GRANULARITE(attente.tv_nsec);
2232: }
2233:
2234: if ((*s_etat_processus).profilage == d_vrai)
2235: {
2236: profilage(s_etat_processus, NULL);
2237: }
2238:
2239: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2240: {
2241: (*s_etat_processus).erreur_systeme = d_es_processus;
2242: return;
2243: }
2244: }
2245: else
2246: {
2247: liberation(s_etat_processus, s_objet_argument);
2248:
2249: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2250: return;
2251: }
2252:
2253: liberation(s_etat_processus, s_objet_argument);
2254:
2255: return;
2256: }
2257:
2258:
2259: /*
2260: ================================================================================
2261: Fonction 'wfdata'
2262: ================================================================================
2263: Entrées : pointeur sur une structure struct_processus
2264: --------------------------------------------------------------------------------
2265: Sorties :
2266: --------------------------------------------------------------------------------
2267: Effets de bord : néant
2268: ================================================================================
2269: */
2270:
2271: void
2272: instruction_wfdata(struct_processus *s_etat_processus)
2273: {
2274: logical1 drapeau_fin;
2275:
2276: struct_liste_chainee *l_element_courant;
2277:
2278: struct_objet *s_objet_argument;
2279:
2280: struct timespec attente;
2281:
2282: unsigned char registre_instruction_valide;
2283:
2284: (*s_etat_processus).erreur_execution = d_ex;
2285:
2286: attente.tv_sec = 0;
2287: attente.tv_nsec = GRANULARITE_us * 1000;
2288:
2289: if ((*s_etat_processus).affichage_arguments == 'Y')
2290: {
2291: printf("\n WFDATA ");
2292:
2293: if ((*s_etat_processus).langue == 'F')
2294: {
2295: printf("(attente de données d'un processus fils)\n\n");
2296: }
2297: else
2298: {
2299: printf("(wait for data from child process)\n\n");
2300: }
2301:
2302: printf(" 1: %s\n", d_PRC);
2303:
2304: return;
2305: }
2306: else if ((*s_etat_processus).test_instruction == 'Y')
2307: {
2308: (*s_etat_processus).nombre_arguments = -1;
2309: return;
2310: }
2311:
2312: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2313: {
2314: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2315: {
2316: return;
2317: }
2318: }
2319:
2320: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2321: &s_objet_argument) == d_erreur)
2322: {
2323: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2324: return;
2325: }
2326:
2327: if ((*s_objet_argument).type == PRC)
2328: {
2329: drapeau_fin = d_faux;
2330:
2331: if ((*s_etat_processus).profilage == d_vrai)
2332: {
2333: profilage(s_etat_processus, "Interprocess or interthread "
2334: "communications (WFDATA)");
2335:
2336: if ((*s_etat_processus).erreur_systeme != d_es)
2337: {
2338: return;
2339: }
2340: }
2341:
2342: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2343: {
2344: if ((*s_etat_processus).profilage == d_vrai)
2345: {
2346: profilage(s_etat_processus, NULL);
2347: }
2348:
2349: (*s_etat_processus).erreur_systeme = d_es_processus;
2350: return;
2351: }
2352:
2353: while(drapeau_fin == d_faux)
2354: {
2355: l_element_courant = (struct_liste_chainee *)
2356: (*s_etat_processus).l_base_pile_processus;
2357:
2358: while(l_element_courant != NULL)
2359: {
2360: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2361: .donnee).objet)).thread).processus_detache == d_vrai)
2362: {
2363: if (((*(*((struct_processus_fils *) (*(*l_element_courant)
2364: .donnee).objet)).thread).pid ==
2365: (*(*((struct_processus_fils *)
2366: (*s_objet_argument).objet)).thread).pid)
2367: && ((*(*((struct_processus_fils *)
2368: (*s_objet_argument).objet)).thread)
2369: .processus_detache == d_vrai))
2370: {
2371: break;
2372: }
2373: }
2374: else
2375: {
2376: if ((pthread_equal((*(*((struct_processus_fils *)
2377: (*(*l_element_courant).donnee).objet)).thread).tid,
2378: (*(*((struct_processus_fils *) (*s_objet_argument)
2379: .objet)).thread).tid) != 0) &&
2380: ((*(*((struct_processus_fils *)
2381: (*(*l_element_courant).donnee).objet)).thread).pid
2382: == (*(*((struct_processus_fils *)
2383: (*s_objet_argument).objet)).thread).pid) &&
2384: ((*(*((struct_processus_fils *)
2385: (*s_objet_argument).objet)).thread)
2386: .processus_detache == d_faux))
2387: {
2388: break;
2389: }
2390: }
2391:
2392: l_element_courant = (*l_element_courant).suivant;
2393: }
2394:
2395: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2396: {
2397: if ((*s_etat_processus).profilage == d_vrai)
2398: {
2399: profilage(s_etat_processus, NULL);
2400: }
2401:
2402: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2403: {
2404: (*s_etat_processus).erreur_systeme = d_es_processus;
2405: return;
2406: }
2407:
2408: liberation(s_etat_processus, s_objet_argument);
2409: return;
2410: }
2411:
2412: if (l_element_courant != NULL)
2413: {
2414: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2415: (*(*l_element_courant).donnee).objet)).thread).mutex))
2416: != 0)
2417: {
2418: (*s_etat_processus).erreur_systeme = d_es_processus;
2419: return;
2420: }
2421:
2422: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2423: .donnee).objet)).thread).nombre_objets_dans_pipe != 0)
2424: {
2425: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2426: (*(*l_element_courant).donnee).objet)).thread)
2427: .mutex)) != 0)
2428: {
2429: (*s_etat_processus).erreur_systeme = d_es_processus;
2430: return;
2431: }
2432:
2433: drapeau_fin = d_vrai;
2434: }
2435: else
2436: {
2437: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2438: (*(*l_element_courant).donnee).objet)).thread)
2439: .mutex)) != 0)
2440: {
2441: (*s_etat_processus).erreur_systeme = d_es_processus;
2442: return;
2443: }
2444:
2445: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2446: {
2447: if ((*s_etat_processus).profilage == d_vrai)
2448: {
2449: profilage(s_etat_processus, NULL);
2450: }
2451:
2452: (*s_etat_processus).erreur_systeme =
2453: d_es_processus;
2454: return;
2455: }
2456:
2457: if (pthread_mutex_unlock(&((*s_etat_processus)
2458: .mutex_fork)) != 0)
2459: {
2460: (*s_etat_processus).erreur_systeme = d_es_processus;
2461: return;
2462: }
2463:
2464: nanosleep(&attente, NULL);
2465:
2466: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2467: != 0)
2468: {
2469: (*s_etat_processus).erreur_systeme = d_es_processus;
2470: return;
2471: }
2472:
2473: scrutation_injection(s_etat_processus);
2474:
2475: if ((*s_etat_processus).nombre_interruptions_non_affectees
2476: != 0)
2477: {
2478: affectation_interruptions_logicielles(s_etat_processus);
2479: }
2480:
2481: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
2482: {
2483: registre_instruction_valide =
2484: (*s_etat_processus).instruction_valide;
2485: traitement_interruptions_logicielles(s_etat_processus);
2486: (*s_etat_processus).instruction_valide =
2487: registre_instruction_valide;
2488: }
2489:
2490: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2491: {
2492: if ((*s_etat_processus).profilage == d_vrai)
2493: {
2494: profilage(s_etat_processus, NULL);
2495: }
2496:
2497: return;
2498: }
2499:
2500: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2501: {
2502: if ((*s_etat_processus).profilage == d_vrai)
2503: {
2504: profilage(s_etat_processus, NULL);
2505: }
2506:
2507: (*s_etat_processus).erreur_systeme =
2508: d_es_processus;
2509: return;
2510: }
2511: }
2512: }
2513: else
2514: {
2515: drapeau_fin = d_vrai;
2516: (*s_etat_processus).erreur_execution = d_ex_processus;
2517: }
2518:
2519: INCR_GRANULARITE(attente.tv_nsec);
2520: }
2521:
2522: if ((*s_etat_processus).profilage == d_vrai)
2523: {
2524: profilage(s_etat_processus, NULL);
2525: }
2526:
2527: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2528: {
2529: (*s_etat_processus).erreur_systeme = d_es_processus;
2530: return;
2531: }
2532: }
2533: else
2534: {
2535: liberation(s_etat_processus, s_objet_argument);
2536:
2537: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2538: return;
2539: }
2540:
2541: liberation(s_etat_processus, s_objet_argument);
2542:
2543: return;
2544: }
2545:
2546:
2547: /*
2548: ================================================================================
2549: Fonction 'wfsock'
2550: ================================================================================
2551: Entrées : pointeur sur une structure struct_processus
2552: --------------------------------------------------------------------------------
2553: Sorties :
2554: --------------------------------------------------------------------------------
2555: Effets de bord : néant
2556: ================================================================================
2557: */
2558:
2559: void
2560: instruction_wfsock(struct_processus *s_etat_processus)
2561: {
2562: int erreur;
2563:
2564: logical1 drapeau;
2565:
2566: socklen_t longueur;
2567:
2568: struct_liste_chainee *l_element_courant;
2569:
2570: struct_objet *s_objet_argument;
2571: struct_objet *s_objet_resultat;
2572:
2573: struct sockaddr_in adresse_ipv4;
2574: # ifdef IPV6
2575: struct sockaddr_in6 adresse_ipv6;
2576: # endif
2577:
2578: unsigned long i;
2579:
2580: if ((*s_etat_processus).affichage_arguments == 'Y')
2581: {
2582: printf("\n WFSOCK ");
2583:
2584: if ((*s_etat_processus).langue == 'F')
2585: {
2586: printf("(attente d'une connexion sur une socket)\n\n");
2587: }
2588: else
2589: {
2590: printf("(wait for connection on a socket)\n\n");
2591: }
2592:
2593: printf(" 1: %s\n", d_SCK);
2594: printf("-> 2: %s\n", d_SCK);
2595: printf(" 1: %s\n", d_SCK);
2596:
2597: return;
2598: }
2599: else if ((*s_etat_processus).test_instruction == 'Y')
2600: {
2601: (*s_etat_processus).nombre_arguments = -1;
2602: return;
2603: }
2604:
2605: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2606: {
2607: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2608: {
2609: return;
2610: }
2611: }
2612:
2613: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2614: &s_objet_argument) == d_erreur)
2615: {
2616: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2617: return;
2618: }
2619:
2620: if ((*s_objet_argument).type == SCK)
2621: {
2622: if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,
2623: "STREAM") != 0) && (strcmp((*((struct_socket *)
2624: (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
2625: {
2626: liberation(s_etat_processus, s_objet_argument);
2627:
2628: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
2629: return;
2630: }
2631:
2632: if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,
2633: 'O')) == NULL)
2634: {
2635: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2636: return;
2637: }
2638:
2639: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';
2640: (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
2641:
2642: if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)
2643: {
2644: longueur = sizeof(adresse_ipv4);
2645:
2646: do
2647: {
2648: drapeau = d_vrai;
2649:
2650: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork))
2651: != 0)
2652: {
2653: (*s_etat_processus).erreur_systeme = d_es_processus;
2654: return;
2655: }
2656:
2657: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
2658: accept((*((struct_socket *) (*s_objet_argument).objet))
2659: .socket, (struct sockaddr *) &adresse_ipv4, &longueur))
2660: < 0)
2661: {
2662: erreur = errno;
2663:
2664: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2665: != 0)
2666: {
2667: (*s_etat_processus).erreur_systeme = d_es_processus;
2668: return;
2669: }
2670:
2671: if (erreur != EINTR)
2672: {
2673: liberation(s_etat_processus, s_objet_argument);
2674: liberation(s_etat_processus, s_objet_resultat);
2675:
2676: (*s_etat_processus).erreur_execution =
2677: d_ex_erreur_acces_fichier;
2678: return;
2679: }
2680:
2681: scrutation_injection(s_etat_processus);
2682:
2683: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2684: {
2685: drapeau = d_vrai;
2686: }
2687: else
2688: {
2689: drapeau = d_faux;
2690: }
2691: }
2692: else
2693: {
2694: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2695: != 0)
2696: {
2697: (*s_etat_processus).erreur_systeme = d_es_processus;
2698: return;
2699: }
2700: }
2701: } while(drapeau == d_faux);
2702:
2703: if (((*((struct_socket *) (*s_objet_resultat).objet))
2704: .adresse_distante = malloc(22 *
2705: sizeof(unsigned char))) == NULL)
2706: {
2707: (*s_etat_processus).erreur_systeme =
2708: d_es_allocation_memoire;
2709: return;
2710: }
2711:
2712: sprintf((*((struct_socket *) (*s_objet_resultat).objet))
2713: .adresse_distante, "%d.%d.%d.%d(%d)",
2714: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
2715: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
2716: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
2717: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
2718: ntohs(adresse_ipv4.sin_port));
2719: }
2720: else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
2721: PF_INET6)
2722: {
2723: # ifdef IPV6
2724: longueur = sizeof(adresse_ipv6);
2725:
2726: do
2727: {
2728: drapeau = d_vrai;
2729:
2730: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork))
2731: != 0)
2732: {
2733: (*s_etat_processus).erreur_systeme = d_es_processus;
2734: return;
2735: }
2736:
2737: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
2738: accept((*((struct_socket *) (*s_objet_argument).objet))
2739: .socket, (struct sockaddr *) &adresse_ipv6, &longueur))
2740: < 0)
2741: {
2742: erreur = errno;
2743:
2744: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2745: != 0)
2746: {
2747: (*s_etat_processus).erreur_systeme = d_es_processus;
2748: return;
2749: }
2750:
2751: if (erreur != EINTR)
2752: {
2753: liberation(s_etat_processus, s_objet_argument);
2754: liberation(s_etat_processus, s_objet_resultat);
2755:
2756: (*s_etat_processus).erreur_execution =
2757: d_ex_erreur_acces_fichier;
2758: return;
2759: }
2760:
2761: scrutation_injection(s_etat_processus);
2762:
2763: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2764: {
2765: drapeau = d_vrai;
2766: }
2767: else
2768: {
2769: drapeau = d_faux;
2770: }
2771: }
2772: else
2773: {
2774: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2775: != 0)
2776: {
2777: (*s_etat_processus).erreur_systeme = d_es_processus;
2778: return;
2779: }
2780: }
2781: } while(drapeau == d_faux);
2782:
2783: if (((*((struct_socket *) (*s_objet_resultat).objet))
2784: .adresse_distante = malloc(55 *
2785: sizeof(unsigned char))) == NULL)
2786: {
2787: (*s_etat_processus).erreur_systeme =
2788: d_es_allocation_memoire;
2789: return;
2790: }
2791:
2792: (*((struct_socket *) (*s_objet_resultat).objet))
2793: .adresse_distante = d_code_fin_chaine;
2794:
2795: for(i = 0; i < 16; i++)
2796: {
2797: sprintf((*((struct_socket *) (*s_objet_resultat)
2798: .objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X",
2799: (*((struct_socket *) (*s_objet_resultat)
2800: .objet)).adresse_distante,
2801: adresse_ipv6.sin6_addr.s6_addr[i]);
2802: }
2803:
2804: sprintf((*((struct_socket *) (*s_objet_resultat)
2805: .objet)).adresse_distante, "%s(%u)",
2806: (*((struct_socket *) (*s_objet_resultat)
2807: .objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));
2808: # else
2809: if ((*s_etat_processus).langue == 'F')
2810: {
2811: printf("+++Attention : Support du protocole"
2812: " IPv6 indisponible\n");
2813: }
2814: else
2815: {
2816: printf("+++Warning : IPv6 support "
2817: "unavailable\n");
2818: }
2819: # endif
2820: }
2821: else
2822: {
2823: longueur = 0;
2824:
2825: do
2826: {
2827: drapeau = d_vrai;
2828:
2829: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork))
2830: != 0)
2831: {
2832: (*s_etat_processus).erreur_systeme = d_es_processus;
2833: return;
2834: }
2835:
2836: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
2837: accept((*((struct_socket *) (*s_objet_argument).objet))
2838: .socket, NULL, &longueur)) < 0)
2839: {
2840: erreur = errno;
2841:
2842: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2843: != 0)
2844: {
2845: (*s_etat_processus).erreur_systeme = d_es_processus;
2846: return;
2847: }
2848:
2849: if (erreur != EINTR)
2850: {
2851: liberation(s_etat_processus, s_objet_argument);
2852: liberation(s_etat_processus, s_objet_resultat);
2853:
2854: (*s_etat_processus).erreur_execution =
2855: d_ex_erreur_acces_fichier;
2856: return;
2857: }
2858:
2859: scrutation_injection(s_etat_processus);
2860:
2861: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2862: {
2863: drapeau = d_vrai;
2864: }
2865: else
2866: {
2867: drapeau = d_faux;
2868: }
2869: }
2870: else
2871: {
2872: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork))
2873: != 0)
2874: {
2875: (*s_etat_processus).erreur_systeme = d_es_processus;
2876: return;
2877: }
2878: }
2879: } while(drapeau == d_faux);
2880: }
2881:
2882: // Si accept() renvoie une erreur non récupérée, il ne peut s'agir
2883: // que de EINTR sachant qu'une requête d'arrêt est en court de
2884: // traitement.
2885:
2886: if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
2887: {
2888: l_element_courant = (*s_etat_processus).s_sockets;
2889:
2890: if (l_element_courant == NULL)
2891: {
2892: if (((*s_etat_processus).s_sockets =
2893: allocation_maillon(s_etat_processus)) == NULL)
2894: {
2895: (*s_etat_processus).erreur_systeme =
2896: d_es_allocation_memoire;
2897: return;
2898: }
2899:
2900: (*(*s_etat_processus).s_sockets).suivant = NULL;
2901: l_element_courant = (*s_etat_processus).s_sockets;
2902: }
2903: else
2904: {
2905: /*
2906: * Ajout d'un élément à la fin de la liste chaînée
2907: */
2908:
2909: while((*l_element_courant).suivant != NULL)
2910: {
2911: l_element_courant = (*l_element_courant).suivant;
2912: }
2913:
2914: if (((*l_element_courant).suivant =
2915: allocation_maillon(s_etat_processus)) == NULL)
2916: {
2917: (*s_etat_processus).erreur_systeme =
2918: d_es_allocation_memoire;
2919: return;
2920: }
2921:
2922: l_element_courant = (*l_element_courant).suivant;
2923: (*l_element_courant).suivant = NULL;
2924: }
2925:
2926: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
2927: s_objet_resultat, 'O')) == NULL)
2928: {
2929: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2930: return;
2931: }
2932: }
2933:
2934: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2935: s_objet_argument) == d_erreur)
2936: {
2937: return;
2938: }
2939:
2940: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2941: s_objet_resultat) == d_erreur)
2942: {
2943: return;
2944: }
2945: }
2946: else
2947: {
2948: liberation(s_etat_processus, s_objet_argument);
2949:
2950: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2951: return;
2952: }
2953:
2954: return;
2955: }
2956:
2957:
2958: /*
2959: ================================================================================
2960: Fonction 'wfswi'
2961: ================================================================================
2962: Entrées : pointeur sur une structure struct_processus
2963: --------------------------------------------------------------------------------
2964: Sorties :
2965: --------------------------------------------------------------------------------
2966: Effets de bord : néant
2967: ================================================================================
2968: */
2969:
2970: void
2971: instruction_wfswi(struct_processus *s_etat_processus)
2972: {
2973: integer8 interruption;
2974:
2975: logical1 drapeau_fin;
2976:
2977: struct_objet *s_objet_argument;
2978:
2979: struct timespec attente;
2980:
2981: (*s_etat_processus).erreur_execution = d_ex;
2982:
2983: attente.tv_sec = 0;
2984: attente.tv_nsec = GRANULARITE_us * 1000;
2985:
2986: if ((*s_etat_processus).affichage_arguments == 'Y')
2987: {
2988: printf("\n WFSWI ");
2989:
2990: if ((*s_etat_processus).langue == 'F')
2991: {
2992: printf("(attente d'une interruption)\n\n");
2993: }
2994: else
2995: {
2996: printf("(wait for interrupt)\n\n");
2997: }
2998:
2999: printf(" 1: %s\n", d_INT);
3000:
3001: return;
3002: }
3003: else if ((*s_etat_processus).test_instruction == 'Y')
3004: {
3005: (*s_etat_processus).nombre_arguments = -1;
3006: return;
3007: }
3008:
3009: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3010: {
3011: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
3012: {
3013: return;
3014: }
3015: }
3016:
3017: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3018: &s_objet_argument) == d_erreur)
3019: {
3020: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
3021: return;
3022: }
3023:
3024: if ((*s_objet_argument).type == INT)
3025: {
3026: drapeau_fin = d_faux;
3027:
3028: interruption = (*((integer8 *) (*s_objet_argument).objet));
3029:
3030: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
3031: {
3032: liberation(s_etat_processus, s_objet_argument);
3033:
3034: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
3035: return;
3036: }
3037:
3038: while(drapeau_fin == d_faux)
3039: {
3040: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3041: {
3042: liberation(s_etat_processus, s_objet_argument);
3043: return;
3044: }
3045:
3046: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3047: {
3048: affectation_interruptions_logicielles(s_etat_processus);
3049: }
3050:
3051: if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
3052: {
3053: drapeau_fin = d_vrai;
3054: }
3055: else
3056: {
3057: nanosleep(&attente, NULL);
3058: scrutation_injection(s_etat_processus);
3059: INCR_GRANULARITE(attente.tv_nsec);
3060: }
3061: }
3062: }
3063: else
3064: {
3065: liberation(s_etat_processus, s_objet_argument);
3066:
3067: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3068: return;
3069: }
3070:
3071: liberation(s_etat_processus, s_objet_argument);
3072:
3073: return;
3074: }
3075:
3076:
3077: /*
3078: ================================================================================
3079: Fonction 'wfpoke'
3080: ================================================================================
3081: Entrées : pointeur sur une structure struct_processus
3082: --------------------------------------------------------------------------------
3083: Sorties :
3084: --------------------------------------------------------------------------------
3085: Effets de bord : néant
3086: ================================================================================
3087: */
3088:
3089: void
3090: instruction_wfpoke(struct_processus *s_etat_processus)
3091: {
3092: struct timespec attente;
3093:
3094: unsigned char registre_instruction_valide;
3095:
3096: (*s_etat_processus).erreur_execution = d_ex;
3097:
3098: attente.tv_sec = 0;
3099: attente.tv_nsec = GRANULARITE_us * 1000;
3100:
3101: if ((*s_etat_processus).affichage_arguments == 'Y')
3102: {
3103: printf("\n WFPOKE ");
3104:
3105: if ((*s_etat_processus).langue == 'F')
3106: {
3107: printf("(attente de données en provenance du processus père)\n\n");
3108: printf(" Aucun argument\n");
3109: }
3110: else
3111: {
3112: printf("(wait for data from parent process)\n\n");
3113: printf(" No argument\n");
3114: }
3115:
3116: return;
3117: }
3118: else if ((*s_etat_processus).test_instruction == 'Y')
3119: {
3120: (*s_etat_processus).nombre_arguments = -1;
3121: return;
3122: }
3123:
3124: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3125: {
3126: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
3127: {
3128: return;
3129: }
3130: }
3131:
3132: if ((*s_etat_processus).presence_pipes == d_faux)
3133: {
3134: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
3135: return;
3136: }
3137:
3138: if ((*s_etat_processus).nombre_objets_injectes > 0)
3139: {
3140: return;
3141: }
3142:
3143: if ((*s_etat_processus).profilage == d_vrai)
3144: {
3145: profilage(s_etat_processus, "Interprocess or interthread "
3146: "communications (WFPOKE)");
3147:
3148: if ((*s_etat_processus).erreur_systeme != d_es)
3149: {
3150: return;
3151: }
3152: }
3153:
3154: do
3155: {
3156: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
3157: {
3158: (*s_etat_processus).erreur_systeme = d_es_processus;
3159: return;
3160: }
3161:
3162: nanosleep(&attente, NULL);
3163:
3164: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
3165: {
3166: (*s_etat_processus).erreur_systeme = d_es_processus;
3167: return;
3168: }
3169:
3170: scrutation_injection(s_etat_processus);
3171:
3172: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3173: {
3174: affectation_interruptions_logicielles(s_etat_processus);
3175: }
3176:
3177: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
3178: {
3179: registre_instruction_valide =
3180: (*s_etat_processus).instruction_valide;
3181: traitement_interruptions_logicielles(s_etat_processus);
3182: (*s_etat_processus).instruction_valide =
3183: registre_instruction_valide;
3184: }
3185:
3186: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3187: {
3188: if ((*s_etat_processus).profilage == d_vrai)
3189: {
3190: profilage(s_etat_processus, NULL);
3191: }
3192:
3193: return;
3194: }
3195:
3196: INCR_GRANULARITE(attente.tv_nsec);
3197: } while((*s_etat_processus).nombre_objets_injectes == 0);
3198:
3199: return;
3200: }
3201:
3202:
3203: /*
3204: ================================================================================
3205: Fonction 'wfack'
3206: ================================================================================
3207: Entrées : pointeur sur une structure struct_processus
3208: --------------------------------------------------------------------------------
3209: Sorties :
3210: --------------------------------------------------------------------------------
3211: Effets de bord : néant
3212: ================================================================================
3213: */
3214:
3215: void
3216: instruction_wfack(struct_processus *s_etat_processus)
3217: {
3218: struct timespec attente;
3219:
3220: unsigned char registre_instruction_valide;
3221:
3222: (*s_etat_processus).erreur_execution = d_ex;
3223:
3224: attente.tv_sec = 0;
3225: attente.tv_nsec = GRANULARITE_us * 1000;
3226:
3227: if ((*s_etat_processus).affichage_arguments == 'Y')
3228: {
3229: printf("\n WFACK ");
3230:
3231: if ((*s_etat_processus).langue == 'F')
3232: {
3233: printf("(attente des acquittements de lecture)\n\n");
3234: printf(" Aucun argument\n");
3235: }
3236: else
3237: {
3238: printf("(wait for reading of data acknowledgement)\n\n");
3239: printf(" No argument\n");
3240: }
3241:
3242: return;
3243: }
3244: else if ((*s_etat_processus).test_instruction == 'Y')
3245: {
3246: (*s_etat_processus).nombre_arguments = -1;
3247: return;
3248: }
3249:
3250: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3251: {
3252: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
3253: {
3254: return;
3255: }
3256: }
3257:
3258: if ((*s_etat_processus).presence_pipes == d_faux)
3259: {
3260: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
3261: return;
3262: }
3263:
3264: if ((*s_etat_processus).profilage == d_vrai)
3265: {
3266: profilage(s_etat_processus, "Interprocess or interthread communications"
3267: " (WFACK)");
3268:
3269: if ((*s_etat_processus).erreur_systeme != d_es)
3270: {
3271: return;
3272: }
3273: }
3274:
3275: while((*s_etat_processus).nombre_objets_envoyes_non_lus != 0)
3276: {
3277: scrutation_injection(s_etat_processus);
3278:
3279: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3280: {
3281: affectation_interruptions_logicielles(s_etat_processus);
3282: }
3283:
3284: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
3285: {
3286: registre_instruction_valide =
3287: (*s_etat_processus).instruction_valide;
3288: traitement_interruptions_logicielles(s_etat_processus);
3289: (*s_etat_processus).instruction_valide =
3290: registre_instruction_valide;
3291: }
3292:
3293: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3294: {
3295: if ((*s_etat_processus).profilage == d_vrai)
3296: {
3297: profilage(s_etat_processus, NULL);
3298: }
3299:
3300: return;
3301: }
3302:
3303: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
3304: {
3305: (*s_etat_processus).erreur_systeme = d_es_processus;
3306: return;
3307: }
3308:
3309: nanosleep(&attente, NULL);
3310: INCR_GRANULARITE(attente.tv_nsec);
3311:
3312: if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
3313: {
3314: (*s_etat_processus).erreur_systeme = d_es_processus;
3315: return;
3316: }
3317: }
3318:
3319: if ((*s_etat_processus).profilage == d_vrai)
3320: {
3321: profilage(s_etat_processus, NULL);
3322: }
3323:
3324: return;
3325: }
3326:
3327: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_w1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src