1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.21
4: Copyright (C) 1989-2015 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 'r->b'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_r_vers_b(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n R->B ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(réel vers binaire)\n\n");
53: }
54: else
55: {
56: printf("(real to binary)\n\n");
57: }
58:
59: printf(" 1: %s\n", d_INT);
60: printf("-> 1: %s\n", d_BIN);
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_argument) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet_argument).type == INT)
86: {
87: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
88: {
89: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
90: return;
91: }
92:
93: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
94: {
95: (*((logical8 *) (*s_objet_resultat).objet)) = 0;
96: }
97: else
98: {
99: (*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
100: (*((integer8 *) (*s_objet_argument).objet));
101: }
102: }
103: else
104: {
105: liberation(s_etat_processus, s_objet_argument);
106:
107: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
108: return;
109: }
110:
111: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
112: s_objet_resultat) == d_erreur)
113: {
114: return;
115: }
116:
117: liberation(s_etat_processus, s_objet_argument);
118: return;
119: }
120:
121:
122: /*
123: ================================================================================
124: Fonction 'rl'
125: ================================================================================
126: Entrées : pointeur sur une structure struct_processus
127: --------------------------------------------------------------------------------
128: Sorties :
129: --------------------------------------------------------------------------------
130: Effets de bord : néant
131: ================================================================================
132: */
133:
134: void
135: instruction_rl(struct_processus *s_etat_processus)
136: {
137: logical8 masque;
138: logical8 tampon;
139:
140: struct_objet *s_copie;
141: struct_objet *s_objet;
142:
143: unsigned long i;
144: unsigned long j;
145: unsigned long longueur;
146:
147: (*s_etat_processus).erreur_execution = d_ex;
148:
149: if ((*s_etat_processus).affichage_arguments == 'Y')
150: {
151: printf("\n RL ");
152:
153: if ((*s_etat_processus).langue == 'F')
154: {
155: printf("(rotation à gauche)\n\n");
156: }
157: else
158: {
159: printf("(rotate left)\n\n");
160: }
161:
162: printf(" 1: %s\n", d_BIN);
163: printf("-> 1: %s\n", d_BIN);
164:
165: return;
166: }
167: else if ((*s_etat_processus).test_instruction == 'Y')
168: {
169: (*s_etat_processus).nombre_arguments = -1;
170: return;
171: }
172:
173: if (test_cfsf(s_etat_processus, 31) == d_vrai)
174: {
175: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
176: {
177: return;
178: }
179: }
180:
181: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
182: &s_objet) == d_erreur)
183: {
184: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
185: return;
186: }
187:
188: if ((*s_objet).type == BIN)
189: {
190: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
193: return;
194: }
195:
196: longueur = 1;
197: j = 1;
198:
199: for(i = 37; i <= 42; i++)
200: {
201: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
202: == d_vrai) ? j : 0;
203: j *= 2;
204: }
205:
206: tampon = (*((logical8 *) (*s_copie).objet));
207: masque = ((logical8) 1) << (longueur - 1);
208:
209: if ((tampon & masque) == 0)
210: {
211: tampon <<= 1;
212: }
213: else
214: {
215: tampon <<= 1;
216: tampon |= (logical8) 1;
217: }
218:
219: for(masque = 0, i = 0; i < longueur; i++)
220: {
221: masque <<= 1;
222: masque |= (logical8) 1;
223: }
224:
225: tampon &= masque;
226: (*((logical8 *) (*s_copie).objet)) = tampon;
227:
228: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
229: s_copie) == d_erreur)
230: {
231: return;
232: }
233: }
234: else
235: {
236: liberation(s_etat_processus, s_objet);
237:
238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
239: return;
240: }
241:
242: liberation(s_etat_processus, s_objet);
243:
244: return;
245: }
246:
247:
248: /*
249: ================================================================================
250: Fonction 'rlb'
251: ================================================================================
252: Entrées : pointeur sur une structure struct_processus
253: --------------------------------------------------------------------------------
254: Sorties :
255: --------------------------------------------------------------------------------
256: Effets de bord : néant
257: ================================================================================
258: */
259:
260: void
261: instruction_rlb(struct_processus *s_etat_processus)
262: {
263: struct_liste_chainee *l_base_pile;
264:
265: unsigned long i;
266:
267: (*s_etat_processus).erreur_execution = d_ex;
268:
269: if ((*s_etat_processus).affichage_arguments == 'Y')
270: {
271: printf("\n RLB ");
272:
273: if ((*s_etat_processus).langue == 'F')
274: {
275: printf("(rotation d'un octet vers la gauche)\n\n");
276: }
277: else
278: {
279: printf("(rotate left byte)\n\n");
280: }
281:
282: printf(" 1: %s\n", d_BIN);
283: printf("-> 1: %s\n", d_BIN);
284:
285: return;
286: }
287: else if ((*s_etat_processus).test_instruction == 'Y')
288: {
289: (*s_etat_processus).nombre_arguments = -1;
290: return;
291: }
292:
293: if (test_cfsf(s_etat_processus, 31) == d_vrai)
294: {
295: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
296: {
297: return;
298: }
299: }
300:
301: l_base_pile = (*s_etat_processus).l_base_pile_last;
302: (*s_etat_processus).l_base_pile_last = NULL;
303:
304: for(i = 0; i < 8; i++)
305: {
306: instruction_rl(s_etat_processus);
307:
308: if (((*s_etat_processus).erreur_systeme != d_es) ||
309: ((*s_etat_processus).erreur_execution != d_ex))
310: {
311: break;
312: }
313: }
314:
315: if (test_cfsf(s_etat_processus, 31) == d_vrai)
316: {
317: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
318: {
319: return;
320: }
321: }
322:
323: (*s_etat_processus).l_base_pile_last = l_base_pile;
324: return;
325: }
326:
327:
328: /*
329: ================================================================================
330: Fonction 'rr'
331: ================================================================================
332: Entrées : pointeur sur une structure struct_processus
333: --------------------------------------------------------------------------------
334: Sorties :
335: --------------------------------------------------------------------------------
336: Effets de bord : néant
337: ================================================================================
338: */
339:
340: void
341: instruction_rr(struct_processus *s_etat_processus)
342: {
343: logical8 masque;
344: logical8 tampon;
345:
346: struct_objet *s_copie;
347: struct_objet *s_objet;
348:
349: unsigned long i;
350: unsigned long j;
351: unsigned long longueur;
352:
353: (*s_etat_processus).erreur_execution = d_ex;
354:
355: if ((*s_etat_processus).affichage_arguments == 'Y')
356: {
357: printf("\n RR ");
358:
359: if ((*s_etat_processus).langue == 'F')
360: {
361: printf("(rotation à droite)\n\n");
362: }
363: else
364: {
365: printf("(rotate right)\n\n");
366: }
367:
368: printf(" 1: %s\n", d_BIN);
369: printf("-> 1: %s\n", d_BIN);
370:
371: return;
372: }
373: else if ((*s_etat_processus).test_instruction == 'Y')
374: {
375: (*s_etat_processus).nombre_arguments = -1;
376: return;
377: }
378:
379: if (test_cfsf(s_etat_processus, 31) == d_vrai)
380: {
381: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
382: {
383: return;
384: }
385: }
386:
387: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
388: &s_objet) == d_erreur)
389: {
390: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
391: return;
392: }
393:
394: if ((*s_objet).type == BIN)
395: {
396: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
397: {
398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
399: return;
400: }
401:
402: longueur = 1;
403: j = 1;
404:
405: for(i = 37; i <= 42; i++)
406: {
407: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
408: == d_vrai) ? j : 0;
409: j *= 2;
410: }
411:
412: tampon = (*((logical8 *) (*s_copie).objet));
413: masque = (logical8) 1;
414:
415: if ((tampon & masque) == 0)
416: {
417: tampon >>= 1;
418: }
419: else
420: {
421: tampon >>= 1;
422: tampon |= (((logical8) 1) << (longueur - 1));
423: }
424:
425: for(masque = 0, i = 0; i < longueur; i++)
426: {
427: masque <<= 1;
428: masque |= 1;
429: }
430:
431: tampon &= masque;
432: (*((logical8 *) (*s_copie).objet)) = tampon;
433:
434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
435: s_copie) == d_erreur)
436: {
437: return;
438: }
439: }
440: else
441: {
442: liberation(s_etat_processus, s_objet);
443:
444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
445: return;
446: }
447:
448: liberation(s_etat_processus, s_objet);
449:
450: return;
451: }
452:
453:
454: /*
455: ================================================================================
456: Fonction 'rrb'
457: ================================================================================
458: Entrées : pointeur sur une structure struct_processus
459: --------------------------------------------------------------------------------
460: Sorties :
461: --------------------------------------------------------------------------------
462: Effets de bord : néant
463: ================================================================================
464: */
465:
466: void
467: instruction_rrb(struct_processus *s_etat_processus)
468: {
469: struct_liste_chainee *l_base_pile;
470:
471: unsigned long i;
472:
473: (*s_etat_processus).erreur_execution = d_ex;
474:
475: if ((*s_etat_processus).affichage_arguments == 'Y')
476: {
477: printf("\n RRB ");
478:
479: if ((*s_etat_processus).langue == 'F')
480: {
481: printf("(rotation d'un octet vers la droite)\n\n");
482: }
483: else
484: {
485: printf("(rotate right byte)\n\n");
486: }
487:
488: printf(" 1: %s\n", d_BIN);
489: printf("-> 1: %s\n", d_BIN);
490:
491: return;
492: }
493: else if ((*s_etat_processus).test_instruction == 'Y')
494: {
495: (*s_etat_processus).nombre_arguments = -1;
496: return;
497: }
498:
499: if (test_cfsf(s_etat_processus, 31) == d_vrai)
500: {
501: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
502: {
503: return;
504: }
505: }
506:
507: l_base_pile = (*s_etat_processus).l_base_pile_last;
508: (*s_etat_processus).l_base_pile_last = NULL;
509:
510: for(i = 0; i < 8; i++)
511: {
512: instruction_rr(s_etat_processus);
513:
514: if (((*s_etat_processus).erreur_systeme != d_es) ||
515: ((*s_etat_processus).erreur_execution != d_ex))
516: {
517: break;
518: }
519: }
520:
521: if (test_cfsf(s_etat_processus, 31) == d_vrai)
522: {
523: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
524: {
525: return;
526: }
527: }
528:
529: (*s_etat_processus).l_base_pile_last = l_base_pile;
530: return;
531: }
532:
533:
534: /*
535: ================================================================================
536: Fonction 'redraw'
537: ================================================================================
538: Entrées : pointeur sur une structure struct_processus
539: --------------------------------------------------------------------------------
540: Sorties :
541: --------------------------------------------------------------------------------
542: Effets de bord : néant
543: ================================================================================
544: */
545:
546: void
547: instruction_redraw(struct_processus *s_etat_processus)
548: {
549: (*s_etat_processus).erreur_execution = d_ex;
550:
551: if ((*s_etat_processus).affichage_arguments == 'Y')
552: {
553: printf("\n REDRAW ");
554:
555: if ((*s_etat_processus).langue == 'F')
556: {
557: printf("(redessine une courbe)\n\n");
558: printf(" Aucun argument\n");
559: }
560: else
561: {
562: printf("(redraw a graphic)\n\n");
563: printf(" No argument\n");
564: }
565:
566: return;
567: }
568: else if ((*s_etat_processus).test_instruction == 'Y')
569: {
570: (*s_etat_processus).nombre_arguments = -1;
571: return;
572: }
573:
574: if (test_cfsf(s_etat_processus, 31) == d_vrai)
575: {
576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
577: {
578: return;
579: }
580: }
581:
582: if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai)
583: {
584: (*s_etat_processus).erreur_execution = d_ex_graphique_memorise;
585: return;
586: }
587:
588: if ((*s_etat_processus).fichiers_graphiques != NULL)
589: {
590: appel_gnuplot(s_etat_processus, 'N');
591: }
592:
593: return;
594: }
595:
596:
597: /*
598: ================================================================================
599: Fonction 'remove'
600: ================================================================================
601: Entrées : pointeur sur une structure struct_processus
602: --------------------------------------------------------------------------------
603: Sorties :
604: --------------------------------------------------------------------------------
605: Effets de bord : néant
606: ================================================================================
607: */
608:
609: void
610: instruction_remove(struct_processus *s_etat_processus)
611: {
612: struct_objet *s_objet_argument;
613:
614: (*s_etat_processus).erreur_execution = d_ex;
615:
616: if ((*s_etat_processus).affichage_arguments == 'Y')
617: {
618: printf("\n REMOVE ");
619:
620: if ((*s_etat_processus).langue == 'F')
621: {
622: printf("(retrait d'une bibliothèque dynamique)\n\n");
623: }
624: else
625: {
626: printf("(remove a shared library)\n\n");
627: }
628:
629: printf(" 1: %s\n", d_SLB);
630:
631: return;
632: }
633: else if ((*s_etat_processus).test_instruction == 'Y')
634: {
635: (*s_etat_processus).nombre_arguments = -1;
636: return;
637: }
638:
639: if (test_cfsf(s_etat_processus, 31) == d_vrai)
640: {
641: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
642: {
643: return;
644: }
645: }
646:
647: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
648: &s_objet_argument) == d_erreur)
649: {
650: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
651: return;
652: }
653:
654: if ((*s_objet_argument).type == SLB)
655: {
656: /*
657: * On ne décharge que les bibliothèques qui ont été chargées dans
658: * le couple pid/tid courant.
659: */
660:
661: if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid ==
662: getpid()) && (pthread_equal((*((struct_bibliotheque *)
663: (*s_objet_argument).objet)).tid, pthread_self()) != 0))
664: {
665: if (retrait_bibliotheque(s_etat_processus,
666: (*s_objet_argument).objet) == d_erreur)
667: {
668: liberation(s_etat_processus, s_objet_argument);
669:
670: return;
671: }
672: }
673: }
674: else
675: {
676: liberation(s_etat_processus, s_objet_argument);
677:
678: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
679: return;
680: }
681:
682: liberation(s_etat_processus, s_objet_argument);
683:
684: return;
685: }
686:
687:
688: /*
689: ================================================================================
690: Fonction 'relax'
691: ================================================================================
692: Entrées : pointeur sur une structure struct_processus
693: --------------------------------------------------------------------------------
694: Sorties :
695: --------------------------------------------------------------------------------
696: Effets de bord : néant
697: ================================================================================
698: */
699:
700: void
701: instruction_relax(struct_processus *s_etat_processus)
702: {
703: (*s_etat_processus).erreur_execution = d_ex;
704:
705: if ((*s_etat_processus).affichage_arguments == 'Y')
706: {
707: printf("\n RELAX ");
708:
709: if ((*s_etat_processus).langue == 'F')
710: {
711: printf("(ne fait rien)\n\n");
712: printf(" Aucun argument\n");
713: }
714: else
715: {
716: printf("(do nothing)\n\n");
717: printf(" No argument\n");
718: }
719:
720: return;
721: }
722: else if ((*s_etat_processus).test_instruction == 'Y')
723: {
724: (*s_etat_processus).nombre_arguments = 1;
725: return;
726: }
727:
728: /*
729: * Cette instruction ne fait rien. Elle existe pour être symétrique
730: * à l'instruction CHS et permet de traiter les équations de façon
731: * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée
732: * directement par l'utilisateur.
733: */
734:
735: return;
736: }
737:
738:
739: /*
740: ================================================================================
741: Fonction 'rewind'
742: ================================================================================
743: Entrées : pointeur sur une structure struct_processus
744: --------------------------------------------------------------------------------
745: Sorties :
746: --------------------------------------------------------------------------------
747: Effets de bord : néant
748: ================================================================================
749: */
750:
751: void
752: instruction_rewind(struct_processus *s_etat_processus)
753: {
754: struct_descripteur_fichier *descripteur;
755:
756: struct_objet *s_objet_argument;
757:
758: (*s_etat_processus).erreur_execution = d_ex;
759:
760: if ((*s_etat_processus).affichage_arguments == 'Y')
761: {
762: printf("\n REWIND ");
763:
764: if ((*s_etat_processus).langue == 'F')
765: {
766: printf("(retour au début d'un fichier)\n\n");
767: }
768: else
769: {
770: printf("(rewind a file)\n\n");
771: }
772:
773: printf(" 1: %s\n", d_FCH);
774:
775: return;
776: }
777: else if ((*s_etat_processus).test_instruction == 'Y')
778: {
779: (*s_etat_processus).nombre_arguments = -1;
780: return;
781: }
782:
783: if (test_cfsf(s_etat_processus, 31) == d_vrai)
784: {
785: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
786: {
787: return;
788: }
789: }
790:
791: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
792: &s_objet_argument) == d_erreur)
793: {
794: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
795: return;
796: }
797:
798: if ((*s_objet_argument).type == FCH)
799: {
800: if ((descripteur = descripteur_fichier(s_etat_processus,
801: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
802: {
803: return;
804: }
805:
806: if ((*descripteur).type == 'C')
807: {
808: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
809: {
810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
811: return;
812: }
813: }
814: else
815: {
816: liberation(s_etat_processus, s_objet_argument);
817:
818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
819: return;
820: }
821: }
822: else
823: {
824: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
825: return;
826: }
827:
828: liberation(s_etat_processus, s_objet_argument);
829:
830: return;
831: }
832:
833:
834: /*
835: ================================================================================
836: Fonction 'read'
837: ================================================================================
838: Entrées : pointeur sur une structure struct_processus
839: --------------------------------------------------------------------------------
840: Sorties :
841: --------------------------------------------------------------------------------
842: Effets de bord : néant
843: ================================================================================
844: */
845:
846: void
847: instruction_read(struct_processus *s_etat_processus)
848: {
849: const char *queue;
850:
851: int c;
852: int ios;
853: int timeout;
854:
855: integer8 element;
856: integer8 i;
857: integer8 id;
858: integer8 index;
859: integer8 longueur;
860: integer8 position_clef;
861:
862: integer8 longueur_effective;
863: integer8 longueur_enregistrement;
864: integer8 longueur_questure;
865: integer8 niveau;
866: integer8 pointeur;
867: integer8 position_finale;
868: integer8 position_initiale;
869:
870: logical1 device;
871: logical1 format_degenere;
872: logical1 indicateur_48;
873: logical1 presence_chaine;
874: logical1 presence_indicateur;
875: logical1 trame_complete;
876:
877: socklen_t longueur_adresse;
878:
879: sqlite3_stmt *ppStmt;
880:
881: struct flock lock;
882:
883: struct pollfd fds[1];
884:
885: struct sockaddr_un adresse_unix;
886: struct sockaddr_in adresse_ipv4;
887: # ifdef IPV6
888: struct sockaddr_in6 adresse_ipv6;
889: # endif
890:
891: struct termios tc;
892:
893: struct timespec attente;
894:
895: struct_descripteur_fichier *descripteur;
896:
897: struct_liste_chainee *l_element_courant;
898: struct_liste_chainee *l_element_courant_format;
899: struct_liste_chainee *l_element_inclus;
900:
901: struct_objet *s_objet_adresse;
902: struct_objet *s_objet_argument_1;
903: struct_objet *s_objet_argument_2;
904: struct_objet *s_objet_resultat;
905: struct_objet *s_objet_type;
906:
907: unsigned char caractere;
908: unsigned char *clef_utf8;
909: unsigned char *commande;
910: unsigned char *format_chaine;
911: unsigned char *ptr;
912: unsigned char *tampon_lecture;
913: unsigned char *tampon;
914: unsigned char *tampon2;
915: unsigned char *tampon3;
916:
917: int vitesses[] =
918: {
919: 50, 75, 110, 134, 150, 200, 300, 600,
920: 1200, 1800, 2400, 4800, 9600, 19200, 38400,
921: #ifdef B57600
922: 57600,
923: #endif
924: #ifdef B115200
925: 115200,
926: #endif
927: #ifdef B230400
928: 230400,
929: #endif
930: 0
931: };
932:
933: tcflag_t vitesses_constantes[] =
934: {
935: B50, B75, B110, B134, B150, B200, B300, B600,
936: B1200, B1800, B2400, B4800, B9600, B19200, B38400,
937: #ifdef B57600
938: B57600,
939: #endif
940: #ifdef B115200
941: B115200,
942: #endif
943: #ifdef B230400
944: B230400,
945: #endif
946: 0
947: };
948:
949: (*s_etat_processus).erreur_execution = d_ex;
950:
951: if ((*s_etat_processus).affichage_arguments == 'Y')
952: {
953: printf("\n READ ");
954:
955: if ((*s_etat_processus).langue == 'F')
956: {
957: printf("(lecture d'un enregistrement d'un fichier)\n\n");
958: }
959: else
960: {
961: printf("(read a record of a file)\n\n");
962: }
963:
964: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
965:
966: printf(" 2: %s, %s\n", d_INT, d_CHN);
967: printf(" 1: %s\n", d_FCH);
968: return;
969: }
970: else if ((*s_etat_processus).test_instruction == 'Y')
971: {
972: (*s_etat_processus).nombre_arguments = -1;
973: return;
974: }
975:
976: if (test_cfsf(s_etat_processus, 31) == d_vrai)
977: {
978: if ((*s_etat_processus).l_base_pile == NULL)
979: {
980: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
981: return;
982: }
983:
984: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
985: {
986: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
987: .donnee).objet)).acces == 'S')
988: {
989: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
990: {
991: return;
992: }
993: }
994: else
995: {
996: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
997: {
998: return;
999: }
1000: }
1001: }
1002: else
1003: {
1004: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1005: {
1006: return;
1007: }
1008: }
1009: }
1010:
1011: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1012: &s_objet_argument_1) == d_erreur)
1013: {
1014: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1015: return;
1016: }
1017:
1018: if ((*s_objet_argument_1).type == FCH)
1019: {
1020: if ((descripteur = descripteur_fichier(s_etat_processus,
1021: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
1022: {
1023: return;
1024: }
1025:
1026: /*
1027: * Vérification des verrous
1028: */
1029:
1030: lock.l_type = F_RDLCK;
1031: lock.l_whence = SEEK_SET;
1032: lock.l_start = 0;
1033: lock.l_len = 0;
1034: lock.l_pid = getpid();
1035:
1036: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
1037: == -1)
1038: {
1039: liberation(s_etat_processus, s_objet_argument_1);
1040:
1041: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1042: return;
1043: }
1044:
1045: if (lock.l_type != F_UNLCK)
1046: {
1047: liberation(s_etat_processus, s_objet_argument_1);
1048:
1049: (*s_etat_processus).erreur_execution =
1050: d_ex_fichier_verrouille;
1051: return;
1052: }
1053:
1054: /*
1055: * Vérification de l'autorisation de lecture
1056: */
1057:
1058: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1059: == 'W')
1060: {
1061: liberation(s_etat_processus, s_objet_argument_1);
1062:
1063: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1064: return;
1065: }
1066: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1067: == 'N')
1068: {
1069: if ((*descripteur).type == 'C')
1070: {
1071: if (fflush((*descripteur).descripteur_c) != 0)
1072: {
1073: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1074: return;
1075: }
1076: }
1077: }
1078:
1079: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1080: {
1081: /*
1082: * Fichiers formatés
1083: */
1084:
1085: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1086: == 'S')
1087: {
1088: /*
1089: * Fichiers séquentiels
1090: */
1091:
1092: longueur_questure = 4096;
1093:
1094: if ((tampon_lecture = malloc(((size_t) longueur_questure) *
1095: sizeof(unsigned char))) == NULL)
1096: {
1097: (*s_etat_processus).erreur_systeme =
1098: d_es_allocation_memoire;
1099: return;
1100: }
1101:
1102: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1103:
1104: if ((position_initiale = ftell((*descripteur).descripteur_c))
1105: == -1)
1106: {
1107: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1108: return;
1109: }
1110:
1111: do
1112: {
1113: longueur_effective = (integer8) fread(tampon_lecture,
1114: sizeof(unsigned char), (size_t) longueur_questure,
1115: (*descripteur).descripteur_c);
1116:
1117: pointeur = 0;
1118: presence_indicateur = d_faux;
1119:
1120: while(pointeur < longueur_effective)
1121: {
1122: if (tampon_lecture[pointeur] == '{')
1123: {
1124: presence_indicateur = d_vrai;
1125: break;
1126: }
1127:
1128: position_initiale++;
1129: pointeur++;
1130: }
1131:
1132: if (presence_indicateur == d_vrai)
1133: {
1134: break;
1135: }
1136: } while(longueur_effective == longueur_questure);
1137:
1138: if (presence_indicateur == d_faux)
1139: {
1140: liberation(s_etat_processus, s_objet_argument_1);
1141: free(tampon_lecture);
1142:
1143: (*s_etat_processus).erreur_execution =
1144: d_ex_fin_de_fichier_atteinte;
1145: return;
1146: }
1147:
1148: position_finale = position_initiale + 1;
1149: presence_chaine = d_faux;
1150: niveau = 1;
1151:
1152: if (fseek((*descripteur).descripteur_c, (long) position_finale,
1153: SEEK_SET) != 0)
1154: {
1155: liberation(s_etat_processus, s_objet_argument_1);
1156: free(tampon_lecture);
1157:
1158: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1159: return;
1160: }
1161:
1162: do
1163: {
1164: longueur_effective = (integer8) fread(tampon_lecture,
1165: sizeof(unsigned char), (size_t) longueur_questure,
1166: (*descripteur).descripteur_c);
1167:
1168: pointeur = 0;
1169: presence_indicateur = d_faux;
1170:
1171: while(pointeur < longueur_effective)
1172: {
1173: if (tampon_lecture[pointeur] == '"')
1174: {
1175: if (pointeur > 0)
1176: {
1177: if (tampon_lecture[pointeur - 1] != '\\')
1178: {
1179: presence_chaine = (presence_chaine ==
1180: d_vrai) ? d_faux : d_vrai;
1181: }
1182: }
1183: else
1184: {
1185: presence_chaine = (presence_chaine == d_vrai)
1186: ? d_faux : d_vrai;
1187: }
1188: }
1189: else
1190: {
1191: if (presence_chaine == d_faux)
1192: {
1193: if (tampon_lecture[pointeur] == '{')
1194: {
1195: niveau++;
1196: }
1197: else if (tampon_lecture[pointeur] == '}')
1198: {
1199: niveau--;
1200: }
1201: }
1202: }
1203:
1204: position_finale++;
1205: pointeur++;
1206:
1207: if (niveau == 0)
1208: {
1209: presence_indicateur = d_vrai;
1210: break;
1211: }
1212: }
1213:
1214: if (presence_indicateur == d_vrai)
1215: {
1216: break;
1217: }
1218: } while(longueur_effective == longueur_questure);
1219:
1220: if (presence_indicateur == d_faux)
1221: {
1222: liberation(s_etat_processus, s_objet_argument_1);
1223: free(tampon_lecture);
1224:
1225: (*s_etat_processus).erreur_execution =
1226: d_ex_fin_de_fichier_atteinte;
1227: return;
1228: }
1229:
1230: free(tampon_lecture);
1231: longueur_enregistrement = position_finale - position_initiale;
1232:
1233: if ((tampon_lecture = malloc(((size_t)
1234: (longueur_enregistrement + 1)) *
1235: sizeof(unsigned char))) == NULL)
1236: {
1237: (*s_etat_processus).erreur_systeme =
1238: d_es_allocation_memoire;
1239: return;
1240: }
1241:
1242: if (fseek((*descripteur).descripteur_c,
1243: (long) position_initiale, SEEK_SET) != 0)
1244: {
1245: liberation(s_etat_processus, s_objet_argument_1);
1246: free(tampon_lecture);
1247:
1248: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1249: return;
1250: }
1251:
1252: longueur_effective = (integer8) fread(tampon_lecture,
1253: sizeof(unsigned char), (size_t) longueur_enregistrement,
1254: (*descripteur).descripteur_c);
1255:
1256: if (longueur_effective != longueur_enregistrement)
1257: {
1258: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1259: return;
1260: }
1261:
1262: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1263: tampon = (*s_etat_processus).instruction_courante;
1264:
1265: if (((*s_etat_processus).instruction_courante =
1266: transliteration(s_etat_processus, tampon_lecture,
1267: "UTF-8", d_locale)) == NULL)
1268: {
1269: (*s_etat_processus).instruction_courante = tampon;
1270: liberation(s_etat_processus, s_objet_argument_1);
1271: free(tampon_lecture);
1272: return;
1273: }
1274:
1275: indicateur_48 = test_cfsf(s_etat_processus, 48);
1276: cf(s_etat_processus, 48);
1277:
1278: (*s_etat_processus).type_en_cours = NON;
1279: recherche_type(s_etat_processus);
1280: free((*s_etat_processus).instruction_courante);
1281:
1282: if ((*s_etat_processus).erreur_execution != d_ex)
1283: {
1284: if (indicateur_48 == d_vrai)
1285: {
1286: sf(s_etat_processus, 48);
1287: }
1288: else
1289: {
1290: cf(s_etat_processus, 48);
1291: }
1292:
1293: (*s_etat_processus).instruction_courante = tampon;
1294: free(tampon_lecture);
1295:
1296: liberation(s_etat_processus, s_objet_argument_1);
1297: return;
1298: }
1299:
1300: if (indicateur_48 == d_vrai)
1301: {
1302: sf(s_etat_processus, 48);
1303: }
1304: else
1305: {
1306: cf(s_etat_processus, 48);
1307: }
1308:
1309: (*s_etat_processus).instruction_courante = tampon;
1310: free(tampon_lecture);
1311: }
1312: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1313: == 'D')
1314: {
1315: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1316:
1317: if (depilement(s_etat_processus, &((*s_etat_processus)
1318: .l_base_pile), &s_objet_argument_2) == d_erreur)
1319: {
1320: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1321: return;
1322: }
1323:
1324: if ((*s_objet_argument_2).type != INT)
1325: {
1326: liberation(s_etat_processus, s_objet_argument_1);
1327: liberation(s_etat_processus, s_objet_argument_2);
1328:
1329: (*s_etat_processus).erreur_execution =
1330: d_ex_erreur_type_argument;
1331: return;
1332: }
1333:
1334: if (alsprintf(s_etat_processus, &commande,
1335: "select data from data where id = %lld",
1336: (*((integer8 *) (*s_objet_argument_2).objet))) < 0)
1337: {
1338: (*s_etat_processus).erreur_systeme =
1339: d_es_allocation_memoire;
1340: return;
1341: }
1342:
1343: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1344: commande, (int) strlen(commande), &ppStmt, &queue)
1345: != SQLITE_OK)
1346: {
1347: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1348: return;
1349: }
1350:
1351: attente.tv_sec = 0;
1352: attente.tv_nsec = GRANULARITE_us * 1000;
1353:
1354: do
1355: {
1356: ios = sqlite3_step(ppStmt);
1357:
1358: switch(ios)
1359: {
1360: case SQLITE_ROW:
1361: {
1362: // Résultat attendu
1363: break;
1364: }
1365:
1366: case SQLITE_DONE:
1367: {
1368: // Aucun enregistrement
1369: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1370: {
1371: (*s_etat_processus).erreur_systeme =
1372: d_es_erreur_fichier;
1373: return;
1374: }
1375:
1376: free(commande);
1377:
1378: liberation(s_etat_processus, s_objet_argument_1);
1379: liberation(s_etat_processus, s_objet_argument_2);
1380:
1381: (*s_etat_processus).erreur_execution =
1382: d_ex_enregistrement_inexistant;
1383: return;
1384: }
1385:
1386: case SQLITE_BUSY:
1387: case SQLITE_LOCKED:
1388: {
1389: nanosleep(&attente, NULL);
1390: INCR_GRANULARITE(attente.tv_nsec);
1391: break;
1392: }
1393:
1394: default:
1395: {
1396: (*s_etat_processus).erreur_systeme =
1397: d_es_erreur_fichier;
1398: return;
1399: }
1400: }
1401: } while(ios != SQLITE_ROW);
1402:
1403: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1404: {
1405: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1406: return;
1407: }
1408:
1409: tampon = (*s_etat_processus).instruction_courante;
1410:
1411: if ((tampon_lecture = (unsigned char *)
1412: sqlite3_column_text(ppStmt, 0)) == NULL)
1413: {
1414: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1415: return;
1416: }
1417:
1418: if (((*s_etat_processus).instruction_courante =
1419: transliteration(s_etat_processus, tampon_lecture,
1420: "UTF-8", d_locale)) == NULL)
1421: {
1422: (*s_etat_processus).instruction_courante = tampon;
1423:
1424: liberation(s_etat_processus, s_objet_argument_1);
1425: liberation(s_etat_processus, s_objet_argument_2);
1426: free(commande);
1427: return;
1428: }
1429:
1430: indicateur_48 = test_cfsf(s_etat_processus, 48);
1431: cf(s_etat_processus, 48);
1432:
1433: (*s_etat_processus).type_en_cours = NON;
1434: recherche_type(s_etat_processus);
1435:
1436: if ((*s_etat_processus).erreur_execution != d_ex)
1437: {
1438: if (indicateur_48 == d_vrai)
1439: {
1440: sf(s_etat_processus, 48);
1441: }
1442: else
1443: {
1444: cf(s_etat_processus, 48);
1445: }
1446:
1447: liberation(s_etat_processus, s_objet_argument_1);
1448: liberation(s_etat_processus, s_objet_argument_2);
1449:
1450: free((*s_etat_processus).instruction_courante);
1451: free(commande);
1452:
1453: (*s_etat_processus).instruction_courante = tampon;
1454: return;
1455: }
1456:
1457: if (indicateur_48 == d_vrai)
1458: {
1459: sf(s_etat_processus, 48);
1460: }
1461: else
1462: {
1463: cf(s_etat_processus, 48);
1464: }
1465:
1466: free((*s_etat_processus).instruction_courante);
1467: liberation(s_etat_processus, s_objet_argument_2);
1468: (*s_etat_processus).instruction_courante = tampon;
1469:
1470: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1471: {
1472: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1473: return;
1474: }
1475:
1476: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1477: {
1478: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1479: return;
1480: }
1481:
1482: free(commande);
1483: }
1484: else
1485: {
1486: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1487:
1488: if (depilement(s_etat_processus, &((*s_etat_processus)
1489: .l_base_pile), &s_objet_argument_2) == d_erreur)
1490: {
1491: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1492: return;
1493: }
1494:
1495: if ((*s_objet_argument_2).type != CHN)
1496: {
1497: liberation(s_etat_processus, s_objet_argument_1);
1498: liberation(s_etat_processus, s_objet_argument_2);
1499:
1500: (*s_etat_processus).erreur_execution =
1501: d_ex_erreur_type_argument;
1502: return;
1503: }
1504:
1505: // Récupération de la position de la clef
1506:
1507: if (alsprintf(s_etat_processus, &commande,
1508: "select key from control where id = 1") < 0)
1509: {
1510: (*s_etat_processus).erreur_systeme =
1511: d_es_allocation_memoire;
1512: return;
1513: }
1514:
1515: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1516: commande, (int) strlen(commande), &ppStmt, &queue)
1517: != SQLITE_OK)
1518: {
1519: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1520: return;
1521: }
1522:
1523: attente.tv_sec = 0;
1524: attente.tv_nsec = GRANULARITE_us * 1000;
1525:
1526: do
1527: {
1528: ios = sqlite3_step(ppStmt);
1529:
1530: if (ios == SQLITE_ROW)
1531: {
1532: break;
1533: }
1534: else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
1535: {
1536: nanosleep(&attente, NULL);
1537: INCR_GRANULARITE(attente.tv_nsec);
1538: }
1539: else
1540: {
1541: (*s_etat_processus).erreur_systeme =
1542: d_es_erreur_fichier;
1543: return;
1544: }
1545: } while(ios != SQLITE_ROW);
1546:
1547: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1548: {
1549: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1550: return;
1551: }
1552:
1553: position_clef = sqlite3_column_int64(ppStmt, 0);
1554:
1555: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1556: {
1557: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1558: return;
1559: }
1560:
1561: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1562: {
1563: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1564: return;
1565: }
1566:
1567: free(commande);
1568:
1569: if ((clef_utf8 = transliteration(s_etat_processus,
1570: (unsigned char *) (*s_objet_argument_2).objet,
1571: d_locale, "UTF-8")) == NULL)
1572: {
1573: liberation(s_etat_processus, s_objet_argument_1);
1574: liberation(s_etat_processus, s_objet_argument_2);
1575:
1576: return;
1577: }
1578:
1579: // Récupération de l'identifiant de la clef
1580:
1581: if (alsprintf(s_etat_processus, &commande,
1582: "select id from key where key = '{ \"%s\" }'",
1583: clef_utf8) < 0)
1584: {
1585: (*s_etat_processus).erreur_systeme =
1586: d_es_allocation_memoire;
1587: return;
1588: }
1589:
1590: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1591: commande, (int) strlen(commande), &ppStmt, &queue)
1592: != SQLITE_OK)
1593: {
1594: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1595: return;
1596: }
1597:
1598: attente.tv_sec = 0;
1599: attente.tv_nsec = GRANULARITE_us * 1000;
1600:
1601: do
1602: {
1603: ios = sqlite3_step(ppStmt);
1604:
1605: switch(ios)
1606: {
1607: case SQLITE_ROW:
1608: {
1609: // Résultat attendu : une clef correspond.
1610: break;
1611: }
1612:
1613: case SQLITE_DONE:
1614: {
1615: // Aucun enregistrement
1616: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1617: {
1618: (*s_etat_processus).erreur_systeme =
1619: d_es_erreur_fichier;
1620: return;
1621: }
1622:
1623: free(clef_utf8);
1624: free(commande);
1625:
1626: liberation(s_etat_processus, s_objet_argument_1);
1627: liberation(s_etat_processus, s_objet_argument_2);
1628:
1629: (*s_etat_processus).erreur_execution =
1630: d_ex_enregistrement_inexistant;
1631: return;
1632: }
1633:
1634: case SQLITE_BUSY:
1635: case SQLITE_LOCKED:
1636: {
1637: nanosleep(&attente, NULL);
1638: INCR_GRANULARITE(attente.tv_nsec);
1639: break;
1640: }
1641:
1642: default:
1643: {
1644: (*s_etat_processus).erreur_systeme =
1645: d_es_erreur_fichier;
1646: return;
1647: }
1648: }
1649: } while(ios != SQLITE_ROW);
1650:
1651: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1652: {
1653: free(clef_utf8);
1654: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1655: return;
1656: }
1657:
1658: id = sqlite3_column_int64(ppStmt, 0);
1659:
1660: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1661: {
1662: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1663: return;
1664: }
1665:
1666: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1667: {
1668: (*s_etat_processus).erreur_systeme =
1669: d_es_erreur_fichier;
1670: return;
1671: }
1672:
1673: free(commande);
1674:
1675: if (alsprintf(s_etat_processus, &commande,
1676: "select data from data where "
1677: "key_id = %lld order by sequence asc", id) < 0)
1678: {
1679: (*s_etat_processus).erreur_systeme =
1680: d_es_allocation_memoire;
1681: return;
1682: }
1683:
1684: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1685: commande, (int) strlen(commande), &ppStmt, &queue)
1686: != SQLITE_OK)
1687: {
1688: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1689: return;
1690: }
1691:
1692: element = 1;
1693:
1694: attente.tv_sec = 0;
1695: attente.tv_nsec = GRANULARITE_us * 1000;
1696:
1697: do
1698: {
1699: switch(ios = sqlite3_step(ppStmt))
1700: {
1701: case SQLITE_ROW:
1702: {
1703: // Donnée supplémentaire
1704:
1705: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1706: {
1707: (*s_etat_processus).erreur_systeme =
1708: d_es_erreur_fichier;
1709: return;
1710: }
1711:
1712: tampon = (*s_etat_processus).instruction_courante;
1713:
1714: if ((tampon_lecture = (unsigned char *)
1715: sqlite3_column_text(ppStmt, 0)) == NULL)
1716: {
1717: (*s_etat_processus).erreur_systeme =
1718: d_es_erreur_fichier;
1719: return;
1720: }
1721:
1722: if (((*s_etat_processus).instruction_courante =
1723: transliteration(s_etat_processus,
1724: tampon_lecture,
1725: "UTF-8", d_locale)) == NULL)
1726: {
1727: (*s_etat_processus).instruction_courante =
1728: tampon;
1729:
1730: liberation(s_etat_processus,
1731: s_objet_argument_1);
1732: liberation(s_etat_processus,
1733: s_objet_argument_2);
1734:
1735: free(commande);
1736: free(clef_utf8);
1737: return;
1738: }
1739:
1740: indicateur_48 = test_cfsf(s_etat_processus, 48);
1741: cf(s_etat_processus, 48);
1742:
1743: (*s_etat_processus).type_en_cours = NON;
1744: recherche_type(s_etat_processus);
1745:
1746: if ((*s_etat_processus).erreur_execution != d_ex)
1747: {
1748: if (indicateur_48 == d_vrai)
1749: {
1750: sf(s_etat_processus, 48);
1751: }
1752: else
1753: {
1754: cf(s_etat_processus, 48);
1755: }
1756:
1757: liberation(s_etat_processus,
1758: s_objet_argument_1);
1759: liberation(s_etat_processus,
1760: s_objet_argument_2);
1761:
1762: free((*s_etat_processus).instruction_courante);
1763: free(commande);
1764: free(clef_utf8);
1765:
1766: (*s_etat_processus).instruction_courante =
1767: tampon;
1768: return;
1769: }
1770:
1771: if (indicateur_48 == d_vrai)
1772: {
1773: sf(s_etat_processus, 48);
1774: }
1775: else
1776: {
1777: cf(s_etat_processus, 48);
1778: }
1779:
1780: free((*s_etat_processus).instruction_courante);
1781: (*s_etat_processus).instruction_courante = tampon;
1782:
1783: element++;
1784:
1785: // Inscription de la clef
1786:
1787: if (element == position_clef)
1788: {
1789: if (((*s_etat_processus).instruction_courante =
1790: transliteration(s_etat_processus,
1791: clef_utf8, "UTF-8", d_locale)) == NULL)
1792: {
1793: (*s_etat_processus).instruction_courante =
1794: tampon;
1795:
1796: liberation(s_etat_processus,
1797: s_objet_argument_1);
1798: liberation(s_etat_processus,
1799: s_objet_argument_2);
1800:
1801: free(commande);
1802: free(clef_utf8);
1803: return;
1804: }
1805:
1806: if (alsprintf(s_etat_processus, &tampon2,
1807: "{ \"%s\" }", (*s_etat_processus)
1808: .instruction_courante) < 0)
1809: {
1810: (*s_etat_processus).erreur_systeme =
1811: d_es_allocation_memoire;
1812: return;
1813: }
1814:
1815: free((*s_etat_processus).instruction_courante);
1816: (*s_etat_processus).instruction_courante
1817: = tampon2;
1818:
1819: indicateur_48 = test_cfsf(s_etat_processus, 48);
1820: cf(s_etat_processus, 48);
1821:
1822: (*s_etat_processus).type_en_cours = NON;
1823: recherche_type(s_etat_processus);
1824:
1825: if ((*s_etat_processus).erreur_execution
1826: != d_ex)
1827: {
1828: if (indicateur_48 == d_vrai)
1829: {
1830: sf(s_etat_processus, 48);
1831: }
1832: else
1833: {
1834: cf(s_etat_processus, 48);
1835: }
1836:
1837: liberation(s_etat_processus,
1838: s_objet_argument_1);
1839: liberation(s_etat_processus,
1840: s_objet_argument_2);
1841:
1842: free((*s_etat_processus)
1843: .instruction_courante);
1844: free(commande);
1845: free(clef_utf8);
1846:
1847: (*s_etat_processus).instruction_courante =
1848: tampon;
1849: return;
1850: }
1851:
1852: if (indicateur_48 == d_vrai)
1853: {
1854: sf(s_etat_processus, 48);
1855: }
1856: else
1857: {
1858: cf(s_etat_processus, 48);
1859: }
1860:
1861: free((*s_etat_processus).instruction_courante);
1862: (*s_etat_processus).instruction_courante =
1863: tampon;
1864:
1865: element++;
1866: }
1867:
1868: break;
1869: }
1870:
1871: case SQLITE_DONE:
1872: {
1873: // Fin de la liste
1874: break;
1875: }
1876:
1877: case SQLITE_BUSY:
1878: case SQLITE_LOCKED:
1879: {
1880: nanosleep(&attente, NULL);
1881: INCR_GRANULARITE(attente.tv_nsec);
1882: break;
1883: }
1884:
1885: default:
1886: {
1887: (*s_etat_processus).erreur_systeme =
1888: d_es_erreur_fichier;
1889: return;
1890: }
1891: }
1892: } while(ios != SQLITE_DONE);
1893:
1894: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1895: {
1896: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1897: return;
1898: }
1899:
1900: free(commande);
1901: free(clef_utf8);
1902:
1903: liberation(s_etat_processus, s_objet_argument_2);
1904:
1905: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1906: == NULL)
1907: {
1908: (*s_etat_processus).erreur_systeme =
1909: d_es_allocation_memoire;
1910: return;
1911: }
1912:
1913: l_element_courant = NULL;
1914: l_element_inclus = NULL;
1915:
1916: for(element--; element > 0; element--)
1917: {
1918: if (depilement(s_etat_processus, &((*s_etat_processus)
1919: .l_base_pile), &s_objet_argument_2) == d_erreur)
1920: {
1921: (*s_etat_processus).erreur_systeme =
1922: d_es_erreur_fichier;
1923: return;
1924: }
1925:
1926: if ((*s_objet_argument_2).type != LST)
1927: {
1928: (*s_etat_processus).erreur_systeme =
1929: d_es_erreur_fichier;
1930: return;
1931: }
1932:
1933: l_element_inclus = (*s_objet_argument_2).objet;
1934:
1935: if (l_element_inclus != NULL)
1936: {
1937: while(l_element_inclus != NULL)
1938: {
1939: if ((*l_element_inclus).suivant == NULL)
1940: {
1941: (*l_element_inclus).suivant = l_element_courant;
1942: break;
1943: }
1944:
1945: l_element_inclus = (*l_element_inclus).suivant;
1946: }
1947:
1948: l_element_courant = (*s_objet_argument_2).objet;
1949: (*s_objet_argument_2).objet = NULL;
1950: }
1951:
1952: liberation(s_etat_processus, s_objet_argument_2);
1953: }
1954:
1955: (*s_objet_resultat).objet = l_element_inclus;
1956:
1957: if (empilement(s_etat_processus,
1958: &((*s_etat_processus).l_base_pile),
1959: s_objet_resultat) == d_erreur)
1960: {
1961: return;
1962: }
1963: }
1964: }
1965: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1966: == 'Y')
1967: {
1968: /*
1969: * Fichiers non formatés
1970: */
1971:
1972: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1973: == 'S')
1974: {
1975: /*
1976: * Fichiers séquentiels
1977: *
1978: * Les fichiers séquentiels non formatés contiennent comme
1979: * les fichiers séquentiels formatés leurs enregistrements
1980: * sous la forme de listes les unes derrières les autres.
1981: *
1982: * Le quartet de poids fort du premier octet à lire
1983: * doit donc être égal à 0100. Si ce n'est pas le cas,
1984: * il sera impossible de lire le fichier et on renvoie
1985: * immédiatement une erreur. Si on lit dans le fichier
1986: * la valeur attendue, on récupère la longueur en octet
1987: * de l'enregistrement puis on le lit.
1988: */
1989:
1990: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1991:
1992: if ((s_objet_resultat = lecture_fichier_non_formate(
1993: s_etat_processus, (*descripteur).descripteur_c, -1,
1994: d_faux)) == NULL)
1995: {
1996: return;
1997: }
1998:
1999: if (empilement(s_etat_processus,
2000: &((*s_etat_processus).l_base_pile),
2001: s_objet_resultat) == d_erreur)
2002: {
2003: return;
2004: }
2005: }
2006: }
2007: else
2008: {
2009: /*
2010: * Fichiers de type FLOW
2011: */
2012:
2013: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
2014: == 'S')
2015: {
2016: /*
2017: * Fichiers séquentiels
2018: */
2019:
2020: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
2021: longueur_enregistrement = 0;
2022:
2023: device = d_faux;
2024:
2025: if ((position_initiale = ftell((*descripteur).descripteur_c))
2026: == -1)
2027: {
2028: if (errno == ESPIPE)
2029: {
2030: device = d_vrai;
2031: }
2032: else
2033: {
2034: (*s_etat_processus).erreur_systeme =
2035: d_es_erreur_fichier;
2036: return;
2037: }
2038: }
2039:
2040: l_element_courant_format = (struct_liste_chainee *)
2041: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
2042: .format).objet;
2043: l_element_courant = NULL;
2044:
2045: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2046: == NULL)
2047: {
2048: (*s_etat_processus).erreur_systeme =
2049: d_es_allocation_memoire;
2050: return;
2051: }
2052:
2053: while(l_element_courant_format != NULL)
2054: {
2055: if ((*(*l_element_courant_format).donnee).type != CHN)
2056: {
2057: liberation(s_etat_processus, s_objet_argument_1);
2058: liberation(s_etat_processus, s_objet_resultat);
2059:
2060: (*s_etat_processus).erreur_execution =
2061: d_ex_erreur_type_argument;
2062: return;
2063: }
2064:
2065: if ((format_chaine = conversion_majuscule(
2066: s_etat_processus, (unsigned char *)
2067: (*(*l_element_courant_format).donnee).objet))
2068: == NULL)
2069: {
2070: (*s_etat_processus).erreur_systeme =
2071: d_es_allocation_memoire;
2072: return;
2073: }
2074:
2075: if (strncmp("LENGTH*(", format_chaine, 8) != 0)
2076: {
2077: liberation(s_etat_processus, s_objet_argument_1);
2078: liberation(s_etat_processus, s_objet_resultat);
2079: free(format_chaine);
2080:
2081: (*s_etat_processus).erreur_execution =
2082: d_ex_erreur_format_fichier;
2083: return;
2084: }
2085:
2086: longueur = (integer8) strlen(format_chaine);
2087:
2088: if (format_chaine[longueur - 1] != ')')
2089: {
2090: liberation(s_etat_processus, s_objet_argument_1);
2091: liberation(s_etat_processus, s_objet_resultat);
2092: free(format_chaine);
2093:
2094: (*s_etat_processus).erreur_execution =
2095: d_ex_erreur_format_fichier;
2096: return;
2097: }
2098:
2099: format_chaine[longueur] = d_code_fin_chaine;
2100:
2101: if (format_chaine[8] == '*')
2102: {
2103: format_degenere = d_vrai;
2104: }
2105: else
2106: {
2107: // Détermination de la longueur
2108: format_degenere = d_faux;
2109:
2110: if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
2111: {
2112: liberation(s_etat_processus, s_objet_argument_1);
2113: liberation(s_etat_processus, s_objet_resultat);
2114: free(format_chaine);
2115:
2116: (*s_etat_processus).erreur_execution =
2117: d_ex_erreur_format_fichier;
2118: return;
2119: }
2120: }
2121:
2122: free(format_chaine);
2123: tampon3 = NULL;
2124:
2125: if (format_degenere == d_vrai)
2126: {
2127: if (device == d_vrai)
2128: {
2129: longueur_questure = 4096;
2130: index = 0;
2131:
2132: if ((tampon3 = malloc(((size_t) longueur_questure) *
2133: sizeof(unsigned char))) == NULL)
2134: {
2135: (*s_etat_processus).erreur_systeme =
2136: d_es_allocation_memoire;
2137: return;
2138: }
2139:
2140: tampon3[index] = d_code_fin_chaine;
2141:
2142: fds[0].fd = fileno((*descripteur).descripteur_c);
2143: fds[0].events = POLLIN;
2144: fds[0].revents = 0;
2145:
2146: tcgetattr(fileno((*descripteur).descripteur_c),
2147: &tc);
2148: timeout = 0;
2149:
2150: for(i = 0; vitesses[i] != 0; i++)
2151: {
2152: if (cfgetispeed(&tc) == vitesses_constantes[i])
2153: {
2154: // La durée entre deux caractères sur le
2155: // périphérique série ne doit pas dépasser
2156: // la moitié de la durée de transmission
2157: // d'un caractère complet.
2158:
2159: timeout = (int) (((double) 1000) /
2160: (((double) vitesses_constantes[i]) /
2161: 4));
2162: break;
2163: }
2164: }
2165: }
2166:
2167: do
2168: {
2169: if (device == d_vrai)
2170: {
2171: if (poll(fds, 1, timeout) == 0)
2172: {
2173: break;
2174: }
2175: }
2176:
2177: c = getc((*descripteur).descripteur_c);
2178: longueur_enregistrement++;
2179:
2180: if (device == d_vrai)
2181: {
2182: if (longueur_enregistrement >=
2183: longueur_questure)
2184: {
2185: if ((tampon3 = realloc(tampon3,
2186: (size_t) (longueur_questure *= 2)))
2187: == NULL)
2188: {
2189: (*s_etat_processus).erreur_systeme =
2190: d_es_allocation_memoire;
2191: return;
2192: }
2193: }
2194:
2195: tampon3[index++] = (unsigned char) c;
2196: }
2197: } while(c != EOF);
2198:
2199: if (device == d_faux)
2200: {
2201: if (fseek((*descripteur).descripteur_c,
2202: (long) position_initiale, SEEK_SET) != 0)
2203: {
2204: liberation(s_etat_processus,
2205: s_objet_argument_1);
2206: liberation(s_etat_processus, s_objet_resultat);
2207:
2208: (*s_etat_processus).erreur_systeme =
2209: d_es_erreur_fichier;
2210: return;
2211: }
2212: }
2213: }
2214: else
2215: {
2216: longueur_enregistrement = longueur;
2217: }
2218:
2219: if ((device == d_vrai) && (format_degenere == d_vrai))
2220: {
2221: longueur_effective = longueur_enregistrement;
2222: tampon_lecture = tampon3;
2223: }
2224: else
2225: {
2226: if ((tampon_lecture = malloc(((size_t)
2227: longueur_enregistrement) *
2228: sizeof(unsigned char))) == NULL)
2229: {
2230: (*s_etat_processus).erreur_systeme =
2231: d_es_allocation_memoire;
2232: return;
2233: }
2234:
2235: longueur_effective = (integer8) fread(tampon_lecture,
2236: sizeof(unsigned char),
2237: (size_t) longueur_enregistrement,
2238: (*descripteur).descripteur_c);
2239: }
2240:
2241: if (l_element_courant == NULL)
2242: {
2243: // Premier maillon de la liste
2244: if (((*s_objet_resultat).objet =
2245: allocation_maillon(s_etat_processus)) == NULL)
2246: {
2247: (*s_etat_processus).erreur_systeme =
2248: d_es_allocation_memoire;
2249: return;
2250: }
2251:
2252: l_element_courant = (*s_objet_resultat).objet;
2253: }
2254: else
2255: {
2256: if (((*l_element_courant).suivant =
2257: allocation_maillon(s_etat_processus)) == NULL)
2258: {
2259: (*s_etat_processus).erreur_systeme =
2260: d_es_allocation_memoire;
2261: return;
2262: }
2263:
2264: l_element_courant = (*l_element_courant).suivant;
2265: }
2266:
2267: (*l_element_courant).suivant = NULL;
2268:
2269: if (((*l_element_courant).donnee =
2270: allocation(s_etat_processus, CHN)) == NULL)
2271: {
2272: (*s_etat_processus).erreur_systeme =
2273: d_es_allocation_memoire;
2274: return;
2275: }
2276:
2277: if (format_degenere == d_vrai)
2278: {
2279: if (device == d_faux)
2280: {
2281: if (((*(*l_element_courant).donnee).objet =
2282: analyse_flux(s_etat_processus, tampon_lecture,
2283: longueur_enregistrement - 1)) == NULL)
2284: {
2285: return;
2286: }
2287: }
2288: else
2289: {
2290: if (((*(*l_element_courant).donnee).objet =
2291: analyse_flux(s_etat_processus, tampon_lecture,
2292: longueur_enregistrement)) == NULL)
2293: {
2294: return;
2295: }
2296: }
2297: }
2298: else
2299: {
2300: if (((*(*l_element_courant).donnee).objet =
2301: analyse_flux(s_etat_processus, tampon_lecture,
2302: longueur_enregistrement)) == NULL)
2303: {
2304: return;
2305: }
2306: }
2307:
2308: free(tampon_lecture);
2309:
2310: l_element_courant_format =
2311: (*l_element_courant_format).suivant;
2312: }
2313:
2314: if (empilement(s_etat_processus,
2315: &((*s_etat_processus).l_base_pile),
2316: s_objet_resultat) == d_erreur)
2317: {
2318: return;
2319: }
2320: }
2321: else
2322: {
2323: liberation(s_etat_processus, s_objet_argument_1);
2324:
2325: (*s_etat_processus).erreur_execution =
2326: d_ex_erreur_type_fichier;
2327: return;
2328: }
2329: }
2330: }
2331: else if ((*s_objet_argument_1).type == SCK)
2332: {
2333: /*
2334: * Vérification de l'autorisation de lecture
2335: */
2336:
2337: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
2338: == 'W')
2339: {
2340: liberation(s_etat_processus, s_objet_argument_1);
2341:
2342: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
2343: return;
2344: }
2345:
2346: /*
2347: * Vérification de l'écoute de la socket si celle-ci est connectée
2348: */
2349:
2350: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
2351: "STREAM") == 0) || (strcmp((*((struct_socket *)
2352: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
2353: == 0))
2354: {
2355: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2356: .socket_en_ecoute == 'Y')
2357: {
2358: liberation(s_etat_processus, s_objet_argument_1);
2359:
2360: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
2361: return;
2362: }
2363: }
2364:
2365: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
2366: { // Socket formatée
2367: longueur_questure = 4096;
2368: longueur_effective = 0;
2369: tampon_lecture = NULL;
2370:
2371: attente.tv_sec = 0;
2372: attente.tv_nsec = GRANULARITE_us * 1000;
2373:
2374: trame_complete = d_faux;
2375: position_initiale = 0;
2376: position_finale = 0;
2377:
2378: do
2379: {
2380: presence_indicateur = d_faux;
2381:
2382: if ((tampon_lecture = realloc(tampon_lecture,
2383: ((size_t) (longueur_effective + longueur_questure + 1))
2384: * sizeof(unsigned char))) == NULL)
2385: {
2386: (*s_etat_processus).erreur_systeme =
2387: d_es_allocation_memoire;
2388: return;
2389: }
2390:
2391: # ifndef SEMAPHORES_NOMMES
2392: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2393: # else
2394: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2395: # endif
2396: {
2397: (*s_etat_processus).erreur_systeme = d_es_processus;
2398: return;
2399: }
2400:
2401: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2402: .domaine == PF_UNIX)
2403: {
2404: longueur_adresse = sizeof(adresse_unix);
2405:
2406: do
2407: {
2408: ios = (int) recvfrom((*((struct_socket *)
2409: (*s_objet_argument_1).objet)).socket,
2410: tampon_lecture, (size_t) (longueur_effective +
2411: longueur_questure),
2412: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2413: &adresse_unix, &longueur_adresse);
2414: } while((ios == -1) && (errno == EINTR));
2415: }
2416: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2417: .domaine == PF_INET)
2418: {
2419: longueur_adresse = sizeof(adresse_ipv4);
2420:
2421: do
2422: {
2423: ios = (int) recvfrom((*((struct_socket *)
2424: (*s_objet_argument_1).objet)).socket,
2425: tampon_lecture, (size_t) (longueur_effective +
2426: longueur_questure),
2427: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2428: &adresse_ipv4, &longueur_adresse);
2429: } while((ios == -1) && (errno == EINTR));
2430: }
2431: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2432: .domaine == PF_INET6)
2433: {
2434: # ifdef IPV6
2435: longueur_adresse = sizeof(adresse_ipv6);
2436:
2437: do
2438: {
2439: ios = (int) recvfrom((*((struct_socket *)
2440: (*s_objet_argument_1).objet)).socket,
2441: tampon_lecture, (size_t) (longueur_effective +
2442: longueur_questure),
2443: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2444: &adresse_ipv6, &longueur_adresse);
2445: } while((ios == -1) && (errno == EINTR));
2446: # else
2447: if ((*s_etat_processus).langue == 'F')
2448: {
2449: printf("+++Attention : Support du protocole"
2450: " IPv6 indisponible\n");
2451: }
2452: else
2453: {
2454: printf("+++Warning : IPv6 support "
2455: "unavailable\n");
2456: }
2457:
2458: longueur_adresse = 0;
2459: longueur_effective = 0;
2460: ios = 0;
2461: # endif
2462: }
2463: else
2464: {
2465: free(tampon_lecture);
2466: liberation(s_etat_processus, s_objet_argument_1);
2467:
2468: # ifndef SEMAPHORES_NOMMES
2469: while(sem_wait(&((*s_etat_processus)
2470: .semaphore_fork)) != 0)
2471: # else
2472: while(sem_wait((*s_etat_processus)
2473: .semaphore_fork) != 0)
2474: # endif
2475: {
2476: (*s_etat_processus).erreur_systeme =
2477: d_es_processus;
2478: }
2479:
2480: (*s_etat_processus).erreur_execution =
2481: d_ex_erreur_acces_fichier;
2482: return;
2483: }
2484:
2485: if (ios <= 0)
2486: {
2487: nanosleep(&attente, NULL);
2488: INCR_GRANULARITE(attente.tv_nsec);
2489: }
2490: else
2491: {
2492: attente.tv_sec = 0;
2493: attente.tv_nsec = GRANULARITE_us * 1000;
2494: }
2495:
2496: scrutation_injection(s_etat_processus);
2497:
2498: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2499: {
2500: if (ios >= 0)
2501: {
2502: longueur_effective = ios;
2503: }
2504:
2505: break;
2506: }
2507:
2508: // Une donnée a été reçue.
2509:
2510: if (ios >= 0)
2511: {
2512: longueur_effective = ios;
2513: position_initiale = 0;
2514: presence_indicateur = d_faux;
2515:
2516: do
2517: {
2518: if (tampon_lecture[position_initiale] == '{')
2519: {
2520: presence_indicateur = d_vrai;
2521: break;
2522: }
2523:
2524: position_initiale++;
2525: } while(position_initiale < longueur_effective);
2526:
2527: if (presence_indicateur == d_vrai)
2528: {
2529: position_finale = position_initiale + 1;
2530: presence_chaine = d_faux;
2531: presence_indicateur = d_faux;
2532: niveau = 1;
2533:
2534: while(position_finale < longueur_effective)
2535: {
2536: caractere = tampon_lecture[position_finale];
2537:
2538: if (caractere == '"')
2539: {
2540: if (position_finale > 0)
2541: {
2542: if (tampon_lecture[position_finale - 1]
2543: != '\\')
2544: {
2545: presence_chaine = (presence_chaine ==
2546: d_vrai) ? d_faux : d_vrai;
2547: }
2548: }
2549: else
2550: {
2551: presence_chaine =
2552: (presence_chaine == d_vrai)
2553: ? d_faux : d_vrai;
2554: }
2555: }
2556: else
2557: {
2558: if (presence_chaine == d_faux)
2559: {
2560: if (caractere == '{')
2561: {
2562: niveau++;
2563: }
2564: else if (caractere == '}')
2565: {
2566: niveau--;
2567: }
2568: }
2569: }
2570:
2571: if (niveau == 0)
2572: {
2573: presence_indicateur = d_vrai;
2574: trame_complete = d_vrai;
2575: break;
2576: }
2577:
2578: position_finale++;
2579: }
2580: }
2581:
2582: // On retire une trame du buffer.
2583:
2584: if (trame_complete == d_vrai)
2585: {
2586: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2587: .domaine == PF_UNIX)
2588: {
2589: do
2590: {
2591: longueur_adresse = sizeof(adresse_unix);
2592: recvfrom((*((struct_socket *)
2593: (*s_objet_argument_1).objet)).socket,
2594: tampon_lecture,
2595: (size_t) longueur_effective,
2596: 0, (struct sockaddr *)
2597: &adresse_unix, &longueur_adresse);
2598: } while((ios == -1) && (errno == EINTR));
2599: }
2600: else if ((*((struct_socket *) (*s_objet_argument_1)
2601: .objet)).domaine == PF_INET)
2602: {
2603: do
2604: {
2605: longueur_adresse = sizeof(adresse_ipv4);
2606: recvfrom((*((struct_socket *)
2607: (*s_objet_argument_1).objet)).socket,
2608: tampon_lecture,
2609: (size_t) longueur_effective,
2610: 0, (struct sockaddr *)
2611: &adresse_ipv4, &longueur_adresse);
2612: } while((ios == -1) && (errno == EINTR));
2613: }
2614: else if ((*((struct_socket *) (*s_objet_argument_1)
2615: .objet)) .domaine == PF_INET6)
2616: {
2617: # ifdef IPV6
2618: do
2619: {
2620: longueur_adresse = sizeof(adresse_ipv6);
2621: recvfrom((*((struct_socket *)
2622: (*s_objet_argument_1).objet)).socket,
2623: tampon_lecture,
2624: (size_t) longueur_effective,
2625: 0, (struct sockaddr *)
2626: &adresse_ipv6, &longueur_adresse);
2627: } while((ios == -1) && (errno == EINTR));
2628: # else
2629: if ((*s_etat_processus).langue == 'F')
2630: {
2631: printf("+++Attention : Support du protocole"
2632: " IPv6 indisponible\n");
2633: }
2634: else
2635: {
2636: printf("+++Warning : IPv6 support "
2637: "unavailable\n");
2638: }
2639:
2640: # endif
2641: }
2642:
2643: longueur_effective = ios;
2644: }
2645: else
2646: {
2647: // Si on a lu toute une trame et qu'on n'a pas
2648: // réussi à en trouver la structure, on remonte
2649: // une erreur de syntaxe.
2650:
2651: if (longueur_effective == ios)
2652: {
2653: if ((*((struct_socket *) (*s_objet_argument_1)
2654: .objet)).domaine == PF_UNIX)
2655: {
2656: do
2657: {
2658: longueur_adresse = sizeof(adresse_unix);
2659: recvfrom((*((struct_socket *)
2660: (*s_objet_argument_1).objet))
2661: .socket, tampon_lecture,
2662: (size_t) longueur_effective,
2663: 0, (struct sockaddr *)
2664: &adresse_unix, &longueur_adresse);
2665: } while((ios == -1) && (errno == EINTR));
2666: }
2667: else if ((*((struct_socket *) (*s_objet_argument_1)
2668: .objet)).domaine == PF_INET)
2669: {
2670: do
2671: {
2672: longueur_adresse = sizeof(adresse_ipv4);
2673: recvfrom((*((struct_socket *)
2674: (*s_objet_argument_1).objet))
2675: .socket, tampon_lecture,
2676: (size_t) longueur_effective,
2677: 0, (struct sockaddr *)
2678: &adresse_ipv4, &longueur_adresse);
2679: } while((ios == -1) && (errno == EINTR));
2680: }
2681: else if ((*((struct_socket *) (*s_objet_argument_1)
2682: .objet)) .domaine == PF_INET6)
2683: {
2684: # ifdef IPV6
2685: do
2686: {
2687: longueur_adresse = sizeof(adresse_ipv6);
2688: recvfrom((*((struct_socket *)
2689: (*s_objet_argument_1).objet))
2690: .socket, tampon_lecture,
2691: (size_t) longueur_effective,
2692: 0, (struct sockaddr *)
2693: &adresse_ipv6, &longueur_adresse);
2694: } while((ios == -1) && (errno == EINTR));
2695: # else
2696: if ((*s_etat_processus).langue == 'F')
2697: {
2698: printf("+++Attention : Support du protocole"
2699: " IPv6 indisponible\n");
2700: }
2701: else
2702: {
2703: printf("+++Warning : IPv6 support "
2704: "unavailable\n");
2705: }
2706:
2707: # endif
2708: }
2709:
2710: liberation(s_etat_processus, s_objet_argument_1);
2711: free(tampon_lecture);
2712:
2713: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2714: return;
2715: }
2716: }
2717: }
2718:
2719: # ifndef SEMAPHORES_NOMMES
2720: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
2721: # else
2722: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2723: # endif
2724: {
2725: if (errno == EINTR)
2726: {
2727: (*s_etat_processus).erreur_systeme = d_es_processus;
2728: return;
2729: }
2730: }
2731:
2732: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2733: {
2734:
2735: /*
2736: * Si le père tue le processus courant grâce au signal
2737: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
2738: * correspond à l'utilisation de STOP sur le processus
2739: * en cours. La variable longueur_effective vaut '-1'.
2740: */
2741:
2742: free(tampon_lecture);
2743: liberation(s_etat_processus, s_objet_argument_1);
2744: return;
2745: }
2746:
2747: if (longueur_effective == -1)
2748: {
2749: free(tampon_lecture);
2750: liberation(s_etat_processus, s_objet_argument_1);
2751:
2752: (*s_etat_processus).erreur_execution =
2753: d_ex_erreur_acces_fichier;
2754: return;
2755: }
2756: } while(trame_complete == d_faux);
2757:
2758: tampon_lecture[++position_finale] = d_code_fin_chaine;
2759: tampon = (*s_etat_processus).instruction_courante;
2760: (*s_etat_processus).instruction_courante = tampon_lecture;
2761:
2762: indicateur_48 = test_cfsf(s_etat_processus, 48);
2763: cf(s_etat_processus, 48);
2764:
2765: (*s_etat_processus).type_en_cours = NON;
2766: recherche_type(s_etat_processus);
2767:
2768: if ((*s_etat_processus).erreur_execution != d_ex)
2769: {
2770: (*s_etat_processus).instruction_courante = tampon;
2771: free(tampon_lecture);
2772:
2773: if (indicateur_48 == d_vrai)
2774: {
2775: sf(s_etat_processus, 48);
2776: }
2777: else
2778: {
2779: cf(s_etat_processus, 48);
2780: }
2781:
2782: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2783: {
2784: (*s_etat_processus).erreur_execution = d_ex;
2785: }
2786:
2787: liberation(s_etat_processus, s_objet_argument_1);
2788: return;
2789: }
2790:
2791: if (indicateur_48 == d_vrai)
2792: {
2793: sf(s_etat_processus, 48);
2794: }
2795: else
2796: {
2797: cf(s_etat_processus, 48);
2798: }
2799:
2800: (*s_etat_processus).instruction_courante = tampon;
2801:
2802: /*
2803: * Création de la liste de sortie
2804: */
2805:
2806: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2807: &s_objet_type) == d_erreur)
2808: {
2809: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2810: return;
2811: }
2812:
2813: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2814: == NULL)
2815: {
2816: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2817: return;
2818: }
2819:
2820: if (((*s_objet_resultat).objet =
2821: allocation_maillon(s_etat_processus)) == NULL)
2822: {
2823: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2824: return;
2825: }
2826:
2827: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2828: .donnee = s_objet_type;
2829:
2830: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
2831: .suivant = allocation_maillon(s_etat_processus)) == NULL)
2832: {
2833: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2834: return;
2835: }
2836:
2837: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2838: .suivant = NULL;
2839:
2840: if ((s_objet_adresse = allocation(s_etat_processus, LST))
2841: == NULL)
2842: {
2843: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2844: return;
2845: }
2846:
2847: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2848: .donnee = s_objet_adresse;
2849:
2850: /*
2851: * Les informations concernant la cible sont valides si
2852: * la socket est non connectée et des domaines INET ou INET6.
2853: * Dans tous les autres cas, on renvoie une liste vide.
2854: */
2855:
2856: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
2857: == PF_UNIX) || (strcmp((*((struct_socket *)
2858: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
2859: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
2860: .type, "SEQUENTIAL DATAGRAM") == 0))
2861: {
2862: (*s_objet_adresse).objet = NULL;
2863: }
2864: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2865: .domaine == PF_INET)
2866: {
2867: if (((*s_objet_adresse).objet =
2868: allocation_maillon(s_etat_processus)) == NULL)
2869: {
2870: (*s_etat_processus).erreur_systeme =
2871: d_es_allocation_memoire;
2872: return;
2873: }
2874:
2875: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2876: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2877: {
2878: (*s_etat_processus).erreur_systeme =
2879: d_es_allocation_memoire;
2880: return;
2881: }
2882:
2883: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2884: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
2885:
2886: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2887: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2888: malloc(4 * sizeof(integer8))) == NULL)
2889: {
2890: (*s_etat_processus).erreur_systeme =
2891: d_es_allocation_memoire;
2892: return;
2893: }
2894:
2895: ((integer8 *) (*((struct_vecteur *)
2896: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2897: .objet)).donnee).objet)).tableau)[0] =
2898: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
2899: ((integer8 *) (*((struct_vecteur *)
2900: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2901: .objet)).donnee).objet)).tableau)[1] =
2902: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
2903: ((integer8 *) (*((struct_vecteur *)
2904: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2905: .objet)).donnee).objet)).tableau)[2] =
2906: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
2907: ((integer8 *) (*((struct_vecteur *)
2908: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2909: .objet)).donnee).objet)).tableau)[3] =
2910: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
2911:
2912: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2913: .suivant = allocation_maillon(s_etat_processus))
2914: == NULL)
2915: {
2916: (*s_etat_processus).erreur_systeme =
2917: d_es_allocation_memoire;
2918: return;
2919: }
2920:
2921: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2922: .suivant).donnee = allocation(s_etat_processus, INT))
2923: == NULL)
2924: {
2925: (*s_etat_processus).erreur_systeme =
2926: d_es_allocation_memoire;
2927: return;
2928: }
2929:
2930: (*((integer8 *) (*(*(*((struct_liste_chainee *)
2931: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
2932: (integer8) ntohs(adresse_ipv4.sin_port);
2933:
2934: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2935: .suivant).suivant = NULL;
2936: }
2937: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2938: .domaine == PF_INET6)
2939: {
2940: # ifdef IPV6
2941: if (((*s_objet_adresse).objet =
2942: allocation_maillon(s_etat_processus)) == NULL)
2943: {
2944: (*s_etat_processus).erreur_systeme =
2945: d_es_allocation_memoire;
2946: return;
2947: }
2948:
2949: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2950: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2951: {
2952: (*s_etat_processus).erreur_systeme =
2953: d_es_allocation_memoire;
2954: return;
2955: }
2956:
2957: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2958: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
2959:
2960: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2961: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2962: malloc(16 * sizeof(integer8))) == NULL)
2963: {
2964: (*s_etat_processus).erreur_systeme =
2965: d_es_allocation_memoire;
2966: return;
2967: }
2968:
2969: for(i = 0; i < 16; i++)
2970: {
2971: ((integer8 *) (*((struct_vecteur *)
2972: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2973: .objet)).donnee).objet)).tableau)[0] =
2974: adresse_ipv6.sin6_addr.s6_addr[i];
2975: }
2976:
2977: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2978: .suivant = allocation_maillon(s_etat_processus))
2979: == NULL)
2980: {
2981: (*s_etat_processus).erreur_systeme =
2982: d_es_allocation_memoire;
2983: return;
2984: }
2985:
2986: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2987: .suivant).donnee = allocation(s_etat_processus, INT))
2988: == NULL)
2989: {
2990: (*s_etat_processus).erreur_systeme =
2991: d_es_allocation_memoire;
2992: return;
2993: }
2994:
2995: (*((integer8 *) (*(*(*((struct_liste_chainee *)
2996: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
2997: (integer8) ntohs(adresse_ipv6.sin6_port);
2998:
2999: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3000: .suivant).suivant = NULL;
3001: # else
3002: if ((*s_etat_processus).langue == 'F')
3003: {
3004: printf("+++Attention : Support du protocole"
3005: " IPv6 indisponible\n");
3006: }
3007: else
3008: {
3009: printf("+++Warning : IPv6 support "
3010: "unavailable\n");
3011: }
3012: # endif
3013: }
3014: else
3015: {
3016: longueur_adresse = 0;
3017: recvfrom((*((struct_socket *)
3018: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3019: (size_t) position_finale, MSG_DONTWAIT,
3020: NULL, &longueur_adresse);
3021: }
3022:
3023: free(tampon_lecture);
3024:
3025: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3026: s_objet_resultat) == d_erreur)
3027: {
3028: return;
3029: }
3030: }
3031: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
3032: == 'Y')
3033: { // socket non formatée
3034: longueur_questure = 4096;
3035: longueur_effective = 0;
3036: tampon_lecture = NULL;
3037:
3038: attente.tv_sec = 0;
3039: attente.tv_nsec = GRANULARITE_us * 1000;
3040:
3041: trame_complete = d_faux;
3042: position_initiale = 0;
3043: position_finale = 0;
3044:
3045: do
3046: {
3047: presence_indicateur = d_faux;
3048:
3049: if ((tampon_lecture = realloc(tampon_lecture,
3050: ((size_t) (longueur_effective + longueur_questure) + 1)
3051: * sizeof(unsigned char))) == NULL)
3052: {
3053: (*s_etat_processus).erreur_systeme =
3054: d_es_allocation_memoire;
3055: return;
3056: }
3057:
3058: # ifndef SEMAPHORES_NOMMES
3059: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3060: # else
3061: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3062: # endif
3063: {
3064: (*s_etat_processus).erreur_systeme = d_es_processus;
3065: return;
3066: }
3067:
3068: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3069: .domaine == PF_UNIX)
3070: {
3071: longueur_adresse = sizeof(adresse_unix);
3072:
3073: do
3074: {
3075: ios = (int) recvfrom((*((struct_socket *)
3076: (*s_objet_argument_1).objet)).socket,
3077: tampon_lecture, (size_t)
3078: (longueur_effective + longueur_questure),
3079: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3080: &adresse_unix, &longueur_adresse);
3081: } while((ios == -1) && (errno == EINTR));
3082: }
3083: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3084: .domaine == PF_INET)
3085: {
3086: longueur_adresse = sizeof(adresse_ipv4);
3087:
3088: do
3089: {
3090: ios = (int) recvfrom((*((struct_socket *)
3091: (*s_objet_argument_1).objet)).socket,
3092: tampon_lecture, (size_t)
3093: (longueur_effective + longueur_questure),
3094: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3095: &adresse_ipv4, &longueur_adresse);
3096: } while((ios == -1) && (errno == EINTR));
3097: }
3098: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3099: .domaine == PF_INET6)
3100: {
3101: # ifdef IPV6
3102: longueur_adresse = sizeof(adresse_ipv6);
3103:
3104: do
3105: {
3106: ios = (int) recvfrom((*((struct_socket *)
3107: (*s_objet_argument_1).objet)).socket,
3108: tampon_lecture, (size_t)
3109: (longueur_effective + longueur_questure),
3110: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3111: &adresse_ipv6, &longueur_adresse);
3112: } while((ios == -1) && (errno == EINTR));
3113: # else
3114: if ((*s_etat_processus).langue == 'F')
3115: {
3116: printf("+++Attention : Support du protocole"
3117: " IPv6 indisponible\n");
3118: }
3119: else
3120: {
3121: printf("+++Warning : IPv6 support "
3122: "unavailable\n");
3123: }
3124:
3125: longueur_adresse = 0;
3126: longueur_effective = 0;
3127: ios = 0;
3128: # endif
3129: }
3130: else
3131: {
3132: free(tampon_lecture);
3133: liberation(s_etat_processus, s_objet_argument_1);
3134:
3135: # ifndef SEMAPHORES_NOMMES
3136: while(sem_wait(&((*s_etat_processus)
3137: .semaphore_fork)) != 0)
3138: # else
3139: while(sem_wait((*s_etat_processus)
3140: .semaphore_fork) != 0)
3141: # endif
3142: {
3143: (*s_etat_processus).erreur_systeme =
3144: d_es_processus;
3145: }
3146:
3147: (*s_etat_processus).erreur_execution =
3148: d_ex_erreur_acces_fichier;
3149: return;
3150: }
3151:
3152: if (ios <= 0)
3153: {
3154: nanosleep(&attente, NULL);
3155: INCR_GRANULARITE(attente.tv_nsec);
3156: }
3157: else
3158: {
3159: attente.tv_sec = 0;
3160: attente.tv_nsec = GRANULARITE_us * 1000;
3161: }
3162:
3163: scrutation_injection(s_etat_processus);
3164:
3165: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3166: {
3167: if (ios >= 0)
3168: {
3169: longueur_effective += ios;
3170: }
3171:
3172: break;
3173: }
3174:
3175: // Une donnée a été reçue.
3176:
3177: if (ios == (longueur_effective + longueur_questure))
3178: {
3179: longueur_effective = ios;
3180: position_initiale = 0;
3181: presence_indicateur = d_faux;
3182: }
3183: else if (ios > 0)
3184: {
3185: // On retire une trame du buffer.
3186:
3187: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3188: .domaine == PF_UNIX)
3189: {
3190: do
3191: {
3192: longueur_adresse = sizeof(adresse_unix);
3193: recvfrom((*((struct_socket *)
3194: (*s_objet_argument_1).objet)).socket,
3195: tampon_lecture, (size_t) longueur_effective,
3196: 0, (struct sockaddr *)
3197: &adresse_unix, &longueur_adresse);
3198: } while((ios == -1) && (errno == EINTR));
3199: }
3200: else if ((*((struct_socket *) (*s_objet_argument_1)
3201: .objet)).domaine == PF_INET)
3202: {
3203: do
3204: {
3205: longueur_adresse = sizeof(adresse_ipv4);
3206: recvfrom((*((struct_socket *)
3207: (*s_objet_argument_1).objet)).socket,
3208: tampon_lecture, (size_t) longueur_effective,
3209: 0, (struct sockaddr *)
3210: &adresse_ipv4, &longueur_adresse);
3211: } while((ios == -1) && (errno == EINTR));
3212: }
3213: else if ((*((struct_socket *) (*s_objet_argument_1)
3214: .objet)) .domaine == PF_INET6)
3215: {
3216: # ifdef IPV6
3217: do
3218: {
3219: longueur_adresse = sizeof(adresse_ipv6);
3220: recvfrom((*((struct_socket *)
3221: (*s_objet_argument_1).objet)).socket,
3222: tampon_lecture, (size_t) longueur_effective,
3223: 0, (struct sockaddr *)
3224: &adresse_ipv6, &longueur_adresse);
3225: } while((ios == -1) && (errno == EINTR));
3226: # else
3227: if ((*s_etat_processus).langue == 'F')
3228: {
3229: printf("+++Attention : Support du protocole"
3230: " IPv6 indisponible\n");
3231: }
3232: else
3233: {
3234: printf("+++Warning : IPv6 support "
3235: "unavailable\n");
3236: }
3237: # endif
3238: }
3239:
3240: longueur_effective = ios;
3241: trame_complete = d_vrai;
3242: }
3243:
3244: # ifndef SEMAPHORES_NOMMES
3245: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3246: # else
3247: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3248: # endif
3249: {
3250: if (errno == EINTR)
3251: {
3252: (*s_etat_processus).erreur_systeme = d_es_processus;
3253: return;
3254: }
3255: }
3256:
3257: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3258: {
3259:
3260: /*
3261: * Si le père tue le processus courant grâce au signal
3262: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3263: * correspond à l'utilisation de STOP sur le processus
3264: * en cours. La variable longueur_effective vaut '-1'.
3265: */
3266:
3267: free(tampon_lecture);
3268: liberation(s_etat_processus, s_objet_argument_1);
3269: return;
3270: }
3271:
3272: if (longueur_effective == -1)
3273: {
3274: free(tampon_lecture);
3275: liberation(s_etat_processus, s_objet_argument_1);
3276:
3277: (*s_etat_processus).erreur_execution =
3278: d_ex_erreur_acces_fichier;
3279: return;
3280: }
3281: } while(trame_complete == d_faux);
3282:
3283: /*
3284: * Création de la liste de sortie
3285: */
3286:
3287: ptr = tampon_lecture;
3288:
3289: if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
3290: &ptr, longueur_effective, d_faux)) == NULL)
3291: {
3292: free(tampon_lecture);
3293:
3294: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3295: return;
3296: }
3297:
3298: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3299: == NULL)
3300: {
3301: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3302: return;
3303: }
3304:
3305: if (((*s_objet_resultat).objet =
3306: allocation_maillon(s_etat_processus)) == NULL)
3307: {
3308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3309: return;
3310: }
3311:
3312: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3313: .donnee = s_objet_type;
3314:
3315: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3316: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3317: {
3318: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3319: return;
3320: }
3321:
3322: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3323: .suivant = NULL;
3324:
3325: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3326: == NULL)
3327: {
3328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3329: return;
3330: }
3331:
3332: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3333: .donnee = s_objet_adresse;
3334:
3335: /*
3336: * Les informations concernant la cible sont valides si
3337: * la socket est non connectée et des domaines INET ou INET6.
3338: * Dans tous les autres cas, on renvoie une liste vide.
3339: */
3340:
3341: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3342: == PF_UNIX) || (strcmp((*((struct_socket *)
3343: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3344: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3345: .type, "SEQUENTIAL DATAGRAM") == 0))
3346: {
3347: (*s_objet_adresse).objet = NULL;
3348: }
3349: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3350: .domaine == PF_INET)
3351: {
3352: if (((*s_objet_adresse).objet =
3353: allocation_maillon(s_etat_processus)) == NULL)
3354: {
3355: (*s_etat_processus).erreur_systeme =
3356: d_es_allocation_memoire;
3357: return;
3358: }
3359:
3360: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3361: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3362: {
3363: (*s_etat_processus).erreur_systeme =
3364: d_es_allocation_memoire;
3365: return;
3366: }
3367:
3368: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3369: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3370:
3371: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3372: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3373: malloc(4 * sizeof(integer8))) == NULL)
3374: {
3375: (*s_etat_processus).erreur_systeme =
3376: d_es_allocation_memoire;
3377: return;
3378: }
3379:
3380: ((integer8 *) (*((struct_vecteur *)
3381: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3382: .objet)).donnee).objet)).tableau)[0] =
3383: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3384: ((integer8 *) (*((struct_vecteur *)
3385: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3386: .objet)).donnee).objet)).tableau)[1] =
3387: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3388: ((integer8 *) (*((struct_vecteur *)
3389: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3390: .objet)).donnee).objet)).tableau)[2] =
3391: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3392: ((integer8 *) (*((struct_vecteur *)
3393: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3394: .objet)).donnee).objet)).tableau)[3] =
3395: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3396:
3397: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3398: .suivant = allocation_maillon(s_etat_processus))
3399: == NULL)
3400: {
3401: (*s_etat_processus).erreur_systeme =
3402: d_es_allocation_memoire;
3403: return;
3404: }
3405:
3406: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3407: .suivant).donnee = allocation(s_etat_processus, INT))
3408: == NULL)
3409: {
3410: (*s_etat_processus).erreur_systeme =
3411: d_es_allocation_memoire;
3412: return;
3413: }
3414:
3415: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3416: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3417: (integer8) ntohs(adresse_ipv4.sin_port);
3418:
3419: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3420: .suivant).suivant = NULL;
3421: }
3422: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3423: .domaine == PF_INET6)
3424: {
3425: # ifdef IPV6
3426: if (((*s_objet_adresse).objet =
3427: allocation_maillon(s_etat_processus)) == NULL)
3428: {
3429: (*s_etat_processus).erreur_systeme =
3430: d_es_allocation_memoire;
3431: return;
3432: }
3433:
3434: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3435: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3436: {
3437: (*s_etat_processus).erreur_systeme =
3438: d_es_allocation_memoire;
3439: return;
3440: }
3441:
3442: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3443: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3444:
3445: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3446: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3447: malloc(16 * sizeof(integer8))) == NULL)
3448: {
3449: (*s_etat_processus).erreur_systeme =
3450: d_es_allocation_memoire;
3451: return;
3452: }
3453:
3454: for(i = 0; i < 16; i++)
3455: {
3456: ((integer8 *) (*((struct_vecteur *)
3457: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3458: .objet)).donnee).objet)).tableau)[0] =
3459: adresse_ipv6.sin6_addr.s6_addr[i];
3460: }
3461:
3462: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3463: .suivant = allocation_maillon(s_etat_processus))
3464: == NULL)
3465: {
3466: (*s_etat_processus).erreur_systeme =
3467: d_es_allocation_memoire;
3468: return;
3469: }
3470:
3471: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3472: .suivant).donnee = allocation(s_etat_processus, INT))
3473: == NULL)
3474: {
3475: (*s_etat_processus).erreur_systeme =
3476: d_es_allocation_memoire;
3477: return;
3478: }
3479:
3480: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3481: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3482: (integer8) ntohs(adresse_ipv6.sin6_port);
3483:
3484: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3485: .suivant).suivant = NULL;
3486: # else
3487: if ((*s_etat_processus).langue == 'F')
3488: {
3489: printf("+++Attention : Support du protocole"
3490: " IPv6 indisponible\n");
3491: }
3492: else
3493: {
3494: printf("+++Warning : IPv6 support "
3495: "unavailable\n");
3496: }
3497: # endif
3498: }
3499: else
3500: {
3501: longueur_adresse = 0;
3502: recvfrom((*((struct_socket *)
3503: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3504: (size_t) position_finale, MSG_DONTWAIT,
3505: NULL, &longueur_adresse);
3506: }
3507:
3508: free(tampon_lecture);
3509:
3510: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3511: s_objet_resultat) == d_erreur)
3512: {
3513: return;
3514: }
3515: }
3516: else
3517: { // FLOW
3518: #if 0
3519: longueur_questure = 256;
3520:
3521: do
3522: {
3523: if ((tampon_lecture = malloc((longueur_questure + 1) *
3524: sizeof(unsigned char))) == NULL)
3525: {
3526: (*s_etat_processus).erreur_systeme =
3527: d_es_allocation_memoire;
3528: return;
3529: }
3530:
3531: # ifndef SEMAPHORES_NOMMES
3532: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3533: # else
3534: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3535: # endif
3536: {
3537: (*s_etat_processus).erreur_systeme = d_es_processus;
3538: return;
3539: }
3540:
3541: attente.tv_sec = 0;
3542: attente.tv_nsec = GRANULARITE_us * 1000;
3543:
3544: for(;;)
3545: {
3546: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3547: .domaine == PF_UNIX)
3548: {
3549: longueur_adresse = sizeof(adresse_unix);
3550: longueur_effective = recvfrom((*((struct_socket *)
3551: (*s_objet_argument_1).objet)).socket,
3552: tampon_lecture, longueur_questure,
3553: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3554: &adresse_unix, &longueur_adresse);
3555: }
3556: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3557: .domaine == PF_INET)
3558: {
3559: longueur_adresse = sizeof(adresse_ipv4);
3560: longueur_effective = recvfrom((*((struct_socket *)
3561: (*s_objet_argument_1).objet)).socket,
3562: tampon_lecture, longueur_questure,
3563: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3564: &adresse_ipv4, &longueur_adresse);
3565: }
3566: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3567: .domaine == PF_INET6)
3568: {
3569: # ifdef IPV6
3570: longueur_adresse = sizeof(adresse_ipv6);
3571: longueur_effective = recvfrom((*((struct_socket *)
3572: (*s_objet_argument_1).objet)).socket,
3573: tampon_lecture, longueur_questure,
3574: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3575: &adresse_ipv6, &longueur_adresse);
3576: # else
3577: if ((*s_etat_processus).langue == 'F')
3578: {
3579: printf("+++Attention : Support du protocole"
3580: " IPv6 indisponible\n");
3581: }
3582: else
3583: {
3584: printf("+++Warning : IPv6 support "
3585: "unavailable\n");
3586: }
3587:
3588: longueur_adresse = 0;
3589: longueur_effective = 0;
3590: # endif
3591: }
3592: else
3593: {
3594: free(tampon_lecture);
3595: liberation(s_etat_processus, s_objet_argument_1);
3596:
3597: # ifndef SEMAPHORES_NOMMES
3598: while(sem_wait(&((*s_etat_processus)
3599: .semaphore_fork)) != 0)
3600: # else
3601: while(sem_wait((*s_etat_processus)
3602: .semaphore_fork) != 0)
3603: # endif
3604: {
3605: if (errno != EINTR)
3606: {
3607: (*s_etat_processus).erreur_systeme =
3608: d_es_processus;
3609: return;
3610: }
3611: }
3612:
3613: (*s_etat_processus).erreur_execution =
3614: d_ex_erreur_acces_fichier;
3615: return;
3616: }
3617:
3618: if (longueur_effective < 0)
3619: {
3620: nanosleep(&attente, NULL);
3621: INCR_GRANULARITE(attente.tv_nsec);
3622: scrutation_injection(s_etat_processus);
3623: }
3624:
3625: if (((*s_etat_processus).var_volatile_requete_arret == -1)
3626: || (longueur_effective >= 0))
3627: {
3628: break;
3629: }
3630: }
3631:
3632: # ifndef SEMAPHORES_NOMMES
3633: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3634: # else
3635: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3636: # endif
3637: {
3638: if (errno != EINTR)
3639: {
3640: (*s_etat_processus).erreur_systeme = d_es_processus;
3641: return;
3642: }
3643: }
3644:
3645: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3646: {
3647:
3648: /*
3649: * Si le père tue le processus courant grâce au signal
3650: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3651: * correspond à l'utilisation de STOP sur le processus
3652: * en cours. La variable longueur_effective vaut '-1'.
3653: */
3654:
3655: free(tampon_lecture);
3656: liberation(s_etat_processus, s_objet_argument_1);
3657: return;
3658: }
3659:
3660: if (longueur_effective == -1)
3661: {
3662: free(tampon_lecture);
3663: liberation(s_etat_processus, s_objet_argument_1);
3664:
3665: (*s_etat_processus).erreur_execution =
3666: d_ex_erreur_acces_fichier;
3667: return;
3668: }
3669:
3670: if (longueur_effective == longueur_questure)
3671: {
3672: free(tampon_lecture);
3673: longueur_questure *= 2;
3674: }
3675: } while(longueur_effective == longueur_questure);
3676:
3677: longueur_enregistrement = 1;
3678:
3679: for(i = 0; i < longueur_effective; i++)
3680: {
3681: if (isprint(tampon_lecture[i]) != 0)
3682: {
3683: longueur_enregistrement += 4;
3684: }
3685: else
3686: {
3687: longueur_enregistrement++;
3688: }
3689: }
3690:
3691: /*
3692: * Création de la liste de sortie
3693: */
3694:
3695: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
3696: {
3697: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3698: return;
3699: }
3700:
3701: if (((*s_objet_type).objet = malloc(longueur_enregistrement *
3702: sizeof(unsigned char))) == NULL)
3703: {
3704: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3705: return;
3706: }
3707:
3708: ptr = (*s_objet_type).objet;
3709:
3710: for(i = 0; i < longueur_effective; i++)
3711: {
3712: if (isprint(tampon_lecture[i]) != 0)
3713: {
3714: (*ptr) = tampon_lecture[i];
3715: ptr++;
3716: }
3717: else
3718: {
3719: (*ptr) = '\\';
3720: ptr++;
3721: (*ptr) = 'x';
3722: ptr++;
3723: sprintf(ptr, "%02X", tampon_lecture[i]);
3724: ptr += 2;
3725: }
3726: }
3727:
3728: (*ptr) = d_code_fin_chaine;
3729:
3730: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3731: == NULL)
3732: {
3733: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3734: return;
3735: }
3736:
3737: if (((*s_objet_resultat).objet =
3738: allocation_maillon(s_etat_processus)) == NULL)
3739: {
3740: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3741: return;
3742: }
3743:
3744: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3745: .donnee = s_objet_type;
3746:
3747: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3748: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3749: {
3750: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3751: return;
3752: }
3753:
3754: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3755: .suivant = NULL;
3756:
3757: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3758: == NULL)
3759: {
3760: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3761: return;
3762: }
3763:
3764: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3765: .donnee = s_objet_adresse;
3766:
3767: /*
3768: * Les informations concernant la cible sont valides si
3769: * la socket est non connectée et que les domaines sont
3770: * INET ou INET6.
3771: * Dans tous les autres cas, on renvoie une liste vide.
3772: */
3773:
3774: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3775: == PF_UNIX) || (strcmp((*((struct_socket *)
3776: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3777: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3778: .type, "SEQUENTIAL DATAGRAM") == 0))
3779: {
3780: // POSITION_FINALE peut être utilisée sans être initialisée !
3781: // virer position_finale pour longueur_effective
3782: longueur_adresse = 0;
3783: recvfrom((*((struct_socket *)
3784: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3785: position_finale, MSG_DONTWAIT,
3786: NULL, &longueur_adresse);
3787:
3788: (*s_objet_adresse).objet = NULL;
3789: }
3790: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3791: .domaine == PF_INET)
3792: {
3793: longueur_adresse = sizeof(adresse_ipv4);
3794: recvfrom((*((struct_socket *)
3795: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3796: position_finale, MSG_DONTWAIT,
3797: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
3798:
3799: if (((*s_objet_adresse).objet =
3800: allocation_maillon(s_etat_processus)) == NULL)
3801: {
3802: (*s_etat_processus).erreur_systeme =
3803: d_es_allocation_memoire;
3804: return;
3805: }
3806:
3807: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3808: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3809: {
3810: (*s_etat_processus).erreur_systeme =
3811: d_es_allocation_memoire;
3812: return;
3813: }
3814:
3815: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3816: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3817:
3818: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3819: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3820: malloc(4 * sizeof(integer8))) == NULL)
3821: {
3822: (*s_etat_processus).erreur_systeme =
3823: d_es_allocation_memoire;
3824: return;
3825: }
3826:
3827: ((integer8 *) (*((struct_vecteur *)
3828: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3829: .objet)).donnee).objet)).tableau)[0] =
3830: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3831: ((integer8 *) (*((struct_vecteur *)
3832: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3833: .objet)).donnee).objet)).tableau)[1] =
3834: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3835: ((integer8 *) (*((struct_vecteur *)
3836: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3837: .objet)).donnee).objet)).tableau)[2] =
3838: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3839: ((integer8 *) (*((struct_vecteur *)
3840: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3841: .objet)).donnee).objet)).tableau)[3] =
3842: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3843:
3844: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3845: .suivant = allocation_maillon(s_etat_processus))
3846: == NULL)
3847: {
3848: (*s_etat_processus).erreur_systeme =
3849: d_es_allocation_memoire;
3850: return;
3851: }
3852:
3853: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3854: .suivant).donnee = allocation(s_etat_processus, INT))
3855: == NULL)
3856: {
3857: (*s_etat_processus).erreur_systeme =
3858: d_es_allocation_memoire;
3859: return;
3860: }
3861:
3862: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3863: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3864: (integer8) ntohs(adresse_ipv4.sin_port);
3865:
3866: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3867: .suivant).suivant = NULL;
3868: }
3869: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3870: .domaine == PF_INET6)
3871: {
3872: # ifdef IPV6
3873: longueur_adresse = sizeof(adresse_ipv6);
3874: recvfrom((*((struct_socket *)
3875: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3876: position_finale, MSG_DONTWAIT,
3877: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
3878:
3879: if (((*s_objet_adresse).objet =
3880: allocation_maillon(s_etat_processus)) == NULL)
3881: {
3882: (*s_etat_processus).erreur_systeme =
3883: d_es_allocation_memoire;
3884: return;
3885: }
3886:
3887: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3888: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3889: {
3890: (*s_etat_processus).erreur_systeme =
3891: d_es_allocation_memoire;
3892: return;
3893: }
3894:
3895: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3896: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3897:
3898: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3899: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3900: malloc(16 * sizeof(integer8))) == NULL)
3901: {
3902: (*s_etat_processus).erreur_systeme =
3903: d_es_allocation_memoire;
3904: return;
3905: }
3906:
3907: for(i = 0; i < 16; i++)
3908: {
3909: ((integer8 *) (*((struct_vecteur *)
3910: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3911: .objet)).donnee).objet)).tableau)[0] =
3912: adresse_ipv6.sin6_addr.s6_addr[i];
3913: }
3914:
3915: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3916: .suivant = allocation_maillon(s_etat_processus))
3917: == NULL)
3918: {
3919: (*s_etat_processus).erreur_systeme =
3920: d_es_allocation_memoire;
3921: return;
3922: }
3923:
3924: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3925: .suivant).donnee = allocation(s_etat_processus, INT))
3926: == NULL)
3927: {
3928: (*s_etat_processus).erreur_systeme =
3929: d_es_allocation_memoire;
3930: return;
3931: }
3932:
3933: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3934: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3935: (integer8) ntohs(adresse_ipv6.sin6_port);
3936:
3937: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3938: .suivant).suivant = NULL;
3939: # else
3940: if ((*s_etat_processus).langue == 'F')
3941: {
3942: printf("+++Attention : Support du protocole"
3943: " IPv6 indisponible\n");
3944: }
3945: else
3946: {
3947: printf("+++Warning : IPv6 support "
3948: "unavailable\n");
3949: }
3950: # endif
3951: }
3952: else
3953: {
3954: longueur_adresse = 0;
3955: recvfrom((*((struct_socket *)
3956: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3957: position_finale, MSG_DONTWAIT,
3958: NULL, &longueur_adresse);
3959: }
3960:
3961: free(tampon_lecture);
3962:
3963: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3964: s_objet_resultat) == d_erreur)
3965: {
3966: return;
3967: }
3968: #endif
3969: }
3970: }
3971: else
3972: {
3973: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3974: return;
3975: }
3976:
3977: liberation(s_etat_processus, s_objet_argument_1);
3978:
3979: return;
3980: }
3981:
3982: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src