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