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