![[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|
Return to instructions_r4.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.70 bertrand 3: RPL/2 (R) version 4.1.13
1.69 bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 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:
1.19 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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: {
1.5 bertrand 754: struct_descripteur_fichier *descripteur;
1.1 bertrand 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:
1.5 bertrand 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
1.1 bertrand 815: {
816: liberation(s_etat_processus, s_objet_argument);
817:
1.5 bertrand 818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
1.1 bertrand 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: {
1.6 bertrand 849: const char *queue;
850:
1.28 bertrand 851: int c;
1.8 bertrand 852: int ios;
853:
854: integer8 element;
1.46 bertrand 855: integer8 i;
1.8 bertrand 856: integer8 id;
857: integer8 position_clef;
1.46 bertrand 858: integer8 longueur_effective;
859: integer8 longueur_enregistrement;
860: integer8 longueur_questure;
861: integer8 niveau;
862: integer8 pointeur;
863: integer8 position_finale;
864: integer8 position_initiale;
865:
1.59 bertrand 866: logical1 format_degenere;
1.1 bertrand 867: logical1 indicateur_48;
868: logical1 presence_chaine;
869: logical1 presence_indicateur;
1.57 bertrand 870: logical1 trame_complete;
1.1 bertrand 871:
1.59 bertrand 872: long longueur;
873:
1.1 bertrand 874: socklen_t longueur_adresse;
875:
1.6 bertrand 876: sqlite3_stmt *ppStmt;
877:
1.1 bertrand 878: struct flock lock;
879:
880: struct sockaddr_un adresse_unix;
881: struct sockaddr_in adresse_ipv4;
1.19 bertrand 882: # ifdef IPV6
1.1 bertrand 883: struct sockaddr_in6 adresse_ipv6;
1.19 bertrand 884: # endif
1.1 bertrand 885:
1.71 bertrand 886: struct pollfd poll_fd;
887:
1.1 bertrand 888: struct timespec attente;
889:
1.5 bertrand 890: struct_descripteur_fichier *descripteur;
891:
1.8 bertrand 892: struct_liste_chainee *l_element_courant;
1.59 bertrand 893: struct_liste_chainee *l_element_courant_format;
1.8 bertrand 894: struct_liste_chainee *l_element_inclus;
895:
1.1 bertrand 896: struct_objet *s_objet_adresse;
1.6 bertrand 897: struct_objet *s_objet_argument_1;
898: struct_objet *s_objet_argument_2;
1.1 bertrand 899: struct_objet *s_objet_resultat;
900: struct_objet *s_objet_type;
901:
902: unsigned char caractere;
1.8 bertrand 903: unsigned char *clef_utf8;
1.6 bertrand 904: unsigned char *commande;
1.59 bertrand 905: unsigned char *format_chaine;
1.28 bertrand 906: unsigned char *ptr;
1.1 bertrand 907: unsigned char *tampon_lecture;
908: unsigned char *tampon;
1.8 bertrand 909: unsigned char *tampon2;
1.1 bertrand 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:
1.6 bertrand 926: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
1.1 bertrand 927:
1.8 bertrand 928: printf(" 2: %s, %s\n", d_INT, d_CHN);
1.6 bertrand 929: printf(" 1: %s\n", d_FCH);
1.1 bertrand 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: {
1.6 bertrand 940: if ((*s_etat_processus).l_base_pile == NULL)
1.1 bertrand 941: {
1.6 bertrand 942: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1.1 bertrand 943: return;
944: }
1.6 bertrand 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: }
1.1 bertrand 971: }
972:
973: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1.6 bertrand 974: &s_objet_argument_1) == d_erreur)
1.1 bertrand 975: {
976: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
977: return;
978: }
979:
1.6 bertrand 980: if ((*s_objet_argument_1).type == FCH)
1.1 bertrand 981: {
1.5 bertrand 982: if ((descripteur = descripteur_fichier(s_etat_processus,
1.6 bertrand 983: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
1.5 bertrand 984: {
985: return;
986: }
987:
1.1 bertrand 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:
1.5 bertrand 998: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
999: == -1)
1.1 bertrand 1000: {
1.6 bertrand 1001: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1002:
1003: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1004: return;
1005: }
1006:
1007: if (lock.l_type != F_UNLCK)
1008: {
1.6 bertrand 1009: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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:
1.6 bertrand 1020: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1021: == 'W')
1.1 bertrand 1022: {
1.6 bertrand 1023: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1024:
1025: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1026: return;
1027: }
1.6 bertrand 1028: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1.1 bertrand 1029: == 'N')
1030: {
1.5 bertrand 1031: if ((*descripteur).type == 'C')
1.1 bertrand 1032: {
1.5 bertrand 1033: if (fflush((*descripteur).descripteur_c) != 0)
1034: {
1035: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1036: return;
1037: }
1.1 bertrand 1038: }
1039: }
1040:
1.6 bertrand 1041: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 1042: {
1043: /*
1044: * Fichiers formatés
1045: */
1046:
1.6 bertrand 1047: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1048: == 'S')
1.1 bertrand 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:
1.5 bertrand 1064: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1065:
1066: if ((position_initiale = ftell((*descripteur).descripteur_c))
1067: == -1)
1.1 bertrand 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,
1.5 bertrand 1077: (*descripteur).descripteur_c);
1.1 bertrand 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: {
1.6 bertrand 1102: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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:
1.5 bertrand 1114: if (fseek((*descripteur).descripteur_c, position_finale,
1115: SEEK_SET) != 0)
1.1 bertrand 1116: {
1.6 bertrand 1117: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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,
1.5 bertrand 1128: (*descripteur).descripteur_c);
1.1 bertrand 1129:
1130: pointeur = 0;
1131: presence_indicateur = d_faux;
1132:
1133: while(pointeur < longueur_effective)
1134: {
1135: if (tampon_lecture[pointeur] == '"')
1136: {
1.7 bertrand 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: }
1.1 bertrand 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: {
1.6 bertrand 1184: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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:
1.5 bertrand 1203: if (fseek((*descripteur).descripteur_c, position_initiale,
1204: SEEK_SET) != 0)
1.1 bertrand 1205: {
1.6 bertrand 1206: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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,
1.5 bertrand 1216: (*descripteur).descripteur_c);
1.1 bertrand 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;
1.5 bertrand 1226:
1227: if (((*s_etat_processus).instruction_courante =
1228: transliteration(s_etat_processus, tampon_lecture,
1229: "UTF-8", d_locale)) == NULL)
1230: {
1.6 bertrand 1231: (*s_etat_processus).instruction_courante = tampon;
1232: liberation(s_etat_processus, s_objet_argument_1);
1.5 bertrand 1233: free(tampon_lecture);
1234: return;
1235: }
1.1 bertrand 1236:
1237: indicateur_48 = test_cfsf(s_etat_processus, 48);
1238: cf(s_etat_processus, 48);
1239:
1240: recherche_type(s_etat_processus);
1.5 bertrand 1241: free((*s_etat_processus).instruction_courante);
1.1 bertrand 1242:
1243: if ((*s_etat_processus).erreur_execution != d_ex)
1244: {
1.6 bertrand 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:
1.1 bertrand 1254: (*s_etat_processus).instruction_courante = tampon;
1255: free(tampon_lecture);
1256:
1.6 bertrand 1257: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 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: }
1.6 bertrand 1273: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1.1 bertrand 1274: == 'D')
1275: {
1.6 bertrand 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: }
1.68 bertrand 1311:
1312: attente.tv_sec = 0;
1313: attente.tv_nsec = GRANULARITE_us * 1000;
1314:
1315: do
1.6 bertrand 1316: {
1.68 bertrand 1317: ios = sqlite3_step(ppStmt);
1.6 bertrand 1318:
1.68 bertrand 1319: switch(ios)
1.6 bertrand 1320: {
1.68 bertrand 1321: case SQLITE_ROW:
1.6 bertrand 1322: {
1.68 bertrand 1323: // Résultat attendu
1324: break;
1.6 bertrand 1325: }
1326:
1.68 bertrand 1327: case SQLITE_DONE:
1328: {
1329: // Aucun enregistrement
1330: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1331: {
1332: (*s_etat_processus).erreur_systeme =
1333: d_es_erreur_fichier;
1334: return;
1335: }
1336:
1337: free(commande);
1.6 bertrand 1338:
1.68 bertrand 1339: liberation(s_etat_processus, s_objet_argument_1);
1340: liberation(s_etat_processus, s_objet_argument_2);
1341:
1342: (*s_etat_processus).erreur_execution =
1343: d_ex_enregistrement_inexistant;
1344: return;
1345: }
1.6 bertrand 1346:
1.68 bertrand 1347: case SQLITE_BUSY:
1348: case SQLITE_LOCKED:
1349: {
1350: nanosleep(&attente, NULL);
1351: INCR_GRANULARITE(attente.tv_nsec);
1352: break;
1353: }
1.6 bertrand 1354:
1.68 bertrand 1355: default:
1356: {
1357: (*s_etat_processus).erreur_systeme =
1358: d_es_erreur_fichier;
1359: return;
1360: }
1.6 bertrand 1361: }
1.68 bertrand 1362: } while(ios != SQLITE_ROW);
1.6 bertrand 1363:
1364: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1365: {
1366: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1367: return;
1368: }
1369:
1370: tampon = (*s_etat_processus).instruction_courante;
1371:
1372: if ((tampon_lecture = (unsigned char *)
1373: sqlite3_column_text(ppStmt, 0)) == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1376: return;
1377: }
1378:
1379: if (((*s_etat_processus).instruction_courante =
1380: transliteration(s_etat_processus, tampon_lecture,
1381: "UTF-8", d_locale)) == NULL)
1382: {
1383: (*s_etat_processus).instruction_courante = tampon;
1384:
1385: liberation(s_etat_processus, s_objet_argument_1);
1386: liberation(s_etat_processus, s_objet_argument_2);
1387: free(commande);
1388: return;
1389: }
1390:
1391: indicateur_48 = test_cfsf(s_etat_processus, 48);
1392: cf(s_etat_processus, 48);
1393:
1394: recherche_type(s_etat_processus);
1395:
1396: if ((*s_etat_processus).erreur_execution != d_ex)
1397: {
1398: if (indicateur_48 == d_vrai)
1399: {
1400: sf(s_etat_processus, 48);
1401: }
1402: else
1403: {
1404: cf(s_etat_processus, 48);
1405: }
1406:
1407: liberation(s_etat_processus, s_objet_argument_1);
1408: liberation(s_etat_processus, s_objet_argument_2);
1409:
1410: free((*s_etat_processus).instruction_courante);
1411: free(commande);
1.8 bertrand 1412:
1413: (*s_etat_processus).instruction_courante = tampon;
1.6 bertrand 1414: return;
1415: }
1416:
1417: if (indicateur_48 == d_vrai)
1418: {
1419: sf(s_etat_processus, 48);
1420: }
1421: else
1422: {
1423: cf(s_etat_processus, 48);
1424: }
1425:
1426: free((*s_etat_processus).instruction_courante);
1427: liberation(s_etat_processus, s_objet_argument_2);
1428: (*s_etat_processus).instruction_courante = tampon;
1429:
1430: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1431: {
1432: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1433: return;
1434: }
1435:
1436: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1437: {
1438: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1439: return;
1440: }
1441:
1442: free(commande);
1.1 bertrand 1443: }
1444: else
1445: {
1.8 bertrand 1446: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1447:
1448: if (depilement(s_etat_processus, &((*s_etat_processus)
1449: .l_base_pile), &s_objet_argument_2) == d_erreur)
1450: {
1451: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1452: return;
1453: }
1454:
1455: if ((*s_objet_argument_2).type != CHN)
1456: {
1457: liberation(s_etat_processus, s_objet_argument_1);
1458: liberation(s_etat_processus, s_objet_argument_2);
1459:
1460: (*s_etat_processus).erreur_execution =
1461: d_ex_erreur_type_argument;
1462: return;
1463: }
1464:
1465: // Récupération de la position de la clef
1466:
1467: if (alsprintf(&commande, "select key from control "
1468: "where id = 1") < 0)
1469: {
1470: (*s_etat_processus).erreur_systeme =
1471: d_es_allocation_memoire;
1472: return;
1473: }
1474:
1475: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1476: commande, strlen(commande), &ppStmt, &queue)
1477: != SQLITE_OK)
1478: {
1479: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1480: return;
1481: }
1482:
1.68 bertrand 1483: attente.tv_sec = 0;
1484: attente.tv_nsec = GRANULARITE_us * 1000;
1485:
1486: do
1.8 bertrand 1487: {
1.68 bertrand 1488: ios = sqlite3_step(ppStmt);
1489:
1490: if (ios == SQLITE_ROW)
1491: {
1492: break;
1493: }
1494: else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
1495: {
1496: nanosleep(&attente, NULL);
1497: INCR_GRANULARITE(attente.tv_nsec);
1498: }
1499: else
1500: {
1501: (*s_etat_processus).erreur_systeme =
1502: d_es_erreur_fichier;
1503: return;
1504: }
1505: } while(ios != SQLITE_ROW);
1.8 bertrand 1506:
1507: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1508: {
1509: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1510: return;
1511: }
1512:
1513: position_clef = sqlite3_column_int64(ppStmt, 0);
1514:
1515: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1516: {
1517: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1518: return;
1519: }
1520:
1521: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1522: {
1523: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1524: return;
1525: }
1526:
1527: free(commande);
1528:
1529: if ((clef_utf8 = transliteration(s_etat_processus,
1530: (unsigned char *) (*s_objet_argument_2).objet,
1531: d_locale, "UTF-8")) == NULL)
1532: {
1533: liberation(s_etat_processus, s_objet_argument_1);
1534: liberation(s_etat_processus, s_objet_argument_2);
1535:
1536: return;
1537: }
1538:
1539: // Récupération de l'identifiant de la clef
1540:
1541: if (alsprintf(&commande, "select id from key where key = "
1542: "'{ \"%s\" }'", clef_utf8) < 0)
1543: {
1544: (*s_etat_processus).erreur_systeme =
1545: d_es_allocation_memoire;
1546: return;
1547: }
1548:
1549: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1550: commande, strlen(commande), &ppStmt, &queue)
1551: != SQLITE_OK)
1552: {
1553: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1554: return;
1555: }
1556:
1.68 bertrand 1557: attente.tv_sec = 0;
1558: attente.tv_nsec = GRANULARITE_us * 1000;
1559:
1560: do
1.8 bertrand 1561: {
1.68 bertrand 1562: ios = sqlite3_step(ppStmt);
1.8 bertrand 1563:
1.68 bertrand 1564: switch(ios)
1.8 bertrand 1565: {
1.68 bertrand 1566: case SQLITE_ROW:
1.8 bertrand 1567: {
1.68 bertrand 1568: // Résultat attendu : une clef correspond.
1569: break;
1.8 bertrand 1570: }
1571:
1.68 bertrand 1572: case SQLITE_DONE:
1573: {
1574: // Aucun enregistrement
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(clef_utf8);
1583: free(commande);
1584:
1585: liberation(s_etat_processus, s_objet_argument_1);
1586: liberation(s_etat_processus, s_objet_argument_2);
1.8 bertrand 1587:
1.68 bertrand 1588: (*s_etat_processus).erreur_execution =
1589: d_ex_enregistrement_inexistant;
1590: return;
1591: }
1.8 bertrand 1592:
1.68 bertrand 1593: case SQLITE_BUSY:
1594: case SQLITE_LOCKED:
1595: {
1596: nanosleep(&attente, NULL);
1597: INCR_GRANULARITE(attente.tv_nsec);
1598: break;
1599: }
1.8 bertrand 1600:
1.68 bertrand 1601: default:
1602: {
1603: (*s_etat_processus).erreur_systeme =
1604: d_es_erreur_fichier;
1605: return;
1606: }
1.8 bertrand 1607: }
1.68 bertrand 1608: } while(ios != SQLITE_ROW);
1.8 bertrand 1609:
1610: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1611: {
1612: free(clef_utf8);
1613: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1614: return;
1615: }
1616:
1617: id = sqlite3_column_int64(ppStmt, 0);
1618:
1619: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1620: {
1621: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1622: return;
1623: }
1624:
1625: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1626: {
1627: (*s_etat_processus).erreur_systeme =
1628: d_es_erreur_fichier;
1629: return;
1630: }
1631:
1632: free(commande);
1633:
1634: if (alsprintf(&commande, "select data from data where "
1635: "key_id = %lld order by sequence asc", id) < 0)
1636: {
1637: (*s_etat_processus).erreur_systeme =
1638: d_es_allocation_memoire;
1639: return;
1640: }
1641:
1642: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1643: commande, strlen(commande), &ppStmt, &queue)
1644: != SQLITE_OK)
1645: {
1646: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1647: return;
1648: }
1649:
1650: element = 1;
1651:
1.68 bertrand 1652: attente.tv_sec = 0;
1653: attente.tv_nsec = GRANULARITE_us * 1000;
1654:
1.8 bertrand 1655: do
1656: {
1657: switch(ios = sqlite3_step(ppStmt))
1658: {
1659: case SQLITE_ROW:
1660: {
1661: // Donnée supplémentaire
1662:
1663: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1664: {
1665: (*s_etat_processus).erreur_systeme =
1666: d_es_erreur_fichier;
1667: return;
1668: }
1669:
1670: tampon = (*s_etat_processus).instruction_courante;
1671:
1672: if ((tampon_lecture = (unsigned char *)
1673: sqlite3_column_text(ppStmt, 0)) == NULL)
1674: {
1675: (*s_etat_processus).erreur_systeme =
1676: d_es_erreur_fichier;
1677: return;
1678: }
1679:
1680: if (((*s_etat_processus).instruction_courante =
1681: transliteration(s_etat_processus,
1682: tampon_lecture,
1683: "UTF-8", d_locale)) == NULL)
1684: {
1685: (*s_etat_processus).instruction_courante =
1686: tampon;
1687:
1688: liberation(s_etat_processus,
1689: s_objet_argument_1);
1690: liberation(s_etat_processus,
1691: s_objet_argument_2);
1692:
1693: free(commande);
1694: free(clef_utf8);
1695: return;
1696: }
1697:
1698: indicateur_48 = test_cfsf(s_etat_processus, 48);
1699: cf(s_etat_processus, 48);
1700:
1701: recherche_type(s_etat_processus);
1702:
1703: if ((*s_etat_processus).erreur_execution != d_ex)
1704: {
1705: if (indicateur_48 == d_vrai)
1706: {
1707: sf(s_etat_processus, 48);
1708: }
1709: else
1710: {
1711: cf(s_etat_processus, 48);
1712: }
1713:
1714: liberation(s_etat_processus,
1715: s_objet_argument_1);
1716: liberation(s_etat_processus,
1717: s_objet_argument_2);
1718:
1719: free((*s_etat_processus).instruction_courante);
1720: free(commande);
1721: free(clef_utf8);
1722:
1723: (*s_etat_processus).instruction_courante =
1724: tampon;
1725: return;
1726: }
1727:
1728: if (indicateur_48 == d_vrai)
1729: {
1730: sf(s_etat_processus, 48);
1731: }
1732: else
1733: {
1734: cf(s_etat_processus, 48);
1735: }
1736:
1737: free((*s_etat_processus).instruction_courante);
1738: (*s_etat_processus).instruction_courante = tampon;
1739:
1740: element++;
1741:
1742: // Inscription de la clef
1743:
1744: if (element == position_clef)
1745: {
1746: if (((*s_etat_processus).instruction_courante =
1747: transliteration(s_etat_processus,
1748: clef_utf8, "UTF-8", d_locale)) == NULL)
1749: {
1750: (*s_etat_processus).instruction_courante =
1751: tampon;
1752:
1753: liberation(s_etat_processus,
1754: s_objet_argument_1);
1755: liberation(s_etat_processus,
1756: s_objet_argument_2);
1757:
1758: free(commande);
1759: free(clef_utf8);
1760: return;
1761: }
1762:
1763: if (alsprintf(&tampon2, "{ \"%s\" }",
1764: (*s_etat_processus)
1765: .instruction_courante) < 0)
1766: {
1767: (*s_etat_processus).erreur_systeme =
1768: d_es_allocation_memoire;
1769: return;
1770: }
1771:
1772: free((*s_etat_processus).instruction_courante);
1773: (*s_etat_processus).instruction_courante
1774: = tampon2;
1775:
1776: indicateur_48 = test_cfsf(s_etat_processus, 48);
1777: cf(s_etat_processus, 48);
1778:
1779: recherche_type(s_etat_processus);
1780:
1781: if ((*s_etat_processus).erreur_execution
1782: != d_ex)
1783: {
1784: if (indicateur_48 == d_vrai)
1785: {
1786: sf(s_etat_processus, 48);
1787: }
1788: else
1789: {
1790: cf(s_etat_processus, 48);
1791: }
1792:
1793: liberation(s_etat_processus,
1794: s_objet_argument_1);
1795: liberation(s_etat_processus,
1796: s_objet_argument_2);
1797:
1798: free((*s_etat_processus)
1799: .instruction_courante);
1800: free(commande);
1801: free(clef_utf8);
1802:
1803: (*s_etat_processus).instruction_courante =
1804: tampon;
1805: return;
1806: }
1807:
1808: if (indicateur_48 == d_vrai)
1809: {
1810: sf(s_etat_processus, 48);
1811: }
1812: else
1813: {
1814: cf(s_etat_processus, 48);
1815: }
1816:
1817: free((*s_etat_processus).instruction_courante);
1818: (*s_etat_processus).instruction_courante =
1819: tampon;
1820:
1821: element++;
1822: }
1823:
1824: break;
1825: }
1826:
1827: case SQLITE_DONE:
1828: {
1829: // Fin de la liste
1830: break;
1831: }
1832:
1.68 bertrand 1833: case SQLITE_BUSY:
1834: case SQLITE_LOCKED:
1835: {
1836: nanosleep(&attente, NULL);
1837: INCR_GRANULARITE(attente.tv_nsec);
1838: break;
1839: }
1840:
1.8 bertrand 1841: default:
1842: {
1843: (*s_etat_processus).erreur_systeme =
1844: d_es_erreur_fichier;
1845: return;
1846: }
1847: }
1848: } while(ios != SQLITE_DONE);
1849:
1850: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1851: {
1852: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1853: return;
1854: }
1855:
1856: free(commande);
1857: free(clef_utf8);
1858:
1859: liberation(s_etat_processus, s_objet_argument_2);
1860:
1861: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1862: == NULL)
1863: {
1864: (*s_etat_processus).erreur_systeme =
1865: d_es_allocation_memoire;
1866: return;
1867: }
1868:
1869: l_element_courant = NULL;
1.9 bertrand 1870: l_element_inclus = NULL;
1.8 bertrand 1871:
1872: for(element--; element > 0; element--)
1873: {
1874: if (depilement(s_etat_processus, &((*s_etat_processus)
1875: .l_base_pile), &s_objet_argument_2) == d_erreur)
1876: {
1877: (*s_etat_processus).erreur_systeme =
1878: d_es_erreur_fichier;
1879: return;
1880: }
1881:
1882: if ((*s_objet_argument_2).type != LST)
1883: {
1884: (*s_etat_processus).erreur_systeme =
1885: d_es_erreur_fichier;
1886: return;
1887: }
1888:
1889: l_element_inclus = (*s_objet_argument_2).objet;
1890:
1891: if (l_element_inclus != NULL)
1892: {
1893: while(l_element_inclus != NULL)
1894: {
1895: if ((*l_element_inclus).suivant == NULL)
1896: {
1897: (*l_element_inclus).suivant = l_element_courant;
1898: break;
1899: }
1900:
1901: l_element_inclus = (*l_element_inclus).suivant;
1902: }
1903:
1904: l_element_courant = (*s_objet_argument_2).objet;
1905: (*s_objet_argument_2).objet = NULL;
1906: }
1907:
1908: liberation(s_etat_processus, s_objet_argument_2);
1909: }
1910:
1911: (*s_objet_resultat).objet = l_element_inclus;
1912:
1913: if (empilement(s_etat_processus,
1914: &((*s_etat_processus).l_base_pile),
1915: s_objet_resultat) == d_erreur)
1916: {
1917: return;
1918: }
1.1 bertrand 1919: }
1920: }
1.6 bertrand 1921: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1.1 bertrand 1922: == 'Y')
1923: {
1924: /*
1925: * Fichiers non formatés
1926: */
1.46 bertrand 1927:
1928: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1929: == 'S')
1930: {
1931: /*
1932: * Fichiers séquentiels
1933: *
1934: * Les fichiers séquentiels non formatés contiennent comme
1935: * les fichiers séquentiels formatés leurs enregistrements
1936: * sous la forme de listes les unes derrières les autres.
1937: *
1938: * Le quartet de poids fort du premier octet à lire
1939: * doit donc être égal à 0100. Si ce n'est pas le cas,
1940: * il sera impossible de lire le fichier et on renvoie
1941: * immédiatement une erreur. Si on lit dans le fichier
1942: * la valeur attendue, on récupère la longueur en octet
1943: * de l'enregistrement puis on le lit.
1944: */
1945:
1946: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1947:
1.72 bertrand 1948: if ((s_objet_resultat = lecture_fichier_non_formate(
1949: s_etat_processus, (*descripteur).descripteur_c, -1,
1950: d_faux)) == NULL)
1.46 bertrand 1951: {
1952: return;
1953: }
1954:
1.72 bertrand 1955: if (empilement(s_etat_processus,
1956: &((*s_etat_processus).l_base_pile),
1957: s_objet_resultat) == d_erreur)
1.46 bertrand 1958: {
1959: return;
1960: }
1961: }
1.1 bertrand 1962: }
1963: else
1964: {
1965: /*
1966: * Fichiers de type FLOW
1967: */
1.28 bertrand 1968:
1969: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1970: == 'S')
1971: {
1972: /*
1973: * Fichiers séquentiels
1974: */
1975:
1976: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1977: longueur_enregistrement = 0;
1978:
1979: if ((position_initiale = ftell((*descripteur).descripteur_c))
1980: == -1)
1981: {
1982: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1983: return;
1984: }
1985:
1.59 bertrand 1986: l_element_courant_format = (struct_liste_chainee *)
1987: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
1988: .format).objet;
1989: l_element_courant = NULL;
1.28 bertrand 1990:
1991: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1992: == NULL)
1993: {
1994: (*s_etat_processus).erreur_systeme =
1995: d_es_allocation_memoire;
1996: return;
1997: }
1998:
1.59 bertrand 1999: while(l_element_courant_format != NULL)
1.28 bertrand 2000: {
1.59 bertrand 2001: if ((*(*l_element_courant_format).donnee).type != CHN)
2002: {
2003: liberation(s_etat_processus, s_objet_argument_1);
2004: liberation(s_etat_processus, s_objet_resultat);
2005:
2006: (*s_etat_processus).erreur_execution =
2007: d_ex_erreur_type_argument;
2008: return;
2009: }
2010:
2011: if ((format_chaine = conversion_majuscule((unsigned char *)
2012: (*(*l_element_courant_format).donnee).objet))
2013: == NULL)
2014: {
2015: (*s_etat_processus).erreur_systeme =
2016: d_es_allocation_memoire;
2017: return;
2018: }
2019:
2020: if (strncmp("LENGTH*(", format_chaine, 8) != 0)
2021: {
2022: liberation(s_etat_processus, s_objet_argument_1);
2023: liberation(s_etat_processus, s_objet_resultat);
2024: free(format_chaine);
2025:
2026: (*s_etat_processus).erreur_execution =
2027: d_ex_erreur_format_fichier;
2028: return;
2029: }
2030:
2031: longueur = strlen(format_chaine);
2032:
1.60 bertrand 2033: if (format_chaine[longueur - 1] != ')')
1.59 bertrand 2034: {
2035: liberation(s_etat_processus, s_objet_argument_1);
2036: liberation(s_etat_processus, s_objet_resultat);
2037: free(format_chaine);
2038:
2039: (*s_etat_processus).erreur_execution =
2040: d_ex_erreur_format_fichier;
2041: return;
2042: }
2043:
2044: format_chaine[longueur] = d_code_fin_chaine;
2045:
2046: if (format_chaine[8] == '*')
2047: {
2048: format_degenere = d_vrai;
2049: }
2050: else
2051: {
2052: // Détermination de la longueur
2053: format_degenere = d_faux;
2054:
2055: if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
2056: {
2057: liberation(s_etat_processus, s_objet_argument_1);
2058: liberation(s_etat_processus, s_objet_resultat);
2059: free(format_chaine);
2060:
2061: (*s_etat_processus).erreur_execution =
2062: d_ex_erreur_format_fichier;
2063: return;
2064: }
2065: }
2066:
2067: free(format_chaine);
2068:
2069: if (format_degenere == d_vrai)
2070: {
2071: do
2072: {
2073: c = getc((*descripteur).descripteur_c);
2074: longueur_enregistrement++;
2075: } while((c != '\n') && (c != EOF));
2076:
2077: if (fseek((*descripteur).descripteur_c,
2078: position_initiale, SEEK_SET) != 0)
2079: {
2080: liberation(s_etat_processus, s_objet_argument_1);
2081: liberation(s_etat_processus, s_objet_resultat);
2082:
2083: (*s_etat_processus).erreur_systeme =
2084: d_es_erreur_fichier;
2085: return;
2086: }
2087: }
2088: else
2089: {
2090: longueur_enregistrement = longueur;
2091: }
2092:
2093: if ((tampon_lecture = malloc((longueur_enregistrement)
2094: * sizeof(unsigned char))) == NULL)
2095: {
2096: (*s_etat_processus).erreur_systeme =
2097: d_es_allocation_memoire;
2098: return;
2099: }
2100:
2101: longueur_effective = fread(tampon_lecture,
2102: (size_t) sizeof(unsigned char),
2103: (size_t) longueur_enregistrement,
2104: (*descripteur).descripteur_c);
2105:
2106: if (l_element_courant == NULL)
2107: {
2108: // Premier maillon de la liste
2109: if (((*s_objet_resultat).objet =
2110: allocation_maillon(s_etat_processus)) == NULL)
2111: {
2112: (*s_etat_processus).erreur_systeme =
2113: d_es_allocation_memoire;
2114: return;
2115: }
2116:
2117: l_element_courant = (*s_objet_resultat).objet;
2118: }
2119: else
2120: {
2121: if (((*l_element_courant).suivant =
2122: allocation_maillon(s_etat_processus)) == NULL)
2123: {
2124: (*s_etat_processus).erreur_systeme =
2125: d_es_allocation_memoire;
2126: return;
2127: }
2128:
2129: l_element_courant = (*l_element_courant).suivant;
2130: }
2131:
2132: (*l_element_courant).suivant = NULL;
2133:
2134: if (((*l_element_courant).donnee =
2135: allocation(s_etat_processus, CHN)) == NULL)
2136: {
2137: (*s_etat_processus).erreur_systeme =
2138: d_es_allocation_memoire;
2139: return;
2140: }
1.28 bertrand 2141:
1.59 bertrand 2142: if (format_degenere == d_vrai)
2143: {
2144: if (((*(*l_element_courant).donnee).objet =
2145: analyse_flux(s_etat_processus, tampon_lecture,
2146: longueur_enregistrement - 1)) == NULL)
2147: {
2148: return;
2149: }
2150: }
2151: else
2152: {
2153: if (((*(*l_element_courant).donnee).objet =
2154: analyse_flux(s_etat_processus, tampon_lecture,
2155: longueur_enregistrement)) == NULL)
2156: {
2157: return;
2158: }
2159: }
1.28 bertrand 2160:
1.59 bertrand 2161: free(tampon_lecture);
1.28 bertrand 2162:
1.59 bertrand 2163: l_element_courant_format =
2164: (*l_element_courant_format).suivant;
1.28 bertrand 2165: }
2166:
2167: if (empilement(s_etat_processus,
2168: &((*s_etat_processus).l_base_pile),
2169: s_objet_resultat) == d_erreur)
2170: {
2171: return;
2172: }
2173: }
2174: else
2175: {
2176: liberation(s_etat_processus, s_objet_argument_1);
2177:
2178: (*s_etat_processus).erreur_execution =
2179: d_ex_erreur_type_fichier;
2180: return;
2181: }
1.1 bertrand 2182: }
2183: }
1.6 bertrand 2184: else if ((*s_objet_argument_1).type == SCK)
1.1 bertrand 2185: {
2186: /*
2187: * Vérification de l'autorisation de lecture
2188: */
2189:
1.6 bertrand 2190: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
2191: == 'W')
1.1 bertrand 2192: {
1.6 bertrand 2193: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2194:
2195: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
2196: return;
2197: }
2198:
2199: /*
2200: * Vérification de l'écoute de la socket si celle-ci est connectée
2201: */
2202:
1.6 bertrand 2203: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1.1 bertrand 2204: "STREAM") == 0) || (strcmp((*((struct_socket *)
1.6 bertrand 2205: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
2206: == 0))
1.1 bertrand 2207: {
1.6 bertrand 2208: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2209: .socket_en_ecoute == 'Y')
2210: {
1.6 bertrand 2211: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2212:
2213: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
2214: return;
2215: }
2216: }
2217:
1.6 bertrand 2218: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 2219: { // Socket formatée
1.71 bertrand 2220: longueur_questure = 4096;
1.55 bertrand 2221: longueur_effective = 0;
2222: tampon_lecture = NULL;
1.1 bertrand 2223:
1.56 bertrand 2224: attente.tv_sec = 0;
2225: attente.tv_nsec = GRANULARITE_us * 1000;
2226:
1.57 bertrand 2227: trame_complete = d_faux;
2228: position_initiale = 0;
2229: position_finale = 0;
2230:
1.1 bertrand 2231: do
2232: {
1.55 bertrand 2233: presence_indicateur = d_faux;
2234:
2235: if ((tampon_lecture = realloc(tampon_lecture,
1.57 bertrand 2236: (longueur_effective + longueur_questure + 1)
1.55 bertrand 2237: * sizeof(unsigned char))) == NULL)
1.1 bertrand 2238: {
2239: (*s_etat_processus).erreur_systeme =
2240: d_es_allocation_memoire;
2241: return;
2242: }
2243:
1.44 bertrand 2244: # ifndef SEMAPHORES_NOMMES
2245: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2246: # else
2247: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2248: # endif
1.1 bertrand 2249: {
2250: (*s_etat_processus).erreur_systeme = d_es_processus;
2251: return;
2252: }
2253:
1.55 bertrand 2254: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2255: .domaine == PF_UNIX)
2256: {
2257: longueur_adresse = sizeof(adresse_unix);
1.57 bertrand 2258:
2259: do
2260: {
2261: ios = recvfrom((*((struct_socket *)
2262: (*s_objet_argument_1).objet)).socket,
1.71 bertrand 2263: tampon_lecture,
2264: longueur_effective + longueur_questure,
1.57 bertrand 2265: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2266: &adresse_unix, &longueur_adresse);
2267: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2268: }
2269: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2270: .domaine == PF_INET)
2271: {
2272: longueur_adresse = sizeof(adresse_ipv4);
1.57 bertrand 2273:
2274: do
2275: {
2276: ios = recvfrom((*((struct_socket *)
2277: (*s_objet_argument_1).objet)).socket,
1.71 bertrand 2278: tampon_lecture,
2279: longueur_effective + longueur_questure,
1.57 bertrand 2280: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2281: &adresse_ipv4, &longueur_adresse);
2282: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2283: }
2284: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2285: .domaine == PF_INET6)
2286: {
2287: # ifdef IPV6
2288: longueur_adresse = sizeof(adresse_ipv6);
1.57 bertrand 2289:
2290: do
2291: {
2292: ios = recvfrom((*((struct_socket *)
2293: (*s_objet_argument_1).objet)).socket,
1.71 bertrand 2294: tampon_lecture,
2295: longueur_effective + longueur_questure,
1.57 bertrand 2296: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2297: &adresse_ipv6, &longueur_adresse);
2298: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2299: # else
2300: if ((*s_etat_processus).langue == 'F')
2301: {
2302: printf("+++Attention : Support du protocole"
2303: " IPv6 indisponible\n");
2304: }
2305: else
2306: {
2307: printf("+++Warning : IPv6 support "
2308: "unavailable\n");
2309: }
2310:
2311: longueur_adresse = 0;
2312: longueur_effective = 0;
2313: ios = 0;
2314: # endif
2315: }
2316: else
2317: {
2318: free(tampon_lecture);
2319: liberation(s_etat_processus, s_objet_argument_1);
2320:
2321: # ifndef SEMAPHORES_NOMMES
2322: while(sem_wait(&((*s_etat_processus)
2323: .semaphore_fork)) != 0)
2324: # else
2325: while(sem_wait((*s_etat_processus)
2326: .semaphore_fork) != 0)
2327: # endif
2328: {
2329: (*s_etat_processus).erreur_systeme =
2330: d_es_processus;
2331: }
2332:
2333: (*s_etat_processus).erreur_execution =
2334: d_ex_erreur_acces_fichier;
2335: return;
2336: }
2337:
2338: if (ios < 0)
2339: {
2340: nanosleep(&attente, NULL);
2341: INCR_GRANULARITE(attente.tv_nsec);
2342: scrutation_injection(s_etat_processus);
2343: }
1.56 bertrand 2344: else
2345: {
2346: attente.tv_sec = 0;
2347: attente.tv_nsec = GRANULARITE_us * 1000;
2348: }
1.55 bertrand 2349:
2350: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2351: {
1.62 bertrand 2352: if (ios >= 0)
2353: {
2354: longueur_effective += ios;
2355: }
2356:
1.55 bertrand 2357: break;
2358: }
2359:
2360: // Une donnée a été reçue.
2361:
2362: if (ios >= 0)
1.1 bertrand 2363: {
1.55 bertrand 2364: longueur_effective += ios;
2365: position_initiale = 0;
2366: presence_indicateur = d_faux;
2367:
2368: do
2369: {
2370: if (tampon_lecture[position_initiale] == '{')
2371: {
2372: presence_indicateur = d_vrai;
2373: break;
2374: }
2375:
2376: position_initiale++;
2377: } while(position_initiale < longueur_effective);
2378:
2379: if (presence_indicateur == d_vrai)
2380: {
2381: position_finale = position_initiale + 1;
2382: presence_chaine = d_faux;
2383: presence_indicateur = d_faux;
2384: niveau = 1;
2385:
2386: while(position_finale < longueur_effective)
2387: {
2388: caractere = tampon_lecture[position_finale];
2389:
2390: if (caractere == '"')
2391: {
1.59 bertrand 2392: if (position_finale > 0)
2393: {
2394: if (tampon_lecture[position_finale - 1]
2395: != '\\')
2396: {
2397: presence_chaine = (presence_chaine ==
2398: d_vrai) ? d_faux : d_vrai;
2399: }
2400: }
2401: else
2402: {
2403: presence_chaine =
2404: (presence_chaine == d_vrai)
2405: ? d_faux : d_vrai;
2406: }
1.55 bertrand 2407: }
2408: else
2409: {
2410: if (presence_chaine == d_faux)
2411: {
2412: if (caractere == '{')
2413: {
2414: niveau++;
2415: }
2416: else if (caractere == '}')
2417: {
2418: niveau--;
2419: }
2420: }
2421: }
2422:
2423: if (niveau == 0)
2424: {
2425: presence_indicateur = d_vrai;
1.57 bertrand 2426: trame_complete = d_vrai;
1.55 bertrand 2427: break;
2428: }
2429:
2430: position_finale++;
2431: }
2432: }
2433:
1.71 bertrand 2434: // On retire une trame du buffer.
1.55 bertrand 2435:
1.71 bertrand 2436: if (trame_complete == d_vrai)
1.1 bertrand 2437: {
1.71 bertrand 2438: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2439: .domaine == PF_UNIX)
1.57 bertrand 2440: {
1.71 bertrand 2441: do
2442: {
2443: longueur_adresse = sizeof(adresse_unix);
2444: recvfrom((*((struct_socket *)
2445: (*s_objet_argument_1).objet)).socket,
2446: tampon_lecture, longueur_effective,
2447: 0, (struct sockaddr *)
2448: &adresse_unix, &longueur_adresse);
2449: } while((ios == -1) && (errno == EINTR));
2450: }
2451: else if ((*((struct_socket *) (*s_objet_argument_1)
2452: .objet)).domaine == PF_INET)
1.57 bertrand 2453: {
1.71 bertrand 2454: do
2455: {
2456: longueur_adresse = sizeof(adresse_ipv4);
2457: recvfrom((*((struct_socket *)
2458: (*s_objet_argument_1).objet)).socket,
2459: tampon_lecture, longueur_effective,
2460: 0, (struct sockaddr *)
2461: &adresse_ipv4, &longueur_adresse);
2462: } while((ios == -1) && (errno == EINTR));
1.21 bertrand 2463: }
1.71 bertrand 2464: else if ((*((struct_socket *) (*s_objet_argument_1)
2465: .objet)) .domaine == PF_INET6)
1.21 bertrand 2466: {
1.71 bertrand 2467: # ifdef IPV6
2468: do
2469: {
2470: longueur_adresse = sizeof(adresse_ipv6);
2471: recvfrom((*((struct_socket *)
2472: (*s_objet_argument_1).objet)).socket,
2473: tampon_lecture, longueur_effective,
2474: 0, (struct sockaddr *)
2475: &adresse_ipv6, &longueur_adresse);
2476: } while((ios == -1) && (errno == EINTR));
2477: # else
2478: if ((*s_etat_processus).langue == 'F')
2479: {
2480: printf("+++Attention : Support du protocole"
2481: " IPv6 indisponible\n");
2482: }
2483: else
2484: {
2485: printf("+++Warning : IPv6 support "
2486: "unavailable\n");
2487: }
2488:
2489: # endif
1.21 bertrand 2490: }
1.51 bertrand 2491:
1.71 bertrand 2492: longueur_effective = ios;
1.1 bertrand 2493: }
1.71 bertrand 2494: else
2495: {
2496: // Installation d'un timeout pour sortir de
2497: // l'instruction dans le cas où la transmission serait
2498: // invalide et que la trame reçue serait erronée.
1.55 bertrand 2499:
2500: poll_fd.fd = (*((struct_socket *)
2501: (*s_objet_argument_1).objet)).socket;
2502: poll_fd.events = POLLIN;
1.1 bertrand 2503:
1.63 bertrand 2504: while((ios = poll(&poll_fd, 1, 10000)) <= 0)
1.1 bertrand 2505: {
1.71 bertrand 2506: // La fin de la trame n'est pas atteinte.
1.1 bertrand 2507:
1.55 bertrand 2508: switch(ios)
2509: {
2510: case EINTR:
2511: {
1.62 bertrand 2512: if ((*s_etat_processus)
2513: .var_volatile_requete_arret == -1)
2514: {
2515: liberation(s_etat_processus,
2516: s_objet_argument_1);
2517: free(tampon_lecture);
2518: return;
2519: }
2520:
1.55 bertrand 2521: break;
2522: }
1.1 bertrand 2523:
1.55 bertrand 2524: case 0:
2525: {
2526: liberation(s_etat_processus,
2527: s_objet_argument_1);
2528: free(tampon_lecture);
1.1 bertrand 2529:
1.55 bertrand 2530: (*s_etat_processus).erreur_execution =
2531: d_ex_fin_de_fichier_atteinte;
2532: return;
2533: }
2534: }
2535: }
1.1 bertrand 2536: }
2537: }
2538:
1.44 bertrand 2539: # ifndef SEMAPHORES_NOMMES
2540: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
2541: # else
2542: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2543: # endif
1.1 bertrand 2544: {
1.44 bertrand 2545: if (errno == EINTR)
1.43 bertrand 2546: {
2547: (*s_etat_processus).erreur_systeme = d_es_processus;
2548: return;
2549: }
1.1 bertrand 2550: }
2551:
2552: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2553: {
2554:
2555: /*
2556: * Si le père tue le processus courant grâce au signal
2557: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
2558: * correspond à l'utilisation de STOP sur le processus
2559: * en cours. La variable longueur_effective vaut '-1'.
2560: */
2561:
2562: free(tampon_lecture);
1.6 bertrand 2563: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2564: return;
2565: }
2566:
2567: if (longueur_effective == -1)
2568: {
2569: free(tampon_lecture);
1.6 bertrand 2570: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2571:
2572: (*s_etat_processus).erreur_execution =
2573: d_ex_erreur_acces_fichier;
2574: return;
2575: }
1.57 bertrand 2576: } while(trame_complete == d_faux);
1.1 bertrand 2577:
2578: tampon_lecture[++position_finale] = d_code_fin_chaine;
2579: tampon = (*s_etat_processus).instruction_courante;
1.71 bertrand 2580: (*s_etat_processus).instruction_courante = tampon_lecture;
1.1 bertrand 2581:
2582: indicateur_48 = test_cfsf(s_etat_processus, 48);
2583: cf(s_etat_processus, 48);
2584:
2585: recherche_type(s_etat_processus);
2586:
2587: if ((*s_etat_processus).erreur_execution != d_ex)
2588: {
2589: (*s_etat_processus).instruction_courante = tampon;
2590: free(tampon_lecture);
2591:
1.57 bertrand 2592: if (indicateur_48 == d_vrai)
2593: {
2594: sf(s_etat_processus, 48);
2595: }
2596: else
2597: {
2598: cf(s_etat_processus, 48);
2599: }
2600:
2601: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2602: {
2603: (*s_etat_processus).erreur_execution = d_ex;
2604: }
2605:
1.6 bertrand 2606: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2607: return;
2608: }
2609:
2610: if (indicateur_48 == d_vrai)
2611: {
2612: sf(s_etat_processus, 48);
2613: }
2614: else
2615: {
2616: cf(s_etat_processus, 48);
2617: }
2618:
2619: (*s_etat_processus).instruction_courante = tampon;
2620:
2621: /*
2622: * Création de la liste de sortie
2623: */
2624:
2625: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2626: &s_objet_type) == d_erreur)
2627: {
2628: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2629: return;
2630: }
2631:
2632: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2633: == NULL)
2634: {
2635: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2636: return;
2637: }
2638:
2639: if (((*s_objet_resultat).objet =
2640: allocation_maillon(s_etat_processus)) == NULL)
2641: {
2642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2643: return;
2644: }
2645:
2646: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2647: .donnee = s_objet_type;
2648:
2649: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
2650: .suivant = allocation_maillon(s_etat_processus)) == NULL)
2651: {
2652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2653: return;
2654: }
2655:
2656: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2657: .suivant = NULL;
2658:
2659: if ((s_objet_adresse = allocation(s_etat_processus, LST))
2660: == NULL)
2661: {
2662: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2663: return;
2664: }
2665:
2666: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2667: .donnee = s_objet_adresse;
2668:
2669: /*
2670: * Les informations concernant la cible sont valides si
2671: * la socket est non connectée et des domaines INET ou INET6.
2672: * Dans tous les autres cas, on renvoie une liste vide.
2673: */
2674:
1.6 bertrand 2675: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1.1 bertrand 2676: == PF_UNIX) || (strcmp((*((struct_socket *)
1.6 bertrand 2677: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
2678: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2679: .type, "SEQUENTIAL DATAGRAM") == 0))
2680: {
2681: (*s_objet_adresse).objet = NULL;
2682: }
1.6 bertrand 2683: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2684: .domaine == PF_INET)
2685: {
2686: if (((*s_objet_adresse).objet =
2687: allocation_maillon(s_etat_processus)) == NULL)
2688: {
2689: (*s_etat_processus).erreur_systeme =
2690: d_es_allocation_memoire;
2691: return;
2692: }
2693:
2694: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2695: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2696: {
2697: (*s_etat_processus).erreur_systeme =
2698: d_es_allocation_memoire;
2699: return;
2700: }
2701:
2702: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2703: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
2704:
2705: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2706: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2707: malloc(4 * sizeof(integer8))) == NULL)
2708: {
2709: (*s_etat_processus).erreur_systeme =
2710: d_es_allocation_memoire;
2711: return;
2712: }
2713:
2714: ((integer8 *) (*((struct_vecteur *)
2715: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2716: .objet)).donnee).objet)).tableau)[0] =
2717: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
2718: ((integer8 *) (*((struct_vecteur *)
2719: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2720: .objet)).donnee).objet)).tableau)[1] =
2721: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
2722: ((integer8 *) (*((struct_vecteur *)
2723: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2724: .objet)).donnee).objet)).tableau)[2] =
2725: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
2726: ((integer8 *) (*((struct_vecteur *)
2727: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2728: .objet)).donnee).objet)).tableau)[3] =
2729: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
2730:
2731: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2732: .suivant = allocation_maillon(s_etat_processus))
2733: == NULL)
2734: {
2735: (*s_etat_processus).erreur_systeme =
2736: d_es_allocation_memoire;
2737: return;
2738: }
2739:
2740: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2741: .suivant).donnee = allocation(s_etat_processus, INT))
2742: == NULL)
2743: {
2744: (*s_etat_processus).erreur_systeme =
2745: d_es_allocation_memoire;
2746: return;
2747: }
2748:
2749: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2750: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2751: (integer8) ntohs(adresse_ipv4.sin_port);
2752:
2753: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2754: .suivant).suivant = NULL;
2755: }
1.6 bertrand 2756: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2757: .domaine == PF_INET6)
2758: {
1.19 bertrand 2759: # ifdef IPV6
1.1 bertrand 2760: if (((*s_objet_adresse).objet =
2761: allocation_maillon(s_etat_processus)) == NULL)
2762: {
2763: (*s_etat_processus).erreur_systeme =
2764: d_es_allocation_memoire;
2765: return;
2766: }
2767:
2768: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2769: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2770: {
2771: (*s_etat_processus).erreur_systeme =
2772: d_es_allocation_memoire;
2773: return;
2774: }
2775:
2776: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2777: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
2778:
2779: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2780: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2781: malloc(16 * sizeof(integer8))) == NULL)
2782: {
2783: (*s_etat_processus).erreur_systeme =
2784: d_es_allocation_memoire;
2785: return;
2786: }
2787:
2788: for(i = 0; i < 16; i++)
2789: {
2790: ((integer8 *) (*((struct_vecteur *)
2791: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2792: .objet)).donnee).objet)).tableau)[0] =
2793: adresse_ipv6.sin6_addr.s6_addr[i];
2794: }
2795:
2796: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2797: .suivant = allocation_maillon(s_etat_processus))
2798: == NULL)
2799: {
2800: (*s_etat_processus).erreur_systeme =
2801: d_es_allocation_memoire;
2802: return;
2803: }
2804:
2805: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2806: .suivant).donnee = allocation(s_etat_processus, INT))
2807: == NULL)
2808: {
2809: (*s_etat_processus).erreur_systeme =
2810: d_es_allocation_memoire;
2811: return;
2812: }
2813:
2814: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2815: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2816: (integer8) ntohs(adresse_ipv6.sin6_port);
2817:
2818: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2819: .suivant).suivant = NULL;
1.19 bertrand 2820: # else
1.21 bertrand 2821: if ((*s_etat_processus).langue == 'F')
2822: {
2823: printf("+++Attention : Support du protocole"
1.22 bertrand 2824: " IPv6 indisponible\n");
1.21 bertrand 2825: }
2826: else
2827: {
1.23 bertrand 2828: printf("+++Warning : IPv6 support "
1.21 bertrand 2829: "unavailable\n");
2830: }
1.19 bertrand 2831: # endif
1.1 bertrand 2832: }
2833: else
2834: {
2835: longueur_adresse = 0;
2836: recvfrom((*((struct_socket *)
1.6 bertrand 2837: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2838: position_finale, MSG_DONTWAIT,
2839: NULL, &longueur_adresse);
2840: }
2841:
2842: free(tampon_lecture);
2843:
2844: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2845: s_objet_resultat) == d_erreur)
2846: {
2847: return;
2848: }
2849: }
1.28 bertrand 2850: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
2851: == 'Y')
1.73 ! bertrand 2852: { // socket non formatée
! 2853: longueur_questure = 4096;
! 2854: longueur_effective = 0;
! 2855: tampon_lecture = NULL;
! 2856:
! 2857: attente.tv_sec = 0;
! 2858: attente.tv_nsec = GRANULARITE_us * 1000;
! 2859:
! 2860: trame_complete = d_faux;
! 2861: position_initiale = 0;
! 2862: position_finale = 0;
! 2863:
! 2864: do
! 2865: {
! 2866: presence_indicateur = d_faux;
! 2867:
! 2868: if ((tampon_lecture = realloc(tampon_lecture,
! 2869: (longueur_effective + longueur_questure + 1)
! 2870: * sizeof(unsigned char))) == NULL)
! 2871: {
! 2872: (*s_etat_processus).erreur_systeme =
! 2873: d_es_allocation_memoire;
! 2874: return;
! 2875: }
! 2876:
! 2877: # ifndef SEMAPHORES_NOMMES
! 2878: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 2879: # else
! 2880: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
! 2881: # endif
! 2882: {
! 2883: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2884: return;
! 2885: }
! 2886:
! 2887: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2888: .domaine == PF_UNIX)
! 2889: {
! 2890: longueur_adresse = sizeof(adresse_unix);
! 2891:
! 2892: do
! 2893: {
! 2894: ios = recvfrom((*((struct_socket *)
! 2895: (*s_objet_argument_1).objet)).socket,
! 2896: tampon_lecture,
! 2897: longueur_effective + longueur_questure,
! 2898: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 2899: &adresse_unix, &longueur_adresse);
! 2900: } while((ios == -1) && (errno == EINTR));
! 2901: }
! 2902: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2903: .domaine == PF_INET)
! 2904: {
! 2905: longueur_adresse = sizeof(adresse_ipv4);
! 2906:
! 2907: do
! 2908: {
! 2909: ios = recvfrom((*((struct_socket *)
! 2910: (*s_objet_argument_1).objet)).socket,
! 2911: tampon_lecture,
! 2912: longueur_effective + longueur_questure,
! 2913: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 2914: &adresse_ipv4, &longueur_adresse);
! 2915: } while((ios == -1) && (errno == EINTR));
! 2916: }
! 2917: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2918: .domaine == PF_INET6)
! 2919: {
! 2920: # ifdef IPV6
! 2921: longueur_adresse = sizeof(adresse_ipv6);
! 2922:
! 2923: do
! 2924: {
! 2925: ios = recvfrom((*((struct_socket *)
! 2926: (*s_objet_argument_1).objet)).socket,
! 2927: tampon_lecture,
! 2928: longueur_effective + longueur_questure,
! 2929: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 2930: &adresse_ipv6, &longueur_adresse);
! 2931: } while((ios == -1) && (errno == EINTR));
! 2932: # else
! 2933: if ((*s_etat_processus).langue == 'F')
! 2934: {
! 2935: printf("+++Attention : Support du protocole"
! 2936: " IPv6 indisponible\n");
! 2937: }
! 2938: else
! 2939: {
! 2940: printf("+++Warning : IPv6 support "
! 2941: "unavailable\n");
! 2942: }
! 2943:
! 2944: longueur_adresse = 0;
! 2945: longueur_effective = 0;
! 2946: ios = 0;
! 2947: # endif
! 2948: }
! 2949: else
! 2950: {
! 2951: free(tampon_lecture);
! 2952: liberation(s_etat_processus, s_objet_argument_1);
! 2953:
! 2954: # ifndef SEMAPHORES_NOMMES
! 2955: while(sem_wait(&((*s_etat_processus)
! 2956: .semaphore_fork)) != 0)
! 2957: # else
! 2958: while(sem_wait((*s_etat_processus)
! 2959: .semaphore_fork) != 0)
! 2960: # endif
! 2961: {
! 2962: (*s_etat_processus).erreur_systeme =
! 2963: d_es_processus;
! 2964: }
! 2965:
! 2966: (*s_etat_processus).erreur_execution =
! 2967: d_ex_erreur_acces_fichier;
! 2968: return;
! 2969: }
! 2970:
! 2971: if (ios < 0)
! 2972: {
! 2973: nanosleep(&attente, NULL);
! 2974: INCR_GRANULARITE(attente.tv_nsec);
! 2975: scrutation_injection(s_etat_processus);
! 2976: }
! 2977: else
! 2978: {
! 2979: attente.tv_sec = 0;
! 2980: attente.tv_nsec = GRANULARITE_us * 1000;
! 2981: }
! 2982:
! 2983: if ((*s_etat_processus).var_volatile_requete_arret == -1)
! 2984: {
! 2985: if (ios >= 0)
! 2986: {
! 2987: longueur_effective += ios;
! 2988: }
! 2989:
! 2990: break;
! 2991: }
! 2992:
! 2993: // Une donnée a été reçue.
! 2994:
! 2995: if (ios >= 0)
! 2996: {
! 2997: longueur_effective += ios;
! 2998: position_initiale = 0;
! 2999: presence_indicateur = d_faux;
! 3000:
! 3001: do
! 3002: {
! 3003: if (tampon_lecture[position_initiale] == '{')
! 3004: {
! 3005: presence_indicateur = d_vrai;
! 3006: break;
! 3007: }
! 3008:
! 3009: position_initiale++;
! 3010: } while(position_initiale < longueur_effective);
! 3011:
! 3012: if (presence_indicateur == d_vrai)
! 3013: {
! 3014: position_finale = position_initiale + 1;
! 3015: presence_chaine = d_faux;
! 3016: presence_indicateur = d_faux;
! 3017: niveau = 1;
! 3018:
! 3019: while(position_finale < longueur_effective)
! 3020: {
! 3021: caractere = tampon_lecture[position_finale];
! 3022:
! 3023: if (caractere == '"')
! 3024: {
! 3025: if (position_finale > 0)
! 3026: {
! 3027: if (tampon_lecture[position_finale - 1]
! 3028: != '\\')
! 3029: {
! 3030: presence_chaine = (presence_chaine ==
! 3031: d_vrai) ? d_faux : d_vrai;
! 3032: }
! 3033: }
! 3034: else
! 3035: {
! 3036: presence_chaine =
! 3037: (presence_chaine == d_vrai)
! 3038: ? d_faux : d_vrai;
! 3039: }
! 3040: }
! 3041: else
! 3042: {
! 3043: if (presence_chaine == d_faux)
! 3044: {
! 3045: if (caractere == '{')
! 3046: {
! 3047: niveau++;
! 3048: }
! 3049: else if (caractere == '}')
! 3050: {
! 3051: niveau--;
! 3052: }
! 3053: }
! 3054: }
! 3055:
! 3056: if (niveau == 0)
! 3057: {
! 3058: presence_indicateur = d_vrai;
! 3059: trame_complete = d_vrai;
! 3060: break;
! 3061: }
! 3062:
! 3063: position_finale++;
! 3064: }
! 3065: }
! 3066:
! 3067: // On retire une trame du buffer.
! 3068:
! 3069: if (trame_complete == d_vrai)
! 3070: {
! 3071: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 3072: .domaine == PF_UNIX)
! 3073: {
! 3074: do
! 3075: {
! 3076: longueur_adresse = sizeof(adresse_unix);
! 3077: recvfrom((*((struct_socket *)
! 3078: (*s_objet_argument_1).objet)).socket,
! 3079: tampon_lecture, longueur_effective,
! 3080: 0, (struct sockaddr *)
! 3081: &adresse_unix, &longueur_adresse);
! 3082: } while((ios == -1) && (errno == EINTR));
! 3083: }
! 3084: else if ((*((struct_socket *) (*s_objet_argument_1)
! 3085: .objet)).domaine == PF_INET)
! 3086: {
! 3087: do
! 3088: {
! 3089: longueur_adresse = sizeof(adresse_ipv4);
! 3090: recvfrom((*((struct_socket *)
! 3091: (*s_objet_argument_1).objet)).socket,
! 3092: tampon_lecture, longueur_effective,
! 3093: 0, (struct sockaddr *)
! 3094: &adresse_ipv4, &longueur_adresse);
! 3095: } while((ios == -1) && (errno == EINTR));
! 3096: }
! 3097: else if ((*((struct_socket *) (*s_objet_argument_1)
! 3098: .objet)) .domaine == PF_INET6)
! 3099: {
! 3100: # ifdef IPV6
! 3101: do
! 3102: {
! 3103: longueur_adresse = sizeof(adresse_ipv6);
! 3104: recvfrom((*((struct_socket *)
! 3105: (*s_objet_argument_1).objet)).socket,
! 3106: tampon_lecture, longueur_effective,
! 3107: 0, (struct sockaddr *)
! 3108: &adresse_ipv6, &longueur_adresse);
! 3109: } while((ios == -1) && (errno == EINTR));
! 3110: # else
! 3111: if ((*s_etat_processus).langue == 'F')
! 3112: {
! 3113: printf("+++Attention : Support du protocole"
! 3114: " IPv6 indisponible\n");
! 3115: }
! 3116: else
! 3117: {
! 3118: printf("+++Warning : IPv6 support "
! 3119: "unavailable\n");
! 3120: }
! 3121:
! 3122: # endif
! 3123: }
! 3124:
! 3125: longueur_effective = ios;
! 3126: }
! 3127: else
! 3128: {
! 3129: // Installation d'un timeout pour sortir de
! 3130: // l'instruction dans le cas où la transmission serait
! 3131: // invalide et que la trame reçue serait erronée.
! 3132:
! 3133: poll_fd.fd = (*((struct_socket *)
! 3134: (*s_objet_argument_1).objet)).socket;
! 3135: poll_fd.events = POLLIN;
! 3136:
! 3137: while((ios = poll(&poll_fd, 1, 10000)) <= 0)
! 3138: {
! 3139: // La fin de la trame n'est pas atteinte.
! 3140:
! 3141: switch(ios)
! 3142: {
! 3143: case EINTR:
! 3144: {
! 3145: if ((*s_etat_processus)
! 3146: .var_volatile_requete_arret == -1)
! 3147: {
! 3148: liberation(s_etat_processus,
! 3149: s_objet_argument_1);
! 3150: free(tampon_lecture);
! 3151: return;
! 3152: }
! 3153:
! 3154: break;
! 3155: }
! 3156:
! 3157: case 0:
! 3158: {
! 3159: liberation(s_etat_processus,
! 3160: s_objet_argument_1);
! 3161: free(tampon_lecture);
! 3162:
! 3163: (*s_etat_processus).erreur_execution =
! 3164: d_ex_fin_de_fichier_atteinte;
! 3165: return;
! 3166: }
! 3167: }
! 3168: }
! 3169: }
! 3170: }
! 3171:
! 3172: # ifndef SEMAPHORES_NOMMES
! 3173: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
! 3174: # else
! 3175: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
! 3176: # endif
! 3177: {
! 3178: if (errno == EINTR)
! 3179: {
! 3180: (*s_etat_processus).erreur_systeme = d_es_processus;
! 3181: return;
! 3182: }
! 3183: }
! 3184:
! 3185: if ((*s_etat_processus).var_volatile_requete_arret == -1)
! 3186: {
! 3187:
! 3188: /*
! 3189: * Si le père tue le processus courant grâce au signal
! 3190: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
! 3191: * correspond à l'utilisation de STOP sur le processus
! 3192: * en cours. La variable longueur_effective vaut '-1'.
! 3193: */
! 3194:
! 3195: free(tampon_lecture);
! 3196: liberation(s_etat_processus, s_objet_argument_1);
! 3197: return;
! 3198: }
! 3199:
! 3200: if (longueur_effective == -1)
! 3201: {
! 3202: free(tampon_lecture);
! 3203: liberation(s_etat_processus, s_objet_argument_1);
! 3204:
! 3205: (*s_etat_processus).erreur_execution =
! 3206: d_ex_erreur_acces_fichier;
! 3207: return;
! 3208: }
! 3209: } while(trame_complete == d_faux);
! 3210:
! 3211: tampon_lecture[++position_finale] = d_code_fin_chaine;
! 3212: tampon = (*s_etat_processus).instruction_courante;
! 3213: (*s_etat_processus).instruction_courante = tampon_lecture;
! 3214:
! 3215: indicateur_48 = test_cfsf(s_etat_processus, 48);
! 3216: cf(s_etat_processus, 48);
! 3217:
! 3218: recherche_type(s_etat_processus);
! 3219:
! 3220: if ((*s_etat_processus).erreur_execution != d_ex)
! 3221: {
! 3222: (*s_etat_processus).instruction_courante = tampon;
! 3223: free(tampon_lecture);
! 3224:
! 3225: if (indicateur_48 == d_vrai)
! 3226: {
! 3227: sf(s_etat_processus, 48);
! 3228: }
! 3229: else
! 3230: {
! 3231: cf(s_etat_processus, 48);
! 3232: }
! 3233:
! 3234: if ((*s_etat_processus).var_volatile_requete_arret == -1)
! 3235: {
! 3236: (*s_etat_processus).erreur_execution = d_ex;
! 3237: }
! 3238:
! 3239: liberation(s_etat_processus, s_objet_argument_1);
! 3240: return;
! 3241: }
! 3242:
! 3243: if (indicateur_48 == d_vrai)
! 3244: {
! 3245: sf(s_etat_processus, 48);
! 3246: }
! 3247: else
! 3248: {
! 3249: cf(s_etat_processus, 48);
! 3250: }
! 3251:
! 3252: (*s_etat_processus).instruction_courante = tampon;
! 3253:
! 3254: /*
! 3255: * Création de la liste de sortie
! 3256: */
! 3257:
! 3258: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 3259: &s_objet_type) == d_erreur)
! 3260: {
! 3261: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 3262: return;
! 3263: }
! 3264:
! 3265: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 3266: == NULL)
! 3267: {
! 3268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3269: return;
! 3270: }
! 3271:
! 3272: if (((*s_objet_resultat).objet =
! 3273: allocation_maillon(s_etat_processus)) == NULL)
! 3274: {
! 3275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3276: return;
! 3277: }
! 3278:
! 3279: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
! 3280: .donnee = s_objet_type;
! 3281:
! 3282: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
! 3283: .suivant = allocation_maillon(s_etat_processus)) == NULL)
! 3284: {
! 3285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3286: return;
! 3287: }
! 3288:
! 3289: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
! 3290: .suivant = NULL;
! 3291:
! 3292: if ((s_objet_adresse = allocation(s_etat_processus, LST))
! 3293: == NULL)
! 3294: {
! 3295: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3296: return;
! 3297: }
! 3298:
! 3299: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
! 3300: .donnee = s_objet_adresse;
! 3301:
! 3302: /*
! 3303: * Les informations concernant la cible sont valides si
! 3304: * la socket est non connectée et des domaines INET ou INET6.
! 3305: * Dans tous les autres cas, on renvoie une liste vide.
! 3306: */
! 3307:
! 3308: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
! 3309: == PF_UNIX) || (strcmp((*((struct_socket *)
! 3310: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
! 3311: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
! 3312: .type, "SEQUENTIAL DATAGRAM") == 0))
! 3313: {
! 3314: (*s_objet_adresse).objet = NULL;
! 3315: }
! 3316: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 3317: .domaine == PF_INET)
! 3318: {
! 3319: if (((*s_objet_adresse).objet =
! 3320: allocation_maillon(s_etat_processus)) == NULL)
! 3321: {
! 3322: (*s_etat_processus).erreur_systeme =
! 3323: d_es_allocation_memoire;
! 3324: return;
! 3325: }
! 3326:
! 3327: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3328: .donnee = allocation(s_etat_processus, VIN)) == NULL)
! 3329: {
! 3330: (*s_etat_processus).erreur_systeme =
! 3331: d_es_allocation_memoire;
! 3332: return;
! 3333: }
! 3334:
! 3335: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 3336: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
! 3337:
! 3338: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 3339: (*s_objet_adresse).objet)).donnee).objet)).tableau =
! 3340: malloc(4 * sizeof(integer8))) == NULL)
! 3341: {
! 3342: (*s_etat_processus).erreur_systeme =
! 3343: d_es_allocation_memoire;
! 3344: return;
! 3345: }
! 3346:
! 3347: ((integer8 *) (*((struct_vecteur *)
! 3348: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 3349: .objet)).donnee).objet)).tableau)[0] =
! 3350: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
! 3351: ((integer8 *) (*((struct_vecteur *)
! 3352: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 3353: .objet)).donnee).objet)).tableau)[1] =
! 3354: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
! 3355: ((integer8 *) (*((struct_vecteur *)
! 3356: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 3357: .objet)).donnee).objet)).tableau)[2] =
! 3358: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
! 3359: ((integer8 *) (*((struct_vecteur *)
! 3360: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 3361: .objet)).donnee).objet)).tableau)[3] =
! 3362: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
! 3363:
! 3364: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3365: .suivant = allocation_maillon(s_etat_processus))
! 3366: == NULL)
! 3367: {
! 3368: (*s_etat_processus).erreur_systeme =
! 3369: d_es_allocation_memoire;
! 3370: return;
! 3371: }
! 3372:
! 3373: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3374: .suivant).donnee = allocation(s_etat_processus, INT))
! 3375: == NULL)
! 3376: {
! 3377: (*s_etat_processus).erreur_systeme =
! 3378: d_es_allocation_memoire;
! 3379: return;
! 3380: }
! 3381:
! 3382: (*((integer8 *) (*(*(*((struct_liste_chainee *)
! 3383: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
! 3384: (integer8) ntohs(adresse_ipv4.sin_port);
! 3385:
! 3386: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3387: .suivant).suivant = NULL;
! 3388: }
! 3389: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 3390: .domaine == PF_INET6)
! 3391: {
! 3392: # ifdef IPV6
! 3393: if (((*s_objet_adresse).objet =
! 3394: allocation_maillon(s_etat_processus)) == NULL)
! 3395: {
! 3396: (*s_etat_processus).erreur_systeme =
! 3397: d_es_allocation_memoire;
! 3398: return;
! 3399: }
! 3400:
! 3401: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3402: .donnee = allocation(s_etat_processus, VIN)) == NULL)
! 3403: {
! 3404: (*s_etat_processus).erreur_systeme =
! 3405: d_es_allocation_memoire;
! 3406: return;
! 3407: }
! 3408:
! 3409: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 3410: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
! 3411:
! 3412: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 3413: (*s_objet_adresse).objet)).donnee).objet)).tableau =
! 3414: malloc(16 * sizeof(integer8))) == NULL)
! 3415: {
! 3416: (*s_etat_processus).erreur_systeme =
! 3417: d_es_allocation_memoire;
! 3418: return;
! 3419: }
! 3420:
! 3421: for(i = 0; i < 16; i++)
! 3422: {
! 3423: ((integer8 *) (*((struct_vecteur *)
! 3424: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 3425: .objet)).donnee).objet)).tableau)[0] =
! 3426: adresse_ipv6.sin6_addr.s6_addr[i];
! 3427: }
! 3428:
! 3429: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3430: .suivant = allocation_maillon(s_etat_processus))
! 3431: == NULL)
! 3432: {
! 3433: (*s_etat_processus).erreur_systeme =
! 3434: d_es_allocation_memoire;
! 3435: return;
! 3436: }
! 3437:
! 3438: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3439: .suivant).donnee = allocation(s_etat_processus, INT))
! 3440: == NULL)
! 3441: {
! 3442: (*s_etat_processus).erreur_systeme =
! 3443: d_es_allocation_memoire;
! 3444: return;
! 3445: }
! 3446:
! 3447: (*((integer8 *) (*(*(*((struct_liste_chainee *)
! 3448: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
! 3449: (integer8) ntohs(adresse_ipv6.sin6_port);
! 3450:
! 3451: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 3452: .suivant).suivant = NULL;
! 3453: # else
! 3454: if ((*s_etat_processus).langue == 'F')
! 3455: {
! 3456: printf("+++Attention : Support du protocole"
! 3457: " IPv6 indisponible\n");
! 3458: }
! 3459: else
! 3460: {
! 3461: printf("+++Warning : IPv6 support "
! 3462: "unavailable\n");
! 3463: }
! 3464: # endif
! 3465: }
! 3466: else
! 3467: {
! 3468: longueur_adresse = 0;
! 3469: recvfrom((*((struct_socket *)
! 3470: (*s_objet_argument_1).objet)).socket, tampon_lecture,
! 3471: position_finale, MSG_DONTWAIT,
! 3472: NULL, &longueur_adresse);
! 3473: }
! 3474:
! 3475: free(tampon_lecture);
! 3476:
! 3477: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 3478: s_objet_resultat) == d_erreur)
! 3479: {
! 3480: return;
! 3481: }
1.28 bertrand 3482: }
1.1 bertrand 3483: else
1.28 bertrand 3484: { // FLOW
1.73 ! bertrand 3485: #if 0
1.28 bertrand 3486: longueur_questure = 256;
3487:
3488: do
3489: {
3490: if ((tampon_lecture = malloc((longueur_questure + 1) *
3491: sizeof(unsigned char))) == NULL)
3492: {
3493: (*s_etat_processus).erreur_systeme =
3494: d_es_allocation_memoire;
3495: return;
3496: }
3497:
1.44 bertrand 3498: # ifndef SEMAPHORES_NOMMES
3499: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3500: # else
3501: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3502: # endif
1.28 bertrand 3503: {
3504: (*s_etat_processus).erreur_systeme = d_es_processus;
3505: return;
3506: }
3507:
1.30 bertrand 3508: attente.tv_sec = 0;
3509: attente.tv_nsec = GRANULARITE_us * 1000;
3510:
1.28 bertrand 3511: for(;;)
3512: {
3513: if ((*((struct_socket *) (*s_objet_argument_1).objet))
3514: .domaine == PF_UNIX)
3515: {
3516: longueur_adresse = sizeof(adresse_unix);
3517: longueur_effective = recvfrom((*((struct_socket *)
3518: (*s_objet_argument_1).objet)).socket,
3519: tampon_lecture, longueur_questure,
3520: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3521: &adresse_unix, &longueur_adresse);
3522: }
3523: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3524: .domaine == PF_INET)
3525: {
3526: longueur_adresse = sizeof(adresse_ipv4);
3527: longueur_effective = recvfrom((*((struct_socket *)
3528: (*s_objet_argument_1).objet)).socket,
3529: tampon_lecture, longueur_questure,
3530: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3531: &adresse_ipv4, &longueur_adresse);
3532: }
3533: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3534: .domaine == PF_INET6)
3535: {
3536: # ifdef IPV6
3537: longueur_adresse = sizeof(adresse_ipv6);
3538: longueur_effective = recvfrom((*((struct_socket *)
3539: (*s_objet_argument_1).objet)).socket,
3540: tampon_lecture, longueur_questure,
3541: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
3542: &adresse_ipv6, &longueur_adresse);
3543: # else
3544: if ((*s_etat_processus).langue == 'F')
3545: {
3546: printf("+++Attention : Support du protocole"
3547: " IPv6 indisponible\n");
3548: }
3549: else
3550: {
3551: printf("+++Warning : IPv6 support "
3552: "unavailable\n");
3553: }
1.51 bertrand 3554:
3555: longueur_adresse = 0;
3556: longueur_effective = 0;
1.28 bertrand 3557: # endif
3558: }
3559: else
3560: {
3561: free(tampon_lecture);
3562: liberation(s_etat_processus, s_objet_argument_1);
3563:
1.44 bertrand 3564: # ifndef SEMAPHORES_NOMMES
3565: while(sem_wait(&((*s_etat_processus)
3566: .semaphore_fork)) != 0)
3567: # else
3568: while(sem_wait((*s_etat_processus)
3569: .semaphore_fork) != 0)
3570: # endif
1.28 bertrand 3571: {
1.43 bertrand 3572: if (errno != EINTR)
3573: {
3574: (*s_etat_processus).erreur_systeme =
3575: d_es_processus;
3576: return;
3577: }
1.28 bertrand 3578: }
3579:
3580: (*s_etat_processus).erreur_execution =
3581: d_ex_erreur_acces_fichier;
3582: return;
3583: }
3584:
3585: if (longueur_effective < 0)
3586: {
3587: nanosleep(&attente, NULL);
1.30 bertrand 3588: INCR_GRANULARITE(attente.tv_nsec);
1.28 bertrand 3589: scrutation_injection(s_etat_processus);
3590: }
3591:
3592: if (((*s_etat_processus).var_volatile_requete_arret == -1)
3593: || (longueur_effective >= 0))
3594: {
3595: break;
3596: }
3597: }
3598:
1.44 bertrand 3599: # ifndef SEMAPHORES_NOMMES
3600: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3601: # else
3602: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3603: # endif
1.28 bertrand 3604: {
1.43 bertrand 3605: if (errno != EINTR)
3606: {
3607: (*s_etat_processus).erreur_systeme = d_es_processus;
3608: return;
3609: }
1.28 bertrand 3610: }
3611:
3612: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3613: {
3614:
3615: /*
3616: * Si le père tue le processus courant grâce au signal
3617: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3618: * correspond à l'utilisation de STOP sur le processus
3619: * en cours. La variable longueur_effective vaut '-1'.
3620: */
3621:
3622: free(tampon_lecture);
3623: liberation(s_etat_processus, s_objet_argument_1);
3624: return;
3625: }
3626:
3627: if (longueur_effective == -1)
3628: {
3629: free(tampon_lecture);
3630: liberation(s_etat_processus, s_objet_argument_1);
3631:
3632: (*s_etat_processus).erreur_execution =
3633: d_ex_erreur_acces_fichier;
3634: return;
3635: }
3636:
3637: if (longueur_effective == longueur_questure)
3638: {
3639: free(tampon_lecture);
3640: longueur_questure *= 2;
3641: }
3642: } while(longueur_effective == longueur_questure);
3643:
3644: longueur_enregistrement = 1;
3645:
3646: for(i = 0; i < longueur_effective; i++)
3647: {
3648: if (isprint(tampon_lecture[i]) != 0)
3649: {
3650: longueur_enregistrement += 4;
3651: }
3652: else
3653: {
3654: longueur_enregistrement++;
3655: }
3656: }
3657:
3658: /*
3659: * Création de la liste de sortie
3660: */
3661:
3662: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
3663: {
3664: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3665: return;
3666: }
3667:
3668: if (((*s_objet_type).objet = malloc(longueur_enregistrement *
3669: sizeof(unsigned char))) == NULL)
3670: {
3671: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3672: return;
3673: }
3674:
3675: ptr = (*s_objet_type).objet;
3676:
3677: for(i = 0; i < longueur_effective; i++)
3678: {
3679: if (isprint(tampon_lecture[i]) != 0)
3680: {
3681: (*ptr) = tampon_lecture[i];
3682: ptr++;
3683: }
3684: else
3685: {
3686: (*ptr) = '\\';
3687: ptr++;
3688: (*ptr) = 'x';
3689: ptr++;
3690: sprintf(ptr, "%02X", tampon_lecture[i]);
3691: ptr += 2;
3692: }
3693: }
3694:
3695: (*ptr) = d_code_fin_chaine;
3696:
3697: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3698: == NULL)
3699: {
3700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3701: return;
3702: }
3703:
3704: if (((*s_objet_resultat).objet =
3705: allocation_maillon(s_etat_processus)) == NULL)
3706: {
3707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3708: return;
3709: }
3710:
3711: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3712: .donnee = s_objet_type;
3713:
3714: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3715: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3716: {
3717: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3718: return;
3719: }
3720:
3721: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3722: .suivant = NULL;
3723:
3724: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3725: == NULL)
3726: {
3727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3728: return;
3729: }
3730:
3731: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3732: .donnee = s_objet_adresse;
3733:
3734: /*
3735: * Les informations concernant la cible sont valides si
1.30 bertrand 3736: * la socket est non connectée et que les domaines sont
3737: * INET ou INET6.
1.28 bertrand 3738: * Dans tous les autres cas, on renvoie une liste vide.
3739: */
3740:
3741: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3742: == PF_UNIX) || (strcmp((*((struct_socket *)
3743: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3744: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3745: .type, "SEQUENTIAL DATAGRAM") == 0))
3746: {
1.30 bertrand 3747: // POSITION_FINALE peut être utilisée sans être initialisée !
3748: // virer position_finale pour longueur_effective
1.28 bertrand 3749: longueur_adresse = 0;
3750: recvfrom((*((struct_socket *)
3751: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3752: position_finale, MSG_DONTWAIT,
3753: NULL, &longueur_adresse);
3754:
3755: (*s_objet_adresse).objet = NULL;
3756: }
3757: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3758: .domaine == PF_INET)
3759: {
3760: longueur_adresse = sizeof(adresse_ipv4);
3761: recvfrom((*((struct_socket *)
3762: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3763: position_finale, MSG_DONTWAIT,
3764: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
3765:
3766: if (((*s_objet_adresse).objet =
3767: allocation_maillon(s_etat_processus)) == NULL)
3768: {
3769: (*s_etat_processus).erreur_systeme =
3770: d_es_allocation_memoire;
3771: return;
3772: }
3773:
3774: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3775: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3776: {
3777: (*s_etat_processus).erreur_systeme =
3778: d_es_allocation_memoire;
3779: return;
3780: }
3781:
3782: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3783: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3784:
3785: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3786: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3787: malloc(4 * sizeof(integer8))) == NULL)
3788: {
3789: (*s_etat_processus).erreur_systeme =
3790: d_es_allocation_memoire;
3791: return;
3792: }
3793:
3794: ((integer8 *) (*((struct_vecteur *)
3795: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3796: .objet)).donnee).objet)).tableau)[0] =
3797: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3798: ((integer8 *) (*((struct_vecteur *)
3799: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3800: .objet)).donnee).objet)).tableau)[1] =
3801: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3802: ((integer8 *) (*((struct_vecteur *)
3803: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3804: .objet)).donnee).objet)).tableau)[2] =
3805: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3806: ((integer8 *) (*((struct_vecteur *)
3807: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3808: .objet)).donnee).objet)).tableau)[3] =
3809: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3810:
3811: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3812: .suivant = allocation_maillon(s_etat_processus))
3813: == NULL)
3814: {
3815: (*s_etat_processus).erreur_systeme =
3816: d_es_allocation_memoire;
3817: return;
3818: }
3819:
3820: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3821: .suivant).donnee = allocation(s_etat_processus, INT))
3822: == NULL)
3823: {
3824: (*s_etat_processus).erreur_systeme =
3825: d_es_allocation_memoire;
3826: return;
3827: }
3828:
3829: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3830: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3831: (integer8) ntohs(adresse_ipv4.sin_port);
3832:
3833: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3834: .suivant).suivant = NULL;
3835: }
3836: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3837: .domaine == PF_INET6)
3838: {
3839: # ifdef IPV6
3840: longueur_adresse = sizeof(adresse_ipv6);
3841: recvfrom((*((struct_socket *)
3842: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3843: position_finale, MSG_DONTWAIT,
3844: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
3845:
3846: if (((*s_objet_adresse).objet =
3847: allocation_maillon(s_etat_processus)) == NULL)
3848: {
3849: (*s_etat_processus).erreur_systeme =
3850: d_es_allocation_memoire;
3851: return;
3852: }
3853:
3854: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3855: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3856: {
3857: (*s_etat_processus).erreur_systeme =
3858: d_es_allocation_memoire;
3859: return;
3860: }
3861:
3862: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3863: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3864:
3865: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3866: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3867: malloc(16 * sizeof(integer8))) == NULL)
3868: {
3869: (*s_etat_processus).erreur_systeme =
3870: d_es_allocation_memoire;
3871: return;
3872: }
3873:
3874: for(i = 0; i < 16; i++)
3875: {
3876: ((integer8 *) (*((struct_vecteur *)
3877: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3878: .objet)).donnee).objet)).tableau)[0] =
3879: adresse_ipv6.sin6_addr.s6_addr[i];
3880: }
3881:
3882: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3883: .suivant = allocation_maillon(s_etat_processus))
3884: == NULL)
3885: {
3886: (*s_etat_processus).erreur_systeme =
3887: d_es_allocation_memoire;
3888: return;
3889: }
3890:
3891: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3892: .suivant).donnee = allocation(s_etat_processus, INT))
3893: == NULL)
3894: {
3895: (*s_etat_processus).erreur_systeme =
3896: d_es_allocation_memoire;
3897: return;
3898: }
3899:
3900: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3901: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3902: (integer8) ntohs(adresse_ipv6.sin6_port);
3903:
3904: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3905: .suivant).suivant = NULL;
3906: # else
3907: if ((*s_etat_processus).langue == 'F')
3908: {
3909: printf("+++Attention : Support du protocole"
3910: " IPv6 indisponible\n");
3911: }
3912: else
3913: {
3914: printf("+++Warning : IPv6 support "
3915: "unavailable\n");
3916: }
3917: # endif
3918: }
3919: else
3920: {
3921: longueur_adresse = 0;
3922: recvfrom((*((struct_socket *)
3923: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3924: position_finale, MSG_DONTWAIT,
3925: NULL, &longueur_adresse);
3926: }
3927:
3928: free(tampon_lecture);
3929:
3930: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3931: s_objet_resultat) == d_erreur)
3932: {
3933: return;
3934: }
1.73 ! bertrand 3935: #endif
1.1 bertrand 3936: }
3937: }
3938: else
3939: {
3940: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3941: return;
3942: }
3943:
1.6 bertrand 3944: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 3945:
3946: return;
3947: }
3948:
3949: // vim: ts=4