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