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