1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.35
4: Copyright (C) 1989-2024 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 format_oriente_ligne;
873: logical1 indicateur_48;
874: logical1 presence_chaine;
875: logical1 presence_indicateur;
876: logical1 trame_complete;
877:
878: socklen_t longueur_adresse;
879:
880: sqlite3_stmt *ppStmt;
881:
882: struct flock lock;
883:
884: struct pollfd fds[1];
885:
886: struct sockaddr_un adresse_unix;
887: struct sockaddr_in adresse_ipv4;
888: # ifdef IPV6
889: struct sockaddr_in6 adresse_ipv6;
890: # endif
891:
892: struct termios tc;
893:
894: struct timespec attente;
895:
896: struct_descripteur_fichier *descripteur;
897:
898: struct_liste_chainee *l_element_courant;
899: struct_liste_chainee *l_element_courant_format;
900: struct_liste_chainee *l_element_inclus;
901:
902: struct_objet *s_objet_adresse;
903: struct_objet *s_objet_argument_1;
904: struct_objet *s_objet_argument_2;
905: struct_objet *s_objet_resultat;
906: struct_objet *s_objet_type;
907:
908: unsigned char caractere;
909: unsigned char *clef_utf8;
910: unsigned char *commande;
911: unsigned char *format_chaine;
912: unsigned char *ptr;
913: unsigned char *tampon_lecture;
914: unsigned char *tampon;
915: unsigned char *tampon2;
916: unsigned char *tampon3;
917:
918: int vitesses[] =
919: {
920: 50, 75, 110, 134, 150, 200, 300, 600,
921: 1200, 1800, 2400, 4800, 9600, 19200, 38400,
922: #ifdef B57600
923: 57600,
924: #endif
925: #ifdef B115200
926: 115200,
927: #endif
928: #ifdef B230400
929: 230400,
930: #endif
931: 0
932: };
933:
934: tcflag_t vitesses_constantes[] =
935: {
936: B50, B75, B110, B134, B150, B200, B300, B600,
937: B1200, B1800, B2400, B4800, B9600, B19200, B38400,
938: #ifdef B57600
939: B57600,
940: #endif
941: #ifdef B115200
942: B115200,
943: #endif
944: #ifdef B230400
945: B230400,
946: #endif
947: 0
948: };
949:
950: (*s_etat_processus).erreur_execution = d_ex;
951:
952: if ((*s_etat_processus).affichage_arguments == 'Y')
953: {
954: printf("\n READ ");
955:
956: if ((*s_etat_processus).langue == 'F')
957: {
958: printf("(lecture d'un enregistrement d'un fichier)\n\n");
959: }
960: else
961: {
962: printf("(read a record of a file)\n\n");
963: }
964:
965: printf(" 1: %s, %s\n", d_FCH, d_SCK);
966: printf("-> 1: %s\n\n", d_LST);
967:
968: printf(" 2: %s, %s\n", d_INT, d_CHN);
969: printf(" 1: %s\n", d_FCH);
970: printf("-> 1: %s\n\n", d_LST);
971: return;
972: }
973: else if ((*s_etat_processus).test_instruction == 'Y')
974: {
975: (*s_etat_processus).nombre_arguments = -1;
976: return;
977: }
978:
979: if (test_cfsf(s_etat_processus, 31) == d_vrai)
980: {
981: if ((*s_etat_processus).l_base_pile == NULL)
982: {
983: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
984: return;
985: }
986:
987: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
988: {
989: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
990: .donnee).objet)).acces == 'S')
991: {
992: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
993: {
994: return;
995: }
996: }
997: else
998: {
999: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1000: {
1001: return;
1002: }
1003: }
1004: }
1005: else
1006: {
1007: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1008: {
1009: return;
1010: }
1011: }
1012: }
1013:
1014: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1015: &s_objet_argument_1) == d_erreur)
1016: {
1017: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1018: return;
1019: }
1020:
1021: if ((*s_objet_argument_1).type == FCH)
1022: {
1023: if ((descripteur = descripteur_fichier(s_etat_processus,
1024: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
1025: {
1026: return;
1027: }
1028:
1029: /*
1030: * Vérification des verrous
1031: */
1032:
1033: lock.l_type = F_RDLCK;
1034: lock.l_whence = SEEK_SET;
1035: lock.l_start = 0;
1036: lock.l_len = 0;
1037: lock.l_pid = getpid();
1038:
1039: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
1040: == -1)
1041: {
1042: liberation(s_etat_processus, s_objet_argument_1);
1043:
1044: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1045: return;
1046: }
1047:
1048: if (lock.l_type != F_UNLCK)
1049: {
1050: liberation(s_etat_processus, s_objet_argument_1);
1051:
1052: (*s_etat_processus).erreur_execution =
1053: d_ex_fichier_verrouille;
1054: return;
1055: }
1056:
1057: /*
1058: * Vérification de l'autorisation de lecture
1059: */
1060:
1061: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1062: == 'W')
1063: {
1064: liberation(s_etat_processus, s_objet_argument_1);
1065:
1066: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1067: return;
1068: }
1069: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1070: == 'N')
1071: {
1072: if ((*descripteur).type == 'C')
1073: {
1074: if (fflush((*descripteur).descripteur_c) != 0)
1075: {
1076: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1077: return;
1078: }
1079: }
1080: }
1081:
1082: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1083: {
1084: /*
1085: * Fichiers formatés
1086: */
1087:
1088: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1089: == 'S')
1090: {
1091: /*
1092: * Fichiers séquentiels
1093: */
1094:
1095: longueur_questure = 4096;
1096:
1097: if ((tampon_lecture = malloc(((size_t) longueur_questure) *
1098: sizeof(unsigned char))) == NULL)
1099: {
1100: (*s_etat_processus).erreur_systeme =
1101: d_es_allocation_memoire;
1102: return;
1103: }
1104:
1105: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1106:
1107: if ((position_initiale = ftell((*descripteur).descripteur_c))
1108: == -1)
1109: {
1110: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1111: return;
1112: }
1113:
1114: do
1115: {
1116: longueur_effective = (integer8) fread(tampon_lecture,
1117: sizeof(unsigned char), (size_t) longueur_questure,
1118: (*descripteur).descripteur_c);
1119:
1120: pointeur = 0;
1121: presence_indicateur = d_faux;
1122:
1123: while(pointeur < longueur_effective)
1124: {
1125: if (tampon_lecture[pointeur] == '{')
1126: {
1127: presence_indicateur = d_vrai;
1128: break;
1129: }
1130:
1131: position_initiale++;
1132: pointeur++;
1133: }
1134:
1135: if (presence_indicateur == d_vrai)
1136: {
1137: break;
1138: }
1139: } while(longueur_effective == longueur_questure);
1140:
1141: if (presence_indicateur == d_faux)
1142: {
1143: liberation(s_etat_processus, s_objet_argument_1);
1144: free(tampon_lecture);
1145:
1146: (*s_etat_processus).erreur_execution =
1147: d_ex_fin_de_fichier_atteinte;
1148: return;
1149: }
1150:
1151: position_finale = position_initiale + 1;
1152: presence_chaine = d_faux;
1153: niveau = 1;
1154:
1155: if (fseek((*descripteur).descripteur_c, (long) position_finale,
1156: SEEK_SET) != 0)
1157: {
1158: liberation(s_etat_processus, s_objet_argument_1);
1159: free(tampon_lecture);
1160:
1161: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1162: return;
1163: }
1164:
1165: do
1166: {
1167: longueur_effective = (integer8) fread(tampon_lecture,
1168: sizeof(unsigned char), (size_t) longueur_questure,
1169: (*descripteur).descripteur_c);
1170:
1171: pointeur = 0;
1172: presence_indicateur = d_faux;
1173:
1174: while(pointeur < longueur_effective)
1175: {
1176: if (tampon_lecture[pointeur] == '"')
1177: {
1178: if (pointeur > 0)
1179: {
1180: if (tampon_lecture[pointeur - 1] != '\\')
1181: {
1182: presence_chaine = (presence_chaine ==
1183: d_vrai) ? d_faux : d_vrai;
1184: }
1185: }
1186: else
1187: {
1188: presence_chaine = (presence_chaine == d_vrai)
1189: ? d_faux : d_vrai;
1190: }
1191: }
1192: else
1193: {
1194: if (presence_chaine == d_faux)
1195: {
1196: if (tampon_lecture[pointeur] == '{')
1197: {
1198: niveau++;
1199: }
1200: else if (tampon_lecture[pointeur] == '}')
1201: {
1202: niveau--;
1203: }
1204: }
1205: }
1206:
1207: position_finale++;
1208: pointeur++;
1209:
1210: if (niveau == 0)
1211: {
1212: presence_indicateur = d_vrai;
1213: break;
1214: }
1215: }
1216:
1217: if (presence_indicateur == d_vrai)
1218: {
1219: break;
1220: }
1221: } while(longueur_effective == longueur_questure);
1222:
1223: if (presence_indicateur == d_faux)
1224: {
1225: liberation(s_etat_processus, s_objet_argument_1);
1226: free(tampon_lecture);
1227:
1228: (*s_etat_processus).erreur_execution =
1229: d_ex_fin_de_fichier_atteinte;
1230: return;
1231: }
1232:
1233: free(tampon_lecture);
1234: longueur_enregistrement = position_finale - position_initiale;
1235:
1236: if ((tampon_lecture = malloc(((size_t)
1237: (longueur_enregistrement + 1)) *
1238: sizeof(unsigned char))) == NULL)
1239: {
1240: (*s_etat_processus).erreur_systeme =
1241: d_es_allocation_memoire;
1242: return;
1243: }
1244:
1245: if (fseek((*descripteur).descripteur_c,
1246: (long) position_initiale, SEEK_SET) != 0)
1247: {
1248: liberation(s_etat_processus, s_objet_argument_1);
1249: free(tampon_lecture);
1250:
1251: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1252: return;
1253: }
1254:
1255: longueur_effective = (integer8) fread(tampon_lecture,
1256: sizeof(unsigned char), (size_t) longueur_enregistrement,
1257: (*descripteur).descripteur_c);
1258:
1259: if (longueur_effective != longueur_enregistrement)
1260: {
1261: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1262: return;
1263: }
1264:
1265: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1266: tampon = (*s_etat_processus).instruction_courante;
1267:
1268: if (((*s_etat_processus).instruction_courante =
1269: transliteration(s_etat_processus, tampon_lecture,
1270: "UTF-8", d_locale)) == NULL)
1271: {
1272: (*s_etat_processus).instruction_courante = tampon;
1273: liberation(s_etat_processus, s_objet_argument_1);
1274: free(tampon_lecture);
1275: return;
1276: }
1277:
1278: indicateur_48 = test_cfsf(s_etat_processus, 48);
1279: cf(s_etat_processus, 48);
1280:
1281: (*s_etat_processus).type_en_cours = NON;
1282: recherche_type(s_etat_processus);
1283: free((*s_etat_processus).instruction_courante);
1284:
1285: if ((*s_etat_processus).erreur_execution != d_ex)
1286: {
1287: if (indicateur_48 == d_vrai)
1288: {
1289: sf(s_etat_processus, 48);
1290: }
1291: else
1292: {
1293: cf(s_etat_processus, 48);
1294: }
1295:
1296: (*s_etat_processus).instruction_courante = tampon;
1297: free(tampon_lecture);
1298:
1299: liberation(s_etat_processus, s_objet_argument_1);
1300: return;
1301: }
1302:
1303: if (indicateur_48 == d_vrai)
1304: {
1305: sf(s_etat_processus, 48);
1306: }
1307: else
1308: {
1309: cf(s_etat_processus, 48);
1310: }
1311:
1312: (*s_etat_processus).instruction_courante = tampon;
1313: free(tampon_lecture);
1314: }
1315: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1316: == 'D')
1317: {
1318: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1319:
1320: if (depilement(s_etat_processus, &((*s_etat_processus)
1321: .l_base_pile), &s_objet_argument_2) == d_erreur)
1322: {
1323: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1324: return;
1325: }
1326:
1327: if ((*s_objet_argument_2).type != INT)
1328: {
1329: liberation(s_etat_processus, s_objet_argument_1);
1330: liberation(s_etat_processus, s_objet_argument_2);
1331:
1332: (*s_etat_processus).erreur_execution =
1333: d_ex_erreur_type_argument;
1334: return;
1335: }
1336:
1337: if (alsprintf(s_etat_processus, &commande,
1338: "select data from data where id = %lld",
1339: (*((integer8 *) (*s_objet_argument_2).objet))) < 0)
1340: {
1341: (*s_etat_processus).erreur_systeme =
1342: d_es_allocation_memoire;
1343: return;
1344: }
1345:
1346: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1347: commande, (int) strlen(commande), &ppStmt, &queue)
1348: != SQLITE_OK)
1349: {
1350: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1351: return;
1352: }
1353:
1354: attente.tv_sec = 0;
1355: attente.tv_nsec = GRANULARITE_us * 1000;
1356:
1357: do
1358: {
1359: ios = sqlite3_step(ppStmt);
1360:
1361: switch(ios)
1362: {
1363: case SQLITE_ROW:
1364: {
1365: // Résultat attendu
1366: break;
1367: }
1368:
1369: case SQLITE_DONE:
1370: {
1371: // Aucun enregistrement
1372: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1373: {
1374: (*s_etat_processus).erreur_systeme =
1375: d_es_erreur_fichier;
1376: return;
1377: }
1378:
1379: free(commande);
1380:
1381: liberation(s_etat_processus, s_objet_argument_1);
1382: liberation(s_etat_processus, s_objet_argument_2);
1383:
1384: (*s_etat_processus).erreur_execution =
1385: d_ex_enregistrement_inexistant;
1386: return;
1387: }
1388:
1389: case SQLITE_BUSY:
1390: case SQLITE_LOCKED:
1391: {
1392: nanosleep(&attente, NULL);
1393: INCR_GRANULARITE(attente.tv_nsec);
1394: break;
1395: }
1396:
1397: default:
1398: {
1399: (*s_etat_processus).erreur_systeme =
1400: d_es_erreur_fichier;
1401: return;
1402: }
1403: }
1404: } while(ios != SQLITE_ROW);
1405:
1406: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1407: {
1408: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1409: return;
1410: }
1411:
1412: tampon = (*s_etat_processus).instruction_courante;
1413:
1414: if ((tampon_lecture = (unsigned char *)
1415: sqlite3_column_text(ppStmt, 0)) == NULL)
1416: {
1417: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1418: return;
1419: }
1420:
1421: if (((*s_etat_processus).instruction_courante =
1422: transliteration(s_etat_processus, tampon_lecture,
1423: "UTF-8", d_locale)) == NULL)
1424: {
1425: (*s_etat_processus).instruction_courante = tampon;
1426:
1427: liberation(s_etat_processus, s_objet_argument_1);
1428: liberation(s_etat_processus, s_objet_argument_2);
1429: free(commande);
1430: return;
1431: }
1432:
1433: indicateur_48 = test_cfsf(s_etat_processus, 48);
1434: cf(s_etat_processus, 48);
1435:
1436: (*s_etat_processus).type_en_cours = NON;
1437: recherche_type(s_etat_processus);
1438:
1439: if ((*s_etat_processus).erreur_execution != d_ex)
1440: {
1441: if (indicateur_48 == d_vrai)
1442: {
1443: sf(s_etat_processus, 48);
1444: }
1445: else
1446: {
1447: cf(s_etat_processus, 48);
1448: }
1449:
1450: liberation(s_etat_processus, s_objet_argument_1);
1451: liberation(s_etat_processus, s_objet_argument_2);
1452:
1453: free((*s_etat_processus).instruction_courante);
1454: free(commande);
1455:
1456: (*s_etat_processus).instruction_courante = tampon;
1457: return;
1458: }
1459:
1460: if (indicateur_48 == d_vrai)
1461: {
1462: sf(s_etat_processus, 48);
1463: }
1464: else
1465: {
1466: cf(s_etat_processus, 48);
1467: }
1468:
1469: free((*s_etat_processus).instruction_courante);
1470: liberation(s_etat_processus, s_objet_argument_2);
1471: (*s_etat_processus).instruction_courante = tampon;
1472:
1473: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1474: {
1475: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1476: return;
1477: }
1478:
1479: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1480: {
1481: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1482: return;
1483: }
1484:
1485: free(commande);
1486: }
1487: else
1488: {
1489: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1490:
1491: if (depilement(s_etat_processus, &((*s_etat_processus)
1492: .l_base_pile), &s_objet_argument_2) == d_erreur)
1493: {
1494: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1495: return;
1496: }
1497:
1498: if ((*s_objet_argument_2).type != CHN)
1499: {
1500: liberation(s_etat_processus, s_objet_argument_1);
1501: liberation(s_etat_processus, s_objet_argument_2);
1502:
1503: (*s_etat_processus).erreur_execution =
1504: d_ex_erreur_type_argument;
1505: return;
1506: }
1507:
1508: // Récupération de la position de la clef
1509:
1510: if (alsprintf(s_etat_processus, &commande,
1511: "select key from control where id = 1") < 0)
1512: {
1513: (*s_etat_processus).erreur_systeme =
1514: d_es_allocation_memoire;
1515: return;
1516: }
1517:
1518: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1519: commande, (int) strlen(commande), &ppStmt, &queue)
1520: != SQLITE_OK)
1521: {
1522: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1523: return;
1524: }
1525:
1526: attente.tv_sec = 0;
1527: attente.tv_nsec = GRANULARITE_us * 1000;
1528:
1529: do
1530: {
1531: ios = sqlite3_step(ppStmt);
1532:
1533: if (ios == SQLITE_ROW)
1534: {
1535: break;
1536: }
1537: else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
1538: {
1539: nanosleep(&attente, NULL);
1540: INCR_GRANULARITE(attente.tv_nsec);
1541: }
1542: else
1543: {
1544: (*s_etat_processus).erreur_systeme =
1545: d_es_erreur_fichier;
1546: return;
1547: }
1548: } while(ios != SQLITE_ROW);
1549:
1550: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1551: {
1552: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1553: return;
1554: }
1555:
1556: position_clef = sqlite3_column_int64(ppStmt, 0);
1557:
1558: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1559: {
1560: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1561: return;
1562: }
1563:
1564: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1565: {
1566: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1567: return;
1568: }
1569:
1570: free(commande);
1571:
1572: if ((clef_utf8 = transliteration(s_etat_processus,
1573: (unsigned char *) (*s_objet_argument_2).objet,
1574: d_locale, "UTF-8")) == NULL)
1575: {
1576: liberation(s_etat_processus, s_objet_argument_1);
1577: liberation(s_etat_processus, s_objet_argument_2);
1578:
1579: return;
1580: }
1581:
1582: // Récupération de l'identifiant de la clef
1583:
1584: if (alsprintf(s_etat_processus, &commande,
1585: "select id from key where key = '{ \"%s\" }'",
1586: clef_utf8) < 0)
1587: {
1588: (*s_etat_processus).erreur_systeme =
1589: d_es_allocation_memoire;
1590: return;
1591: }
1592:
1593: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1594: commande, (int) strlen(commande), &ppStmt, &queue)
1595: != SQLITE_OK)
1596: {
1597: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1598: return;
1599: }
1600:
1601: attente.tv_sec = 0;
1602: attente.tv_nsec = GRANULARITE_us * 1000;
1603:
1604: do
1605: {
1606: ios = sqlite3_step(ppStmt);
1607:
1608: switch(ios)
1609: {
1610: case SQLITE_ROW:
1611: {
1612: // Résultat attendu : une clef correspond.
1613: break;
1614: }
1615:
1616: case SQLITE_DONE:
1617: {
1618: // Aucun enregistrement
1619: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1620: {
1621: (*s_etat_processus).erreur_systeme =
1622: d_es_erreur_fichier;
1623: return;
1624: }
1625:
1626: free(clef_utf8);
1627: free(commande);
1628:
1629: liberation(s_etat_processus, s_objet_argument_1);
1630: liberation(s_etat_processus, s_objet_argument_2);
1631:
1632: (*s_etat_processus).erreur_execution =
1633: d_ex_enregistrement_inexistant;
1634: return;
1635: }
1636:
1637: case SQLITE_BUSY:
1638: case SQLITE_LOCKED:
1639: {
1640: nanosleep(&attente, NULL);
1641: INCR_GRANULARITE(attente.tv_nsec);
1642: break;
1643: }
1644:
1645: default:
1646: {
1647: (*s_etat_processus).erreur_systeme =
1648: d_es_erreur_fichier;
1649: return;
1650: }
1651: }
1652: } while(ios != SQLITE_ROW);
1653:
1654: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1655: {
1656: free(clef_utf8);
1657: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1658: return;
1659: }
1660:
1661: id = sqlite3_column_int64(ppStmt, 0);
1662:
1663: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1664: {
1665: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1666: return;
1667: }
1668:
1669: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1670: {
1671: (*s_etat_processus).erreur_systeme =
1672: d_es_erreur_fichier;
1673: return;
1674: }
1675:
1676: free(commande);
1677:
1678: if (alsprintf(s_etat_processus, &commande,
1679: "select data from data where "
1680: "key_id = %lld order by sequence asc", id) < 0)
1681: {
1682: (*s_etat_processus).erreur_systeme =
1683: d_es_allocation_memoire;
1684: return;
1685: }
1686:
1687: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1688: commande, (int) strlen(commande), &ppStmt, &queue)
1689: != SQLITE_OK)
1690: {
1691: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1692: return;
1693: }
1694:
1695: element = 1;
1696:
1697: attente.tv_sec = 0;
1698: attente.tv_nsec = GRANULARITE_us * 1000;
1699:
1700: do
1701: {
1702: switch(ios = sqlite3_step(ppStmt))
1703: {
1704: case SQLITE_ROW:
1705: {
1706: // Donnée supplémentaire
1707:
1708: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1709: {
1710: (*s_etat_processus).erreur_systeme =
1711: d_es_erreur_fichier;
1712: return;
1713: }
1714:
1715: tampon = (*s_etat_processus).instruction_courante;
1716:
1717: if ((tampon_lecture = (unsigned char *)
1718: sqlite3_column_text(ppStmt, 0)) == NULL)
1719: {
1720: (*s_etat_processus).erreur_systeme =
1721: d_es_erreur_fichier;
1722: return;
1723: }
1724:
1725: if (((*s_etat_processus).instruction_courante =
1726: transliteration(s_etat_processus,
1727: tampon_lecture,
1728: "UTF-8", d_locale)) == NULL)
1729: {
1730: (*s_etat_processus).instruction_courante =
1731: tampon;
1732:
1733: liberation(s_etat_processus,
1734: s_objet_argument_1);
1735: liberation(s_etat_processus,
1736: s_objet_argument_2);
1737:
1738: free(commande);
1739: free(clef_utf8);
1740: return;
1741: }
1742:
1743: indicateur_48 = test_cfsf(s_etat_processus, 48);
1744: cf(s_etat_processus, 48);
1745:
1746: (*s_etat_processus).type_en_cours = NON;
1747: recherche_type(s_etat_processus);
1748:
1749: if ((*s_etat_processus).erreur_execution != d_ex)
1750: {
1751: if (indicateur_48 == d_vrai)
1752: {
1753: sf(s_etat_processus, 48);
1754: }
1755: else
1756: {
1757: cf(s_etat_processus, 48);
1758: }
1759:
1760: liberation(s_etat_processus,
1761: s_objet_argument_1);
1762: liberation(s_etat_processus,
1763: s_objet_argument_2);
1764:
1765: free((*s_etat_processus).instruction_courante);
1766: free(commande);
1767: free(clef_utf8);
1768:
1769: (*s_etat_processus).instruction_courante =
1770: tampon;
1771: return;
1772: }
1773:
1774: if (indicateur_48 == d_vrai)
1775: {
1776: sf(s_etat_processus, 48);
1777: }
1778: else
1779: {
1780: cf(s_etat_processus, 48);
1781: }
1782:
1783: free((*s_etat_processus).instruction_courante);
1784: (*s_etat_processus).instruction_courante = tampon;
1785:
1786: element++;
1787:
1788: // Inscription de la clef
1789:
1790: if (element == position_clef)
1791: {
1792: if (((*s_etat_processus).instruction_courante =
1793: transliteration(s_etat_processus,
1794: clef_utf8, "UTF-8", d_locale)) == NULL)
1795: {
1796: (*s_etat_processus).instruction_courante =
1797: tampon;
1798:
1799: liberation(s_etat_processus,
1800: s_objet_argument_1);
1801: liberation(s_etat_processus,
1802: s_objet_argument_2);
1803:
1804: free(commande);
1805: free(clef_utf8);
1806: return;
1807: }
1808:
1809: if (alsprintf(s_etat_processus, &tampon2,
1810: "{ \"%s\" }", (*s_etat_processus)
1811: .instruction_courante) < 0)
1812: {
1813: (*s_etat_processus).erreur_systeme =
1814: d_es_allocation_memoire;
1815: return;
1816: }
1817:
1818: free((*s_etat_processus).instruction_courante);
1819: (*s_etat_processus).instruction_courante
1820: = tampon2;
1821:
1822: indicateur_48 = test_cfsf(s_etat_processus, 48);
1823: cf(s_etat_processus, 48);
1824:
1825: (*s_etat_processus).type_en_cours = NON;
1826: recherche_type(s_etat_processus);
1827:
1828: if ((*s_etat_processus).erreur_execution
1829: != d_ex)
1830: {
1831: if (indicateur_48 == d_vrai)
1832: {
1833: sf(s_etat_processus, 48);
1834: }
1835: else
1836: {
1837: cf(s_etat_processus, 48);
1838: }
1839:
1840: liberation(s_etat_processus,
1841: s_objet_argument_1);
1842: liberation(s_etat_processus,
1843: s_objet_argument_2);
1844:
1845: free((*s_etat_processus)
1846: .instruction_courante);
1847: free(commande);
1848: free(clef_utf8);
1849:
1850: (*s_etat_processus).instruction_courante =
1851: tampon;
1852: return;
1853: }
1854:
1855: if (indicateur_48 == d_vrai)
1856: {
1857: sf(s_etat_processus, 48);
1858: }
1859: else
1860: {
1861: cf(s_etat_processus, 48);
1862: }
1863:
1864: free((*s_etat_processus).instruction_courante);
1865: (*s_etat_processus).instruction_courante =
1866: tampon;
1867:
1868: element++;
1869: }
1870:
1871: break;
1872: }
1873:
1874: case SQLITE_DONE:
1875: {
1876: // Fin de la liste
1877: break;
1878: }
1879:
1880: case SQLITE_BUSY:
1881: case SQLITE_LOCKED:
1882: {
1883: nanosleep(&attente, NULL);
1884: INCR_GRANULARITE(attente.tv_nsec);
1885: break;
1886: }
1887:
1888: default:
1889: {
1890: (*s_etat_processus).erreur_systeme =
1891: d_es_erreur_fichier;
1892: return;
1893: }
1894: }
1895: } while(ios != SQLITE_DONE);
1896:
1897: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1898: {
1899: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1900: return;
1901: }
1902:
1903: free(commande);
1904: free(clef_utf8);
1905:
1906: liberation(s_etat_processus, s_objet_argument_2);
1907:
1908: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1909: == NULL)
1910: {
1911: (*s_etat_processus).erreur_systeme =
1912: d_es_allocation_memoire;
1913: return;
1914: }
1915:
1916: l_element_courant = NULL;
1917: l_element_inclus = NULL;
1918:
1919: for(element--; element > 0; element--)
1920: {
1921: if (depilement(s_etat_processus, &((*s_etat_processus)
1922: .l_base_pile), &s_objet_argument_2) == d_erreur)
1923: {
1924: (*s_etat_processus).erreur_systeme =
1925: d_es_erreur_fichier;
1926: return;
1927: }
1928:
1929: if ((*s_objet_argument_2).type != LST)
1930: {
1931: (*s_etat_processus).erreur_systeme =
1932: d_es_erreur_fichier;
1933: return;
1934: }
1935:
1936: l_element_inclus = (*s_objet_argument_2).objet;
1937:
1938: if (l_element_inclus != NULL)
1939: {
1940: while(l_element_inclus != NULL)
1941: {
1942: if ((*l_element_inclus).suivant == NULL)
1943: {
1944: (*l_element_inclus).suivant = l_element_courant;
1945: break;
1946: }
1947:
1948: l_element_inclus = (*l_element_inclus).suivant;
1949: }
1950:
1951: l_element_courant = (*s_objet_argument_2).objet;
1952: (*s_objet_argument_2).objet = NULL;
1953: }
1954:
1955: liberation(s_etat_processus, s_objet_argument_2);
1956: }
1957:
1958: (*s_objet_resultat).objet = l_element_inclus;
1959:
1960: if (empilement(s_etat_processus,
1961: &((*s_etat_processus).l_base_pile),
1962: s_objet_resultat) == d_erreur)
1963: {
1964: return;
1965: }
1966: }
1967: }
1968: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1969: == 'Y')
1970: {
1971: /*
1972: * Fichiers non formatés
1973: */
1974:
1975: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1976: == 'S')
1977: {
1978: /*
1979: * Fichiers séquentiels
1980: *
1981: * Les fichiers séquentiels non formatés contiennent comme
1982: * les fichiers séquentiels formatés leurs enregistrements
1983: * sous la forme de listes les unes derrières les autres.
1984: *
1985: * Le quartet de poids fort du premier octet à lire
1986: * doit donc être égal à 0100. Si ce n'est pas le cas,
1987: * il sera impossible de lire le fichier et on renvoie
1988: * immédiatement une erreur. Si on lit dans le fichier
1989: * la valeur attendue, on récupère la longueur en octet
1990: * de l'enregistrement puis on le lit.
1991: */
1992:
1993: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1994:
1995: if ((s_objet_resultat = lecture_fichier_non_formate(
1996: s_etat_processus, (*descripteur).descripteur_c, -1,
1997: d_faux)) == NULL)
1998: {
1999: return;
2000: }
2001:
2002: if (empilement(s_etat_processus,
2003: &((*s_etat_processus).l_base_pile),
2004: s_objet_resultat) == d_erreur)
2005: {
2006: return;
2007: }
2008: }
2009: }
2010: else
2011: {
2012: /*
2013: * Fichiers de type FLOW
2014: */
2015:
2016: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
2017: == 'S')
2018: {
2019: /*
2020: * Fichiers séquentiels
2021: */
2022:
2023: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
2024: longueur_enregistrement = 0;
2025:
2026: device = d_faux;
2027:
2028: if ((position_initiale = ftell((*descripteur).descripteur_c))
2029: == -1)
2030: {
2031: if (errno == ESPIPE)
2032: {
2033: device = d_vrai;
2034: }
2035: else
2036: {
2037: (*s_etat_processus).erreur_systeme =
2038: d_es_erreur_fichier;
2039: return;
2040: }
2041: }
2042:
2043: l_element_courant_format = (struct_liste_chainee *)
2044: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
2045: .format).objet;
2046: l_element_courant = NULL;
2047:
2048: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2049: == NULL)
2050: {
2051: (*s_etat_processus).erreur_systeme =
2052: d_es_allocation_memoire;
2053: return;
2054: }
2055:
2056: while(l_element_courant_format != NULL)
2057: {
2058: if ((*(*l_element_courant_format).donnee).type != CHN)
2059: {
2060: liberation(s_etat_processus, s_objet_argument_1);
2061: liberation(s_etat_processus, s_objet_resultat);
2062:
2063: (*s_etat_processus).erreur_execution =
2064: d_ex_erreur_type_argument;
2065: return;
2066: }
2067:
2068: if ((format_chaine = conversion_majuscule(
2069: s_etat_processus, (unsigned char *)
2070: (*(*l_element_courant_format).donnee).objet))
2071: == NULL)
2072: {
2073: (*s_etat_processus).erreur_systeme =
2074: d_es_allocation_memoire;
2075: return;
2076: }
2077:
2078: if (strcmp("LINE*(*)", format_chaine) == 0)
2079: {
2080: format_degenere = d_vrai;
2081: format_oriente_ligne = d_vrai;
2082: }
2083: else
2084: {
2085: format_oriente_ligne = d_faux;
2086:
2087: if (strncmp("LENGTH*(", format_chaine, 8) != 0)
2088: {
2089: liberation(s_etat_processus, s_objet_argument_1);
2090: liberation(s_etat_processus, s_objet_resultat);
2091: free(format_chaine);
2092:
2093: (*s_etat_processus).erreur_execution =
2094: d_ex_erreur_format_fichier;
2095: return;
2096: }
2097:
2098: longueur = (integer8) strlen(format_chaine);
2099:
2100: if (format_chaine[longueur - 1] != ')')
2101: {
2102: liberation(s_etat_processus, s_objet_argument_1);
2103: liberation(s_etat_processus, s_objet_resultat);
2104: free(format_chaine);
2105:
2106: (*s_etat_processus).erreur_execution =
2107: d_ex_erreur_format_fichier;
2108: return;
2109: }
2110:
2111: format_chaine[longueur] = d_code_fin_chaine;
2112:
2113: if (format_chaine[8] == '*')
2114: {
2115: format_degenere = d_vrai;
2116: }
2117: else
2118: {
2119: // Détermination de la longueur
2120: format_degenere = d_faux;
2121:
2122: if (sscanf(&(format_chaine[8]), "%lld", &longueur)
2123: != 1)
2124: {
2125: liberation(s_etat_processus,
2126: s_objet_argument_1);
2127: liberation(s_etat_processus, s_objet_resultat);
2128: free(format_chaine);
2129:
2130: (*s_etat_processus).erreur_execution =
2131: d_ex_erreur_format_fichier;
2132: return;
2133: }
2134: }
2135: }
2136:
2137: free(format_chaine);
2138: tampon3 = NULL;
2139:
2140: if (format_degenere == d_vrai)
2141: {
2142: if (device == d_vrai)
2143: {
2144: longueur_questure = 4096;
2145: index = 0;
2146:
2147: if ((tampon3 = malloc(((size_t) longueur_questure) *
2148: sizeof(unsigned char))) == NULL)
2149: {
2150: (*s_etat_processus).erreur_systeme =
2151: d_es_allocation_memoire;
2152: return;
2153: }
2154:
2155: tampon3[index] = d_code_fin_chaine;
2156:
2157: fds[0].fd = fileno((*descripteur).descripteur_c);
2158: fds[0].events = POLLIN;
2159: fds[0].revents = 0;
2160:
2161: tcgetattr(fileno((*descripteur).descripteur_c),
2162: &tc);
2163: timeout = 0;
2164:
2165: for(i = 0; vitesses[i] != 0; i++)
2166: {
2167: if (cfgetispeed(&tc) == vitesses_constantes[i])
2168: {
2169: // La durée entre deux caractères sur le
2170: // périphérique série ne doit pas dépasser
2171: // la moitié de la durée de transmission
2172: // d'un caractère complet.
2173:
2174: timeout = (int) (((double) 1000) /
2175: (((double) vitesses_constantes[i]) /
2176: 4));
2177: break;
2178: }
2179: }
2180: }
2181: else
2182: {
2183: // Évite un warning de gcc.
2184: longueur_questure = 0;
2185: index = 0;
2186: timeout = 0;
2187: }
2188:
2189: do
2190: {
2191: if (device == d_vrai)
2192: {
2193: if (poll(fds, 1, timeout) == 0)
2194: {
2195: break;
2196: }
2197: }
2198:
2199: c = getc((*descripteur).descripteur_c);
2200: longueur_enregistrement++;
2201:
2202: if (device == d_vrai)
2203: {
2204: if (longueur_enregistrement >=
2205: longueur_questure)
2206: {
2207: if ((tampon3 = realloc(tampon3,
2208: (size_t) (longueur_questure *= 2)))
2209: == NULL)
2210: {
2211: (*s_etat_processus).erreur_systeme =
2212: d_es_allocation_memoire;
2213: return;
2214: }
2215: }
2216:
2217: tampon3[index++] = (unsigned char) c;
2218: }
2219:
2220: if (format_oriente_ligne == d_vrai)
2221: {
2222: if (c == '\n')
2223: {
2224: break;
2225: }
2226: }
2227: } while(c != EOF);
2228:
2229: if (device == d_faux)
2230: {
2231: if (fseek((*descripteur).descripteur_c,
2232: (long) position_initiale, SEEK_SET) != 0)
2233: {
2234: liberation(s_etat_processus,
2235: s_objet_argument_1);
2236: liberation(s_etat_processus, s_objet_resultat);
2237:
2238: (*s_etat_processus).erreur_systeme =
2239: d_es_erreur_fichier;
2240: return;
2241: }
2242: }
2243: }
2244: else
2245: {
2246: longueur_enregistrement = longueur;
2247: }
2248:
2249: if ((device == d_vrai) && (format_degenere == d_vrai))
2250: {
2251: longueur_effective = longueur_enregistrement;
2252: tampon_lecture = tampon3;
2253: }
2254: else
2255: {
2256: if ((tampon_lecture = malloc(((size_t)
2257: longueur_enregistrement) *
2258: sizeof(unsigned char))) == NULL)
2259: {
2260: (*s_etat_processus).erreur_systeme =
2261: d_es_allocation_memoire;
2262: return;
2263: }
2264:
2265: longueur_effective = (integer8) fread(tampon_lecture,
2266: sizeof(unsigned char),
2267: (size_t) longueur_enregistrement,
2268: (*descripteur).descripteur_c);
2269: }
2270:
2271: if (l_element_courant == NULL)
2272: {
2273: // Premier maillon de la liste
2274: if (((*s_objet_resultat).objet =
2275: allocation_maillon(s_etat_processus)) == NULL)
2276: {
2277: (*s_etat_processus).erreur_systeme =
2278: d_es_allocation_memoire;
2279: return;
2280: }
2281:
2282: l_element_courant = (*s_objet_resultat).objet;
2283: }
2284: else
2285: {
2286: if (((*l_element_courant).suivant =
2287: allocation_maillon(s_etat_processus)) == NULL)
2288: {
2289: (*s_etat_processus).erreur_systeme =
2290: d_es_allocation_memoire;
2291: return;
2292: }
2293:
2294: l_element_courant = (*l_element_courant).suivant;
2295: }
2296:
2297: (*l_element_courant).suivant = NULL;
2298:
2299: if (((*l_element_courant).donnee =
2300: allocation(s_etat_processus, CHN)) == NULL)
2301: {
2302: (*s_etat_processus).erreur_systeme =
2303: d_es_allocation_memoire;
2304: return;
2305: }
2306:
2307: if (format_degenere == d_vrai)
2308: {
2309: if (device == d_faux)
2310: {
2311: if (((*(*l_element_courant).donnee).objet =
2312: analyse_flux(s_etat_processus, tampon_lecture,
2313: longueur_enregistrement - 1)) == NULL)
2314: {
2315: return;
2316: }
2317: }
2318: else
2319: {
2320: if (((*(*l_element_courant).donnee).objet =
2321: analyse_flux(s_etat_processus, tampon_lecture,
2322: longueur_enregistrement)) == NULL)
2323: {
2324: return;
2325: }
2326: }
2327: }
2328: else
2329: {
2330: if (((*(*l_element_courant).donnee).objet =
2331: analyse_flux(s_etat_processus, tampon_lecture,
2332: longueur_enregistrement)) == NULL)
2333: {
2334: return;
2335: }
2336: }
2337:
2338: free(tampon_lecture);
2339:
2340: l_element_courant_format =
2341: (*l_element_courant_format).suivant;
2342: }
2343:
2344: if (empilement(s_etat_processus,
2345: &((*s_etat_processus).l_base_pile),
2346: s_objet_resultat) == d_erreur)
2347: {
2348: return;
2349: }
2350: }
2351: else
2352: {
2353: liberation(s_etat_processus, s_objet_argument_1);
2354:
2355: (*s_etat_processus).erreur_execution =
2356: d_ex_erreur_type_fichier;
2357: return;
2358: }
2359: }
2360: }
2361: else if ((*s_objet_argument_1).type == SCK)
2362: {
2363: /*
2364: * Vérification de l'autorisation de lecture
2365: */
2366:
2367: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
2368: == 'W')
2369: {
2370: liberation(s_etat_processus, s_objet_argument_1);
2371:
2372: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
2373: return;
2374: }
2375:
2376: /*
2377: * Vérification de l'écoute de la socket si celle-ci est connectée
2378: */
2379:
2380: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
2381: "STREAM") == 0) || (strcmp((*((struct_socket *)
2382: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
2383: == 0))
2384: {
2385: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2386: .socket_en_ecoute == 'Y')
2387: {
2388: liberation(s_etat_processus, s_objet_argument_1);
2389:
2390: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
2391: return;
2392: }
2393: }
2394:
2395: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
2396: { // Socket formatée
2397: longueur_questure = 4096;
2398: longueur_effective = 0;
2399: tampon_lecture = NULL;
2400:
2401: attente.tv_sec = 0;
2402: attente.tv_nsec = GRANULARITE_us * 1000;
2403:
2404: trame_complete = d_faux;
2405: position_initiale = 0;
2406: position_finale = 0;
2407:
2408: do
2409: {
2410: presence_indicateur = d_faux;
2411:
2412: if ((tampon_lecture = realloc(tampon_lecture,
2413: ((size_t) (longueur_effective + longueur_questure + 1))
2414: * sizeof(unsigned char))) == NULL)
2415: {
2416: (*s_etat_processus).erreur_systeme =
2417: d_es_allocation_memoire;
2418: return;
2419: }
2420:
2421: # ifndef SEMAPHORES_NOMMES
2422: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2423: # else
2424: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2425: # endif
2426: {
2427: (*s_etat_processus).erreur_systeme = d_es_processus;
2428: return;
2429: }
2430:
2431: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2432: .domaine == PF_UNIX)
2433: {
2434: longueur_adresse = sizeof(adresse_unix);
2435:
2436: do
2437: {
2438: ios = (int) recvfrom((*((struct_socket *)
2439: (*s_objet_argument_1).objet)).socket,
2440: tampon_lecture, (size_t) (longueur_effective +
2441: longueur_questure),
2442: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2443: &adresse_unix, &longueur_adresse);
2444: } while((ios == -1) && (errno == EINTR));
2445: }
2446: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2447: .domaine == PF_INET)
2448: {
2449: longueur_adresse = sizeof(adresse_ipv4);
2450:
2451: do
2452: {
2453: ios = (int) recvfrom((*((struct_socket *)
2454: (*s_objet_argument_1).objet)).socket,
2455: tampon_lecture, (size_t) (longueur_effective +
2456: longueur_questure),
2457: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2458: &adresse_ipv4, &longueur_adresse);
2459: } while((ios == -1) && (errno == EINTR));
2460: }
2461: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2462: .domaine == PF_INET6)
2463: {
2464: # ifdef IPV6
2465: longueur_adresse = sizeof(adresse_ipv6);
2466:
2467: do
2468: {
2469: ios = (int) recvfrom((*((struct_socket *)
2470: (*s_objet_argument_1).objet)).socket,
2471: tampon_lecture, (size_t) (longueur_effective +
2472: longueur_questure),
2473: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2474: &adresse_ipv6, &longueur_adresse);
2475: } while((ios == -1) && (errno == EINTR));
2476: # else
2477: if ((*s_etat_processus).langue == 'F')
2478: {
2479: printf("+++Attention : Support du protocole"
2480: " IPv6 indisponible\n");
2481: }
2482: else
2483: {
2484: printf("+++Warning : IPv6 support "
2485: "unavailable\n");
2486: }
2487:
2488: longueur_adresse = 0;
2489: longueur_effective = 0;
2490: ios = 0;
2491: # endif
2492: }
2493: else
2494: {
2495: free(tampon_lecture);
2496: liberation(s_etat_processus, s_objet_argument_1);
2497:
2498: # ifndef SEMAPHORES_NOMMES
2499: while(sem_wait(&((*s_etat_processus)
2500: .semaphore_fork)) != 0)
2501: # else
2502: while(sem_wait((*s_etat_processus)
2503: .semaphore_fork) != 0)
2504: # endif
2505: {
2506: (*s_etat_processus).erreur_systeme =
2507: d_es_processus;
2508: }
2509:
2510: (*s_etat_processus).erreur_execution =
2511: d_ex_erreur_acces_fichier;
2512: return;
2513: }
2514:
2515: if (ios <= 0)
2516: {
2517: nanosleep(&attente, NULL);
2518: INCR_GRANULARITE(attente.tv_nsec);
2519: }
2520: else
2521: {
2522: attente.tv_sec = 0;
2523: attente.tv_nsec = GRANULARITE_us * 1000;
2524: }
2525:
2526: scrutation_injection(s_etat_processus);
2527:
2528: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2529: {
2530: if (ios >= 0)
2531: {
2532: longueur_effective = ios;
2533: }
2534:
2535: break;
2536: }
2537:
2538: // Une donnée a été reçue.
2539: // Attention : on peut TOUJOURS recevoir 0
2540: // indiquant que la socket est close.
2541:
2542: if (ios >= 0)
2543: {
2544: longueur_effective = ios;
2545: position_initiale = 0;
2546: presence_indicateur = d_faux;
2547:
2548: if (ios > 0)
2549: {
2550: do
2551: {
2552: if (tampon_lecture[position_initiale] == '{')
2553: {
2554: presence_indicateur = d_vrai;
2555: break;
2556: }
2557:
2558: position_initiale++;
2559: } while(position_initiale < longueur_effective);
2560: }
2561: else
2562: {
2563: presence_indicateur = d_vrai;
2564: }
2565:
2566: if (presence_indicateur == d_vrai)
2567: {
2568: position_finale = position_initiale + 1;
2569: presence_chaine = d_faux;
2570: presence_indicateur = d_faux;
2571: niveau = 0;
2572:
2573: while(position_finale < longueur_effective)
2574: {
2575: caractere = tampon_lecture[position_finale];
2576:
2577: if (caractere == '"')
2578: {
2579: if (tampon_lecture[position_finale - 1]
2580: != '\\')
2581: {
2582: presence_chaine = (presence_chaine ==
2583: d_vrai) ? d_faux : d_vrai;
2584: }
2585: }
2586: else
2587: {
2588: if (presence_chaine == d_faux)
2589: {
2590: if (caractere == '{')
2591: {
2592: niveau++;
2593: }
2594: else if (caractere == '}')
2595: {
2596: niveau--;
2597: }
2598: }
2599: }
2600:
2601: if (niveau == 0)
2602: {
2603: presence_indicateur = d_vrai;
2604: trame_complete = d_vrai;
2605: break;
2606: }
2607:
2608: position_finale++;
2609: }
2610: }
2611:
2612: // On retire une trame du buffer.
2613:
2614: if (trame_complete == d_vrai)
2615: {
2616: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2617: .domaine == PF_UNIX)
2618: {
2619: do
2620: {
2621: longueur_adresse = sizeof(adresse_unix);
2622: recvfrom((*((struct_socket *)
2623: (*s_objet_argument_1).objet)).socket,
2624: tampon_lecture,
2625: (size_t) longueur_effective,
2626: 0, (struct sockaddr *)
2627: &adresse_unix, &longueur_adresse);
2628: } while((ios == -1) && (errno == EINTR));
2629: }
2630: else if ((*((struct_socket *) (*s_objet_argument_1)
2631: .objet)).domaine == PF_INET)
2632: {
2633: do
2634: {
2635: longueur_adresse = sizeof(adresse_ipv4);
2636: recvfrom((*((struct_socket *)
2637: (*s_objet_argument_1).objet)).socket,
2638: tampon_lecture,
2639: (size_t) longueur_effective,
2640: 0, (struct sockaddr *)
2641: &adresse_ipv4, &longueur_adresse);
2642: } while((ios == -1) && (errno == EINTR));
2643: }
2644: else if ((*((struct_socket *) (*s_objet_argument_1)
2645: .objet)) .domaine == PF_INET6)
2646: {
2647: # ifdef IPV6
2648: do
2649: {
2650: longueur_adresse = sizeof(adresse_ipv6);
2651: recvfrom((*((struct_socket *)
2652: (*s_objet_argument_1).objet)).socket,
2653: tampon_lecture,
2654: (size_t) longueur_effective,
2655: 0, (struct sockaddr *)
2656: &adresse_ipv6, &longueur_adresse);
2657: } while((ios == -1) && (errno == EINTR));
2658: # else
2659: if ((*s_etat_processus).langue == 'F')
2660: {
2661: printf("+++Attention : Support du protocole"
2662: " IPv6 indisponible\n");
2663: }
2664: else
2665: {
2666: printf("+++Warning : IPv6 support "
2667: "unavailable\n");
2668: }
2669:
2670: # endif
2671: }
2672:
2673: longueur_effective = ios;
2674: }
2675: else
2676: {
2677: // Si on a lu toute une trame et qu'on n'a pas
2678: // réussi à en trouver la structure, on remonte
2679: // une erreur de syntaxe.
2680:
2681: if (longueur_effective == ios)
2682: {
2683: if ((*((struct_socket *) (*s_objet_argument_1)
2684: .objet)).domaine == PF_UNIX)
2685: {
2686: do
2687: {
2688: longueur_adresse = sizeof(adresse_unix);
2689: recvfrom((*((struct_socket *)
2690: (*s_objet_argument_1).objet))
2691: .socket, tampon_lecture,
2692: (size_t) longueur_effective,
2693: 0, (struct sockaddr *)
2694: &adresse_unix, &longueur_adresse);
2695: } while((ios == -1) && (errno == EINTR));
2696: }
2697: else if ((*((struct_socket *) (*s_objet_argument_1)
2698: .objet)).domaine == PF_INET)
2699: {
2700: do
2701: {
2702: longueur_adresse = sizeof(adresse_ipv4);
2703: recvfrom((*((struct_socket *)
2704: (*s_objet_argument_1).objet))
2705: .socket, tampon_lecture,
2706: (size_t) longueur_effective,
2707: 0, (struct sockaddr *)
2708: &adresse_ipv4, &longueur_adresse);
2709: } while((ios == -1) && (errno == EINTR));
2710: }
2711: else if ((*((struct_socket *) (*s_objet_argument_1)
2712: .objet)) .domaine == PF_INET6)
2713: {
2714: # ifdef IPV6
2715: do
2716: {
2717: longueur_adresse = sizeof(adresse_ipv6);
2718: recvfrom((*((struct_socket *)
2719: (*s_objet_argument_1).objet))
2720: .socket, tampon_lecture,
2721: (size_t) longueur_effective,
2722: 0, (struct sockaddr *)
2723: &adresse_ipv6, &longueur_adresse);
2724: } while((ios == -1) && (errno == EINTR));
2725: # else
2726: if ((*s_etat_processus).langue == 'F')
2727: {
2728: printf("+++Attention : Support du protocole"
2729: " IPv6 indisponible\n");
2730: }
2731: else
2732: {
2733: printf("+++Warning : IPv6 support "
2734: "unavailable\n");
2735: }
2736:
2737: # endif
2738: }
2739:
2740: liberation(s_etat_processus, s_objet_argument_1);
2741: free(tampon_lecture);
2742:
2743: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2744: return;
2745: }
2746: }
2747: }
2748:
2749: # ifndef SEMAPHORES_NOMMES
2750: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
2751: # else
2752: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2753: # endif
2754: {
2755: if (errno == EINTR)
2756: {
2757: (*s_etat_processus).erreur_systeme = d_es_processus;
2758: return;
2759: }
2760: }
2761:
2762: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2763: {
2764:
2765: /*
2766: * Si le père tue le processus courant grâce au signal
2767: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
2768: * correspond à l'utilisation de STOP sur le processus
2769: * en cours. La variable longueur_effective vaut '-1'.
2770: */
2771:
2772: free(tampon_lecture);
2773: liberation(s_etat_processus, s_objet_argument_1);
2774: return;
2775: }
2776:
2777: if (longueur_effective == -1)
2778: {
2779: free(tampon_lecture);
2780: liberation(s_etat_processus, s_objet_argument_1);
2781:
2782: (*s_etat_processus).erreur_execution =
2783: d_ex_erreur_acces_fichier;
2784: return;
2785: }
2786: } while(trame_complete == d_faux);
2787:
2788: tampon = (*s_etat_processus).instruction_courante;
2789: (*s_etat_processus).instruction_courante = tampon_lecture;
2790:
2791: indicateur_48 = test_cfsf(s_etat_processus, 48);
2792: cf(s_etat_processus, 48);
2793:
2794: (*s_etat_processus).type_en_cours = NON;
2795: recherche_type(s_etat_processus);
2796:
2797: if ((*s_etat_processus).erreur_execution != d_ex)
2798: {
2799: (*s_etat_processus).instruction_courante = tampon;
2800: free(tampon_lecture);
2801:
2802: if (indicateur_48 == d_vrai)
2803: {
2804: sf(s_etat_processus, 48);
2805: }
2806: else
2807: {
2808: cf(s_etat_processus, 48);
2809: }
2810:
2811: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2812: {
2813: (*s_etat_processus).erreur_execution = d_ex;
2814: }
2815:
2816: liberation(s_etat_processus, s_objet_argument_1);
2817: return;
2818: }
2819:
2820: if (indicateur_48 == d_vrai)
2821: {
2822: sf(s_etat_processus, 48);
2823: }
2824: else
2825: {
2826: cf(s_etat_processus, 48);
2827: }
2828:
2829: (*s_etat_processus).instruction_courante = tampon;
2830:
2831: /*
2832: * Création de la liste de sortie
2833: */
2834:
2835: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2836: &s_objet_type) == d_erreur)
2837: {
2838: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2839: return;
2840: }
2841:
2842: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2843: == NULL)
2844: {
2845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2846: return;
2847: }
2848:
2849: if (((*s_objet_resultat).objet =
2850: allocation_maillon(s_etat_processus)) == NULL)
2851: {
2852: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2853: return;
2854: }
2855:
2856: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2857: .donnee = s_objet_type;
2858:
2859: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
2860: .suivant = allocation_maillon(s_etat_processus)) == NULL)
2861: {
2862: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2863: return;
2864: }
2865:
2866: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2867: .suivant = NULL;
2868:
2869: if ((s_objet_adresse = allocation(s_etat_processus, LST))
2870: == NULL)
2871: {
2872: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2873: return;
2874: }
2875:
2876: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2877: .donnee = s_objet_adresse;
2878:
2879: /*
2880: * Les informations concernant la cible sont valides si
2881: * la socket est non connectée et des domaines INET ou INET6.
2882: * Dans tous les autres cas, on renvoie une liste vide.
2883: */
2884:
2885: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
2886: == PF_UNIX) || (strcmp((*((struct_socket *)
2887: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
2888: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
2889: .type, "SEQUENTIAL DATAGRAM") == 0))
2890: {
2891: (*s_objet_adresse).objet = NULL;
2892: }
2893: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2894: .domaine == PF_INET)
2895: {
2896: if (((*s_objet_adresse).objet =
2897: allocation_maillon(s_etat_processus)) == NULL)
2898: {
2899: (*s_etat_processus).erreur_systeme =
2900: d_es_allocation_memoire;
2901: return;
2902: }
2903:
2904: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2905: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2906: {
2907: (*s_etat_processus).erreur_systeme =
2908: d_es_allocation_memoire;
2909: return;
2910: }
2911:
2912: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2913: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
2914:
2915: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2916: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2917: malloc(4 * sizeof(integer8))) == NULL)
2918: {
2919: (*s_etat_processus).erreur_systeme =
2920: d_es_allocation_memoire;
2921: return;
2922: }
2923:
2924: ((integer8 *) (*((struct_vecteur *)
2925: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2926: .objet)).donnee).objet)).tableau)[0] =
2927: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
2928: ((integer8 *) (*((struct_vecteur *)
2929: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2930: .objet)).donnee).objet)).tableau)[1] =
2931: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
2932: ((integer8 *) (*((struct_vecteur *)
2933: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2934: .objet)).donnee).objet)).tableau)[2] =
2935: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
2936: ((integer8 *) (*((struct_vecteur *)
2937: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2938: .objet)).donnee).objet)).tableau)[3] =
2939: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
2940:
2941: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2942: .suivant = allocation_maillon(s_etat_processus))
2943: == NULL)
2944: {
2945: (*s_etat_processus).erreur_systeme =
2946: d_es_allocation_memoire;
2947: return;
2948: }
2949:
2950: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2951: .suivant).donnee = allocation(s_etat_processus, INT))
2952: == NULL)
2953: {
2954: (*s_etat_processus).erreur_systeme =
2955: d_es_allocation_memoire;
2956: return;
2957: }
2958:
2959: (*((integer8 *) (*(*(*((struct_liste_chainee *)
2960: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
2961: (integer8) ntohs(adresse_ipv4.sin_port);
2962:
2963: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2964: .suivant).suivant = NULL;
2965: }
2966: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2967: .domaine == PF_INET6)
2968: {
2969: # ifdef IPV6
2970: if (((*s_objet_adresse).objet =
2971: allocation_maillon(s_etat_processus)) == NULL)
2972: {
2973: (*s_etat_processus).erreur_systeme =
2974: d_es_allocation_memoire;
2975: return;
2976: }
2977:
2978: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2979: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2980: {
2981: (*s_etat_processus).erreur_systeme =
2982: d_es_allocation_memoire;
2983: return;
2984: }
2985:
2986: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2987: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
2988:
2989: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2990: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2991: malloc(16 * sizeof(integer8))) == NULL)
2992: {
2993: (*s_etat_processus).erreur_systeme =
2994: d_es_allocation_memoire;
2995: return;
2996: }
2997:
2998: for(i = 0; i < 16; i++)
2999: {
3000: ((integer8 *) (*((struct_vecteur *)
3001: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3002: .objet)).donnee).objet)).tableau)[0] =
3003: adresse_ipv6.sin6_addr.s6_addr[i];
3004: }
3005:
3006: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3007: .suivant = allocation_maillon(s_etat_processus))
3008: == NULL)
3009: {
3010: (*s_etat_processus).erreur_systeme =
3011: d_es_allocation_memoire;
3012: return;
3013: }
3014:
3015: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3016: .suivant).donnee = allocation(s_etat_processus, INT))
3017: == NULL)
3018: {
3019: (*s_etat_processus).erreur_systeme =
3020: d_es_allocation_memoire;
3021: return;
3022: }
3023:
3024: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3025: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3026: (integer8) ntohs(adresse_ipv6.sin6_port);
3027:
3028: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3029: .suivant).suivant = NULL;
3030: # else
3031: if ((*s_etat_processus).langue == 'F')
3032: {
3033: printf("+++Attention : Support du protocole"
3034: " IPv6 indisponible\n");
3035: }
3036: else
3037: {
3038: printf("+++Warning : IPv6 support "
3039: "unavailable\n");
3040: }
3041: # endif
3042: }
3043: else
3044: {
3045: longueur_adresse = 0;
3046: recvfrom((*((struct_socket *)
3047: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3048: (size_t) position_finale, MSG_DONTWAIT,
3049: NULL, &longueur_adresse);
3050: }
3051:
3052: free(tampon_lecture);
3053:
3054: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3055: s_objet_resultat) == d_erreur)
3056: {
3057: return;
3058: }
3059: }
3060: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
3061: == 'Y')
3062: { // socket non formatée
3063: longueur_questure = 4096;
3064: longueur_effective = 0;
3065: tampon_lecture = NULL;
3066:
3067: attente.tv_sec = 0;
3068: attente.tv_nsec = GRANULARITE_us * 1000;
3069:
3070: trame_complete = d_faux;
3071: position_initiale = 0;
3072: position_finale = 0;
3073:
3074: do
3075: {
3076: presence_indicateur = d_faux;
3077:
3078: if ((tampon_lecture = realloc(tampon_lecture,
3079: ((size_t) (longueur_effective + longueur_questure) + 1)
3080: * sizeof(unsigned char))) == NULL)
3081: {
3082: (*s_etat_processus).erreur_systeme =
3083: d_es_allocation_memoire;
3084: return;
3085: }
3086:
3087: # ifndef SEMAPHORES_NOMMES
3088: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3089: # else
3090: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3091: # endif
3092: {
3093: (*s_etat_processus).erreur_systeme = d_es_processus;
3094: return;
3095: }
3096:
3097: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3098: .domaine == PF_UNIX)
3099: {
3100: longueur_adresse = sizeof(adresse_unix);
3101:
3102: do
3103: {
3104: ios = (int) recvfrom((*((struct_socket *)
3105: (*s_objet_argument_1).objet)).socket,
3106: tampon_lecture, (size_t)
3107: (longueur_effective + longueur_questure),
3108: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3109: &adresse_unix, &longueur_adresse);
3110: } while((ios == -1) && (errno == EINTR));
3111: }
3112: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3113: .domaine == PF_INET)
3114: {
3115: longueur_adresse = sizeof(adresse_ipv4);
3116:
3117: do
3118: {
3119: ios = (int) recvfrom((*((struct_socket *)
3120: (*s_objet_argument_1).objet)).socket,
3121: tampon_lecture, (size_t)
3122: (longueur_effective + longueur_questure),
3123: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3124: &adresse_ipv4, &longueur_adresse);
3125: } while((ios == -1) && (errno == EINTR));
3126: }
3127: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3128: .domaine == PF_INET6)
3129: {
3130: # ifdef IPV6
3131: longueur_adresse = sizeof(adresse_ipv6);
3132:
3133: do
3134: {
3135: ios = (int) recvfrom((*((struct_socket *)
3136: (*s_objet_argument_1).objet)).socket,
3137: tampon_lecture, (size_t)
3138: (longueur_effective + longueur_questure),
3139: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3140: &adresse_ipv6, &longueur_adresse);
3141: } while((ios == -1) && (errno == EINTR));
3142: # else
3143: if ((*s_etat_processus).langue == 'F')
3144: {
3145: printf("+++Attention : Support du protocole"
3146: " IPv6 indisponible\n");
3147: }
3148: else
3149: {
3150: printf("+++Warning : IPv6 support "
3151: "unavailable\n");
3152: }
3153:
3154: longueur_adresse = 0;
3155: longueur_effective = 0;
3156: ios = 0;
3157: # endif
3158: }
3159: else
3160: {
3161: free(tampon_lecture);
3162: liberation(s_etat_processus, s_objet_argument_1);
3163:
3164: # ifndef SEMAPHORES_NOMMES
3165: while(sem_wait(&((*s_etat_processus)
3166: .semaphore_fork)) != 0)
3167: # else
3168: while(sem_wait((*s_etat_processus)
3169: .semaphore_fork) != 0)
3170: # endif
3171: {
3172: (*s_etat_processus).erreur_systeme =
3173: d_es_processus;
3174: }
3175:
3176: (*s_etat_processus).erreur_execution =
3177: d_ex_erreur_acces_fichier;
3178: return;
3179: }
3180:
3181: if (ios < 0)
3182: {
3183: nanosleep(&attente, NULL);
3184: INCR_GRANULARITE(attente.tv_nsec);
3185: }
3186: else
3187: {
3188: attente.tv_sec = 0;
3189: attente.tv_nsec = GRANULARITE_us * 1000;
3190: }
3191:
3192: scrutation_injection(s_etat_processus);
3193:
3194: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3195: {
3196: if (ios >= 0)
3197: {
3198: longueur_effective += ios;
3199: }
3200:
3201: break;
3202: }
3203:
3204: // Une donnée a été reçue.
3205:
3206: if (ios == (longueur_effective + longueur_questure))
3207: {
3208: longueur_effective = ios;
3209: position_initiale = 0;
3210: presence_indicateur = d_faux;
3211: }
3212: else if (ios >= 0)
3213: {
3214: // On retire une trame du buffer.
3215:
3216: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3217: .domaine == PF_UNIX)
3218: {
3219: do
3220: {
3221: longueur_adresse = sizeof(adresse_unix);
3222: recvfrom((*((struct_socket *)
3223: (*s_objet_argument_1).objet)).socket,
3224: tampon_lecture, (size_t) longueur_effective,
3225: 0, (struct sockaddr *)
3226: &adresse_unix, &longueur_adresse);
3227: } while((ios == -1) && (errno == EINTR));
3228: }
3229: else if ((*((struct_socket *) (*s_objet_argument_1)
3230: .objet)).domaine == PF_INET)
3231: {
3232: do
3233: {
3234: longueur_adresse = sizeof(adresse_ipv4);
3235: recvfrom((*((struct_socket *)
3236: (*s_objet_argument_1).objet)).socket,
3237: tampon_lecture, (size_t) longueur_effective,
3238: 0, (struct sockaddr *)
3239: &adresse_ipv4, &longueur_adresse);
3240: } while((ios == -1) && (errno == EINTR));
3241: }
3242: else if ((*((struct_socket *) (*s_objet_argument_1)
3243: .objet)) .domaine == PF_INET6)
3244: {
3245: # ifdef IPV6
3246: do
3247: {
3248: longueur_adresse = sizeof(adresse_ipv6);
3249: recvfrom((*((struct_socket *)
3250: (*s_objet_argument_1).objet)).socket,
3251: tampon_lecture, (size_t) longueur_effective,
3252: 0, (struct sockaddr *)
3253: &adresse_ipv6, &longueur_adresse);
3254: } while((ios == -1) && (errno == EINTR));
3255: # else
3256: if ((*s_etat_processus).langue == 'F')
3257: {
3258: printf("+++Attention : Support du protocole"
3259: " IPv6 indisponible\n");
3260: }
3261: else
3262: {
3263: printf("+++Warning : IPv6 support "
3264: "unavailable\n");
3265: }
3266: # endif
3267: }
3268:
3269: longueur_effective = ios;
3270: trame_complete = d_vrai;
3271: }
3272:
3273: # ifndef SEMAPHORES_NOMMES
3274: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3275: # else
3276: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3277: # endif
3278: {
3279: if (errno == EINTR)
3280: {
3281: (*s_etat_processus).erreur_systeme = d_es_processus;
3282: return;
3283: }
3284: }
3285:
3286: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3287: {
3288:
3289: /*
3290: * Si le père tue le processus courant grâce au signal
3291: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3292: * correspond à l'utilisation de STOP sur le processus
3293: * en cours. La variable longueur_effective vaut '-1'.
3294: */
3295:
3296: free(tampon_lecture);
3297: liberation(s_etat_processus, s_objet_argument_1);
3298: return;
3299: }
3300:
3301: if (longueur_effective == -1)
3302: {
3303: free(tampon_lecture);
3304: liberation(s_etat_processus, s_objet_argument_1);
3305:
3306: (*s_etat_processus).erreur_execution =
3307: d_ex_erreur_acces_fichier;
3308: return;
3309: }
3310: } while(trame_complete == d_faux);
3311:
3312: /*
3313: * Création de la liste de sortie
3314: */
3315:
3316: ptr = tampon_lecture;
3317:
3318: if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
3319: &ptr, longueur_effective, d_faux)) == NULL)
3320: {
3321: free(tampon_lecture);
3322:
3323: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3324: return;
3325: }
3326:
3327: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3328: == NULL)
3329: {
3330: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3331: return;
3332: }
3333:
3334: if (((*s_objet_resultat).objet =
3335: allocation_maillon(s_etat_processus)) == NULL)
3336: {
3337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3338: return;
3339: }
3340:
3341: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3342: .donnee = s_objet_type;
3343:
3344: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3345: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3346: {
3347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3348: return;
3349: }
3350:
3351: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3352: .suivant = NULL;
3353:
3354: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3355: == NULL)
3356: {
3357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3358: return;
3359: }
3360:
3361: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3362: .donnee = s_objet_adresse;
3363:
3364: /*
3365: * Les informations concernant la cible sont valides si
3366: * la socket est non connectée et des domaines INET ou INET6.
3367: * Dans tous les autres cas, on renvoie une liste vide.
3368: */
3369:
3370: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3371: == PF_UNIX) || (strcmp((*((struct_socket *)
3372: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3373: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3374: .type, "SEQUENTIAL DATAGRAM") == 0))
3375: {
3376: (*s_objet_adresse).objet = NULL;
3377: }
3378: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3379: .domaine == PF_INET)
3380: {
3381: if (((*s_objet_adresse).objet =
3382: allocation_maillon(s_etat_processus)) == NULL)
3383: {
3384: (*s_etat_processus).erreur_systeme =
3385: d_es_allocation_memoire;
3386: return;
3387: }
3388:
3389: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3390: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3391: {
3392: (*s_etat_processus).erreur_systeme =
3393: d_es_allocation_memoire;
3394: return;
3395: }
3396:
3397: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3398: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3399:
3400: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3401: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3402: malloc(4 * sizeof(integer8))) == NULL)
3403: {
3404: (*s_etat_processus).erreur_systeme =
3405: d_es_allocation_memoire;
3406: return;
3407: }
3408:
3409: ((integer8 *) (*((struct_vecteur *)
3410: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3411: .objet)).donnee).objet)).tableau)[0] =
3412: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3413: ((integer8 *) (*((struct_vecteur *)
3414: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3415: .objet)).donnee).objet)).tableau)[1] =
3416: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3417: ((integer8 *) (*((struct_vecteur *)
3418: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3419: .objet)).donnee).objet)).tableau)[2] =
3420: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3421: ((integer8 *) (*((struct_vecteur *)
3422: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3423: .objet)).donnee).objet)).tableau)[3] =
3424: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3425:
3426: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3427: .suivant = allocation_maillon(s_etat_processus))
3428: == NULL)
3429: {
3430: (*s_etat_processus).erreur_systeme =
3431: d_es_allocation_memoire;
3432: return;
3433: }
3434:
3435: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3436: .suivant).donnee = allocation(s_etat_processus, INT))
3437: == NULL)
3438: {
3439: (*s_etat_processus).erreur_systeme =
3440: d_es_allocation_memoire;
3441: return;
3442: }
3443:
3444: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3445: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3446: (integer8) ntohs(adresse_ipv4.sin_port);
3447:
3448: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3449: .suivant).suivant = NULL;
3450: }
3451: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3452: .domaine == PF_INET6)
3453: {
3454: # ifdef IPV6
3455: if (((*s_objet_adresse).objet =
3456: allocation_maillon(s_etat_processus)) == NULL)
3457: {
3458: (*s_etat_processus).erreur_systeme =
3459: d_es_allocation_memoire;
3460: return;
3461: }
3462:
3463: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3464: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3465: {
3466: (*s_etat_processus).erreur_systeme =
3467: d_es_allocation_memoire;
3468: return;
3469: }
3470:
3471: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3472: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3473:
3474: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3475: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3476: malloc(16 * sizeof(integer8))) == NULL)
3477: {
3478: (*s_etat_processus).erreur_systeme =
3479: d_es_allocation_memoire;
3480: return;
3481: }
3482:
3483: for(i = 0; i < 16; i++)
3484: {
3485: ((integer8 *) (*((struct_vecteur *)
3486: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3487: .objet)).donnee).objet)).tableau)[0] =
3488: adresse_ipv6.sin6_addr.s6_addr[i];
3489: }
3490:
3491: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3492: .suivant = allocation_maillon(s_etat_processus))
3493: == NULL)
3494: {
3495: (*s_etat_processus).erreur_systeme =
3496: d_es_allocation_memoire;
3497: return;
3498: }
3499:
3500: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3501: .suivant).donnee = allocation(s_etat_processus, INT))
3502: == NULL)
3503: {
3504: (*s_etat_processus).erreur_systeme =
3505: d_es_allocation_memoire;
3506: return;
3507: }
3508:
3509: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3510: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3511: (integer8) ntohs(adresse_ipv6.sin6_port);
3512:
3513: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3514: .suivant).suivant = NULL;
3515: # else
3516: if ((*s_etat_processus).langue == 'F')
3517: {
3518: printf("+++Attention : Support du protocole"
3519: " IPv6 indisponible\n");
3520: }
3521: else
3522: {
3523: printf("+++Warning : IPv6 support "
3524: "unavailable\n");
3525: }
3526: # endif
3527: }
3528: else
3529: {
3530: longueur_adresse = 0;
3531: recvfrom((*((struct_socket *)
3532: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3533: (size_t) position_finale, MSG_DONTWAIT,
3534: NULL, &longueur_adresse);
3535: }
3536:
3537: free(tampon_lecture);
3538:
3539: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3540: s_objet_resultat) == d_erreur)
3541: {
3542: return;
3543: }
3544: }
3545: else
3546: { // FLOW
3547: longueur_questure = 256;
3548:
3549: do
3550: {
3551: if ((tampon_lecture = malloc((((size_t) longueur_questure) + 1)
3552: * sizeof(unsigned char))) == NULL)
3553: {
3554: (*s_etat_processus).erreur_systeme =
3555: d_es_allocation_memoire;
3556: return;
3557: }
3558:
3559: # ifndef SEMAPHORES_NOMMES
3560: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3561: # else
3562: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3563: # endif
3564: {
3565: (*s_etat_processus).erreur_systeme = d_es_processus;
3566: return;
3567: }
3568:
3569: attente.tv_sec = 0;
3570: attente.tv_nsec = GRANULARITE_us * 1000;
3571:
3572: for(;;)
3573: {
3574: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3575: .domaine == PF_UNIX)
3576: {
3577: longueur_adresse = sizeof(adresse_unix);
3578: longueur_effective = recvfrom((*((struct_socket *)
3579: (*s_objet_argument_1).objet)).socket,
3580: tampon_lecture, (long unsigned int)
3581: longueur_questure,
3582: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3583: &adresse_unix, &longueur_adresse);
3584: }
3585: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3586: .domaine == PF_INET)
3587: {
3588: longueur_adresse = sizeof(adresse_ipv4);
3589: longueur_effective = recvfrom((*((struct_socket *)
3590: (*s_objet_argument_1).objet)).socket,
3591: tampon_lecture, (long unsigned int)
3592: longueur_questure,
3593: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3594: &adresse_ipv4, &longueur_adresse);
3595: }
3596: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3597: .domaine == PF_INET6)
3598: {
3599: # ifdef IPV6
3600: longueur_adresse = sizeof(adresse_ipv6);
3601: longueur_effective = recvfrom((*((struct_socket *)
3602: (*s_objet_argument_1).objet)).socket,
3603: tampon_lecture, (long unsigned int)
3604: longueur_questure,
3605: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3606: &adresse_ipv6, &longueur_adresse);
3607: # else
3608: if ((*s_etat_processus).langue == 'F')
3609: {
3610: printf("+++Attention : Support du protocole"
3611: " IPv6 indisponible\n");
3612: }
3613: else
3614: {
3615: printf("+++Warning : IPv6 support "
3616: "unavailable\n");
3617: }
3618:
3619: longueur_adresse = 0;
3620: longueur_effective = 0;
3621: # endif
3622: }
3623: else
3624: {
3625: free(tampon_lecture);
3626: liberation(s_etat_processus, s_objet_argument_1);
3627:
3628: # ifndef SEMAPHORES_NOMMES
3629: while(sem_wait(&((*s_etat_processus)
3630: .semaphore_fork)) != 0)
3631: # else
3632: while(sem_wait((*s_etat_processus)
3633: .semaphore_fork) != 0)
3634: # endif
3635: {
3636: if (errno != EINTR)
3637: {
3638: (*s_etat_processus).erreur_systeme =
3639: d_es_processus;
3640: return;
3641: }
3642: }
3643:
3644: (*s_etat_processus).erreur_execution =
3645: d_ex_erreur_acces_fichier;
3646: return;
3647: }
3648:
3649: if (longueur_effective < 0)
3650: {
3651: nanosleep(&attente, NULL);
3652: INCR_GRANULARITE(attente.tv_nsec);
3653: scrutation_injection(s_etat_processus);
3654: }
3655:
3656: if (((*s_etat_processus).var_volatile_requete_arret == -1)
3657: || (longueur_effective >= 0))
3658: {
3659: break;
3660: }
3661: }
3662:
3663: # ifndef SEMAPHORES_NOMMES
3664: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3665: # else
3666: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3667: # endif
3668: {
3669: if (errno != EINTR)
3670: {
3671: (*s_etat_processus).erreur_systeme = d_es_processus;
3672: return;
3673: }
3674: }
3675:
3676: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3677: {
3678:
3679: /*
3680: * Si le père tue le processus courant grâce au signal
3681: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3682: * correspond à l'utilisation de STOP sur le processus
3683: * en cours. La variable longueur_effective vaut '-1'.
3684: */
3685:
3686: free(tampon_lecture);
3687: liberation(s_etat_processus, s_objet_argument_1);
3688: return;
3689: }
3690:
3691: if (longueur_effective == -1)
3692: {
3693: free(tampon_lecture);
3694: liberation(s_etat_processus, s_objet_argument_1);
3695:
3696: (*s_etat_processus).erreur_execution =
3697: d_ex_erreur_acces_fichier;
3698: return;
3699: }
3700:
3701: if (longueur_effective == longueur_questure)
3702: {
3703: trame_complete = d_faux;
3704: free(tampon_lecture);
3705:
3706: // Taille standard des jumbo frames
3707: if (longueur_questure <= 9000)
3708: {
3709: longueur_questure *= 2;
3710: }
3711: else
3712: {
3713: longueur_questure += 9000;
3714: }
3715: }
3716: else
3717: {
3718: trame_complete = d_vrai;
3719: }
3720: } while(trame_complete == d_faux);
3721:
3722: longueur_enregistrement = 1;
3723:
3724: for(i = 0; i < longueur_effective; i++)
3725: {
3726: if (isprint(tampon_lecture[i]) == 0)
3727: {
3728: longueur_enregistrement += 4;
3729: }
3730: else
3731: {
3732: if ((tampon_lecture[i] == '"') ||
3733: (tampon_lecture[i] == '"'))
3734: {
3735: longueur_enregistrement += 2;
3736: }
3737: else
3738: {
3739: longueur_enregistrement++;
3740: }
3741: }
3742: }
3743:
3744: /*
3745: * Création de la liste de sortie
3746: */
3747:
3748: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
3749: {
3750: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3751: return;
3752: }
3753:
3754: if (((*s_objet_type).objet = malloc((size_t) longueur_enregistrement
3755: * sizeof(unsigned char))) == NULL)
3756: {
3757: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3758: return;
3759: }
3760:
3761: ptr = (*s_objet_type).objet;
3762:
3763: for(i = 0; i < longueur_effective; i++)
3764: {
3765: if (isprint(tampon_lecture[i]) != 0)
3766: {
3767: if ((tampon_lecture[i] == '"') ||
3768: (tampon_lecture[i] == '"'))
3769: {
3770: (*ptr) = '\\';
3771: ptr++;
3772: (*ptr) = tampon_lecture[i];
3773: ptr++;
3774: }
3775: else
3776: {
3777: (*ptr) = tampon_lecture[i];
3778: ptr++;
3779: }
3780: }
3781: else
3782: {
3783: (*ptr) = '\\';
3784: ptr++;
3785: (*ptr) = 'x';
3786: ptr++;
3787: sprintf(ptr, "%02X", tampon_lecture[i]);
3788: ptr += 2;
3789: }
3790: }
3791:
3792: (*ptr) = d_code_fin_chaine;
3793:
3794: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3795: == NULL)
3796: {
3797: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3798: return;
3799: }
3800:
3801: if (((*s_objet_resultat).objet =
3802: allocation_maillon(s_etat_processus)) == NULL)
3803: {
3804: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3805: return;
3806: }
3807:
3808: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3809: .donnee = s_objet_type;
3810:
3811: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3812: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3813: {
3814: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3815: return;
3816: }
3817:
3818: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3819: .suivant = NULL;
3820:
3821: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3822: == NULL)
3823: {
3824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3825: return;
3826: }
3827:
3828: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3829: .donnee = s_objet_adresse;
3830:
3831: /*
3832: * Les informations concernant la cible sont valides si
3833: * la socket est non connectée et que les domaines sont
3834: * INET ou INET6.
3835: * Dans tous les autres cas, on renvoie une liste vide.
3836: */
3837:
3838: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3839: == PF_UNIX) || (strcmp((*((struct_socket *)
3840: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3841: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3842: .type, "SEQUENTIAL DATAGRAM") == 0))
3843: {
3844: // POSITION_FINALE peut être utilisée sans être initialisée !
3845: // virer position_finale pour longueur_effective
3846: longueur_adresse = 0;
3847: recvfrom((*((struct_socket *)
3848: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3849: (long unsigned int) longueur_effective, MSG_DONTWAIT,
3850: NULL, &longueur_adresse);
3851:
3852: (*s_objet_adresse).objet = NULL;
3853: }
3854: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3855: .domaine == PF_INET)
3856: {
3857: longueur_adresse = sizeof(adresse_ipv4);
3858: recvfrom((*((struct_socket *)
3859: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3860: (long unsigned int) longueur_effective, MSG_DONTWAIT,
3861: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
3862:
3863: if (((*s_objet_adresse).objet =
3864: allocation_maillon(s_etat_processus)) == NULL)
3865: {
3866: (*s_etat_processus).erreur_systeme =
3867: d_es_allocation_memoire;
3868: return;
3869: }
3870:
3871: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3872: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3873: {
3874: (*s_etat_processus).erreur_systeme =
3875: d_es_allocation_memoire;
3876: return;
3877: }
3878:
3879: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3880: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3881:
3882: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3883: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3884: malloc(4 * sizeof(integer8))) == NULL)
3885: {
3886: (*s_etat_processus).erreur_systeme =
3887: d_es_allocation_memoire;
3888: return;
3889: }
3890:
3891: ((integer8 *) (*((struct_vecteur *)
3892: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3893: .objet)).donnee).objet)).tableau)[0] =
3894: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3895: ((integer8 *) (*((struct_vecteur *)
3896: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3897: .objet)).donnee).objet)).tableau)[1] =
3898: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3899: ((integer8 *) (*((struct_vecteur *)
3900: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3901: .objet)).donnee).objet)).tableau)[2] =
3902: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3903: ((integer8 *) (*((struct_vecteur *)
3904: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3905: .objet)).donnee).objet)).tableau)[3] =
3906: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3907:
3908: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3909: .suivant = allocation_maillon(s_etat_processus))
3910: == NULL)
3911: {
3912: (*s_etat_processus).erreur_systeme =
3913: d_es_allocation_memoire;
3914: return;
3915: }
3916:
3917: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3918: .suivant).donnee = allocation(s_etat_processus, INT))
3919: == NULL)
3920: {
3921: (*s_etat_processus).erreur_systeme =
3922: d_es_allocation_memoire;
3923: return;
3924: }
3925:
3926: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3927: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3928: (integer8) ntohs(adresse_ipv4.sin_port);
3929:
3930: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3931: .suivant).suivant = NULL;
3932: }
3933: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3934: .domaine == PF_INET6)
3935: {
3936: # ifdef IPV6
3937: longueur_adresse = sizeof(adresse_ipv6);
3938: recvfrom((*((struct_socket *)
3939: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3940: (long unsigned int) longueur_effective, MSG_DONTWAIT,
3941: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
3942:
3943: if (((*s_objet_adresse).objet =
3944: allocation_maillon(s_etat_processus)) == NULL)
3945: {
3946: (*s_etat_processus).erreur_systeme =
3947: d_es_allocation_memoire;
3948: return;
3949: }
3950:
3951: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3952: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3953: {
3954: (*s_etat_processus).erreur_systeme =
3955: d_es_allocation_memoire;
3956: return;
3957: }
3958:
3959: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3960: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3961:
3962: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3963: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3964: malloc(16 * sizeof(integer8))) == NULL)
3965: {
3966: (*s_etat_processus).erreur_systeme =
3967: d_es_allocation_memoire;
3968: return;
3969: }
3970:
3971: for(i = 0; i < 16; i++)
3972: {
3973: ((integer8 *) (*((struct_vecteur *)
3974: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3975: .objet)).donnee).objet)).tableau)[0] =
3976: adresse_ipv6.sin6_addr.s6_addr[i];
3977: }
3978:
3979: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3980: .suivant = allocation_maillon(s_etat_processus))
3981: == NULL)
3982: {
3983: (*s_etat_processus).erreur_systeme =
3984: d_es_allocation_memoire;
3985: return;
3986: }
3987:
3988: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3989: .suivant).donnee = allocation(s_etat_processus, INT))
3990: == NULL)
3991: {
3992: (*s_etat_processus).erreur_systeme =
3993: d_es_allocation_memoire;
3994: return;
3995: }
3996:
3997: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3998: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3999: (integer8) ntohs(adresse_ipv6.sin6_port);
4000:
4001: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
4002: .suivant).suivant = NULL;
4003: # else
4004: if ((*s_etat_processus).langue == 'F')
4005: {
4006: printf("+++Attention : Support du protocole"
4007: " IPv6 indisponible\n");
4008: }
4009: else
4010: {
4011: printf("+++Warning : IPv6 support "
4012: "unavailable\n");
4013: }
4014: # endif
4015: }
4016: else
4017: {
4018: longueur_adresse = 0;
4019: recvfrom((*((struct_socket *)
4020: (*s_objet_argument_1).objet)).socket, tampon_lecture,
4021: (long unsigned int) longueur_effective, MSG_DONTWAIT,
4022: NULL, &longueur_adresse);
4023: }
4024:
4025: free(tampon_lecture);
4026:
4027: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
4028: s_objet_resultat) == d_erreur)
4029: {
4030: return;
4031: }
4032: }
4033: }
4034: else
4035: {
4036: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
4037: return;
4038: }
4039:
4040: liberation(s_etat_processus, s_objet_argument_1);
4041:
4042: return;
4043: }
4044:
4045: // 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