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