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